libs/common: Refactor libs/common 4 (#4237)

* libs/common: Refactor libs/common 4

- move byte function out of cmn to its own pkg
- move tempfile out of cmn to its own pkg
- move throttletimer to its own pkg

ref #4147

Signed-off-by: Marko Baricevic <marbar3778@yahoo.com>

* add changelog entry

* fix linting issues

libs/timer/throttle_timer.go

@@ -0,0 +1,75 @@
+package timer
+
+import (
+	"sync"
+	"time"
+)
+
+/*
+ThrottleTimer fires an event at most "dur" after each .Set() call.
+If a short burst of .Set() calls happens, ThrottleTimer fires once.
+If a long continuous burst of .Set() calls happens, ThrottleTimer fires
+at most once every "dur".
+*/
+type ThrottleTimer struct {
+	Name string
+	Ch   chan struct{}
+	quit chan struct{}
+	dur  time.Duration
+
+	mtx   sync.Mutex
+	timer *time.Timer
+	isSet bool
+}
+
+func NewThrottleTimer(name string, dur time.Duration) *ThrottleTimer {
+	var ch = make(chan struct{})
+	var quit = make(chan struct{})
+	var t = &ThrottleTimer{Name: name, Ch: ch, dur: dur, quit: quit}
+	t.mtx.Lock()
+	t.timer = time.AfterFunc(dur, t.fireRoutine)
+	t.mtx.Unlock()
+	t.timer.Stop()
+	return t
+}
+
+func (t *ThrottleTimer) fireRoutine() {
+	t.mtx.Lock()
+	defer t.mtx.Unlock()
+	select {
+	case t.Ch <- struct{}{}:
+		t.isSet = false
+	case <-t.quit:
+		// do nothing
+	default:
+		t.timer.Reset(t.dur)
+	}
+}
+
+func (t *ThrottleTimer) Set() {
+	t.mtx.Lock()
+	defer t.mtx.Unlock()
+	if !t.isSet {
+		t.isSet = true
+		t.timer.Reset(t.dur)
+	}
+}
+
+func (t *ThrottleTimer) Unset() {
+	t.mtx.Lock()
+	defer t.mtx.Unlock()
+	t.isSet = false
+	t.timer.Stop()
+}
+
+// For ease of .Stop()'ing services before .Start()'ing them,
+// we ignore .Stop()'s on nil ThrottleTimers
+func (t *ThrottleTimer) Stop() bool {
+	if t == nil {
+		return false
+	}
+	close(t.quit)
+	t.mtx.Lock()
+	defer t.mtx.Unlock()
+	return t.timer.Stop()
+}

libs/timer/throttle_timer_test.go

@@ -0,0 +1,79 @@
+package timer
+
+import (
+	"sync"
+	"testing"
+	"time"
+
+	// make govet noshadow happy...
+
+	asrt "github.com/stretchr/testify/assert"
+)
+
+type thCounter struct {
+	input chan struct{}
+	mtx   sync.Mutex
+	count int
+}
+
+func (c *thCounter) Increment() {
+	c.mtx.Lock()
+	c.count++
+	c.mtx.Unlock()
+}
+
+func (c *thCounter) Count() int {
+	c.mtx.Lock()
+	val := c.count
+	c.mtx.Unlock()
+	return val
+}
+
+// Read should run in a go-routine and
+// updates count by one every time a packet comes in
+func (c *thCounter) Read() {
+	for range c.input {
+		c.Increment()
+	}
+}
+
+func TestThrottle(test *testing.T) {
+	assert := asrt.New(test)
+
+	ms := 50
+	delay := time.Duration(ms) * time.Millisecond
+	longwait := time.Duration(2) * delay
+	t := NewThrottleTimer("foo", delay)
+
+	// start at 0
+	c := &thCounter{input: t.Ch}
+	assert.Equal(0, c.Count())
+	go c.Read()
+
+	// waiting does nothing
+	time.Sleep(longwait)
+	assert.Equal(0, c.Count())
+
+	// send one event adds one
+	t.Set()
+	time.Sleep(longwait)
+	assert.Equal(1, c.Count())
+
+	// send a burst adds one
+	for i := 0; i < 5; i++ {
+		t.Set()
+	}
+	time.Sleep(longwait)
+	assert.Equal(2, c.Count())
+
+	// send 12, over 2 delay sections, adds 3
+	short := time.Duration(ms/5) * time.Millisecond
+	for i := 0; i < 13; i++ {
+		t.Set()
+		time.Sleep(short)
+	}
+	time.Sleep(longwait)
+	assert.Equal(5, c.Count())
+
+	close(t.Ch)
+}