README
¶
bwlimit
Go net.Conn bandwidth limiter.
Only depends on the standard library.
Usage
go get github.com/linkdata/bwlimit
Ticker must be created with bwlimit.NewTicker(). The zero-value Ticker is not supported.
Limits are enforced in 100ms slices with fractional carry-over between slices, so very low limits are accurate over time but can still be bursty at slice boundaries.
After calling Limiter.Stop(), bandwidth metrics (Count and Rate) are no longer updated.
Example
import (
"fmt"
"io"
"net/http"
"net/http/httptest"
"time"
"github.com/linkdata/bwlimit"
)
func main() {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("Hello world!"))
}))
defer srv.Close()
// limit reads to 100 bytes/sec, unlimited writes
lim := bwlimit.NewLimiter(100, 0)
defer lim.Stop()
// clone the default transport so this change is local to this client
tp := http.DefaultTransport.(*http.Transport).Clone()
tp.DialContext = lim.Wrap(nil).DialContext
client := &http.Client{Transport: tp}
// make a request and time it
now := time.Now()
resp, err := client.Get(srv.URL)
elapsed := time.Since(now)
if err == nil {
defer resp.Body.Close()
var body []byte
if body, err = io.ReadAll(resp.Body); err == nil {
fmt.Printf("%v %v %q\n", elapsed >= time.Second, lim.Reads.Count.Load() > 100, string(body))
}
}
}
Documentation
¶
Index ¶
Constants ¶
This section is empty.
Variables ¶
var DefaultNetDialer = &net.Dialer{}
Functions ¶
This section is empty.
Types ¶
type ContextDialer ¶ added in v0.12.0
type Dialer ¶
type Dialer struct {
ContextDialer // ContextDialer we wrap
*Limiter // Limiter to use
}
type Limiter ¶
func NewLimiter ¶
NewLimiter returns a new limiter from DefaultTicker. If DefaultTicker has been stopped, returns nil. If you provide limits, the first will set both read and write limits, the second will set the write limit. Limits are applied in 100ms slices with fractional carry-over between slices, so very low rates are accurate over time but can be bursty at slice boundaries.
To stop the Limiter and free it's resources, call Stop.
func (*Limiter) Stop ¶ added in v0.11.0
func (l *Limiter) Stop()
Stop stops the Limiter and frees any resources. Reads and writes on a stopped and rate-limited Limiter returns io.EOF. On an unlimited Limiter they function as normal.
Count and Rate metrics are not updated after Stop.
func (*Limiter) Wrap ¶ added in v0.7.0
func (l *Limiter) Wrap(cd ContextDialer) ContextDialer
Wrap returns a ContextDialer wrapping cd that is bandwidth limited by this Limiter.
If cd is nil we use DefaultNetDialer. If cd is already limited by this Limiter, cd is returned unchanged.
type Operation ¶
type Ticker ¶ added in v0.10.0
type Ticker struct {
// contains filtered or unexported fields
}
A Ticker synchronizes rate calculation among multiple Limiters. Ticker values must be created with NewTicker; the zero value is not supported.
func NewTicker ¶ added in v1.0.0
func NewTicker() (ot *Ticker)
NewTicker creates and starts a Ticker.
func (*Ticker) NewLimiter ¶ added in v0.11.0
NewLimiter returns a new Limiter using this Ticker. If this Ticker is stopped, returns nil.
If you provide limits, the first will set both read and write limits, the second will set the write limit. Limits are applied in 100ms slices with fractional carry-over between slices, so very low rates are accurate over time but can be bursty at slice boundaries.
To stop the limiter and free it's resources, call Stop.
Source Files