proxylib: Move proxylib from cilium to proxy repo

This is to make sure that we can build self-contained and independent
proxy image, which will be used in cilium. Along with main implementation
of proxylib, a minimal dependency is copied from cilium/cilium/pkg to
cilium/proxy/pkg.

Signed-off-by: Tam Mach <[email protected]>

Author: sayboras

.gitignore

@@ -39,3 +39,6 @@
 /.clwb
 
 /.vagrant
+
+/proxylib/libcilium.so*
+/proxylib/_obj*

Makefile.defs

@@ -1,4 +1,5 @@
-include Makefile.quiet
+ROOT_DIR := $(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))
+include $(ROOT_DIR)/Makefile.quiet
 
 PREFIX?=/usr
 BINDIR?=$(PREFIX)/bin

go.mod

@@ -1,14 +1,38 @@
 module github.com/cilium/proxy
 
-go 1.13
+go 1.20
 
 require (
 	github.com/census-instrumentation/opencensus-proto v0.3.0
-	github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1
+	github.com/cilium/checkmate v1.0.3
+	github.com/cilium/kafka v0.0.0-20180809090225-01ce283b732b
+	github.com/cncf/xds/go v0.0.0-20211130200136-a8f946100490
 	github.com/envoyproxy/protoc-gen-validate v0.6.2
 	github.com/golang/protobuf v1.5.2
-	github.com/prometheus/client_model v0.2.1-0.20210607210712-147c58e9608a
-	google.golang.org/genproto v0.0.0-20211208223120-3a66f561d7aa
-	google.golang.org/grpc v1.43.0
-	google.golang.org/protobuf v1.27.1
+	github.com/google/uuid v1.3.0
+	github.com/prometheus/client_model v0.3.0
+	github.com/sasha-s/go-deadlock v0.3.1
+	github.com/sirupsen/logrus v1.9.2
+	github.com/stretchr/testify v1.8.1
+	golang.org/x/sync v0.1.0
+	golang.org/x/sys v0.5.0
+	google.golang.org/genproto v0.0.0-20221024183307-1bc688fe9f3e
+	google.golang.org/grpc v1.51.0
+	google.golang.org/protobuf v1.28.1
+	k8s.io/klog/v2 v2.100.1
+)
+
+require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/go-logr/logr v1.2.3 // indirect
+	github.com/golang/snappy v0.0.4 // indirect
+	github.com/kr/pretty v0.3.1 // indirect
+	github.com/kr/text v0.2.0 // indirect
+	github.com/petermattis/goid v0.0.0-20180202154549-b0b1615b78e5 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/rogpeppe/go-internal v1.9.0 // indirect
+	golang.org/x/net v0.7.0 // indirect
+	golang.org/x/text v0.7.0 // indirect
+	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -0,0 +1,168 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Authors of Cilium
+
+package backoff
+
+import (
+	"context"
+	"fmt"
+	"math"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/sirupsen/logrus"
+
+	"github.com/cilium/proxy/pkg/logging"
+	"github.com/cilium/proxy/pkg/logging/logfields"
+	"github.com/cilium/proxy/pkg/rand"
+)
+
+var (
+	log = logging.DefaultLogger.WithField(logfields.LogSubsys, "backoff")
+
+	randGen = rand.NewSafeRand(time.Now().UnixNano())
+)
+
+// Exponential implements an exponential backoff
+type Exponential struct {
+	// Min is the minimal backoff time, if unspecified, 1 second will be
+	// used
+	Min time.Duration
+
+	// Max is the maximum backoff time, if unspecified, no maximum time is
+	// applied
+	Max time.Duration
+
+	// Factor is the factor the backoff time grows exponentially, if
+	// unspecified, a factor of 2.0 will be used
+	Factor float64
+
+	// Jitter, when enabled, adds random jitter to the interval
+	Jitter bool
+
+	// Name is a free form string describing the operation subject to the
+	// backoff, if unspecified, a UUID is generated. This string is used
+	// for logging purposes.
+	Name string
+
+	// ResetAfter will reset the exponential back-off if no attempt is made for the amount of time specified here.
+	// Needs to be larger than the Max duration, otherwise it will be ignored to avoid accidental resets.
+	// If unspecified, no reset is performed.
+	ResetAfter time.Duration
+
+	lastBackoffStart time.Time
+
+	attempt int
+}
+
+// CalculateDuration calculates the backoff duration based on minimum base
+// interval, exponential factor, jitter and number of failures.
+func CalculateDuration(min, max time.Duration, factor float64, jitter bool, failures int) time.Duration {
+	minFloat := float64(min)
+	maxFloat := float64(max)
+
+	t := minFloat * math.Pow(factor, float64(failures))
+	if max != time.Duration(0) && t > maxFloat {
+		t = maxFloat
+	}
+
+	if jitter {
+		t = randGen.Float64()*(t-minFloat) + minFloat
+	}
+
+	return time.Duration(t)
+}
+
+// ClusterSizeDependantInterval returns a time.Duration that is dependent on
+// the cluster size, i.e. the number of nodes that have been discovered. This
+// can be used to control sync intervals of shared or centralized resources to
+// avoid overloading these resources as the cluster grows.
+//
+// Example sync interval with baseInterval = 1 * time.Minute
+//
+// nodes | sync interval
+// ------+-----------------
+// 1     |   41.588830833s
+// 2     | 1m05.916737320s
+// 4     | 1m36.566274746s
+// 8     | 2m11.833474640s
+// 16    | 2m49.992800643s
+// 32    | 3m29.790453687s
+// 64    | 4m10.463236193s
+// 128   | 4m51.588744261s
+// 256   | 5m32.944565093s
+// 512   | 6m14.416550710s
+// 1024  | 6m55.946873494s
+// 2048  | 7m37.506428894s
+// 4096  | 8m19.080616652s
+// 8192  | 9m00.662124608s
+// 16384 | 9m42.247293667s
+func ClusterSizeDependantInterval(baseInterval time.Duration, numNodes int) time.Duration {
+	// no nodes are being managed, no work will be performed, return
+	// baseInterval to check again in a reasonable timeframe
+	if numNodes == 0 {
+		return baseInterval
+	}
+
+	waitNanoseconds := float64(baseInterval.Nanoseconds()) * math.Log1p(float64(numNodes))
+	return time.Duration(int64(waitNanoseconds))
+}
+
+// Reset backoff attempt counter
+func (b *Exponential) Reset() {
+	b.attempt = 0
+}
+
+// Wait waits for the required time using an exponential backoff
+func (b *Exponential) Wait(ctx context.Context) error {
+	if resetDuration := b.ResetAfter; resetDuration != time.Duration(0) && resetDuration > b.Max {
+		if !b.lastBackoffStart.IsZero() {
+			if time.Since(b.lastBackoffStart) > resetDuration {
+				b.Reset()
+			}
+		}
+	}
+
+	b.lastBackoffStart = time.Now()
+	b.attempt++
+	t := b.Duration(b.attempt)
+
+	log.WithFields(logrus.Fields{
+		"time":    t,
+		"attempt": b.attempt,
+		"name":    b.Name,
+	}).Debug("Sleeping with exponential backoff")
+
+	select {
+	case <-ctx.Done():
+		return fmt.Errorf("exponential backoff cancelled via context: %s", ctx.Err())
+	case <-time.After(t):
+	}
+
+	return nil
+}
+
+// Duration returns the wait duration for the nth attempt
+func (b *Exponential) Duration(attempt int) time.Duration {
+	if b.Name == "" {
+		b.Name = uuid.New().String()
+	}
+
+	min := time.Duration(1) * time.Second
+	if b.Min != time.Duration(0) {
+		min = b.Min
+	}
+
+	factor := float64(2)
+	if b.Factor != float64(0) {
+		factor = b.Factor
+	}
+
+	t := CalculateDuration(min, b.Max, factor, b.Jitter, attempt)
+
+	if b.Max != time.Duration(0) && t > b.Max {
+		t = b.Max
+	}
+
+	return t
+}

