engine/exchanges: Add exchange currency state subsystem (#774)

* state: Add management system (init)

* linter: fix

* engine: gofmt

* gct: after merge fixup

* documentation: add

* rpc: implement services for testing

* gctcli: gofmt state_management.go

* documentation: reinstate lost information

* state: Add pair check to determine trading operation

* exchanges: add interface for specific state scoped subsystem functionality

* engine/order_man: reduce code footprint using new method

* RPC: implement pair trading request and change exported name to something specific to state

* engine: add tests

* engine: Add to withdraw manager

* documentation: reinstate soxipy in contrib. list

* engine: const fake name

* Glorious: NITERINOS

* merge: fix issues

* engine: csm incorporate service name into log output

* engine: fix linter issues

* gct: fix tests

* currencystate: remove management type

* rpc: fix tests

* backtester: fix tests

* Update engine/currency_state_manager.go

Co-authored-by: Scott <gloriousCode@users.noreply.github.com>

* Update engine/currency_state_manager.go

Co-authored-by: Scott <gloriousCode@users.noreply.github.com>

* Update exchanges/currencystate/currency_state.go

Co-authored-by: Scott <gloriousCode@users.noreply.github.com>

* Update exchanges/alert/alert.go

Co-authored-by: Scott <gloriousCode@users.noreply.github.com>

* Update exchanges/alert/alert.go

Co-authored-by: Scott <gloriousCode@users.noreply.github.com>

* glorious: nits

* config: integrate with config and remove flag delay adjustment

* gctcli: fix issues after name changes

* engine: gofmt manager file

* Update engine/rpcserver.go

Co-authored-by: Scott <gloriousCode@users.noreply.github.com>

* engine: Add enable/disable manager functions, add default popoulation for potential assets

* linter: fix

* engine/test: bump subsystem count

* Update engine/currency_state_manager.go

Co-authored-by: Scott <gloriousCode@users.noreply.github.com>

* Update exchanges/bithumb/bithumb.go

Co-authored-by: Scott <gloriousCode@users.noreply.github.com>

* glorious: nits addressed

* alert: fix commenting for its generalized purpose

* glorious: nits

* engine: use standard string in log output

* bitfinex: apply patch, thanks @thrasher-

* bitfinex: fix spelling

* engine/currencystate: Add logs/fix logs

Co-authored-by: Scott <gloriousCode@users.noreply.github.com>

exchanges/alert/alert.go

@@ -0,0 +1,83 @@
+package alert
+
+import (
+	"sync"
+	"sync/atomic"
+)
+
+// Notice defines fields required to alert sub-systems of a change of state so a
+// routine can re-check in memory data
+type Notice struct {
+	// Channel to wait for an alert on.
+	forAlert chan struct{}
+	// Lets the updater functions know if there are any routines waiting for an
+	// alert.
+	sema uint32
+	// After closing the forAlert channel this will notify when all the routines
+	// that have waited, have completed their checks.
+	wg sync.WaitGroup
+	// Segregated lock only for waiting routines, so as this does not interfere
+	// with the main calling lock, this acts as a rolling gate.
+	m sync.Mutex
+}
+
+// Alert establishes a state change on the required struct.
+func (n *Notice) Alert() {
+	// CompareAndSwap is used to swap from 1 -> 2 so we don't keep actuating
+	// the opposing compare and swap in method wait. This function can return
+	// freely when an alert operation is in process.
+	if !atomic.CompareAndSwapUint32(&n.sema, 1, 2) {
+		// Return if no waiting routines or currently alerting.
+		return
+	}
+	go n.actuate()
+}
+
+// Actuate lock in a different routine, as alerting is a second order priority
+// compared to updating and releasing calling routine.
+func (n *Notice) actuate() {
+	n.m.Lock()
+	// Closing; alerts many waiting routines.
+	close(n.forAlert)
+	// Wait for waiting routines to receive alert and return.
+	n.wg.Wait()
+	atomic.SwapUint32(&n.sema, 0) // Swap back to neutral state.
+	n.m.Unlock()
+}
+
+// Wait pauses calling routine until change of state has been established via
+// notice method Alert. Kick allows for cancellation of waiting or when the
+// caller has been shut down, if this is not needed it can be set to nil. This
+// returns a channel so strategies can cleanly wait on a select statement case.
+func (n *Notice) Wait(kick <-chan struct{}) <-chan bool {
+	reply := make(chan bool)
+	n.m.Lock()
+	n.wg.Add(1)
+	if atomic.CompareAndSwapUint32(&n.sema, 0, 1) {
+		n.forAlert = make(chan struct{})
+	}
+	go n.hold(reply, kick)
+	n.m.Unlock()
+	return reply
+}
+
+// hold waits on either channel in the event that the routine has
+// finished/cancelled or an alert from an update has occurred.
+func (n *Notice) hold(ch chan<- bool, kick <-chan struct{}) {
+	select {
+	// In a select statement, if by chance there is no receiver or its late,
+	// we can still close and return, limiting dead-lock potential.
+	case <-n.forAlert: // Main waiting channel from alert
+		select {
+		case ch <- false:
+		default:
+		}
+	case <-kick: // This can be nil.
+		select {
+		case ch <- true:
+		default:
+		}
+	}
+	n.wg.Done()
+	close(ch)
+}

exchanges/alert/alert_test.go

@@ -0,0 +1,92 @@
+package alert
+
+import (
+	"log"
+	"sync"
+	"testing"
+	"time"
+)
+
+func TestWait(t *testing.T) {
+	wait := Notice{}
+	var wg sync.WaitGroup
+
+	// standard alert
+	wg.Add(100)
+	for x := 0; x < 100; x++ {
+		go func() {
+			w := wait.Wait(nil)
+			wg.Done()
+			if <-w {
+				log.Fatal("incorrect routine wait response for alert expecting false")
+			}
+			wg.Done()
+		}()
+	}
+
+	wg.Wait()
+	wg.Add(100)
+	isLeaky(&wait, nil, t)
+	wait.Alert()
+	wg.Wait()
+	isLeaky(&wait, nil, t)
+
+	// use kick
+	ch := make(chan struct{})
+	wg.Add(100)
+	for x := 0; x < 100; x++ {
+		go func() {
+			w := wait.Wait(ch)
+			wg.Done()
+			if !<-w {
+				log.Fatal("incorrect routine wait response for kick expecting true")
+			}
+			wg.Done()
+		}()
+	}
+	wg.Wait()
+	wg.Add(100)
+	isLeaky(&wait, ch, t)
+	close(ch)
+	wg.Wait()
+	ch = make(chan struct{})
+	isLeaky(&wait, ch, t)
+
+	// late receivers
+	wg.Add(100)
+	for x := 0; x < 100; x++ {
+		go func(x int) {
+			bb := wait.Wait(ch)
+			wg.Done()
+			if x%2 == 0 {
+				time.Sleep(time.Millisecond * 5)
+			}
+			b := <-bb
+			if b {
+				log.Fatal("incorrect routine wait response since we call alert below; expecting false")
+			}
+			wg.Done()
+		}(x)
+	}
+	wg.Wait()
+	wg.Add(100)
+	isLeaky(&wait, ch, t)
+	wait.Alert()
+	wg.Wait()
+	isLeaky(&wait, ch, t)
+}
+
+// isLeaky tests to see if the wait functionality is returning an abnormal
+// channel that is operational when it shouldn't be.
+func isLeaky(a *Notice, ch chan struct{}, t *testing.T) {
+	t.Helper()
+	check := a.Wait(ch)
+	time.Sleep(time.Millisecond * 5) // When we call wait a routine for hold is
+	// spawned, so for a test we need to add in a time for goschedular to allow
+	// routine to actually wait on the forAlert and kick channels
+	select {
+	case <-check:
+		t.Fatal("leaky waiter")
+	default:
+	}
+}