131 lines
3.4 KiB
Go
131 lines
3.4 KiB
Go
package ws
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"log/slog"
|
|
"net/http"
|
|
"time"
|
|
|
|
"github.com/gorilla/websocket"
|
|
)
|
|
|
|
// (de-)register
|
|
|
|
func (wsg *WebsocketGateway) listen(srv *http.Server, addr string, channel chan error) {
|
|
wsg.logger.Info("Gateway listening.", "addr", addr)
|
|
|
|
if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
|
|
channel <- err
|
|
}
|
|
|
|
close(channel)
|
|
}
|
|
|
|
func (wsg *WebsocketGateway) deafen(srv *http.Server) {
|
|
shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
|
defer cancel()
|
|
|
|
wsg.logger.Info("Shutting down Websocket Gateway.")
|
|
|
|
_ = srv.Shutdown(shutdownCtx)
|
|
wsg.closeAll()
|
|
}
|
|
|
|
// responses
|
|
|
|
func (wsg *WebsocketGateway) sendHttpError(w http.ResponseWriter, message string, code int) {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(code)
|
|
_ = json.NewEncoder(w).Encode(map[string]interface{}{"message": message, "code": code})
|
|
}
|
|
|
|
func (wsg *WebsocketGateway) sendWebsocketError(conn *websocket.Conn, message string, code int) {
|
|
_ = conn.SetWriteDeadline(time.Now().Add(5 * time.Second))
|
|
_ = conn.WriteJSON(map[string]interface{}{"message": message, "code": code})
|
|
_ = conn.Close()
|
|
}
|
|
|
|
func (wsg *WebsocketGateway) sendWebsocketResponse(conn *websocket.Conn, content interface{}) error {
|
|
_ = conn.SetWriteDeadline(time.Now().Add(5 * time.Second))
|
|
|
|
if err := conn.WriteJSON(content); err != nil {
|
|
wsg.logger.Error("Failed to respond to connection.", "remote", conn.RemoteAddr().String(), "err", err)
|
|
_ = conn.Close()
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// util
|
|
|
|
func (wsg *WebsocketGateway) validateAndUpgradeConnection(w http.ResponseWriter, r *http.Request) (*websocket.Conn, error) {
|
|
if !wsg.validateApiKey(r) {
|
|
wsg.sendHttpError(w, "Unauthorized", 401)
|
|
wsg.logger.Warn("Authorization failed", "remote", r.RemoteAddr)
|
|
return nil, errors.New("unauthorized")
|
|
}
|
|
|
|
conn, err := wsg.upgrader.Upgrade(w, r, nil)
|
|
if err != nil {
|
|
wsg.logger.Error("Upgrade error.", "remote", r.RemoteAddr)
|
|
return nil, err
|
|
}
|
|
|
|
return conn, err
|
|
}
|
|
|
|
func (wsg *WebsocketGateway) validateApiKey(r *http.Request) bool {
|
|
apiKey := r.URL.Query().Get("api_key")
|
|
if apiKey == "" {
|
|
apiKey = r.Header.Get("X-API-Key")
|
|
}
|
|
|
|
return !(apiKey == "" || apiKey != wsg.apiKey)
|
|
}
|
|
|
|
func writeJSONSafe(c *websocket.Conn, v interface{}) error {
|
|
_ = c.SetWriteDeadline(time.Now().Add(5 * time.Second))
|
|
if err := c.WriteJSON(v); err != nil {
|
|
// caller handles logging
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func loggingMiddleware(logger *slog.Logger, next http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
start := time.Now()
|
|
next.ServeHTTP(w, r)
|
|
logger.Info("http request", "remote", r.RemoteAddr, "method", r.Method, "path", r.URL.Path, "duration", time.Since(start))
|
|
})
|
|
}
|
|
|
|
// connections
|
|
|
|
func (wsg *WebsocketGateway) registerConn(c *websocket.Conn, meta connectionMetaData) {
|
|
wsg.connsMu.Lock()
|
|
wsg.conns[c] = meta
|
|
wsg.connsMu.Unlock()
|
|
}
|
|
|
|
func (wsg *WebsocketGateway) unregisterConn(c *websocket.Conn) {
|
|
wsg.connsMu.Lock()
|
|
delete(wsg.conns, c)
|
|
wsg.connsMu.Unlock()
|
|
}
|
|
|
|
func (wsg *WebsocketGateway) closeAll() {
|
|
wsg.connsMu.Lock()
|
|
defer wsg.connsMu.Unlock()
|
|
|
|
wsg.logger.Info("Closing all websocket connections.")
|
|
|
|
for c := range wsg.conns {
|
|
_ = c.WriteControl(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, "Shutting down."), time.Now().Add(time.Second))
|
|
_ = c.Close()
|
|
}
|
|
}
|