hookdeck-cli 0.6.2

package/pkg/websocket/client.go

@@ -0,0 +1,525 @@
+package websocket
+
+import (
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"errors"
+	"io/ioutil"
+	"net"
+	"net/http"
+	"os"
+	"strings"
+	"sync"
+	"time"
+
+	ws "github.com/gorilla/websocket"
+	log "github.com/sirupsen/logrus"
+
+	"github.com/hookdeck/hookdeck-cli/pkg/useragent"
+)
+
+//
+// Public types
+//
+
+// Config contains the optional configuration parameters of a Client.
+type Config struct {
+	ConnectAttemptWait time.Duration
+
+	Dialer *ws.Dialer
+
+	Log *log.Logger
+
+	// Force use of unencrypted ws:// protocol instead of wss://
+	NoWSS bool
+
+	PingPeriod time.Duration
+
+	PongWait time.Duration
+
+	WriteWait time.Duration
+
+	EventHandler EventHandler
+}
+
+// EventHandler handles an event.
+type EventHandler interface {
+	ProcessEvent(IncomingMessage)
+}
+
+// EventHandlerFunc is an adapter to allow the use of ordinary
+// functions as event handlers. If f is a function with the
+// appropriate signature, EventHandlerFunc(f) is a
+// EventHandler that calls f.
+type EventHandlerFunc func(IncomingMessage)
+
+// ProcessEvent calls f(msg).
+func (f EventHandlerFunc) ProcessEvent(msg IncomingMessage) {
+	f(msg)
+}
+
+// Client is the client used to receive webhook requests from Hookdeck
+// and send back webhook responses from the local endpoint to Hookdeck.
+type Client struct {
+	// URL the client connects to
+	URL string
+
+	CLIKey string
+
+	// ID sent by the client in the `Websocket-Id` header when connecting
+	WebSocketID string
+
+	// Feature that the websocket is specified for
+	//WebSocketAuthorizedFeature string
+
+	// Optional configuration parameters
+	cfg *Config
+
+	conn        *ws.Conn
+	done        chan struct{}
+	isConnected bool
+
+	NotifyExpired chan struct{}
+	notifyClose   chan error
+	send          chan *OutgoingMessage
+	stopReadPump  chan struct{}
+	stopWritePump chan struct{}
+	wg            *sync.WaitGroup
+}
+
+// Connected returns a channel that's closed when the client has finished
+// establishing the websocket connection.
+func (c *Client) Connected() <-chan struct{} {
+	d := make(chan struct{})
+
+	go func() {
+		for !c.isConnected {
+			time.Sleep(100 * time.Millisecond)
+		}
+		close(d)
+	}()
+
+	return d
+}
+
+// Run starts listening for incoming webhook requests from Hookdeck.
+func (c *Client) Run(ctx context.Context) {
+	c.isConnected = false
+	c.cfg.Log.WithFields(log.Fields{
+		"prefix": "websocket.client.Run",
+	}).Debug("Attempting to connect to Hookdeck")
+
+	err := c.connect(ctx)
+	if err != nil {
+		c.cfg.Log.WithFields(log.Fields{
+			"prefix": "websocket.client.Run",
+		}).Debug(err)
+
+		c.cfg.Log.WithFields(log.Fields{
+			"prefix": "websocket.client.Run",
+		}).Debug("Failed to connect to Hookdeck. Retrying...")
+
+		if err == ErrUnknownID {
+			c.cfg.Log.WithFields(log.Fields{
+				"prefix": "websocket.client.Run",
+			}).Debug("Websocket session is expired.")
+		}
+		c.ConnectionLost()
+		return
+	}
+
+	select {
+	case <-ctx.Done():
+		close(c.send)
+		close(c.stopReadPump)
+		close(c.stopWritePump)
+
+		return
+	case <-c.done:
+		close(c.send)
+		close(c.stopReadPump)
+		close(c.stopWritePump)
+		close(c.NotifyExpired)
+
+		return
+	case <-c.notifyClose:
+		c.cfg.Log.WithFields(log.Fields{
+			"prefix": "websocket.client.Run",
+		}).Debug("Disconnected from Hookdeck")
+
+		c.ConnectionLost()
+		close(c.stopReadPump)
+		close(c.stopWritePump)
+		c.wg.Wait()
+	}
+}
+
+// ConnectionLost sends NotifyExpired
+func (c *Client) ConnectionLost() {
+	c.NotifyExpired <- struct{}{}
+}
+
+// Stop stops listening for incoming webhook events.
+func (c *Client) Stop() {
+	close(c.done)
+}
+
+// SendMessage sends a message to Hookdeck through the websocket.
+func (c *Client) SendMessage(msg *OutgoingMessage) {
+	c.send <- msg
+}
+
+func readWSConnectErrorMessage(resp *http.Response) string {
+	if resp == nil {
+		return ""
+	}
+	if resp.Body == nil {
+		return ""
+	}
+
+	se := struct {
+		InnerError struct {
+			Message string `json:"message"`
+		} `json:"error"`
+	}{}
+
+	body, err := ioutil.ReadAll(resp.Body)
+
+	if err != nil {
+		return ""
+	}
+
+	err = json.Unmarshal(body, &se)
+	if err != nil {
+		return ""
+	}
+
+	return se.InnerError.Message
+}
+
+var unknownIDMessage string = "Unknown WebSocket ID."
+
+// ErrUnknownID can occur when the websocket session is expired or invalid
+var ErrUnknownID error = errors.New(unknownIDMessage)
+
+func basicAuth(username, password string) string {
+	auth := username + ":" + password
+	return base64.StdEncoding.EncodeToString([]byte(auth))
+}
+
+// connect makes a single attempt to connect to the websocket URL. It returns
+// the success of the attempt.
+func (c *Client) connect(ctx context.Context) error {
+	header := http.Header{}
+	// Disable compression by requiring "identity"
+	header.Set("Accept-Encoding", "identity")
+	header.Set("User-Agent", useragent.GetEncodedUserAgent())
+	header.Set("X-Hookdeck-Client-User-Agent", useragent.GetEncodedHookdeckUserAgent())
+	header.Set("Websocket-Id", c.WebSocketID)
+	header.Set("Authorization", "Basic "+basicAuth(c.CLIKey, ""))
+
+	url := c.URL
+	if c.cfg.NoWSS && strings.HasPrefix(url, "wss") {
+		url = "ws" + strings.TrimPrefix(c.URL, "wss")
+	}
+
+	c.cfg.Log.WithFields(log.Fields{
+		"prefix": "websocket.Client.connect",
+		"url":    url,
+	}).Debug("Dialing websocket")
+
+	conn, resp, err := c.cfg.Dialer.DialContext(ctx, url, header)
+	if err != nil {
+		message := readWSConnectErrorMessage(resp)
+		c.cfg.Log.WithFields(log.Fields{
+			"prefix":  "websocket.Client.connect",
+			"error":   err,
+			"message": message,
+		}).Debug("Websocket connection error")
+		if message == unknownIDMessage {
+			return ErrUnknownID
+		}
+		return err
+	}
+
+	defer resp.Body.Close()
+
+	c.changeConnection(conn)
+	c.isConnected = true
+
+	c.wg = &sync.WaitGroup{}
+	c.wg.Add(2)
+
+	go c.readPump()
+
+	go c.writePump()
+
+	c.cfg.Log.WithFields(log.Fields{
+		"prefix": "websocket.client.connect",
+	}).Debug("Connected!")
+
+	return err
+}
+
+// changeConnection takes a new connection and recreates the channels.
+func (c *Client) changeConnection(conn *ws.Conn) {
+	c.conn = conn
+	c.notifyClose = make(chan error)
+	c.stopReadPump = make(chan struct{})
+	c.stopWritePump = make(chan struct{})
+}
+
+// readPump pumps messages from the websocket connection and pushes them into
+// RequestHandler's ProcessWebhookRequest.
+//
+// The application runs readPump in a per-connection goroutine. The application
+// ensures that there is at most one reader on a connection by executing all
+// reads from this goroutine.
+func (c *Client) readPump() {
+	defer c.wg.Done()
+
+	err := c.conn.SetReadDeadline(time.Now().Add(c.cfg.PongWait))
+	if err != nil {
+		c.cfg.Log.Debug("SetReadDeadline error: ", err)
+	}
+
+	c.conn.SetPongHandler(func(string) error {
+		c.cfg.Log.WithFields(log.Fields{
+			"prefix": "websocket.Client.readPump",
+		}).Debug("Received pong message")
+
+		err := c.conn.SetReadDeadline(time.Now().Add(c.cfg.PongWait))
+		if err != nil {
+			c.cfg.Log.Debug("SetReadDeadline error: ", err)
+		}
+
+		return nil
+	})
+
+	for {
+		_, data, err := c.conn.ReadMessage()
+		if err != nil {
+			select {
+			case <-c.stopReadPump:
+				c.cfg.Log.WithFields(log.Fields{
+					"prefix": "websocket.Client.readPump",
+				}).Debug("stopReadPump")
+			default:
+				switch {
+				case !ws.IsCloseError(err):
+					// read errors do not prevent websocket reconnects in the CLI so we should
+					// only display this on debug-level logging
+					c.cfg.Log.WithFields(log.Fields{
+						"prefix": "websocket.Client.Close",
+					}).Debug("read error: ", err)
+				case ws.IsUnexpectedCloseError(err, ws.CloseNormalClosure):
+					c.cfg.Log.WithFields(log.Fields{
+						"prefix": "websocket.Client.Close",
+					}).Error("close error: ", err)
+					c.cfg.Log.WithFields(log.Fields{
+						"prefix": "hookdeckcli.ADDITIONAL_INFO",
+					}).Error("If you run into issues, please re-run with `--log-level debug` and share the output with the Hookdeck team on GitHub.")
+				default:
+					c.cfg.Log.Error("other error: ", err)
+					c.cfg.Log.WithFields(log.Fields{
+						"prefix": "hookdeckcli.ADDITIONAL_INFO",
+					}).Error("If you run into issues, please re-run with `--log-level debug` and share the output with the Hookdeck team on GitHub.")
+				}
+				c.notifyClose <- err
+			}
+
+			return
+		}
+
+		c.cfg.Log.WithFields(log.Fields{
+			"prefix":  "websocket.Client.readPump",
+			"message": string(data),
+		}).Debug("Incoming message")
+
+		var msg IncomingMessage
+		if err = json.Unmarshal(data, &msg); err != nil {
+			c.cfg.Log.Debug("Received malformed message: ", err)
+
+			continue
+		}
+
+		go c.cfg.EventHandler.ProcessEvent(msg)
+	}
+}
+
+// writePump pumps messages to the websocket connection that are queued with
+// SendWebhookResponse.
+//
+// A goroutine running writePump is started for each connection. The
+// application ensures that there is at most one writer to a connection by
+// executing all writes from this goroutine.
+func (c *Client) writePump() {
+	ticker := time.NewTicker(c.cfg.PingPeriod)
+	defer func() {
+		ticker.Stop()
+		c.wg.Done()
+	}()
+
+	for {
+		select {
+		case whResp, ok := <-c.send:
+			err := c.conn.SetWriteDeadline(time.Now().Add(c.cfg.WriteWait))
+			if err != nil {
+				c.cfg.Log.Debug("SetWriteDeadline error: ", err)
+			}
+
+			if !ok {
+				c.cfg.Log.WithFields(log.Fields{
+					"prefix": "websocket.Client.writePump",
+				}).Debug("Sending close message")
+
+				err = c.conn.WriteMessage(ws.CloseMessage, ws.FormatCloseMessage(ws.CloseNormalClosure, ""))
+				if err != nil {
+					c.cfg.Log.Debug("WriteMessage error: ", err)
+				}
+
+				return
+			}
+
+			c.cfg.Log.WithFields(log.Fields{
+				"prefix": "websocket.Client.writePump",
+			}).Debug("Sending text message")
+
+			err = c.conn.WriteJSON(whResp)
+			if err != nil {
+				if ws.IsUnexpectedCloseError(err, ws.CloseNormalClosure) {
+					c.cfg.Log.Error("write error: ", err)
+				}
+				// Requeue the message to be processed when writePump restarts
+				c.send <- whResp
+				c.notifyClose <- err
+
+				return
+			}
+		case <-ticker.C:
+			err := c.conn.SetWriteDeadline(time.Now().Add(c.cfg.WriteWait))
+			if err != nil {
+				c.cfg.Log.Debug("SetWriteDeadline error: ", err)
+			}
+
+			c.cfg.Log.WithFields(log.Fields{
+				"prefix": "websocket.Client.writePump",
+			}).Debug("Sending ping message")
+
+			if err = c.conn.WriteMessage(ws.PingMessage, nil); err != nil {
+				if ws.IsUnexpectedCloseError(err, ws.CloseNormalClosure) {
+					c.cfg.Log.Error("write error: ", err)
+				}
+				c.notifyClose <- err
+
+				return
+			}
+		case <-c.stopWritePump:
+			c.cfg.Log.WithFields(log.Fields{
+				"prefix": "websocket.Client.writePump",
+			}).Debug("stopWritePump")
+
+			return
+		}
+	}
+}
+
+//
+// Public functions
+//
+
+// NewClient returns a new Client.
+func NewClient(url string, webSocketID string, CLIKey string, cfg *Config) *Client {
+	if cfg == nil {
+		cfg = &Config{}
+	}
+
+	if cfg.ConnectAttemptWait == 0 {
+		cfg.ConnectAttemptWait = defaultConnectAttemptWait
+	}
+
+	if cfg.Dialer == nil {
+		cfg.Dialer = newWebSocketDialer(os.Getenv("HOOKDECK_CLI_UNIX_SOCKET"))
+	}
+
+	if cfg.Log == nil {
+		cfg.Log = &log.Logger{Out: ioutil.Discard}
+	}
+
+	if cfg.PongWait == 0 {
+		cfg.PongWait = defaultPongWait
+	}
+
+	if cfg.PingPeriod == 0 {
+		cfg.PingPeriod = (cfg.PongWait * 9) / 10
+	}
+
+	if cfg.WriteWait == 0 {
+		cfg.WriteWait = defaultWriteWait
+	}
+
+	if cfg.EventHandler == nil {
+		cfg.EventHandler = nullEventHandler
+	}
+
+	// Note that this client is not configured for websocket communications
+	// and you must call c.changeConnection
+	return &Client{
+		URL:         url,
+		WebSocketID: webSocketID,
+		// WebSocketAuthorizedFeature: websocketAuthorizedFeature,
+		CLIKey:        CLIKey,
+		cfg:           cfg,
+		done:          make(chan struct{}),
+		send:          make(chan *OutgoingMessage),
+		NotifyExpired: make(chan struct{}),
+	}
+}
+
+//
+// Private constants
+//
+
+const (
+	defaultConnectAttemptWait = 10 * time.Second
+
+	defaultPongWait = 10 * time.Second
+
+	defaultWriteWait = 10 * time.Second
+)
+
+//
+// Private variables
+//
+
+var subprotocols = [...]string{"hookdeckcli-devproxy-v1"}
+
+var nullEventHandler = EventHandlerFunc(func(IncomingMessage) {})
+
+//
+// Private functions
+//
+
+func newWebSocketDialer(unixSocket string) *ws.Dialer {
+	var dialer *ws.Dialer
+
+	if unixSocket != "" {
+		dialFunc := func(network, addr string) (net.Conn, error) {
+			return net.Dial("unix", unixSocket)
+		}
+		dialer = &ws.Dialer{
+			HandshakeTimeout: 10 * time.Second,
+			NetDial:          dialFunc,
+			Subprotocols:     subprotocols[:],
+		}
+	} else {
+		dialer = &ws.Dialer{
+			HandshakeTimeout: 10 * time.Second,
+			Proxy:            http.ProxyFromEnvironment,
+			Subprotocols:     subprotocols[:],
+		}
+	}
+
+	return dialer
+}

