revert math/rand

Author: asmyasnikov

CHANGELOG.md

@@ -1,3 +1,6 @@
+## 3.11.11
+* Reverted usage of `math/rand` (instead `crypto/rand`)
+
 ## 3.11.10
 * Imported tool gtrace to `./cmd/gtrace`
 * Changed minimal version of go from 1.13 to 1.14

internal/balancer/rr/rr.go

@@ -24,6 +24,7 @@ type roundRobin struct {
 	belt  []int
 	next  int32
 	conns list.List
+	r     rand.Rand
 }
 
 func (r *roundRobin) Create() balancer.Balancer {
@@ -33,15 +34,22 @@ func (r *roundRobin) Create() balancer.Balancer {
 		belt:  r.belt,
 		next:  r.next,
 		conns: r.conns,
+		r:     rand.New(),
 	}
 }
 
 func RoundRobin() balancer.Balancer {
-	return &roundRobin{}
+	return &roundRobin{
+		r: rand.New(),
+	}
 }
 
 func RandomChoice() balancer.Balancer {
-	return &randomChoice{}
+	return &randomChoice{
+		roundRobin: roundRobin{
+			r: rand.New(),
+		},
+	}
 }
 
 type randomChoice struct {
@@ -51,7 +59,14 @@ type randomChoice struct {
 
 func (r *randomChoice) Create() balancer.Balancer {
 	return &randomChoice{
-		roundRobin: *(r.roundRobin.Create().(*roundRobin)),
+		roundRobin: roundRobin{
+			min:   r.roundRobin.min,
+			max:   r.roundRobin.max,
+			belt:  r.roundRobin.belt,
+			next:  r.roundRobin.next,
+			conns: r.roundRobin.conns,
+			r:     rand.New(),
+		},
 	}
 }
 
@@ -69,7 +84,7 @@ func (r *randomChoice) Next() conn.Conn {
 		return nil
 	}
 	r.m.Lock()
-	i := r.belt[rand.Int(len(r.belt))]
+	i := r.belt[r.r.Int(len(r.belt))]
 	r.m.Unlock()
 	return r.conns[i].Conn
 }

internal/meta/version.go

@@ -1,5 +1,5 @@
 package meta
 
 const (
-	Version = "ydb-go-sdk/3.11.10"
+	Version = "ydb-go-sdk/3.11.11"
 )

internal/rand/rand.go

@@ -1,22 +1,52 @@
 package rand
 
 import (
-	"crypto/rand"
-	"math/big"
+	"math"
+	"math/rand"
+	"sync"
 )
 
-func int64n(max int64) int64 {
-	n, err := rand.Int(rand.Reader, big.NewInt(max))
-	if err != nil {
-		panic(err) // err on negative max
+type Rand interface {
+	Int64(max int64) int64
+	Int(max int) int
+}
+
+type r struct {
+	r *rand.Rand
+	m *sync.Mutex
+}
+
+type option func(r *r)
+
+func WithLock() option {
+	return func(r *r) {
+		r.m = &sync.Mutex{}
+	}
+}
+
+func New(opts ...option) Rand {
+	r := &r{
+		// nolint:gosec
+		r: rand.New(rand.NewSource(math.MaxInt64)),
+	}
+	for _, o := range opts {
+		o(r)
+	}
+	return r
+}
+
+func (r *r) int64n(max int64) int64 {
+	if r.m != nil {
+		r.m.Lock()
+		defer r.m.Unlock()
 	}
-	return n.Int64()
+	return r.r.Int63n(max)
 }
 
-func Int64(max int64) int64 {
-	return int64n(max)
+func (r *r) Int64(max int64) int64 {
+	return r.int64n(max)
 }
 
-func Int(max int) int {
-	return int(int64n(int64(max)))
+func (r *r) Int(max int) int {
+	return int(r.int64n(int64(max)))
 }

internal/repeater/test/repeat_test.go

@@ -48,9 +48,11 @@ func TestRepeaterCancellation(t *testing.T) {
 		enter  = make(chan struct{}, 2)
 		exit   = make(chan struct{}, 2)
 	)
+
 	timer := timetest.Timer{
 		Ch: timerC,
 	}
+
 	cleanup := timeutil.StubTestHookNewTimer(func(time.Duration) timeutil.Timer {
 		return timer
 	})
@@ -59,13 +61,16 @@ func TestRepeaterCancellation(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	r := repeater.NewRepeater(ctx, 42*time.Second,
+	r := repeater.NewRepeater(
+		ctx,
+		42*time.Second,
 		func(ctx context.Context) error {
 			enter <- struct{}{}
 			<-ctx.Done()
 			exit <- struct{}{}
 			return nil
-		})
+		},
+	)
 
 	// Run callback in a separate goroutine to avoid deadlock.
 	// That is, StubTimer run its function in the same goroutine as Emit

internal/table/client_test.go

@@ -53,12 +53,13 @@ func TestSessionPoolCreateAbnormalResult(t *testing.T) {
 	defer func() {
 		_ = p.Close(context.Background())
 	}()
+	r := rand.New(rand.WithLock())
 	errCh := make(chan error, limit*10)
 	fn := func(wg *sync.WaitGroup) {
 		defer wg.Done()
 		childCtx, childCancel := context.WithTimeout(
 			ctx,
-			time.Duration(rand.Int64(int64(time.Minute))),
+			time.Duration(r.Int64(int64(time.Minute))),
 		)
 		defer childCancel()
 		s, err := p.createSession(childCtx)

internal/table/retry_test.go

@@ -301,6 +301,7 @@ func TestRetryContextDeadline(t *testing.T) {
 	p := SessionProviderFunc{
 		OnGet: client.createSession,
 	}
+	r := rand.New(rand.WithLock())
 	for i := range timeouts {
 		for j := range sleeps {
 			timeout := timeouts[i]
@@ -339,7 +340,7 @@ func TestRetryContextDeadline(t *testing.T) {
 						case <-ctx.Done():
 							return ctx.Err()
 						case <-time.After(sleep):
-							return errs[rand.Int(len(errs))]
+							return errs[r.Int(len(errs))]
 						}
 					},
 				)

internal/table/scanner/scanner_test.go

@@ -18,8 +18,8 @@ import (
 )
 
 // nolint:gocyclo
-func valueFromPrimitiveTypeID(c *column) (*Ydb.Value, interface{}) {
-	rv := rand.Int64(math.MaxInt16)
+func valueFromPrimitiveTypeID(c *column, r rand.Rand) (*Ydb.Value, interface{}) {
+	rv := r.Int64(math.MaxInt16)
 	switch c.typeID {
 	case Ydb.Type_BOOL:
 		v := rv%2 == 1
@@ -443,8 +443,8 @@ func valueFromPrimitiveTypeID(c *column) (*Ydb.Value, interface{}) {
 	}
 }
 
-func getResultSet(count int, col []*column) (r *Ydb.ResultSet, testValues [][]indexed.RequiredOrOptional) {
-	r = &Ydb.ResultSet{}
+func getResultSet(count int, col []*column) (result *Ydb.ResultSet, testValues [][]indexed.RequiredOrOptional) {
+	result = &Ydb.ResultSet{}
 	for _, c := range col {
 		t := &Ydb.Type{
 			Type: &Ydb.Type_TypeId{
@@ -460,30 +460,31 @@ func getResultSet(count int, col []*column) (r *Ydb.ResultSet, testValues [][]in
 				},
 			}
 		}
-		r.Columns = append(
-			r.Columns,
+		result.Columns = append(
+			result.Columns,
 			&Ydb.Column{
 				Name: c.name,
 				Type: t,
 			},
 		)
 	}
 
+	r := rand.New(rand.WithLock())
 	testValues = make([][]indexed.RequiredOrOptional, count)
 	for i := 0; i < count; i++ {
 		var items []*Ydb.Value
 		var vals []indexed.RequiredOrOptional
-		for j := range r.Columns {
-			v, val := valueFromPrimitiveTypeID(col[j])
+		for j := range result.Columns {
+			v, val := valueFromPrimitiveTypeID(col[j], r)
 			vals = append(vals, val)
 			items = append(items, v)
 		}
-		r.Rows = append(r.Rows, &Ydb.Value{
+		result.Rows = append(result.Rows, &Ydb.Value{
 			Items: items,
 		})
 		testValues[i] = vals
 	}
-	return r, testValues
+	return result, testValues
 }
 
 func TestScanSqlTypes(t *testing.T) {

retry/retry.go

@@ -18,14 +18,14 @@ const (
 
 // Default parameters used by Retry() functions within different sub packages.
 var (
-	FastBackoff = logBackoff{
-		SlotDuration: fastSlot,
-		Ceiling:      6,
-	}
-	SlowBackoff = logBackoff{
-		SlotDuration: slowSlot,
-		Ceiling:      6,
-	}
+	FastBackoff = newBackoff(
+		withSlotDuration(fastSlot),
+		withCeiling(6),
+	)
+	SlowBackoff = newBackoff(
+		withSlotDuration(slowSlot),
+		withCeiling(6),
+	)
 )
 
 // retryOperation is the interface that holds an operation for retry.
@@ -226,6 +226,39 @@ type logBackoff struct {
 	// where F is a result of multiplication of this value and calculated delay
 	// duration D; and R is a random sized part from [0,(D - F)].
 	JitterLimit float64
+
+	// generator of jitter
+	r rand.Rand
+}
+
+type option func(b *logBackoff)
+
+func withSlotDuration(slotDuration time.Duration) option {
+	return func(b *logBackoff) {
+		b.SlotDuration = slotDuration
+	}
+}
+
+func withCeiling(ceiling uint) option {
+	return func(b *logBackoff) {
+		b.Ceiling = ceiling
+	}
+}
+
+func withJitterLimit(jitterLimit float64) option {
+	return func(b *logBackoff) {
+		b.JitterLimit = jitterLimit
+	}
+}
+
+func newBackoff(opts ...option) logBackoff {
+	b := logBackoff{
+		r: rand.New(rand.WithLock()),
+	}
+	for _, o := range opts {
+		o(&b)
+	}
+	return b
 }
 
 // Wait implements Backoff interface.
@@ -245,7 +278,7 @@ func (b logBackoff) delay(i int) time.Duration {
 	if f == d {
 		return f
 	}
-	return f + time.Duration(rand.Int64(int64(d-f)+1))
+	return f + time.Duration(b.r.Int64(int64(d-f)+1))
 }
 
 func min(a, b uint) uint {

retry/retry_test.go

@@ -25,11 +25,11 @@ func TestLogBackoff(t *testing.T) {
 		seeds   int64
 	}{
 		{
-			backoff: logBackoff{
-				SlotDuration: time.Second,
-				Ceiling:      3,
-				JitterLimit:  0,
-			},
+			backoff: newBackoff(
+				withSlotDuration(time.Second),
+				withCeiling(3),
+				withJitterLimit(0),
+			),
 			exp: []exp{
 				{gte: 0, lte: time.Second},     // 1 << min(0, 3)
 				{gte: 0, lte: 2 * time.Second}, // 1 << min(1, 3)
@@ -42,11 +42,11 @@ func TestLogBackoff(t *testing.T) {
 			seeds: 1000,
 		},
 		{
-			backoff: logBackoff{
-				SlotDuration: time.Second,
-				Ceiling:      3,
-				JitterLimit:  0.5,
-			},
+			backoff: newBackoff(
+				withSlotDuration(time.Second),
+				withCeiling(3),
+				withJitterLimit(0.5),
+			),
 			exp: []exp{
 				{gte: 500 * time.Millisecond, lte: time.Second}, // 1 << min(0, 3)
 				{gte: 1 * time.Second, lte: 2 * time.Second},    // 1 << min(1, 3)
@@ -59,11 +59,11 @@ func TestLogBackoff(t *testing.T) {
 			seeds: 1000,
 		},
 		{
-			backoff: logBackoff{
-				SlotDuration: time.Second,
-				Ceiling:      3,
-				JitterLimit:  1,
-			},
+			backoff: newBackoff(
+				withSlotDuration(time.Second),
+				withCeiling(3),
+				withJitterLimit(1),
+			),
 			exp: []exp{
 				{eq: time.Second},     // 1 << min(0, 3)
 				{eq: 2 * time.Second}, // 1 << min(1, 3)