README
¶
netlimit 🧙🏻♂️
netlimit is a small package that allows you to control bandwitdh usage of net.Listener and net.Conn, it delivers custom wrapper types around net.Listener and net.Conn interfaces and util functions like netlimit.Listen() and netlimit.ListenCtx() to bootstrap the whole process
Usage
Create netlimit.Listener
//globalLimit limits bandwidth of a listener
globalLimit := 1024 //Bps
//localLimit limits bandwidth of a single connection
localLimit := 512 //Bps
ln, err := netlisten.Listen(proto, addr, globalLimit, localLimit)
Use it as you would any other net.Listener e.g
http.Serve(ln, handler)
You can tweak limits during runtime
Change local(per connection) limit use
err := ln.SetLocalLimit(newLocalLimit)
Change global(server) limit use
err := ln.SetGlobalLimit(newLocalLimit)
Resources
Documentation
¶
Overview ¶
netlimit is a package that allows to control the bandwidth of the net.Conn connections and the limiter itself. Below is a simplified architecture diagram:
Listener ┌───────────────────────────────┐ updates limits │ ├─────────────────────────────────┐ │ │ │ │ │ │ │ │ │ │ │ global limiter │ │ │ ┌─────────────────▼─┐ └──────────────┬────────────────┘ │ │
│ │ │
│ │ │
│ └─────────────────▲─┘
│ │
│ │
│ │
net.Conn │ Allocator │
┌─────────────▼───┐ ┌────────────────┐ │
│ │ │ │ │
│ ├──┐ │ │ │
│ │ │ │ local limiter │ │
│ │ ├─┐ │ ┌────────────┐ │ │
│ │ │ │requests │ │ │ │ │
│ │ │ ├────────────► └────────────┘ ├───────────┘
│ │ │ │bandwitdh │ │ allocates
└────┬────────────┘ │ │ └────────────────┘ bandwidth
│ │ │
└───┬───────────┘ │
│ │
└─────────────┘
Index ¶
Constants ¶
This section is empty.
Variables ¶
var ( ErrLimitChangedInflight = errors.New("limit changed while inflight") ErrCouldNotReserveGlobal = errors.New("could not reserve quota in a global limiter") )
var ( // ErrLimitGreaterThanTotal is returned when the limit is greater than the total limit of the listener. ErrLimitGreaterThanTotal = errors.New("limit per conn cannot be greater than total limit") )
Functions ¶
This section is empty.
Types ¶
type Conn ¶
Conn is a net.Conn that obeys quota limits managed by Allocator
func (*Conn) Read ¶
Read reads data from the connection. Read can be made to time out and return an error after a fixed time limit; see SetDeadline and SetReadDeadline. Read will obey quota rules set by Listener
type DefaultAllocator ¶
type DefaultAllocator struct {
// contains filtered or unexported fields
}
DefaultAllocator is responsible for controlling requested allocations and ensuring that they not exceed requested limits. DefaultAllocator controls a single connection
func NewDefaultAllocator ¶
func NewDefaultAllocator(global *rate.Limiter, limit int) *DefaultAllocator
NewDefaultAllocator creates a new allocator with the given global and local limits. Allocator controls requested bandwidth allocations and ensures that they not exceed requested limits.
func (*DefaultAllocator) SetLimit ¶
func (a *DefaultAllocator) SetLimit(limit int) error
SetLimit sets the limit of the local limiter. setting new limit will attempt to cancel inflight allocations.
type Listener ¶
Listener is a net.Listener that allows to control the bandwidth of the net.Conn connections it accepts.
func Listen ¶
Listen returns a *Listener that will be bound to addr with the specified limits. Listen starts gc like process in separate goroutine that attempts to clean up dangling Conn connections limitGlobal is the maximum bytes per second allowed for all net.Conn connections combined limitLocal is the maximum bytes per second allowed for a single net.Conn connection
func ListenCtx ¶
func ListenCtx(ctx context.Context, network, addr string, limitTotal, limitConn int) (*Listener, error)
ListenCtx does the same as Listen but also takes a context.Context. The context argument is not used for anything after Listen returns. It's there to permit an early return for a DNS lookup, and because functions like internetSocket take a context argument even though it won't be used for the particular case of Listen
func (*Listener) SetGlobalLimit ¶
SetGlobalLimit sets the limit of the bandwidth of all net.Conn connections currently active combined.
func (*Listener) SetLocalLimit ¶
SetLocalLimit sets the limit of the bandwidth of all net.Conn active and future connections accepted by the listener.
Source Files