[#1507] timer: Remove unused OnDelta() method

Signed-off-by: Evgenii Stratonikov <e.stratonikov@yadro.com>

pkg/morph/timer/block.go

@@ -15,41 +15,19 @@ type BlockTickHandler func()
 // It can tick the blocks and perform certain actions
 // on block time intervals.
 type BlockTimer struct {
-	rolledBack bool
-
 	mtx sync.Mutex
 
 	dur BlockMeter
 
 	baseDur uint32
 
-	mul, div uint32
-
 	cur, tgt uint32
 
 	last uint32
 
 	h BlockTickHandler
 
-	ps []BlockTimer
-
 	once bool
-
-	deltaCfg
-}
-
-// DeltaOption is an option of delta-interval handler.
-type DeltaOption func(*deltaCfg)
-
-type deltaCfg struct {
-	pulse bool
-}
-
-// WithPulse returns option to call delta-interval handler multiple times.
-func WithPulse() DeltaOption {
-	return func(c *deltaCfg) {
-		c.pulse = true
-	}
 }
 
 // StaticBlockMeter returns BlockMeters that always returns (d, nil).
@@ -65,52 +43,19 @@ func StaticBlockMeter(d uint32) BlockMeter {
 func NewBlockTimer(dur BlockMeter, h BlockTickHandler) *BlockTimer {
 	return &BlockTimer{
 		dur: dur,
-		mul: 1,
-		div: 1,
 		h:   h,
-		deltaCfg: deltaCfg{
-			pulse: true,
-		},
 	}
 }
 
 // NewOneTickTimer creates a new BlockTimer that ticks only once.
-//
-// Do not use delta handlers with pulse in this timer.
 func NewOneTickTimer(dur BlockMeter, h BlockTickHandler) *BlockTimer {
 	return &BlockTimer{
 		dur:  dur,
-		mul:  1,
-		div:  1,
 		h:    h,
 		once: true,
 	}
 }
 
-// OnDelta registers handler which is executed on (mul / div * BlockMeter()) block
-// after basic interval reset.
-//
-// If WithPulse option is provided, handler is executed (mul / div * BlockMeter()) block
-// during base interval.
-func (t *BlockTimer) OnDelta(mul, div uint32, h BlockTickHandler, opts ...DeltaOption) {
-	c := deltaCfg{
-		pulse: false,
-	}
-
-	for i := range opts {
-		opts[i](&c)
-	}
-
-	t.ps = append(t.ps, BlockTimer{
-		mul:  mul,
-		div:  div,
-		h:    h,
-		once: t.once,
-
-		deltaCfg: c,
-	})
-}
-
 // Reset resets previous ticks of the BlockTimer.
 //
 // Returns BlockMeter's error upon occurrence.
@@ -124,29 +69,18 @@ func (t *BlockTimer) Reset() error {
 
 	t.resetWithBaseInterval(d)
 
-	for i := range t.ps {
-		t.ps[i].resetWithBaseInterval(d)
-	}
-
 	t.mtx.Unlock()
 
 	return nil
 }
 
 func (t *BlockTimer) resetWithBaseInterval(d uint32) {
-	t.rolledBack = false
 	t.baseDur = d
 	t.reset()
 }
 
 func (t *BlockTimer) reset() {
-	mul, div := t.mul, t.div
+	delta := t.baseDur
-
-	if !t.pulse && t.rolledBack && mul < div {
-		mul, div = 1, 1
-	}
-
-	delta := mul * t.baseDur / div
 	if delta == 0 {
 		delta = 1
 	}
@@ -180,12 +114,7 @@ func (t *BlockTimer) tick(h uint32) {
 
 		if !t.once {
 			t.cur = 0
-			t.rolledBack = true
 			t.reset()
 		}
 	}
-
-	for i := range t.ps {
-		t.ps[i].tick(h)
-	}
 }

pkg/morph/timer/block_test.go

@@ -63,85 +63,6 @@ func TestBlockTimer(t *testing.T) {
 	tickN(bt, intervalNum*blockDur)
 
 	require.Equal(t, intervalNum, uint32(baseCallCounter))
-
-	// add half-interval handler
-	halfCallCounter := uint32(0)
-
-	bt.OnDelta(1, 2, func() {
-		halfCallCounter++
-	})
-
-	// add double interval handler
-	doubleCallCounter := uint32(0)
-
-	bt.OnDelta(2, 1, func() {
-		doubleCallCounter++
-	})
-
-	require.NoError(t, bt.Reset())
-
-	baseCallCounter = 0
-	intervalNum = 20
-
-	tickN(bt, intervalNum*blockDur)
-
-	require.Equal(t, intervalNum, uint32(halfCallCounter))
-	require.Equal(t, intervalNum, uint32(baseCallCounter))
-	require.Equal(t, intervalNum/2, uint32(doubleCallCounter))
-}
-
-func TestDeltaPulse(t *testing.T) {
-	blockDur := uint32(9)
-	baseCallCounter := uint32(0)
-
-	bt := timer.NewBlockTimer(timer.StaticBlockMeter(blockDur), func() {
-		baseCallCounter++
-	})
-
-	deltaCallCounter := uint32(0)
-
-	div := uint32(3)
-
-	bt.OnDelta(1, div, func() {
-		deltaCallCounter++
-	}, timer.WithPulse())
-
-	require.NoError(t, bt.Reset())
-
-	intervalNum := uint32(7)
-
-	tickN(bt, intervalNum*blockDur)
-
-	require.Equal(t, intervalNum, uint32(baseCallCounter))
-	require.Equal(t, intervalNum*div, uint32(deltaCallCounter))
-}
-
-func TestDeltaReset(t *testing.T) {
-	blockDur := uint32(6)
-	baseCallCounter := 0
-
-	bt := timer.NewBlockTimer(timer.StaticBlockMeter(blockDur), func() {
-		baseCallCounter++
-	})
-
-	detlaCallCounter := 0
-
-	bt.OnDelta(1, 3, func() {
-		detlaCallCounter++
-	})
-
-	require.NoError(t, bt.Reset())
-
-	tickN(bt, 6)
-
-	require.Equal(t, 1, baseCallCounter)
-	require.Equal(t, 1, detlaCallCounter)
-
-	require.NoError(t, bt.Reset())
-
-	tickN(bt, 3)
-
-	require.Equal(t, 2, detlaCallCounter)
 }
 
 func TestNewOneTickTimer(t *testing.T) {
@@ -168,82 +89,51 @@ func TestNewOneTickTimer(t *testing.T) {
 		tickN(bt, 10)
 		require.Equal(t, 1, baseCallCounter)
 	})
-
-	t.Run("delta without pulse", func(t *testing.T) {
-		blockDur = uint32(10)
-		baseCallCounter = 0
-
-		bt = timer.NewOneTickTimer(timer.StaticBlockMeter(blockDur), func() {
-			baseCallCounter++
-		})
-
-		detlaCallCounter := 0
-
-		bt.OnDelta(1, 10, func() {
-			detlaCallCounter++
-		})
-
-		require.NoError(t, bt.Reset())
-
-		tickN(bt, 10)
-		require.Equal(t, 1, baseCallCounter)
-		require.Equal(t, 1, detlaCallCounter)
-
-		tickN(bt, 10) // 10 more ticks must not affect counters
-		require.Equal(t, 1, baseCallCounter)
-		require.Equal(t, 1, detlaCallCounter)
-	})
 }
 
 func TestBlockTimer_TickSameHeight(t *testing.T) {
-	var baseCounter, deltaCounter int
+	var baseCounter int
 
 	blockDur := uint32(2)
 	bt := timer.NewBlockTimer(
 		func() (uint32, error) { return blockDur, nil },
 		func() { baseCounter++ })
-	bt.OnDelta(2, 1, func() {
-		deltaCounter++
-	})
 	require.NoError(t, bt.Reset())
 
-	check := func(t *testing.T, h uint32, base, delta int) {
+	check := func(t *testing.T, h uint32, base int) {
 		for range 2 * int(blockDur) {
 			bt.Tick(h)
 			require.Equal(t, base, baseCounter)
-			require.Equal(t, delta, deltaCounter)
 		}
 	}
 
-	check(t, 1, 0, 0)
+	check(t, 1, 0)
-	check(t, 2, 1, 0)
+	check(t, 2, 1)
-	check(t, 3, 1, 0)
+	check(t, 3, 1)
-	check(t, 4, 2, 1)
+	check(t, 4, 2)
 
 	t.Run("works the same way after `Reset()`", func(t *testing.T) {
 		t.Run("same block duration", func(t *testing.T) {
 			require.NoError(t, bt.Reset())
 			baseCounter = 0
-			deltaCounter = 0
 
-			check(t, 1, 0, 0)
+			check(t, 1, 0)
-			check(t, 2, 1, 0)
+			check(t, 2, 1)
-			check(t, 3, 1, 0)
+			check(t, 3, 1)
-			check(t, 4, 2, 1)
+			check(t, 4, 2)
 		})
 		t.Run("different block duration", func(t *testing.T) {
 			blockDur = 3
 
 			require.NoError(t, bt.Reset())
 			baseCounter = 0
-			deltaCounter = 0
 
-			check(t, 1, 0, 0)
+			check(t, 1, 0)
-			check(t, 2, 0, 0)
+			check(t, 2, 0)
-			check(t, 3, 1, 0)
+			check(t, 3, 1)
-			check(t, 4, 1, 0)
+			check(t, 4, 1)
-			check(t, 5, 1, 0)
+			check(t, 5, 1)
-			check(t, 6, 2, 1)
+			check(t, 6, 2)
 		})
 	})
 }