connect/server/server.go

package server

import (
	"net/http"
	"strings"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/golang-jwt/jwt/v5"
	"github.com/gorilla/websocket"
	"github.com/rotisserie/eris"
	"github.com/spf13/viper"
	"sikey.com/websocket/repositories"
	"sikey.com/websocket/utils/keys"
	"sikey.com/websocket/utils/zlog"
)

type Server struct {
	Ctx          *gin.Context
	Repositories *repositories.Repositories

	Upgrader websocket.Upgrader
	Hub      *Hub

	ReadWait  time.Duration
	WriteWait time.Duration
	PingWait  time.Duration
}

func WebsocketHandler(ctx *gin.Context, srv *Server) {
	srv.Ctx = ctx

	conn, err := srv.Upgrader.Upgrade(ctx.Writer, ctx.Request, nil)
	if err != nil {
		ctx.AbortWithError(http.StatusInternalServerError, err)
		return
	}

	// Builder headers
	headers := headerBuilder(ctx)

	// Validate token
	id, ok, err := jwtParse(headers)
	if !ok {
		ctx.AbortWithError(http.StatusUnauthorized, err)
		return
	}

	// Create client
	client := &Client{
		ctx:             ctx.Copy(),
		UserId:          id,
		hub:             srv.Hub,
		UnderlyingConn:  conn,
		Send:            make(chan *Message, 256),
		RemotelyMessage: make(chan *Message, 256),
		writeWait:       srv.WriteWait,
		readWait:        srv.ReadWait,
		pingWait:        srv.PingWait,

		isSimpleMsg:  headers[keys.SimpleHeader].(bool),
		localization: headers[keys.LocalizationHeader].(string),

		repos: srv.Repositories,
	}
	client.hub.Connect <- client
	// client.hub.exchange.OnlineNotify(client.UserId)
	zlog.Info("client online: ", client.UserId)

	go client.reader()
	go client.writer()
}

type Headers = map[string]interface{}

func headerBuilder(ctx *gin.Context) Headers {
	headers := make(Headers)
	request := ctx.Request
	accessToken := request.URL.Query().Get(keys.AccessTokenHeader)
	simple := request.URL.Query().Get(keys.SimpleHeader)
	localization := request.URL.Query().Get(keys.LocalizationHeader)
	headers[keys.AccessTokenHeader] = accessToken
	headers[keys.SimpleHeader] = simple == "1"
	headers[keys.LocalizationHeader] = localization
	return headers
}

func jwtParse(headers Headers) (string, bool, error) {
	accessToken := headers[keys.AccessTokenHeader].(string)
	if len(accessToken) == 0 {
		return "", false, eris.New("token is empty")
	}
	accessToken = strings.Trim(accessToken, " ")

	token, err := jwt.Parse(accessToken, func(token *jwt.Token) (interface{}, error) {
		return []byte(viper.GetString("auth.secret")), nil
	})
	if err != nil {
		zlog.Error(err.Error())
		return "", false, eris.Wrap(err, "token parse error")
	}

	mapClaims := token.Claims.(jwt.MapClaims)
	// exp := mapClaims["exp"].(float64)
	// if exp != 0 && exp < float64(time.Now().Unix()) {
	// 	return "", false, eris.New("token is expired")
	// }
	uid := mapClaims["Uid"].(string)
	return uid, true, nil
}