Merge pull request #1 from ipfs/feat/refactor-wait-time

Feat/refactor wait time

.travis.yml

@@ -2,7 +2,7 @@ sudo: false
 
 language: go
 go:
-  - 1.9
+  - 1.11
   
 install:
   - go get github.com/whyrusleeping/gx

delay.go

@@ -6,24 +6,19 @@ import (
 	"time"
 )
 
-var sharedRNG = rand.New(rand.NewSource(time.Now().UnixNano()))
-
 // D (Delay) makes it easy to add (threadsafe) configurable delays to other
 // objects.
 type D interface {
 	Set(time.Duration) time.Duration
 	Wait()
+	NextWaitTime() time.Duration
 	Get() time.Duration
 }
 
-// Fixed returns a delay with fixed latency
-func Fixed(t time.Duration) D {
-	return &delay{t: t}
-}
-
 type delay struct {
-	l sync.RWMutex
-	t time.Duration
+	l         sync.RWMutex
+	t         time.Duration
+	generator Generator
 }
 
 func (d *delay) Set(t time.Duration) time.Duration {
@@ -37,7 +32,13 @@ func (d *delay) Set(t time.Duration) time.Duration {
 func (d *delay) Wait() {
 	d.l.RLock()
 	defer d.l.RUnlock()
-	time.Sleep(d.t)
+	time.Sleep(d.generator.NextWaitTime(d.t))
+}
+
+func (d *delay) NextWaitTime() time.Duration {
+	d.l.Lock()
+	defer d.l.Unlock()
+	return d.generator.NextWaitTime(d.t)
 }
 
 func (d *delay) Get() time.Duration {
@@ -46,60 +47,29 @@ func (d *delay) Get() time.Duration {
 	return d.t
 }
 
-// VariableNormal is a delay following a normal distribution
-// Notice that to implement the D interface Set can only change the mean delay
-// the standard deviation is set only at initialization
-func VariableNormal(t, std time.Duration, rng *rand.Rand) D {
-	if rng == nil {
-		rng = sharedRNG
-	}
-
-	v := &variableNormal{
-		std: std,
-		rng: rng,
+// Delay generates a generic delay form a t, a sleeper, and a generator
+func Delay(t time.Duration, generator Generator) D {
+	return &delay{
+		t:         t,
+		generator: generator,
 	}
-	v.t = t
-	return v
-}
-
-type variableNormal struct {
-	delay
-	std time.Duration
-	rng *rand.Rand
 }
 
-func (d *variableNormal) Wait() {
-	d.l.RLock()
-	defer d.l.RUnlock()
-	randomDelay := time.Duration(d.rng.NormFloat64() * float64(d.std))
-	time.Sleep(randomDelay + d.t)
+// Fixed returns a delay with fixed latency
+func Fixed(t time.Duration) D {
+	return Delay(t, FixedGenerator())
 }
 
 // VariableUniform is a delay following a uniform distribution
 // Notice that to implement the D interface Set can only change the minimum delay
 // the delta is set only at initialization
 func VariableUniform(t, d time.Duration, rng *rand.Rand) D {
-	if rng == nil {
-		rng = sharedRNG
-	}
-
-	v := &variableUniform{
-		d:   d,
-		rng: rng,
-	}
-	v.t = t
-	return v
+	return Delay(t, VariableUniformGenerator(d, rng))
 }
 
-type variableUniform struct {
-	delay
-	d   time.Duration // max delta
-	rng *rand.Rand
-}
-
-func (d *variableUniform) Wait() {
-	d.l.RLock()
-	defer d.l.RUnlock()
-	randomDelay := time.Duration(d.rng.Float64() * float64(d.d))
-	time.Sleep(randomDelay + d.t)
+// VariableNormal is a delay following a normal distribution
+// Notice that to implement the D interface Set can only change the mean delay
+// the standard deviation is set only at initialization
+func VariableNormal(t, std time.Duration, rng *rand.Rand) D {
+	return Delay(t, VariableNormalGenerator(std, rng))
 }

delay_test.go

+package delay
+
+import (
+	"testing"
+	"time"
+)
+
+func TestDelaySetAndGet(t *testing.T) {
+	initialValue := 1000 * time.Millisecond
+	modifiedValue := 2000 * time.Millisecond
+	deviation := 1000 * time.Millisecond
+
+	fixed := Fixed(initialValue)
+	variableNormal := VariableNormal(initialValue, deviation, nil)
+	variableUniform := VariableUniform(initialValue, deviation, nil)
+
+	if fixed.Get().Seconds() != 1 {
+		t.Fatal("Fixed delay not initialized correctly")
+	}
+
+	if variableNormal.Get().Seconds() != 1 {
+		t.Fatal("Normalized variable delay not initialized correctly")
+	}
+
+	if variableUniform.Get().Seconds() != 1 {
+		t.Fatal("Uniform variable delay not initialized correctly")
+	}
+
+	fixed.Set(modifiedValue)
+
+	if fixed.Get().Seconds() != 2 {
+		t.Fatal("Fixed delay not set correctly")
+	}
+
+	variableNormal.Set(modifiedValue)
+
+	if variableNormal.Get().Seconds() != 2 {
+		t.Fatal("Normalized variable delay not set correctly")
+	}
+
+	variableUniform.Set(modifiedValue)
+
+	if variableUniform.Get().Seconds() != 2 {
+		t.Fatal("Uniform variable delay not initialized correctly")
+	}
+
+}
+
+type fixedAdd struct {
+	toAdd time.Duration
+}
+
+func (fa *fixedAdd) NextWaitTime(t time.Duration) time.Duration {
+	return t + fa.toAdd
+}
+
+func TestDelaySleep(t *testing.T) {
+	initialValue := 1000 * time.Millisecond
+	toAdd := 500 * time.Millisecond
+	generator := &fixedAdd{toAdd: toAdd}
+	delay := Delay(initialValue, generator)
+
+	if delay.NextWaitTime() != initialValue+toAdd {
+		t.Fatal("NextWaitTime should call the generator")
+	}
+
+}

generator.go

+package delay
+
+import (
+	"math/rand"
+	"time"
+)
+
+// Generator provides an interface for generating wait times
+type Generator interface {
+	NextWaitTime(time.Duration) time.Duration
+}
+
+var sharedRNG = rand.New(rand.NewSource(time.Now().UnixNano()))
+
+// VariableNormalGenerator makes delays that following a normal distribution
+func VariableNormalGenerator(std time.Duration, rng *rand.Rand) Generator {
+	if rng == nil {
+		rng = sharedRNG
+	}
+
+	return &variableNormal{
+		std: std,
+		rng: rng,
+	}
+}
+
+type variableNormal struct {
+	std time.Duration
+	rng *rand.Rand
+}
+
+func (d *variableNormal) NextWaitTime(t time.Duration) time.Duration {
+	return time.Duration(d.rng.NormFloat64()*float64(d.std)) + t
+}
+
+// VariableUniformGenerator generates delays following a uniform distribution
+func VariableUniformGenerator(d time.Duration, rng *rand.Rand) Generator {
+	if rng == nil {
+		rng = sharedRNG
+	}
+
+	return &variableUniform{
+		d:   d,
+		rng: rng,
+	}
+}
+
+type variableUniform struct {
+	d   time.Duration // max delta
+	rng *rand.Rand
+}
+
+func (d *variableUniform) NextWaitTime(t time.Duration) time.Duration {
+	return time.Duration(d.rng.Float64()*float64(d.d)) + t
+}
+
+type fixed struct{}
+
+// FixedGenerator returns a delay with fixed latency
+func FixedGenerator() Generator {
+	return &fixed{}
+}
+
+func (d *fixed) NextWaitTime(t time.Duration) time.Duration {
+	return t
+}

generator_test.go

+package delay
+
+import (
+	"math"
+	"math/rand"
+	"testing"
+	"time"
+)
+
+const testSeed = 99
+
+func TestGeneratorNextWaitTime(t *testing.T) {
+	initialValue := 1000 * time.Millisecond
+	deviation := 1000 * time.Millisecond
+
+	firstRandomNormal := rand.New(rand.NewSource(testSeed)).NormFloat64()
+	firstRandom := rand.New(rand.NewSource(testSeed)).Float64()
+	fixedGenerator := FixedGenerator()
+	variableNormalGenerator := VariableNormalGenerator(deviation, rand.New(rand.NewSource(testSeed)))
+	variableUniformGenerator := VariableUniformGenerator(deviation, rand.New(rand.NewSource(testSeed)))
+
+	if fixedGenerator.NextWaitTime(initialValue).Seconds() != 1 {
+		t.Fatal("Fixed generator output incorrect wait time")
+	}
+
+	if math.Abs(variableNormalGenerator.NextWaitTime(initialValue).Seconds()-(firstRandomNormal*deviation.Seconds()+initialValue.Seconds())) > 0.00001 {
+		t.Fatal("Normalized variable delay generator output incorrect wait time")
+	}
+
+	if math.Abs(variableUniformGenerator.NextWaitTime(initialValue).Seconds()-(firstRandom*deviation.Seconds()+initialValue.Seconds())) > 0.00001 {
+		t.Fatal("Uniform variable delay output incorrect wait time")
+	}
+
+}