gotosocial/internal/api/client/streaming/stream.go

/*
   GoToSocial
   Copyright (C) 2021-2023 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 (
	"context"
	"time"

	"codeberg.org/gruf/go-kv"
	apiutil "github.com/superseriousbusiness/gotosocial/internal/api/util"
	"github.com/superseriousbusiness/gotosocial/internal/gtserror"
	"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
	"github.com/superseriousbusiness/gotosocial/internal/log"
	"github.com/superseriousbusiness/gotosocial/internal/oauth"
	streampkg "github.com/superseriousbusiness/gotosocial/internal/stream"
	"golang.org/x/exp/slices"

	"github.com/gin-gonic/gin"
	"github.com/gorilla/websocket"
)

// StreamGETHandler swagger:operation GET /api/v1/streaming streamGet
//
// Initiate a websocket connection for live streaming of statuses and notifications.
//
// The scheme used should *always* be `wss`. The streaming basepath can be viewed at `/api/v1/instance`.
//
// On a successful connection, a code `101` will be returned, which indicates that the connection is being upgraded to a secure websocket connection.
//
// As long as the connection is open, various message types will be streamed into it.
//
// GoToSocial will ping the connection every 30 seconds to check whether the client is still receiving.
//
// If the ping fails, or something else goes wrong during transmission, then the connection will be dropped, and the client will be expected to start it again.
//
//	---
//	tags:
//	- streaming
//
//	produces:
//	- application/json
//
//	schemes:
//	- wss
//
//	parameters:
//	-
//		name: access_token
//		type: string
//		description: Access token for the requesting account.
//		in: query
//		required: true
//	-
//		name: stream
//		type: string
//		description: |-
//			Type of stream to request.
//
//			Options are:
//
//			`user`: receive updates for the account's home timeline.
//			`public`: receive updates for the public timeline.
//			`public:local`: receive updates for the local timeline.
//			`hashtag`: receive updates for a given hashtag.
//			`hashtag:local`: receive local updates for a given hashtag.
//			`list`: receive updates for a certain list of accounts.
//			`direct`: receive updates for direct messages.
//		in: query
//		required: true
//
//	security:
//	- OAuth2 Bearer:
//		- read:streaming
//
//	responses:
//		'101':
//			schema:
//				type: object
//				properties:
//					stream:
//						type: array
//						items:
//							type: string
//							enum:
//							- user
//							- public
//							- public:local
//							- hashtag
//							- hashtag:local
//							- list
//							- direct
//					event:
//						description: |-
//							The type of event being received.
//
//							`update`: a new status has been received.
//							`notification`: a new notification has been received.
//							`delete`: a status has been deleted.
//							`filters_changed`: not implemented.
//						type: string
//						enum:
//						- update
//						- notification
//						- delete
//						- filters_changed
//					payload:
//						description: |-
//							The payload of the streamed message.
//							Different depending on the `event` type.
//
//							If present, it should be parsed as a string.
//
//							If `event` = `update`, then the payload will be a JSON string of a status.
//							If `event` = `notification`, then the payload will be a JSON string of a notification.
//							If `event` = `delete`, then the payload will be a status ID.
//						type: string
//						example: "{\"id\":\"01FC3TZ5CFG6H65GCKCJRKA669\",\"created_at\":\"2021-08-02T16:25:52Z\",\"sensitive\":false,\"spoiler_text\":\"\",\"visibility\":\"public\",\"language\":\"en\",\"uri\":\"https://gts.superseriousbusiness.org/users/dumpsterqueer/statuses/01FC3TZ5CFG6H65GCKCJRKA669\",\"url\":\"https://gts.superseriousbusiness.org/@dumpsterqueer/statuses/01FC3TZ5CFG6H65GCKCJRKA669\",\"replies_count\":0,\"reblogs_count\":0,\"favourites_count\":0,\"favourited\":false,\"reblogged\":false,\"muted\":false,\"bookmarked\":fals…//gts.superseriousbusiness.org/fileserver/01JNN207W98SGG3CBJ76R5MVDN/header/original/019036W043D8FXPJKSKCX7G965.png\",\"header_static\":\"https://gts.superseriousbusiness.org/fileserver/01JNN207W98SGG3CBJ76R5MVDN/header/small/019036W043D8FXPJKSKCX7G965.png\",\"followers_count\":33,\"following_count\":28,\"statuses_count\":126,\"last_status_at\":\"2021-08-02T16:25:52Z\",\"emojis\":[],\"fields\":[]},\"media_attachments\":[],\"mentions\":[],\"tags\":[],\"emojis\":[],\"card\":null,\"poll\":null,\"text\":\"a\"}"
//		'401':
//			description: unauthorized
//		'400':
//			description: bad request
func (m *Module) StreamGETHandler(c *gin.Context) {

	// First we check for a query param provided access token
	token := c.Query(AccessTokenQueryKey)
	if token == "" {
		// Else we check the HTTP header provided token
		token = c.GetHeader(AccessTokenHeader)
	}

	var account *gtsmodel.Account
	if token != "" {
		// Check the explicit token
		var errWithCode gtserror.WithCode
		account, errWithCode = m.processor.Stream().Authorize(c.Request.Context(), token)
		if errWithCode != nil {
			apiutil.ErrorHandler(c, errWithCode, m.processor.InstanceGetV1)
			return
		}
	} else {
		// If no explicit token was provided, try regular oauth
		auth, errStr := oauth.Authed(c, true, true, true, true)
		if errStr != nil {
			err := gtserror.NewErrorUnauthorized(errStr, errStr.Error())
			apiutil.ErrorHandler(c, err, m.processor.InstanceGetV1)
			return
		}
		account = auth.Account
	}

	// Get the initial stream type, if there is one.
	// streamType will be an empty string if one wasn't supplied. Open() will deal with this
	streamType := c.Query(StreamQueryKey)
	stream, errWithCode := m.processor.Stream().Open(c.Request.Context(), account, streamType)
	if errWithCode != nil {
		apiutil.ErrorHandler(c, errWithCode, m.processor.InstanceGetV1)
		return
	}

	l := log.WithContext(c.Request.Context()).
		WithFields(kv.Fields{
			{"account", account.Username},
			{"streamID", stream.ID},
			{"streamType", streamType},
		}...)

	// Upgrade the incoming HTTP request, which hijacks the underlying
	// connection and reuses it for the websocket (non-http) protocol.
	wsConn, err := m.wsUpgrade.Upgrade(c.Writer, c.Request, nil)
	if err != nil {
		l.Errorf("error upgrading websocket connection: %v", err)
		close(stream.Hangup)
		return
	}

	go func() {
		// We perform the main websocket send loop in a separate
		// goroutine in order to let the upgrade handler return.
		// This prevents the upgrade handler from holding open any
		// throttle / rate-limit request tokens which could become
		// problematic on instances with multiple users.
		l.Info("opened websocket connection")
		defer l.Info("closed websocket connection")

		// Create new context for lifetime of the connection
		ctx, cncl := context.WithCancel(context.Background())

		// Create ticker to send alive pings
		pinger := time.NewTicker(m.dTicker)

		defer func() {
			// Signal done
			cncl()

			// Close websocket conn
			_ = wsConn.Close()

			// Close processor stream
			close(stream.Hangup)

			// Stop ping ticker
			pinger.Stop()
		}()

		go func() {
			// Signal done
			defer cncl()

			for {
				// We have to listen for received websocket messages in
				// order to trigger the underlying wsConn.PingHandler().
				//
				// Read JSON objects from the client and act on them
				var msg map[string]string
				err := wsConn.ReadJSON(&msg)
				if err != nil {
					if ctx.Err() == nil {
						// Only log error if the connection was not closed
						// by us. Uncanceled context indicates this is the case.
						l.Errorf("error reading from websocket: %v", err)
					}
					return
				}
				l.Tracef("received message from websocket: %v", msg)

				// If the message contains 'stream' and 'type' fields, we can
				// update the set of timelines that are subscribed for events.
				// everything else is ignored.
				action := msg["type"]
				streamType := msg["stream"]

				// Ignore if the streamType is unknown (or missing), so a bad
				// client can't cause extra memory allocations
				if !slices.Contains(streampkg.AllStatusTimelines, streamType) {
					l.Warnf("Unknown 'stream' field: %v", msg)
					continue
				}

				switch action {
				case "subscribe":
					stream.Lock()
					stream.Timelines[streamType] = true
					stream.Unlock()
				case "unsubscribe":
					stream.Lock()
					delete(stream.Timelines, streamType)
					stream.Unlock()
				default:
					l.Warnf("Invalid 'type' field: %v", msg)
				}
			}
		}()

		for {
			select {
			// Connection closed
			case <-ctx.Done():
				return

			// Received next stream message
			case msg := <-stream.Messages:
				l.Tracef("sending message to websocket: %+v", msg)
				if err := wsConn.WriteJSON(msg); err != nil {
					l.Errorf("error writing json to websocket: %v", err)
					return
				}

				// Reset on each successful send.
				pinger.Reset(m.dTicker)

			// Send keep-alive "ping"
			case <-pinger.C:
				l.Trace("pinging websocket ...")
				if err := wsConn.WriteMessage(
					websocket.PingMessage,
					[]byte{},
				); err != nil {
					l.Errorf("error writing ping to websocket: %v", err)
					return
				}
			}
		}
	}()
}