package/pkg/websocket/connection_messages.go

@@ -0,0 +1,11 @@
+package websocket
+
+type ConnectionMessageBody struct {
+	SourceId      string   `json:"source_id"`
+	ConnectionIds []string `json:"webhook_ids"`
+}
+
+type ConnectionMessage struct {
+	Event string                `json:"event"`
+	Body  ConnectionMessageBody `json:"body"`
+}

package/pkg/websocket/messages.go

@@ -0,0 +1,64 @@
+package websocket
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+// IncomingMessage represents any incoming message sent by Hookdeck.
+type IncomingMessage struct {
+	*Attempt
+	// *RequestLogEvent
+}
+
+// UnmarshalJSON deserializes incoming messages sent by Hookdeck into the
+// appropriate structure.
+func (m *IncomingMessage) UnmarshalJSON(data []byte) error {
+	incomingMessageEventOnly := struct {
+		Event string `json:"event"`
+	}{}
+
+	if err := json.Unmarshal(data, &incomingMessageEventOnly); err != nil {
+		return err
+	}
+
+	switch incomingMessageEventOnly.Event {
+	case "attempt":
+		var evt Attempt
+		if err := json.Unmarshal(data, &evt); err != nil {
+			return err
+		}
+
+		m.Attempt = &evt
+	case "connect_response":
+		return nil
+	default:
+		return fmt.Errorf("Unexpected message type: %s", incomingMessageEventOnly.Event)
+	}
+
+	return nil
+}
+
+// MarshalJSON serializes outgoing messages sent to Hookdeck.
+func (m OutgoingMessage) MarshalJSON() ([]byte, error) {
+	if m.AttemptResponse != nil {
+		return json.Marshal(m.AttemptResponse)
+	}
+
+	if m.ErrorAttemptResponse != nil {
+		return json.Marshal(m.ErrorAttemptResponse)
+	}
+
+	if m.ConnectionMessage != nil {
+		return json.Marshal(m.ConnectionMessage)
+	}
+
+	return json.Marshal(nil)
+}
+
+// OutgoingMessage represents any outgoing message sent to Hookdeck.
+type OutgoingMessage struct {
+	*ErrorAttemptResponse
+	*AttemptResponse
+	*ConnectionMessage
+}