Streaming (#49)

Add new status and notification websocket streaming capabilities

go.mod

@@ -26,6 +26,7 @@ require (
 	github.com/golang/mock v1.5.0 // indirect
 	github.com/google/uuid v1.2.0
 	github.com/gorilla/sessions v1.2.1 // indirect
+	github.com/gorilla/websocket v1.4.2
 	github.com/h2non/filetype v1.1.1
 	github.com/json-iterator/go v1.1.11 // indirect
 	github.com/leodido/go-urn v1.2.1 // indirect

internal/api/client/streaming/stream.go

@@ -0,0 +1,89 @@
+package streaming
+
+import (
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"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")
+
+	streamType := c.Query(StreamQueryKey)
+	if streamType == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("no stream type provided under query key %s", StreamQueryKey)})
+		return
+	}
+
+	accessToken := c.Query(AccessTokenQueryKey)
+	if accessToken == "" {
+		c.JSON(http.StatusUnauthorized, gin.H{"error": fmt.Sprintf("no access token provided under query key %s", AccessTokenQueryKey)})
+		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{
+		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
+
+	// 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")
+}

internal/api/client/streaming/streaming.go

@@ -0,0 +1,62 @@
+/*
+   GoToSocial
+   Copyright (C) 2021 GoToSocial Authors admin@gotosocial.org
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Affero General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package streaming
+
+import (
+	"net/http"
+
+	"github.com/sirupsen/logrus"
+	"github.com/superseriousbusiness/gotosocial/internal/api"
+	"github.com/superseriousbusiness/gotosocial/internal/config"
+	"github.com/superseriousbusiness/gotosocial/internal/processing"
+	"github.com/superseriousbusiness/gotosocial/internal/router"
+)
+
+const (
+	// BasePath is the path for the streaming api
+	BasePath = "/api/v1/streaming"
+
+	// StreamQueryKey is the query key for the type of stream being requested
+	StreamQueryKey = "stream"
+
+	// AccessTokenQueryKey is the query key for an oauth access token that should be passed in streaming requests.
+	AccessTokenQueryKey = "access_token"
+)
+
+// Module implements the api.ClientModule interface for everything related to streaming
+type Module struct {
+	config    *config.Config
+	processor processing.Processor
+	log       *logrus.Logger
+}
+
+// New returns a new streaming module
+func New(config *config.Config, processor processing.Processor, log *logrus.Logger) api.ClientModule {
+	return &Module{
+		config:    config,
+		processor: processor,
+		log:       log,
+	}
+}
+
+// Route attaches all routes from this module to the given router
+func (m *Module) Route(r router.Router) error {
+	r.AttachHandler(http.MethodGet, BasePath, m.StreamGETHandler)
+	return nil
+}

internal/cliactions/server/server.go

@@ -24,6 +24,7 @@ import (
 	"github.com/superseriousbusiness/gotosocial/internal/api/client/notification"
 	"github.com/superseriousbusiness/gotosocial/internal/api/client/search"
 	"github.com/superseriousbusiness/gotosocial/internal/api/client/status"
+	"github.com/superseriousbusiness/gotosocial/internal/api/client/streaming"
 	"github.com/superseriousbusiness/gotosocial/internal/api/client/timeline"
 	"github.com/superseriousbusiness/gotosocial/internal/api/s2s/user"
 	"github.com/superseriousbusiness/gotosocial/internal/api/s2s/webfinger"
@@ -134,6 +135,7 @@ var Start cliactions.GTSAction = func(ctx context.Context, c *config.Config, log
 	adminModule := admin.New(c, processor, log)
 	statusModule := status.New(c, processor, log)
 	securityModule := security.New(c, log)
+	streamingModule := streaming.New(c, processor, log)
 
 	apis := []api.ClientModule{
 		// modules with middleware go first
@@ -157,6 +159,7 @@ var Start cliactions.GTSAction = func(ctx context.Context, c *config.Config, log
 		filtersModule,
 		emojiModule,
 		listsModule,
+		streamingModule,
 	}
 
 	for _, m := range apis {

internal/db/pg/pg.go

@@ -810,23 +810,23 @@ func (ps *postgresService) Follows(sourceAccount *gtsmodel.Account, targetAccoun
 	if sourceAccount == nil || targetAccount == nil {
 		return false, nil
 	}
-	
+
 	return ps.conn.Model(&gtsmodel.Follow{}).Where("account_id = ?", sourceAccount.ID).Where("target_account_id = ?", targetAccount.ID).Exists()
 }
 
 func (ps *postgresService) FollowRequested(sourceAccount *gtsmodel.Account, targetAccount *gtsmodel.Account) (bool, error) {
 	if sourceAccount == nil || targetAccount == nil {
 		return false, nil
 	}
-	
+
 	return ps.conn.Model(&gtsmodel.FollowRequest{}).Where("account_id = ?", sourceAccount.ID).Where("target_account_id = ?", targetAccount.ID).Exists()
 }
 
 func (ps *postgresService) Mutuals(account1 *gtsmodel.Account, account2 *gtsmodel.Account) (bool, error) {
 	if account1 == nil || account2 == nil {
 		return false, nil
 	}
-	
+
 	// make sure account 1 follows account 2
 	f1, err := ps.conn.Model(&gtsmodel.Follow{}).Where("account_id = ?", account1.ID).Where("target_account_id = ?", account2.ID).Exists()
 	if err != nil {
@@ -975,6 +975,7 @@ func (ps *postgresService) GetPublicTimelineForAccount(accountID string, maxID s
 	q := ps.conn.Model(&statuses).
 		Where("visibility = ?", gtsmodel.VisibilityPublic).
 		Where("? IS NULL", pg.Ident("in_reply_to_id")).
+		Where("? IS NULL", pg.Ident("in_reply_to_uri")).
 		Where("? IS NULL", pg.Ident("boost_of_id")).
 		Order("status.id DESC")
 

internal/gtsmodel/stream.go

@@ -0,0 +1,38 @@
+package gtsmodel
+
+import "sync"
+
+// StreamsForAccount is a wrapper for the multiple streams that one account can have running at the same time.
+// TODO: put a limit on this
+type StreamsForAccount struct {
+	// The currently held streams for this account
+	Streams []*Stream
+	// Mutex to lock/unlock when modifying the slice of streams.
+	sync.Mutex
+}
+
+// Stream represents one open stream for a client.
+type Stream struct {
+	// ID of this stream, generated during creation.
+	ID string
+	// Type of this stream: user/public/etc
+	Type string
+	// Channel of messages for the client to read from
+	Messages chan *Message
+	// Channel to close when the client drops away
+	Hangup chan interface{}
+	// Only put messages in the stream when Connected
+	Connected bool
+	// Mutex to lock/unlock when inserting messages, hanging up, changing the connected state etc.
+	sync.Mutex
+}
+
+// Message represents one streamed message.
+type Message struct {
+	// All the stream types this message should be delivered to.
+	Stream []string `json:"stream"`
+	// The event type of the message (update/delete/notification etc)
+	Event string `json:"event"`
+	// The actual payload of the message. In case of an update or notification, this will be a JSON string.
+	Payload string `json:"payload"`
+}

internal/oauth/server.go

@@ -56,6 +56,7 @@ type Server interface {
 	HandleAuthorizeRequest(w http.ResponseWriter, r *http.Request) error
 	ValidationBearerToken(r *http.Request) (oauth2.TokenInfo, error)
 	GenerateUserAccessToken(ti oauth2.TokenInfo, clientSecret string, userID string) (accessToken oauth2.TokenInfo, err error)
+	LoadAccessToken(ctx context.Context, access string) (accessToken oauth2.TokenInfo, err error)
 }
 
 // s fulfils the Server interface using the underlying oauth2 server
@@ -171,3 +172,7 @@ func (s *s) GenerateUserAccessToken(ti oauth2.TokenInfo, clientSecret string, us
 	s.log.Tracef("obtained user-level access token: %+v", accessToken)
 	return accessToken, nil
 }
+
+func (s *s) LoadAccessToken(ctx context.Context, access string) (accessToken oauth2.TokenInfo, err error) {
+	return s.server.Manager.LoadAccessToken(ctx, access)
+}

internal/processing/fromcommon.go

@@ -96,6 +96,16 @@ func (p *processor) notifyStatus(status *gtsmodel.Status) error {
 		if err := p.db.Put(notif); err != nil {
 			return fmt.Errorf("notifyStatus: error putting notification in database: %s", err)
 		}
+
+		// now stream the notification to the user
+		mastoNotif, err := p.tc.NotificationToMasto(notif)
+		if err != nil {
+			return fmt.Errorf("notifyStatus: error converting notification to masto representation: %s", err)
+		}
+
+		if err := p.streamingProcessor.StreamNotificationToAccount(mastoNotif, m.GTSAccount); err != nil {
+			return fmt.Errorf("notifyStatus: error streaming notification to account: %s", err)
+		}
 	}
 
 	return nil
@@ -123,6 +133,16 @@ func (p *processor) notifyFollowRequest(followRequest *gtsmodel.FollowRequest, r
 		return fmt.Errorf("notifyFollowRequest: error putting notification in database: %s", err)
 	}
 
+	// now stream the notification to the user
+	mastoNotif, err := p.tc.NotificationToMasto(notif)
+	if err != nil {
+		return fmt.Errorf("notifyStatus: error converting notification to masto representation: %s", err)
+	}
+
+	if err := p.streamingProcessor.StreamNotificationToAccount(mastoNotif, receivingAccount); err != nil {
+		return fmt.Errorf("notifyStatus: error streaming notification to account: %s", err)
+	}
+
 	return nil
 }
 
@@ -157,6 +177,16 @@ func (p *processor) notifyFollow(follow *gtsmodel.Follow, receivingAccount *gtsm
 		return fmt.Errorf("notifyFollow: error putting notification in database: %s", err)
 	}
 
+	// now stream the notification to the user
+	mastoNotif, err := p.tc.NotificationToMasto(notif)
+	if err != nil {
+		return fmt.Errorf("notifyStatus: error converting notification to masto representation: %s", err)
+	}
+
+	if err := p.streamingProcessor.StreamNotificationToAccount(mastoNotif, receivingAccount); err != nil {
+		return fmt.Errorf("notifyStatus: error streaming notification to account: %s", err)
+	}
+
 	return nil
 }
 
@@ -183,6 +213,16 @@ func (p *processor) notifyFave(fave *gtsmodel.StatusFave, receivingAccount *gtsm
 		return fmt.Errorf("notifyFave: error putting notification in database: %s", err)
 	}
 
+	// now stream the notification to the user
+	mastoNotif, err := p.tc.NotificationToMasto(notif)
+	if err != nil {
+		return fmt.Errorf("notifyStatus: error converting notification to masto representation: %s", err)
+	}
+
+	if err := p.streamingProcessor.StreamNotificationToAccount(mastoNotif, receivingAccount); err != nil {
+		return fmt.Errorf("notifyStatus: error streaming notification to account: %s", err)
+	}
+
 	return nil
 }
 
@@ -242,6 +282,16 @@ func (p *processor) notifyAnnounce(status *gtsmodel.Status) error {
 		return fmt.Errorf("notifyAnnounce: error putting notification in database: %s", err)
 	}
 
+	// now stream the notification to the user
+	mastoNotif, err := p.tc.NotificationToMasto(notif)
+	if err != nil {
+		return fmt.Errorf("notifyStatus: error converting notification to masto representation: %s", err)
+	}
+
+	if err := p.streamingProcessor.StreamNotificationToAccount(mastoNotif, boostedAcct); err != nil {
+		return fmt.Errorf("notifyStatus: error streaming notification to account: %s", err)
+	}
+
 	return nil
 }
 
@@ -321,8 +371,32 @@ func (p *processor) timelineStatusForAccount(status *gtsmodel.Status, accountID
 		return
 	}
 
-	if err := p.timelineManager.IngestAndPrepare(status, timelineAccount.ID); err != nil {
+	// stick the status in the timeline for the account and then immediately prepare it so they can see it right away
+	inserted, err := p.timelineManager.IngestAndPrepare(status, timelineAccount.ID)
+	if err != nil {
 		errors <- fmt.Errorf("timelineStatusForAccount: error ingesting status %s: %s", status.ID, err)
+		return
+	}
+
+	// the status was inserted to stream it to the user
+	if inserted {
+		mastoStatus, err := p.tc.StatusToMasto(status, timelineAccount)
+		if err != nil {
+			errors <- fmt.Errorf("timelineStatusForAccount: error converting status %s to frontend representation: %s", status.ID, err)
+		} else {
+			if err := p.streamingProcessor.StreamStatusToAccount(mastoStatus, timelineAccount); err != nil {
+				errors <- fmt.Errorf("timelineStatusForAccount: error streaming status %s: %s", status.ID, err)
+			}
+		}
+	}
+
+	mastoStatus, err := p.tc.StatusToMasto(status, timelineAccount)
+	if err != nil {
+		errors <- fmt.Errorf("timelineStatusForAccount: error converting status %s to frontend representation: %s", status.ID, err)
+	} else {
+		if err := p.streamingProcessor.StreamStatusToAccount(mastoStatus, timelineAccount); err != nil {
+			errors <- fmt.Errorf("timelineStatusForAccount: error streaming status %s: %s", status.ID, err)
+		}
 	}
 }