websocket/gateio: Support multi connection management and integrate with GateIO (#1580)

* gateio: Add multi asset websocket support WIP.

* meow

* Add tests and shenanigans

* integrate flushing and for enabling/disabling pairs from rpc shenanigans

* some changes

* linter: fixes strikes again.

* Change name ConnectionAssociation -> ConnectionCandidate for better clarity on purpose. Change connections map to point to candidate to track subscriptions for future dynamic connections holder and drop struct ConnectionDetails.

* Add subscription tests (state functional)

* glorious:nits + proxy handling

* Spelling

* linter: fixerino

* instead of nil, dont do nil.

* clean up nils

* cya nils

* don't need to set URL or check if its running

* stop ping handler routine leak

* * Fix bug where reader routine on error that is not a disconnection error but websocket frame error or anything really makes the reader routine return and then connection never cycles and the buffer gets filled.
* Handle reconnection via an errors.Is check which is simpler and in that scope allow for quick disconnect reconnect without waiting for connection cycle.
* Dial now uses code from DialContext but just calls context.Background()
* Don't allow reader to return on parse binary response error. Just output error and return a non nil response

* Allow rollback on connect on any error across all connections

* fix shadow jutsu

* glorious/gk: nitters - adds in ws mock server

* linter: fix

* fix deadlock on connection as the previous channel had no reader and would hang connection reader for eternity.

* gk: nits

* Leak issue and edge case

* gk: nits

* gk: drain brain

* glorious: nits

* Update exchanges/stream/websocket.go

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

* glorious: nits

* add tests

* linter: fix

* After merge

* Add error connection info

* Fix edge case where it does not reconnect made by an already closed connection

* stream coverage

* glorious: nits

* glorious: nits removed asset error handling in stream package

* linter: fix

* rm block

* Add basic readme

* fix asset enabled flush cycle for multi connection

* spella: fix

* linter: fix

* Add glorious suggestions, fix some race thing

* reinstate name before any routine gets spawned

* stop on error in mock tests

* glorious: nits

* glorious: nits found in CI build

* Add test for drain, bumped wait times as there seems to be something happening on macos CI builds, used context.WithTimeout because its instant.

* mutex across shutdown and connect for protection

* lint: fix

* test time withoffset, reinstate stop

* fix whoops

* const trafficCheckInterval; rm testmain

* y

* fix lint

* bump time check window

* stream: fix intermittant test failures while testing routines and remove code that is not needed.

* spells

* cant do what I did

* protect race due to routine.

* update testURL

* use mock websocket connection instead of test URL's

* linter: fix

* remove url because its throwing errors on CI builds

* connections drop all the time, don't need to worry about not being able to echo back ws data as it can be easily reviewed _test file side.

* remove another superfluous url thats not really set up for this

* spawn overwatch routine when there is no errors, inline checker instead of waiting for a time period, add sleep inline with echo handler as this is really quick and wanted to ensure that latency is handing correctly

* linter: fixerino uperino

* glorious: panix

* linter: things

* whoops

* defer lock and use functions that don't require locking in SetProxyAddress

* lint: fix

* thrasher: nits

---------

Co-authored-by: shazbert <ryan.oharareid@thrasher.io>
Co-authored-by: Scott <gloriousCode@users.noreply.github.com>

internal/testing/exchange/exchange.go

@@ -14,7 +14,6 @@ import (
 	"sync"
 	"testing"
 
-	"github.com/gorilla/websocket"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/thrasher-corp/gocryptotrader/config"
@@ -86,11 +85,6 @@ func MockHTTPInstance(e exchange.IBotExchange) error {
 	return nil
 }
 
-var upgrader = websocket.Upgrader{}
-
-// WsMockFunc is a websocket handler to be called with each websocket message
-type WsMockFunc func(testing.TB, []byte, *websocket.Conn) error
-
 // MockWsInstance creates a new Exchange instance with a mock websocket instance and HTTP server
 // It accepts an exchange package type argument and a http.HandlerFunc
 // See CurryWsMockUpgrader for a convenient way to curry t and a ws mock function
@@ -128,33 +122,6 @@ func MockWsInstance[T any, PT interface {
 	return e
 }
 
-// CurryWsMockUpgrader curries a WsMockUpgrader with a testing.TB and a mock func
-// bridging the gap between information known before the Server is created and during a request
-func CurryWsMockUpgrader(tb testing.TB, wsHandler WsMockFunc) http.HandlerFunc {
-	tb.Helper()
-	return func(w http.ResponseWriter, r *http.Request) {
-		WsMockUpgrader(tb, w, r, wsHandler)
-	}
-}
-
-// WsMockUpgrader handles upgrading an initial HTTP request to WS, and then runs a for loop calling the mock func on each input
-func WsMockUpgrader(tb testing.TB, w http.ResponseWriter, r *http.Request, wsHandler WsMockFunc) {
-	tb.Helper()
-	c, err := upgrader.Upgrade(w, r, nil)
-	require.NoError(tb, err, "Upgrade connection should not error")
-	defer c.Close()
-	for {
-		_, p, err := c.ReadMessage()
-		if websocket.IsUnexpectedCloseError(err) {
-			return
-		}
-		require.NoError(tb, err, "ReadMessage should not error")
-
-		err = wsHandler(tb, p, c)
-		assert.NoError(tb, err, "WS Mock Function should not error")
-	}
-}
-
 // FixtureToDataHandler squirts the contents of a file to a reader function (probably e.wsHandleData)
 func FixtureToDataHandler(tb testing.TB, fixturePath string, reader func([]byte) error) {
 	tb.Helper()

internal/testing/exchange/exchange_test.go

@@ -9,6 +9,7 @@ import (
 	"github.com/thrasher-corp/gocryptotrader/config"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/binance"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/sharedtestvalues"
+	mockws "github.com/thrasher-corp/gocryptotrader/internal/testing/websocket"
 )
 
 // TestSetup exercises Setup
@@ -30,6 +31,6 @@ func TestMockHTTPInstance(t *testing.T) {
 
 // TestMockWsInstance exercises MockWsInstance
 func TestMockWsInstance(t *testing.T) {
-	b := MockWsInstance[binance.Binance](t, CurryWsMockUpgrader(t, func(_ testing.TB, _ []byte, _ *websocket.Conn) error { return nil }))
+	b := MockWsInstance[binance.Binance](t, mockws.CurryWsMockUpgrader(t, func(_ testing.TB, _ []byte, _ *websocket.Conn) error { return nil }))
 	require.NotNil(t, b, "MockWsInstance must not be nil")
 }

internal/testing/websocket/mock.go

@@ -0,0 +1,49 @@
+package websocket
+
+import (
+	"net/http"
+	"testing"
+	"time"
+
+	"github.com/gorilla/websocket"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+var upgrader = websocket.Upgrader{CheckOrigin: func(_ *http.Request) bool { return true }}
+
+// WsMockFunc is a websocket handler to be called with each websocket message
+type WsMockFunc func(testing.TB, []byte, *websocket.Conn) error
+
+// CurryWsMockUpgrader curries a WsMockUpgrader with a testing.TB and a mock func
+// bridging the gap between information known before the Server is created and during a request
+func CurryWsMockUpgrader(tb testing.TB, wsHandler WsMockFunc) http.HandlerFunc {
+	tb.Helper()
+	return func(w http.ResponseWriter, r *http.Request) {
+		WsMockUpgrader(tb, w, r, wsHandler)
+	}
+}
+
+// WsMockUpgrader handles upgrading an initial HTTP request to WS, and then runs a for loop calling the mock func on each input
+func WsMockUpgrader(tb testing.TB, w http.ResponseWriter, r *http.Request, wsHandler WsMockFunc) {
+	tb.Helper()
+	c, err := upgrader.Upgrade(w, r, nil)
+	require.NoError(tb, err, "Upgrade connection should not error")
+	defer c.Close()
+	for {
+		_, p, err := c.ReadMessage()
+		if err != nil {
+			// Any error here is likely due to the connection closing
+			return
+		}
+		err = wsHandler(tb, p, c)
+		assert.NoError(tb, err, "WS Mock Function should not error")
+	}
+}
+
+// EchoHandler is a simple echo function after a read, this doesn't need to worry if writing to the connection fails
+func EchoHandler(_ testing.TB, p []byte, c *websocket.Conn) error {
+	time.Sleep(time.Nanosecond) // Shift clock to simulate time passing
+	_ = c.WriteMessage(websocket.TextMessage, p)
+	return nil
+}