feat: Waku v2 bridge

Issue #12610

vendor/github.com/tsenart/tb/.travis.yml

@@ -0,0 +1,20 @@
+language: go
+sudo: false
+
+go:
+  - 1.2
+  - 1.3
+  - 1.4
+  - 1.5
+  - tip
+
+install:
+  - go get -v golang.org/x/tools/cmd/vet
+  - go get -v golang.org/x/lint/golint
+  - go get -d -t -v ./...
+  - go build -v ./...
+
+script:
+  - go vet ./...
+  - golint .
+  - go test -v -parallel=8 ./...

vendor/github.com/tsenart/tb/README.md

@@ -0,0 +1,49 @@
+# Token Bucket (tb) [![Build Status](https://secure.travis-ci.org/tsenart/tb.png)](http://travis-ci.org/tsenart/tb) [![GoDoc](https://godoc.org/github.com/tsenart/tb?status.png)](https://godoc.org/github.com/tsenart/tb)
+
+This package provides a generic lock-free implementation of the "Token bucket"
+algorithm where handling of non-conformity is left to the user.
+
+
+> The token bucket is an algorithm used in packet switched computer networks and telecommunications networks. It can be used to check that data transmissions, in the form of packets, conform to defined limits on bandwidth and burstiness (a measure of the unevenness or variations in the traffic flow)
+-- <cite>[Wikipedia](http://en.wikipedia.org/wiki/Token_bucket)</cite>
+
+This implementation of the token bucket generalises its applications beyond packet rate conformance. Hence, the word *generic*. You can use it to throttle any flow over time as long as it can be expressed as a number (bytes/s, requests/s, messages/s, packets/s, potatoes/s, heartbeats/s, etc...).
+
+The *lock-free* part of the description refers to the lock-free programming techniques (CAS loop) used in the core `Bucket` methods (`Take` and `Put`). [Here is](http://preshing.com/20120612/an-introduction-to-lock-free-programming/) a good overview of lock-free programming you can refer to.
+
+All utility pacakges such as [http](http/) and [io](io/) are just wrappers around the core package.
+This ought to be your one stop shop for all things **throttling** in Go so feel free to propose missing common functionality.
+
+
+
+## Install
+```shell
+$ go get github.com/tsenart/tb
+```
+
+## Usage
+Read up the [docs](https://godoc.org/github.com/tsenart/tb) and have a look at some [examples](examples/).
+
+## Licence
+```
+The MIT License (MIT)
+
+Copyright (c) 2014-2015 Tomás Senart
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+```

vendor/github.com/tsenart/tb/bucket.go

@@ -0,0 +1,130 @@
+package tb
+
+import (
+	"math"
+	"sync/atomic"
+	"time"
+)
+
+// Bucket defines a generic lock-free implementation of a Token Bucket.
+type Bucket struct {
+	inc      int64
+	tokens   int64
+	capacity int64
+	freq     time.Duration
+	closing  chan struct{}
+}
+
+// NewBucket returns a full Bucket with c capacity and starts a filling
+// go-routine which ticks every freq. The number of tokens added on each tick
+// is computed dynamically to be even across the duration of a second.
+//
+// If freq == -1 then the filling go-routine won't be started. Otherwise,
+// If freq < 1/c seconds, then it will be adjusted to 1/c seconds.
+func NewBucket(c int64, freq time.Duration) *Bucket {
+	b := &Bucket{tokens: c, capacity: c, closing: make(chan struct{})}
+
+	if freq == -1 {
+		return b
+	} else if evenFreq := time.Duration(1e9 / c); freq < evenFreq {
+		freq = evenFreq
+	}
+
+	b.freq = freq
+	b.inc = int64(math.Floor(.5 + (float64(c) * freq.Seconds())))
+
+	go b.fill()
+
+	return b
+}
+
+// Take attempts to take n tokens out of the bucket.
+// If tokens == 0, nothing will be taken.
+// If n <= tokens, n tokens will be taken.
+// If n > tokens, all tokens will be taken.
+//
+// This method is thread-safe.
+func (b *Bucket) Take(n int64) (taken int64) {
+	for {
+		if tokens := atomic.LoadInt64(&b.tokens); tokens == 0 {
+			return 0
+		} else if n <= tokens {
+			if !atomic.CompareAndSwapInt64(&b.tokens, tokens, tokens-n) {
+				continue
+			}
+			return n
+		} else if atomic.CompareAndSwapInt64(&b.tokens, tokens, 0) { // Spill
+			return tokens
+		}
+	}
+}
+
+// Put attempts to add n tokens to the bucket.
+// If tokens == capacity, nothing will be added.
+// If n <= capacity - tokens, n tokens will be added.
+// If n > capacity - tokens, capacity - tokens will be added.
+//
+// This method is thread-safe.
+func (b *Bucket) Put(n int64) (added int64) {
+	for {
+		if tokens := atomic.LoadInt64(&b.tokens); tokens == b.capacity {
+			return 0
+		} else if left := b.capacity - tokens; n <= left {
+			if !atomic.CompareAndSwapInt64(&b.tokens, tokens, tokens+n) {
+				continue
+			}
+			return n
+		} else if atomic.CompareAndSwapInt64(&b.tokens, tokens, b.capacity) {
+			return left
+		}
+	}
+}
+
+// Wait waits for n amount of tokens to be available.
+// If n tokens are immediatelly available it doesn't sleep.
+// Otherwise, it sleeps the minimum amount of time required for the remaining
+// tokens to be available. It returns the wait duration.
+//
+// This method is thread-safe.
+func (b *Bucket) Wait(n int64) time.Duration {
+	var rem int64
+	if rem = n - b.Take(n); rem == 0 {
+		return 0
+	}
+
+	var wait time.Duration
+	for rem > 0 {
+		sleep := b.wait(rem)
+		wait += sleep
+		time.Sleep(sleep)
+		rem -= b.Take(rem)
+	}
+	return wait
+}
+
+// Close stops the filling go-routine given it was started.
+func (b *Bucket) Close() error {
+	close(b.closing)
+	return nil
+}
+
+// wait returns the minimum amount of time required for n tokens to be available.
+// if n > capacity, n will be adjusted to capacity
+func (b *Bucket) wait(n int64) time.Duration {
+	return time.Duration(int64(math.Ceil(math.Min(float64(n), float64(b.capacity))/float64(b.inc))) *
+		b.freq.Nanoseconds())
+}
+
+func (b *Bucket) fill() {
+	ticker := time.NewTicker(b.freq)
+	defer ticker.Stop()
+
+	for _ = range ticker.C {
+		select {
+		case <-b.closing:
+			return
+		default:
+			b.Put(b.inc)
+		}
+	}
+}

vendor/github.com/tsenart/tb/tb.go

@@ -0,0 +1,4 @@
+// Package tb provides a generic lock-free implementation of the
+// Token Bucket algorithm where non-conformity is handled by the user.
+// http://en.wikipedia.org/wiki/Token_bucket
+package tb

vendor/github.com/tsenart/tb/throttler.go

@@ -0,0 +1,124 @@
+package tb
+
+import (
+	"math"
+	"sync"
+	"time"
+)
+
+// Throttler is a thread-safe wrapper around a map of buckets and an easy to
+// use API for generic throttling.
+type Throttler struct {
+	mu      sync.RWMutex
+	freq    time.Duration
+	buckets map[string]*Bucket
+	closing chan struct{}
+}
+
+// NewThrottler returns a Throttler with a single filler go-routine for all
+// its Buckets which ticks every freq.
+// The number of tokens added on each tick for each bucket is computed
+// dynamically to be even accross the duration of a second.
+//
+// If freq <= 0, the filling go-routine won't be started.
+func NewThrottler(freq time.Duration) *Throttler {
+	th := &Throttler{
+		freq:    freq,
+		buckets: map[string]*Bucket{},
+		closing: make(chan struct{}),
+	}
+
+	if freq > 0 {
+		go th.fill(freq)
+	}
+
+	return th
+}
+
+// Bucket returns a Bucket with rate capacity, keyed by key.
+//
+// If a Bucket (key, rate) doesn't exist yet, it is created.
+//
+// You must call Close when you're done with the Throttler in order to not leak
+// a go-routine and a system-timer.
+func (t *Throttler) Bucket(key string, rate int64) *Bucket {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+
+	b, ok := t.buckets[key]
+
+	if !ok {
+		b = NewBucket(rate, -1)
+		b.inc = int64(math.Floor(.5 + (float64(b.capacity) * t.freq.Seconds())))
+		b.freq = t.freq
+		t.buckets[key] = b
+	}
+
+	return b
+}
+
+// Wait waits for n amount of tokens to be available.
+// If n tokens are immediatelly available it doesn't sleep. Otherwise, it sleeps
+// the minimum amount of time required for the remaining tokens to be available.
+// It returns the wait duration.
+//
+// If a Bucket (key, rate) doesn't exist yet, it is created.
+// If freq < 1/rate seconds, the effective wait rate won't be correct.
+//
+// You must call Close when you're done with the Throttler in order to not leak
+// a go-routine and a system-timer.
+func (t *Throttler) Wait(key string, n, rate int64) time.Duration {
+	return t.Bucket(key, rate).Wait(n)
+}
+
+// Halt returns a bool indicating if the Bucket identified by key and rate has
+// n amount of tokens. If it doesn't, the taken tokens are added back to the
+// bucket.
+//
+// If a Bucket (key, rate) doesn't exist yet, it is created.
+// If freq < 1/rate seconds, the results won't be correct.
+//
+// You must call Close when you're done with the Throttler in order to not leak
+// a go-routine and a system-timer.
+func (t *Throttler) Halt(key string, n, rate int64) bool {
+	b := t.Bucket(key, rate)
+
+	if got := b.Take(n); got != n {
+		b.Put(got)
+		return true
+	}
+
+	return false
+}
+
+// Close stops filling the Buckets, closing the filling go-routine.
+func (t *Throttler) Close() error {
+	close(t.closing)
+
+	t.mu.RLock()
+	defer t.mu.RUnlock()
+
+	for _, b := range t.buckets {
+		b.Close()
+	}
+
+	return nil
+}
+
+func (t *Throttler) fill(freq time.Duration) {
+	ticker := time.NewTicker(freq)
+	defer ticker.Stop()
+
+	for _ = range ticker.C {
+		select {
+		case <-t.closing:
+			return
+		default:
+		}
+		t.mu.RLock()
+		for _, b := range t.buckets {
+			b.Put(b.inc)
+		}
+		t.mu.RUnlock()
+	}
+}