websocket/gateio: Add request functions for websocket multi-connection [SPOT] (#1598)

* 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 * stream match update * update tests * linter: fix * glorious: nits + handle context cancellations * 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. * glorious: whooops * gk: nits * Leak issue and edge case * Websocket: Add SendMessageReturnResponses * whooooooopsie * gk: nitssssss * Update exchanges/stream/stream_match.go Co-authored-by: Gareth Kirwan <gbjkirwan@gmail.com> * Update exchanges/stream/stream_match_test.go Co-authored-by: Gareth Kirwan <gbjkirwan@gmail.com> * linter: appease the linter gods * gk: nits * gk: drain brain * started * more changes before merge match pr * gateio: still building out * gateio: finish spot * fix up tests in gateio * Add tests for stream package * rm unused field * glorious: nits * rn files, specifically set function names to asset and offload routing to websocket type. * linter: fix * glorious: nits * add counter and update gateio * fix collision issue * 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 * upgrade to upstream merge * 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 * dont need to make consecutive Unix() calls * websocket: fix potential panic on error and no responses and adding waitForResponses * rm json parser and handle in json package instead * linter: fix * linter: fix again * * change field name OutboundRequestSignature to WrapperDefinedConnectionSignature for agnostic inbound and outbound connections. * change method name GetOutboundConnection to GetConnection for agnostic inbound and outbound connections. * drop outbound field map for improved performance just using a range and field check (less complex as well) * change field name connections to connectionToWrapper for better clarity * spells and magic and wands * glorious: nits * comparable check for signature * mv err var * glorious: nits and stuff * attempt to fix race * glorious: nits * gk: nits; engine log cleanup * gk: nits; OCD * gk: nits; move function change file names * gk: nits; 🚀 * gk: nits; convert variadic function and message inspection to interface and include a specific function for that handling so as to not need nil on every call * gk: nits; continued * gk: engine nits; rm loaded exchange * gk: nits; drop WebsocketLoginResponse * stream: Add match method EnsureMatchWithData * gk: nits; rn Inspect to IsFinal * gk: nits; rn to MessageFilter * linter: fix * gateio: update rate limit definitions (cherry-pick) * Add test and missing * Shared REST rate limit definitions with Websocket service, set lookup item to nil for systems that do not require rate limiting; add glorious nit * integrate rate limits for websocket trading spot * bitstamp: fix issue * glorious: nits * ch name and commentary * fix bug add test * rm a thing * fix test * Update engine/engine.go Co-authored-by: Adrian Gallagher <adrian.gallagher@thrasher.io> * thrasher: nits * Update exchanges/stream/stream_match_test.go Co-authored-by: Adrian Gallagher <adrian.gallagher@thrasher.io> * Update exchanges/stream/stream_match_test.go Co-authored-by: Adrian Gallagher <adrian.gallagher@thrasher.io> * GK: nits rn websocket functions * explicit function names for single to multi outbound orders * linter: fix --------- Co-authored-by: shazbert <ryan.oharareid@thrasher.io> Co-authored-by: Gareth Kirwan <gbjkirwan@gmail.com> Co-authored-by: Scott <gloriousCode@users.noreply.github.com> Co-authored-by: Adrian Gallagher <adrian.gallagher@thrasher.io>
2026-05-30 07:26:46 +00:00 · 2024-12-20 13:50:31 +11:00
parent 143e336c03
commit 50448ec6a0
23 changed files with 951 additions and 103 deletions
--- a/exchanges/stream/stream_match.go
+++ b/exchanges/stream/stream_match.go
@@ -2,9 +2,13 @@ package stream

 import (
 	"errors"
+	"fmt"
 	"sync"
 )

+// ErrSignatureNotMatched is returned when a signature does not match a request
+var ErrSignatureNotMatched = errors.New("websocket response to request signature not matched")
+
 var (
 	errSignatureCollision = errors.New("signature collision")
 	errInvalidBufferSize  = errors.New("buffer size must be positive")
@@ -47,6 +51,15 @@ func (m *Match) IncomingWithData(signature any, data []byte) bool {
 	return true
 }

+// RequireMatchWithData validates that incoming data matches a request's signature.
+// If a match is found, the data is processed; otherwise, it returns an error.
+func (m *Match) RequireMatchWithData(signature any, data []byte) error {
+	if m.IncomingWithData(signature, data) {
+		return nil
+	}
+	return fmt.Errorf("'%v' %w with data %v", signature, ErrSignatureNotMatched, string(data))
+}
+
 // Set the signature response channel for incoming data
 func (m *Match) Set(signature any, bufSize int) (<-chan []byte, error) {
 	if bufSize <= 0 {
--- a/exchanges/stream/stream_match_test.go
+++ b/exchanges/stream/stream_match_test.go
@@ -51,3 +51,18 @@ func TestRemoveSignature(t *testing.T) {
 		t.Fatal("Should be able to read from a closed channel")
 	}
 }
+
+func TestRequireMatchWithData(t *testing.T) {
+	t.Parallel()
+	match := NewMatch()
+	err := match.RequireMatchWithData("hello", []byte("world"))
+	require.ErrorIs(t, err, ErrSignatureNotMatched, "Must error on unmatched signature")
+	assert.Contains(t, err.Error(), "world", "Should contain the data in the error message")
+	assert.Contains(t, err.Error(), "hello", "Should contain the signature in the error message")
+
+	ch, err := match.Set("hello", 1)
+	require.NoError(t, err, "Set must not error")
+	err = match.RequireMatchWithData("hello", []byte("world"))
+	require.NoError(t, err, "Must not error on matched signature")
+	assert.Equal(t, "world", string(<-ch))
+}
--- a/exchanges/stream/stream_types.go
+++ b/exchanges/stream/stream_types.go
@@ -27,6 +27,8 @@ type Connection interface {
 	SendMessageReturnResponse(ctx context.Context, epl request.EndpointLimit, signature any, request any) ([]byte, error)
 	// SendMessageReturnResponses will send a WS message to the connection and wait for N responses
 	SendMessageReturnResponses(ctx context.Context, epl request.EndpointLimit, signature any, request any, expected int) ([][]byte, error)
+	// SendMessageReturnResponsesWithInspector will send a WS message to the connection and wait for N responses with message inspection
+	SendMessageReturnResponsesWithInspector(ctx context.Context, epl request.EndpointLimit, signature any, request any, expected int, messageInspector Inspector) ([][]byte, error)
 	// SendRawMessage sends a message over the connection without JSON encoding it
 	SendRawMessage(ctx context.Context, epl request.EndpointLimit, messageType int, message []byte) error
 	// SendJSONMessage sends a JSON encoded message over the connection
@@ -37,6 +39,12 @@ type Connection interface {
 	Shutdown() error
 }

+// Inspector is used to verify messages via SendMessageReturnResponsesWithInspection
+// It inspects the []bytes websocket message and returns true if the message is the final message in a sequence of expected messages
+type Inspector interface {
+	IsFinal([]byte) bool
+}
+
 // Response defines generalised data from the stream connection
 type Response struct {
 	Type int
@@ -76,6 +84,11 @@ type ConnectionSetup struct {
 	// This is useful for when an exchange connection requires a unique or
 	// structured message ID for each message sent.
 	BespokeGenerateMessageID func(highPrecision bool) int64
+	// Authenticate will be called to authenticate the connection
+	Authenticate func(ctx context.Context, conn Connection) error
+	// MessageFilter defines the criteria used to match messages to a specific connection.
+	// The filter enables precise routing and handling of messages for distinct connection contexts.
+	MessageFilter any
 }

 // ConnectionWrapper contains the connection setup details to be used when
--- a/exchanges/stream/websocket.go
+++ b/exchanges/stream/websocket.go
@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"net/url"
+	"reflect"
 	"slices"
 	"sync"
 	"time"
@@ -27,8 +28,10 @@ var (
 	ErrUnsubscribeFailure       = errors.New("unsubscribe failure")
 	ErrAlreadyDisabled          = errors.New("websocket already disabled")
 	ErrNotConnected             = errors.New("websocket is not connected")
-	ErrNoMessageListener        = errors.New("websocket listener not found for message")
 	ErrSignatureTimeout         = errors.New("websocket timeout waiting for response with signature")
+	ErrRequestRouteNotFound     = errors.New("request route not found")
+	ErrSignatureNotSet          = errors.New("signature not set")
+	ErrRequestPayloadNotSet     = errors.New("request payload not set")
 )

 // Private websocket errors
@@ -64,6 +67,9 @@ var (
 	errConnectionWrapperDuplication         = errors.New("connection wrapper duplication")
 	errCannotChangeConnectionURL            = errors.New("cannot change connection URL when using multi connection management")
 	errExchangeConfigEmpty                  = errors.New("exchange config is empty")
+	errCannotObtainOutboundConnection       = errors.New("cannot obtain outbound connection")
+	errMessageFilterNotSet                  = errors.New("message filter not set")
+	errMessageFilterNotComparable           = errors.New("message filter is not comparable")
 )

 var globalReporter Reporter
@@ -259,13 +265,19 @@ func (w *Websocket) SetupNewConnection(c *ConnectionSetup) error {
 			return fmt.Errorf("%w: %w", errConnSetup, errWebsocketDataHandlerUnset)
 		}

+		if c.MessageFilter != nil && !reflect.TypeOf(c.MessageFilter).Comparable() {
+			return errMessageFilterNotComparable
+		}
+
 		for x := range w.connectionManager {
-			if w.connectionManager[x].Setup.URL == c.URL {
+			// Below allows for multiple connections to the same URL with different outbound request signatures. This
+			// allows for easier determination of inbound and outbound messages. e.g. Gateio cross_margin, margin on
+			// a spot connection.
+			if w.connectionManager[x].Setup.URL == c.URL && c.MessageFilter == w.connectionManager[x].Setup.MessageFilter {
 				return fmt.Errorf("%w: %w", errConnSetup, errConnectionWrapperDuplication)
 			}
 		}
-
-		w.connectionManager = append(w.connectionManager, ConnectionWrapper{
+		w.connectionManager = append(w.connectionManager, &ConnectionWrapper{
 			Setup:         c,
 			Subscriptions: subscription.NewStore(),
 		})
@@ -422,12 +434,21 @@ func (w *Websocket) connect() error {
 			break
 		}

-		w.connections[conn] = &w.connectionManager[i]
+		w.connections[conn] = w.connectionManager[i]
 		w.connectionManager[i].Connection = conn

 		w.Wg.Add(1)
 		go w.Reader(context.TODO(), conn, w.connectionManager[i].Setup.Handler)

+		if w.connectionManager[i].Setup.Authenticate != nil && w.CanUseAuthenticatedEndpoints() {
+			err = w.connectionManager[i].Setup.Authenticate(context.TODO(), conn)
+			if err != nil {
+				// Opted to not fail entirely here for POC. This should be
+				// revisited and handled more gracefully.
+				log.Errorf(log.WebsocketMgr, "%s websocket: [conn:%d] [URL:%s] failed to authenticate %v", w.exchangeName, i+1, conn.URL, err)
+			}
+		}
+
 		err = w.connectionManager[i].Setup.Subscriber(context.TODO(), conn, subs)
 		if err != nil {
 			multiConnectFatalError = fmt.Errorf("%v Error subscribing %w", w.exchangeName, err)
@@ -633,7 +654,7 @@ func (w *Websocket) FlushChannels() error {
 			}
 			w.Wg.Add(1)
 			go w.Reader(context.TODO(), conn, w.connectionManager[x].Setup.Handler)
-			w.connections[conn] = &w.connectionManager[x]
+			w.connections[conn] = w.connectionManager[x]
 			w.connectionManager[x].Connection = conn
 		}

@@ -1064,7 +1085,7 @@ func (w *Websocket) checkSubscriptions(conn Connection, subs subscription.List)
 		if s.State() == subscription.ResubscribingState {
 			continue
 		}
-		if found := w.subscriptions.Get(s); found != nil {
+		if found := subscriptionStore.Get(s); found != nil {
 			return fmt.Errorf("%w: %s", subscription.ErrDuplicate, s)
 		}
 	}
@@ -1241,3 +1262,37 @@ func signalReceived(ch chan struct{}) bool {
 		return false
 	}
 }
+
+// GetConnection returns a connection by message filter (defined in exchange package _wrapper.go websocket connection)
+// for request and response handling in a multi connection context.
+func (w *Websocket) GetConnection(messageFilter any) (Connection, error) {
+	if w == nil {
+		return nil, fmt.Errorf("%w: %T", common.ErrNilPointer, w)
+	}
+
+	if messageFilter == nil {
+		return nil, errMessageFilterNotSet
+	}
+
+	w.m.Lock()
+	defer w.m.Unlock()
+
+	if !w.useMultiConnectionManagement {
+		return nil, fmt.Errorf("%s: multi connection management not enabled %w please use exported Conn and AuthConn fields", w.exchangeName, errCannotObtainOutboundConnection)
+	}
+
+	if !w.IsConnected() {
+		return nil, ErrNotConnected
+	}
+
+	for _, wrapper := range w.connectionManager {
+		if wrapper.Setup.MessageFilter == messageFilter {
+			if wrapper.Connection == nil {
+				return nil, fmt.Errorf("%s: %s %w associated with message filter: '%v'", w.exchangeName, wrapper.Setup.URL, ErrNotConnected, messageFilter)
+			}
+			return wrapper.Connection, nil
+		}
+	}
+
+	return nil, fmt.Errorf("%s: %w associated with message filter: '%v'", w.exchangeName, ErrRequestRouteNotFound, messageFilter)
+}
--- a/exchanges/stream/websocket_connection.go
+++ b/exchanges/stream/websocket_connection.go
@@ -304,6 +304,12 @@ func (w *WebsocketConnection) SendMessageReturnResponse(ctx context.Context, epl
 // SendMessageReturnResponses will send a WS message to the connection and wait for N responses
 // An error of ErrSignatureTimeout can be ignored if individual responses are being otherwise tracked
 func (w *WebsocketConnection) SendMessageReturnResponses(ctx context.Context, epl request.EndpointLimit, signature, payload any, expected int) ([][]byte, error) {
+	return w.SendMessageReturnResponsesWithInspector(ctx, epl, signature, payload, expected, nil)
+}
+
+// SendMessageReturnResponsesWithInspector will send a WS message to the connection and wait for N responses
+// An error of ErrSignatureTimeout can be ignored if individual responses are being otherwise tracked
+func (w *WebsocketConnection) SendMessageReturnResponsesWithInspector(ctx context.Context, epl request.EndpointLimit, signature, payload any, expected int, messageInspector Inspector) ([][]byte, error) {
 	outbound, err := json.Marshal(payload)
 	if err != nil {
 		return nil, fmt.Errorf("error marshaling json for %s: %w", signature, err)
@@ -320,28 +326,43 @@ func (w *WebsocketConnection) SendMessageReturnResponses(ctx context.Context, ep
 		return nil, err
 	}

+	resps, err := w.waitForResponses(ctx, signature, ch, expected, messageInspector)
+	if err != nil {
+		return nil, err
+	}
+
+	if w.Reporter != nil {
+		w.Reporter.Latency(w.ExchangeName, outbound, time.Since(start))
+	}
+
+	return resps, err
+}
+
+// waitForResponses waits for N responses from a channel
+func (w *WebsocketConnection) waitForResponses(ctx context.Context, signature any, ch <-chan []byte, expected int, messageInspector Inspector) ([][]byte, error) {
 	timeout := time.NewTimer(w.ResponseMaxLimit * time.Duration(expected))
+	defer timeout.Stop()

 	resps := make([][]byte, 0, expected)
-	for err == nil && len(resps) < expected {
+inspection:
+	for range expected {
 		select {
 		case resp := <-ch:
 			resps = append(resps, resp)
+			// Checks recently received message to determine if this is in fact the final message in a sequence of messages.
+			if messageInspector != nil && messageInspector.IsFinal(resp) {
+				w.Match.RemoveSignature(signature)
+				break inspection
+			}
 		case <-timeout.C:
 			w.Match.RemoveSignature(signature)
-			err = fmt.Errorf("%s %w %v", w.ExchangeName, ErrSignatureTimeout, signature)
+			return nil, fmt.Errorf("%s %w %v", w.ExchangeName, ErrSignatureTimeout, signature)
 		case <-ctx.Done():
 			w.Match.RemoveSignature(signature)
-			err = ctx.Err()
+			return nil, ctx.Err()
 		}
 	}

-	timeout.Stop()
-
-	if err == nil && w.Reporter != nil {
-		w.Reporter.Latency(w.ExchangeName, outbound, time.Since(start))
-	}
-
 	// Only check context verbosity. If the exchange is verbose, it will log the responses in the ReadMessage() call.
 	if request.IsVerbose(ctx, false) {
 		for i := range resps {
@@ -349,7 +370,7 @@ func (w *WebsocketConnection) SendMessageReturnResponses(ctx context.Context, ep
 		}
 	}

-	return resps, err
+	return resps, nil
 }

 func removeURLQueryString(url string) string {
--- a/exchanges/stream/websocket_test.go
+++ b/exchanges/stream/websocket_test.go
@@ -223,13 +223,16 @@ func TestConnectionMessageErrors(t *testing.T) {
 	assert.ErrorIs(t, err, errNoPendingConnections, "Connect should error correctly")

 	ws.useMultiConnectionManagement = true
+	ws.SetCanUseAuthenticatedEndpoints(true)

 	mock := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { mockws.WsMockUpgrader(t, w, r, mockws.EchoHandler) }))
 	defer mock.Close()
-	ws.connectionManager = []ConnectionWrapper{{Setup: &ConnectionSetup{URL: "ws" + mock.URL[len("http"):] + "/ws"}}}
+	ws.connectionManager = []*ConnectionWrapper{{Setup: &ConnectionSetup{URL: "ws" + mock.URL[len("http"):] + "/ws"}}}
 	err = ws.Connect()
 	require.ErrorIs(t, err, errWebsocketSubscriptionsGeneratorUnset)

+	ws.connectionManager[0].Setup.Authenticate = func(context.Context, Connection) error { return errDastardlyReason }
+
 	ws.connectionManager[0].Setup.GenerateSubscriptions = func() (subscription.List, error) {
 		return nil, errDastardlyReason
 	}
@@ -371,7 +374,7 @@ func TestWebsocket(t *testing.T) {

 	ws.useMultiConnectionManagement = true

-	ws.connectionManager = []ConnectionWrapper{{Setup: &ConnectionSetup{URL: "ws://demos.kaazing.com/echo"}, Connection: &WebsocketConnection{}}}
+	ws.connectionManager = []*ConnectionWrapper{{Setup: &ConnectionSetup{URL: "ws://demos.kaazing.com/echo"}, Connection: &WebsocketConnection{}}}
 	err = ws.SetProxyAddress("https://192.168.0.1:1337")
 	require.NoError(t, err)
 }
@@ -464,7 +467,7 @@ func TestSubscribeUnsubscribe(t *testing.T) {

 	amazingConn := multi.getConnectionFromSetup(amazingCandidate)
 	multi.connections = map[Connection]*ConnectionWrapper{
-		amazingConn: &multi.connectionManager[0],
+		amazingConn: multi.connectionManager[0],
 	}

 	subs, err = amazingCandidate.GenerateSubscriptions()
@@ -761,8 +764,43 @@ func TestSendMessageReturnResponse(t *testing.T) {
 	wc.ResponseMaxLimit = 1
 	_, err = wc.SendMessageReturnResponse(context.Background(), request.Unset, "123", req)
 	assert.ErrorIs(t, err, ErrSignatureTimeout, "SendMessageReturnResponse should error when request ID not found")
+
+	_, err = wc.SendMessageReturnResponsesWithInspector(context.Background(), request.Unset, "123", req, 1, inspection{})
+	assert.ErrorIs(t, err, ErrSignatureTimeout, "SendMessageReturnResponse should error when request ID not found")
 }

+func TestWaitForResponses(t *testing.T) {
+	t.Parallel()
+	dummy := &WebsocketConnection{
+		ResponseMaxLimit: time.Nanosecond,
+		Match:            NewMatch(),
+	}
+	_, err := dummy.waitForResponses(context.Background(), "silly", nil, 1, inspection{})
+	require.ErrorIs(t, err, ErrSignatureTimeout)
+
+	dummy.ResponseMaxLimit = time.Second
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	_, err = dummy.waitForResponses(ctx, "silly", nil, 1, inspection{})
+	require.ErrorIs(t, err, context.Canceled)
+
+	// test break early and hit verbose path
+	ch := make(chan []byte, 1)
+	ch <- []byte("hello")
+	ctx = request.WithVerbose(context.Background())
+
+	got, err := dummy.waitForResponses(ctx, "silly", ch, 2, inspection{breakEarly: true})
+	require.NoError(t, err)
+	require.Len(t, got, 1)
+	assert.Equal(t, "hello", string(got[0]))
+}
+
+type inspection struct {
+	breakEarly bool
+}
+
+func (i inspection) IsFinal([]byte) bool { return i.breakEarly }
+
 type reporter struct {
 	name string
 	msg  []byte
@@ -1229,6 +1267,11 @@ func TestSetupNewConnection(t *testing.T) {
 	require.ErrorIs(t, err, errWebsocketDataHandlerUnset)

 	connSetup.Handler = func(context.Context, []byte) error { return nil }
+	connSetup.MessageFilter = []string{"slices are super naughty and not comparable"}
+	err = multi.SetupNewConnection(connSetup)
+	require.ErrorIs(t, err, errMessageFilterNotComparable)
+
+	connSetup.MessageFilter = "comparable string signature"
 	err = multi.SetupNewConnection(connSetup)
 	require.NoError(t, err)

@@ -1484,3 +1527,42 @@ func TestMonitorTraffic(t *testing.T) {
 	ws.TrafficAlert <- struct{}{}
 	require.False(t, innerShell())
 }
+
+func TestGetConnection(t *testing.T) {
+	t.Parallel()
+	var ws *Websocket
+	_, err := ws.GetConnection(nil)
+	require.ErrorIs(t, err, common.ErrNilPointer)
+
+	ws = &Websocket{}
+
+	_, err = ws.GetConnection(nil)
+	require.ErrorIs(t, err, errMessageFilterNotSet)
+
+	_, err = ws.GetConnection("testURL")
+	require.ErrorIs(t, err, errCannotObtainOutboundConnection)
+
+	ws.useMultiConnectionManagement = true
+
+	_, err = ws.GetConnection("testURL")
+	require.ErrorIs(t, err, ErrNotConnected)
+
+	ws.setState(connectedState)
+
+	_, err = ws.GetConnection("testURL")
+	require.ErrorIs(t, err, ErrRequestRouteNotFound)
+
+	ws.connectionManager = []*ConnectionWrapper{{
+		Setup: &ConnectionSetup{MessageFilter: "testURL", URL: "testURL"},
+	}}
+
+	_, err = ws.GetConnection("testURL")
+	require.ErrorIs(t, err, ErrNotConnected)
+
+	expected := &WebsocketConnection{}
+	ws.connectionManager[0].Connection = expected
+
+	conn, err := ws.GetConnection("testURL")
+	require.NoError(t, err)
+	assert.Same(t, expected, conn)
+}
--- a/exchanges/stream/websocket_types.go
+++ b/exchanges/stream/websocket_types.go
@@ -54,7 +54,7 @@ type Websocket struct {
 	// For example, separate connections can be used for Spot, Margin, and Futures trading. This structure is especially useful
 	// for exchanges that differentiate between trading pairs by using different connection endpoints or protocols for various asset classes.
 	// If an exchange does not require such differentiation, all connections may be managed under a single ConnectionWrapper.
-	connectionManager []ConnectionWrapper
+	connectionManager []*ConnectionWrapper
 	// connections holds a look up table for all connections to their corresponding ConnectionWrapper and subscription holder
 	connections map[Connection]*ConnectionWrapper