pkg/backoff/backoff.go

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Authors of Cilium
+
+package backoff
+
+import (
+	"fmt"
+	"math"
+	"testing"
+	"time"
+
+	check "github.com/cilium/checkmate"
+)
+
+func Test(t *testing.T) {
+	check.TestingT(t)
+}
+
+type BackoffSuite struct{}
+
+var _ = check.Suite(&BackoffSuite{})
+
+func (b *BackoffSuite) TestJitter(c *check.C) {
+	var prev time.Duration
+	for i := 0; i < 100; i++ {
+		current := CalculateDuration(time.Second, time.Minute, 2.0, true, 1)
+		c.Assert(current, check.Not(check.Equals), prev)
+		prev = current
+	}
+}
+
+type fakeNodeManager struct {
+	nodes *int
+}
+
+func (f *fakeNodeManager) ClusterSizeDependantInterval(baseInterval time.Duration) time.Duration {
+	numNodes := *f.nodes
+
+	if numNodes == 0 {
+		return baseInterval
+	}
+
+	waitNanoseconds := float64(baseInterval.Nanoseconds()) * math.Log1p(float64(numNodes))
+	return time.Duration(int64(waitNanoseconds))
+}
+
+func (b *BackoffSuite) TestJitterDistribution(c *check.C) {
+	nodeBackoff := &Exponential{
+		Min:    time.Second,
+		Factor: 2.0,
+	}
+
+	for attempt := 1; attempt <= 8; attempt++ {
+		current := nodeBackoff.Duration(attempt).Round(time.Second / 10)
+		fmt.Printf("%d: %s\n", attempt, current)
+	}
+}

pkg/backoff/backoff_test.go

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Authors of Cilium
+
+package flowdebug
+
+import (
+	"github.com/sirupsen/logrus"
+)
+
+var perFlowDebug = false
+
+// Enable enables per-flow debugging
+func Enable() {
+	perFlowDebug = true
+}
+
+// Enabled reports the status of per-flow debugging
+func Enabled() bool {
+	return perFlowDebug
+}
+
+// Log must be used to log any debug messages emitted per request/message/connection
+func Log(l *logrus.Entry, args ...interface{}) {
+	if perFlowDebug {
+		l.Debug(args...)
+	}
+}
+
+// Logf must be used to log any debug messages emitted per request/message/connection
+func Logf(l *logrus.Entry, format string, args ...interface{}) {
+	if perFlowDebug {
+		l.Debugf(format, args...)
+	}
+}