streaming working

internal/api/client/streaming/stream.go

@@ -9,6 +9,7 @@ import (
 	"github.com/gorilla/websocket"
 )
 
+// StreamGETHandler handles the creation of a new websocket streaming request.
 func (m *Module) StreamGETHandler(c *gin.Context) {
 	l := m.log.WithField("func", "StreamGETHandler")
 
@@ -24,29 +25,65 @@ func (m *Module) StreamGETHandler(c *gin.Context) {
 		return
 	}
 
+	// make sure a valid token has been provided and obtain the associated account
 	account, err := m.processor.AuthorizeStreamingRequest(accessToken)
 	if err != nil {
 		c.JSON(http.StatusUnauthorized, gin.H{"error": "could not authorize with given token"})
 		return
 	}
 
+	// prepare to upgrade the connection to a websocket connection
 	upgrader := websocket.Upgrader{
-		HandshakeTimeout: 5 * time.Second,
-		ReadBufferSize:   1024,
-		WriteBufferSize:  1024,
-		Subprotocols:     []string{"wss"},
+		ReadBufferSize:  1024,
+		WriteBufferSize: 1024,
 		CheckOrigin: func(r *http.Request) bool {
+			// we fully expect cors requests (via something like pinafore.social) so we should be lenient here
 			return true
 		},
 	}
 
+	// do the actual upgrade here
 	conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
 	if err != nil {
 		l.Infof("error upgrading websocket connection: %s", err)
 		return
 	}
+	defer conn.Close() // whatever happens, when we leave this function we want to close the websocket connection
 
-	if errWithCode := m.processor.OpenStreamForAccount(conn, account, streamType); errWithCode != nil {
+	// inform the processor that we have a new connection and want a stream for it
+	stream, errWithCode := m.processor.OpenStreamForAccount(account, streamType)
+	if errWithCode != nil {
 		c.JSON(errWithCode.Code(), errWithCode.Safe())
+		return
 	}
+	defer close(stream.Hangup) // closing stream.Hangup indicates that we've finished with the connection (the client has gone), so we want to do this on exiting this handler
+
+	// spawn a new ticker for pinging the connection periodically
+	t := time.NewTicker(30 * time.Second)
+
+	// we want to stay in the sendloop as long as possible while the client is connected -- the only thing that should break the loop is if the client leaves or something else goes wrong
+sendLoop:
+	for {
+		select {
+		case m := <-stream.Messages:
+			// we've got a streaming message!!
+			l.Debug("received message from stream")
+			if err := conn.WriteJSON(m); err != nil {
+				l.Infof("error writing json to websocket connection: %s", err)
+				// if something is wrong we want to bail and drop the connection -- the client will create a new one
+				break sendLoop
+			}
+			l.Debug("wrote message into websocket connection")
+		case <-t.C:
+			l.Debug("received TICK from ticker")
+			if err := conn.WriteMessage(websocket.PingMessage, []byte(": ping")); err != nil {
+				l.Infof("error writing ping to websocket connection: %s", err)
+				// if something is wrong we want to bail and drop the connection -- the client will create a new one
+				break sendLoop
+			}
+			l.Debug("wrote ping message into websocket connection")
+		}
+	}
+
+	l.Debug("leaving StreamGETHandler")
 }