Add background connect option to common utility - superseding initialConnectAttempts

Signed-off-by: Peter Broadhurst <peter.broadhurst@kaleido.io>

Author: peterbroadhurst

pkg/config/config.go

@@ -89,10 +89,15 @@ type sectionParent interface {
 	AddChild(key string, defValue ...interface{})
 }
 
+type SectionArrayCommon interface {
+	KeySet
+	SubSection(name string) Section
+}
+
 // Section represents a section of the global configuration, at a nested point in the config hierarchy.
 // Note that all keys are added to a GLOBAL map, so this cannot be used for per-instance customization.
 type Section interface {
-	KeySet
+	SectionArrayCommon
 	SetDefault(key string, defValue interface{})
 	SubSection(name string) Section
 	SubArray(name string) ArraySection

pkg/wsclient/wsclient.go

@@ -46,7 +46,8 @@ type WSConfig struct {
 	InitialDelay              time.Duration      `json:"initialDelay,omitempty"`
 	MaximumDelay              time.Duration      `json:"maximumDelay,omitempty"`
 	DelayFactor               float64            `json:"delayFactor,omitempty"`
-	InitialConnectAttempts    int                `json:"initialConnectAttempts,omitempty"`
+	BackgroundConnect         bool               `json:"backgroundConnect,omitempty"`
+	InitialConnectAttempts    int                `json:"initialConnectAttempts,omitempty"` // recommend backgroundConnect instead
 	DisableReconnect          bool               `json:"disableReconnect"`
 	AuthUsername              string             `json:"authUsername,omitempty"`
 	AuthPassword              string             `json:"authPassword,omitempty"`
@@ -104,6 +105,7 @@ type wsClient struct {
 	ctx                  context.Context
 	headers              http.Header
 	url                  string
+	backgroundConnect    bool
 	initialRetryAttempts int
 	wsdialer             *websocket.Dialer
 	wsconn               *websocket.Conn
@@ -114,6 +116,8 @@ type wsClient struct {
 	receiveExt           chan *WSPayload
 	send                 chan []byte
 	sendDone             chan []byte
+	bgConnCancelCtx      context.CancelFunc
+	bgConnDone           chan struct{}
 	closing              chan struct{}
 	beforeConnect        WSPreConnectHandler
 	afterConnect         WSPostConnectHandler
@@ -153,6 +157,7 @@ func New(ctx context.Context, config *WSConfig, beforeConnect WSPreConnectHandle
 			MaximumDelay: config.MaximumDelay,
 			Factor:       config.DelayFactor,
 		},
+		backgroundConnect:    config.BackgroundConnect,
 		initialRetryAttempts: config.InitialConnectAttempts,
 		headers:              make(http.Header),
 		send:                 make(chan []byte),
@@ -225,12 +230,28 @@ func (w *wsClient) setupReceiveChannel() {
 
 func (w *wsClient) Connect() error {
 
+	if w.backgroundConnect && w.bgConnDone == nil {
+		w.bgConnDone = make(chan struct{})
+		w.ctx, w.bgConnCancelCtx = context.WithCancel(w.ctx)
+		go func() {
+			defer close(w.bgConnDone)
+			err := w.initialConnect()
+			if err != nil {
+				// Retry means we only reach here if context closes
+				log.L(w.ctx).Errorf("Connection to WebSocket %s was never established before shutdown: %s", w.url, err)
+			}
+		}()
+		return nil
+	}
+
+	return w.initialConnect()
+}
+
+func (w *wsClient) initialConnect() error {
 	if err := w.connect(true); err != nil {
 		return err
 	}
-
 	go w.receiveReconnectLoop()
-
 	return nil
 }
 
@@ -242,6 +263,12 @@ func (w *wsClient) Close() {
 		if c != nil {
 			_ = c.Close()
 		}
+		bgc := w.bgConnDone
+		if bgc != nil {
+			w.bgConnCancelCtx()
+			<-w.bgConnDone
+			w.bgConnDone = nil
+		}
 	}
 }
 
@@ -337,7 +364,7 @@ func (w *wsClient) connect(initial bool) error {
 			return false, i18n.NewError(w.ctx, i18n.MsgWSClosing)
 		}
 
-		retry = !initial || attempt < w.initialRetryAttempts
+		retry = w.backgroundConnect || !initial || attempt < w.initialRetryAttempts
 		if w.beforeConnect != nil {
 			if err = w.beforeConnect(w.ctx, w); err != nil {
 				l.Warnf("WS %s connect attempt %d failed in beforeConnect", w.url, attempt)
@@ -346,7 +373,7 @@ func (w *wsClient) connect(initial bool) error {
 		}
 
 		var res *http.Response
-		w.wsconn, res, err = w.wsdialer.Dial(w.url, w.headers)
+		w.wsconn, res, err = w.wsdialer.DialContext(w.ctx, w.url, w.headers)
 		if err != nil {
 			var b []byte
 			var status = -1

pkg/wsclient/wsclient_test.go

@@ -130,7 +130,7 @@ func TestWSClientE2ETLS(t *testing.T) {
 
 }
 
-func TestWSClientE2E(t *testing.T) {
+func TestWSClientE2EBG(t *testing.T) {
 
 	toServer, fromServer, url, close := NewTestWSServer(func(req *http.Request) {
 		assert.Equal(t, "/test/updated", req.URL.Path)
@@ -155,7 +155,7 @@ func TestWSClientE2E(t *testing.T) {
 	wsConfig.HTTPURL = url
 	wsConfig.WSKeyPath = "/test"
 	wsConfig.HeartbeatInterval = 50 * time.Millisecond
-	wsConfig.InitialConnectAttempts = 2
+	wsConfig.BackgroundConnect = true
 
 	wsc, err := New(context.Background(), wsConfig, beforeConnect, afterConnect)
 	assert.NoError(t, err)
@@ -261,6 +261,21 @@ func TestWSClientE2EReceiveExt(t *testing.T) {
 
 }
 
+func TestWSNeverConnectBG(t *testing.T) {
+	closedSvr := httptest.NewServer(&http.ServeMux{})
+	closedSvr.Close()
+
+	wsc, err := New(context.Background(), &WSConfig{
+		HTTPURL:           closedSvr.URL,
+		BackgroundConnect: true,
+	}, nil, nil)
+	assert.NoError(t, err)
+	err = wsc.Connect()
+	assert.NoError(t, err)
+
+	wsc.Close()
+}
+
 func TestWSClientBadWSURL(t *testing.T) {
 	wsConfig := generateConfig()
 	wsConfig.WebSocketURL = ":::"

pkg/wsclient/wsconfig.go

@@ -42,6 +42,8 @@ const (
 	WSConfigKeyReadBufferSize = "ws.readBufferSize"
 	// WSConfigKeyInitialConnectAttempts sets how many times the websocket should attempt to connect on startup, before failing (after initial connection, retry is indefinite)
 	WSConfigKeyInitialConnectAttempts = "ws.initialConnectAttempts"
+	// WSConfigKeyBackgroundConnect is recommended instead of initialConnectAttempts for new uses of this library, and makes initial connection and reconnection identical in behavior
+	WSConfigKeyBackgroundConnect = "ws.backgroundConnect"
 	// WSConfigKeyPath if set will define the path to connect to - allows sharing of the same URL between HTTP and WebSocket connection info
 	WSConfigKeyPath = "ws.path"
 	// WSConfigURL if set will be a completely separate URL for WebSockets (must be a ws: or wss: scheme)
@@ -60,7 +62,15 @@ func InitConfig(conf config.Section) {
 	ffresty.InitConfig(conf)
 	conf.AddKnownKey(WSConfigKeyWriteBufferSize, defaultBufferSize)
 	conf.AddKnownKey(WSConfigKeyReadBufferSize, defaultBufferSize)
+
+	// Note that conf.SetDefault(WSConfigKeyBackgroundConnect, true) is recommended for implementations
+	// that embed this library, which will cause continual exponential backoff retry connection
+	// even on the initial connection.
+	conf.AddKnownKey(WSConfigKeyBackgroundConnect, false)
+
+	// Ignored if WSConfigKeyBackgroundConnect is true
 	conf.AddKnownKey(WSConfigKeyInitialConnectAttempts, defaultInitialConnectAttempts)
+
 	conf.AddKnownKey(WSConfigKeyPath)
 	conf.AddKnownKey(WSConfigURL)
 	conf.AddKnownKey(WSConfigKeyHeartbeatInterval, defaultHeartbeatInterval)