Refactor ClientManager into a more generic StreamManager

stream_manager.go

@@ -0,0 +1,138 @@
+package xmpp // import "gosrc.io/xmpp"
+
+import (
+	"time"
+
+	"golang.org/x/xerrors"
+)
+
+// The Fluux XMPP lib can manage client or component XMPP streams.
+// The StreamManager handles the stream workflow handling the common
+// stream events and doing the right operations.
+//
+// It can handle:
+//     - Connection
+//     - Stream establishment workflow
+//     - Reconnection strategies, with exponential backoff. It also takes into account
+//       permanent errors to avoid useless reconnection loops.
+//     - Metrics processing
+
+type StreamSession interface {
+	Connect() error
+	Disconnect()
+	SetHandler(handler EventHandler)
+}
+
+// StreamManager supervises an XMPP client connection. Its role is to handle connection events and
+// apply reconnection strategy.
+type StreamManager struct {
+	Client      *Client
+	Session     *Session
+	PostConnect PostConnect
+
+	// Store low level metrics
+	Metrics *Metrics
+}
+
+type PostConnect func(c *Client)
+
+// NewStreamManager creates a new StreamManager structure, intended to support
+// handling XMPP client state event changes and auto-trigger reconnection
+// based on StreamManager configuration.
+func NewStreamManager(client *Client, pc PostConnect) *StreamManager {
+	return &StreamManager{
+		Client:      client,
+		PostConnect: pc,
+	}
+}
+
+// Start launch the connection loop
+func (cm *StreamManager) Start() error {
+	cm.Client.Handler = func(e Event) {
+		switch e.State {
+		case StateConnected:
+			cm.Metrics.setConnectTime()
+		case StateSessionEstablished:
+			cm.Metrics.setLoginTime()
+		case StateDisconnected:
+			// Reconnect on disconnection
+			cm.connect()
+		case StateStreamError:
+			cm.Client.Disconnect()
+			// Only try reconnecting if we have not been kicked by another session to avoid connection loop.
+			if e.StreamError != "conflict" {
+				cm.connect()
+			}
+		}
+	}
+
+	return cm.connect()
+}
+
+// Stop cancels pending operations and terminates existing XMPP client.
+func (cm *StreamManager) Stop() {
+	// Remove on disconnect handler to avoid triggering reconnect
+	cm.Client.Handler = nil
+	cm.Client.Disconnect()
+}
+
+// connect manages the reconnection loop and apply the define backoff to avoid overloading the server.
+func (cm *StreamManager) connect() error {
+	var backoff Backoff // TODO: Group backoff calculation features with connection manager?
+
+	for {
+		var err error
+		// TODO: Make it possible to define logger to log disconnect and reconnection attempts
+		cm.Metrics = initMetrics()
+
+		if err = cm.Client.Connect(); err != nil {
+			var actualErr ConnError
+			if xerrors.As(err, &actualErr) {
+				if actualErr.Permanent {
+					return xerrors.Errorf("unrecoverable connect error %w", actualErr)
+				}
+			}
+			backoff.Wait()
+		} else { // We are connected, we can leave the retry loop
+			break
+		}
+	}
+
+	if cm.PostConnect != nil {
+		cm.PostConnect(cm.Client)
+	}
+	return nil
+}
+
+// Stream Metrics
+// ============================================================================
+
+type Metrics struct {
+	startTime time.Time
+	// ConnectTime returns the duration between client initiation of the TCP/IP
+	// connection to the server and actual TCP/IP session establishment.
+	// This time includes DNS resolution and can be slightly higher if the DNS
+	// resolution result was not in cache.
+	ConnectTime time.Duration
+	// LoginTime returns the between client initiation of the TCP/IP
+	// connection to the server and the return of the login result.
+	// This includes ConnectTime, but also XMPP level protocol negociation
+	// like starttls.
+	LoginTime time.Duration
+}
+
+// initMetrics set metrics with default value and define the starting point
+// for duration calculation (connect time, login time, etc).
+func initMetrics() *Metrics {
+	return &Metrics{
+		startTime: time.Now(),
+	}
+}
+
+func (m *Metrics) setConnectTime() {
+	m.ConnectTime = time.Since(m.startTime)
+}
+
+func (m *Metrics) setLoginTime() {
+	m.LoginTime = time.Since(m.startTime)
+}