mirror of
https://github.com/superseriousbusiness/gotosocial.git
synced 2024-11-23 20:26:39 +00:00
90 lines
3.1 KiB
Go
90 lines
3.1 KiB
Go
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")
|
|
}
|