193 lines
6.2 KiB
Go
193 lines
6.2 KiB
Go
package middleware
|
|
|
|
//
|
|
//import (
|
|
// "amuz.es/src/mercury/bootstrap"
|
|
// "amuz.es/src/mercury/common"
|
|
// "amuz.es/src/mercury/endpoint/middleware2/internal"
|
|
// rmisc "amuz.es/src/mercury/endpoint/misc"
|
|
// "amuz.es/src/mercury/service"
|
|
// "amuz.es/src/mercury/service/models"
|
|
// "amuz.es/src/go/logging"
|
|
// "amuz.es/src/go/misc"
|
|
// "amuz.es/src/mercury/util/mycrypt"
|
|
// "amuz.es/src/go/eighty"
|
|
// "bytes"
|
|
// "encoding/base64"
|
|
// "encoding/binary"
|
|
// "github.com/pkg/errors"
|
|
// "github.com/valyala/fasthttp"
|
|
// "go.uber.org/multierr"
|
|
// "strings"
|
|
// "time"
|
|
//)
|
|
//
|
|
//func SessionFunc(
|
|
// box mycrypt.SecretBox,
|
|
// sessionCookieName string,
|
|
// sessionExpire time.Duration,
|
|
// sessionSecure bool,
|
|
// parentLogger logging.Logger,
|
|
// userService service.UserService,
|
|
//) (rmisc.SessionMiddleware, error) {
|
|
// logger := parentLogger.Named("session")
|
|
// if box == nil {
|
|
// return nil, errors.New("secret box needed")
|
|
// }
|
|
// sessionKeyReader := readSessionKeyValue(box, sessionCookieName)
|
|
// sessionKeyWriter := writeSessionKeyValue(box, sessionCookieName, sessionExpire, sessionSecure)
|
|
// sessionSyncGenerator := syncSessioner(logger,
|
|
// sessionKeyWriter,
|
|
// sessionService.Update,
|
|
// sessionService.Delete,
|
|
// )
|
|
// var sessionImplPool internal.SessionImplPool
|
|
// return func(next fasthttp.RequestHandler) fasthttp.RequestHandler {
|
|
// return func(ctx *fasthttp.RequestCtx) {
|
|
// sessionData := sessionImplPool.Acquire()
|
|
// defer sessionImplPool.Release(sessionData)
|
|
// var (
|
|
// token misc.UUID
|
|
// userId *int
|
|
// user models.User
|
|
// data map[string]any
|
|
// err error
|
|
// )
|
|
// sessionData.FBox = box
|
|
// token, err = sessionKeyReader(&ctx.Request)
|
|
// if err != nil {
|
|
// logger.Debug("cannot extract token, error:", err)
|
|
// } else if token.IsZero() {
|
|
// logger.Debug("session is empty")
|
|
// } else if userId, data, err = sessionService.Get(token); err != nil {
|
|
// logger.Debug("cannot find session data from redis token:", token, " error : ", err)
|
|
// } else {
|
|
// sessionData.FToken = token
|
|
// sessionData.FData = data
|
|
// }
|
|
//
|
|
// if userId == nil {
|
|
// logger.Debug("user id is nil token:", token.ToHexString())
|
|
// } else if user, err = userService.GetUser(ctx, *userId); err != nil {
|
|
// logger.Debug("cannot query user, Id:", userId, " error : ", err)
|
|
// } else if user == nil {
|
|
// logger.Debug("user not found, Id:", userId)
|
|
// } else if user.Status() != common.UserStatusEnabled {
|
|
// logger.Debug("disabled user, Id:", userId, " status:", user.Status())
|
|
// } else {
|
|
// logger.Info("user : ", user)
|
|
// sessionData.FUser = user
|
|
// }
|
|
// sessionData.FSyncer = sessionSyncGenerator(&ctx.Request, &ctx.Response, token)
|
|
// ctx.SetUserValue(rmisc.SessionContextKey, sessionData)
|
|
// next(ctx)
|
|
// }
|
|
// }, nil
|
|
//}
|
|
//
|
|
//func readSessionKeyValue(box mycrypt.SecretBox, cookieName string) func(r *fasthttp.Request) (misc.UUID, error) {
|
|
// return func(r *fasthttp.Request) (token misc.UUID, err error) {
|
|
// defer func() {
|
|
// if panicErr := recover(); panicErr != nil {
|
|
// err = multierr.Append(err, panicErr.(error))
|
|
// }
|
|
// }()
|
|
// sessionCookieValue := r.Header.Cookie(cookieName)
|
|
// if len(sessionCookieValue) == 0 {
|
|
// err = errors.New("session is Empty")
|
|
// return
|
|
// }
|
|
// decryptor, err := box.NewDecryptReader(base64.NewDecoder(base64.StdEncoding, bytes.NewReader(sessionCookieValue)))
|
|
// if err != nil {
|
|
// return
|
|
// } else if err = binary.Read(decryptor, binary.LittleEndian, &token); err != nil {
|
|
// return
|
|
// }
|
|
// return
|
|
// }
|
|
//}
|
|
//
|
|
//func writeSessionKeyValue(
|
|
// box mycrypt.SecretBox, cookieName string,
|
|
// expireDuration time.Duration, secure bool) func(*fasthttp.Response, []byte, misc.UUID) error {
|
|
// cookieWriter := eighty.SetCookieValueFasthttp(cookieName, expireDuration, secure)
|
|
// return func(w *fasthttp.Response, hostname []byte, token misc.UUID) (err error) {
|
|
// defer func() {
|
|
// if panicErr := recover(); panicErr != nil {
|
|
// err = multierr.Append(err, panicErr.(error))
|
|
// }
|
|
// }()
|
|
// if token.IsZero() {
|
|
// cookieWriter(w, hostname, "")
|
|
// return
|
|
// }
|
|
//
|
|
// var b strings.Builder
|
|
// encryptor, err := box.NewEncryptWriter(base64.NewEncoder(base64.StdEncoding, &b))
|
|
// if err != nil {
|
|
// return
|
|
// } else if err = binary.Write(encryptor, binary.LittleEndian, token[:]); err != nil {
|
|
// return
|
|
// }
|
|
// _ = encryptor.Close()
|
|
//
|
|
// cookieWriter(w, hostname, b.String())
|
|
// return
|
|
// }
|
|
//}
|
|
//
|
|
//func syncSessioner(
|
|
// logger logging.Logger,
|
|
// sessionKeyWriter func(*fasthttp.Response, []byte, misc.UUID) error,
|
|
// sessionDataUpdater func(misc.UUID, *int, map[string]any) error,
|
|
// sessionDataDeleter func(misc.UUID) error,
|
|
//) func(*fasthttp.Request, *fasthttp.Response, misc.UUID) func(newdata internal.SessionImpl) error {
|
|
// return func(r *fasthttp.Request, w *fasthttp.Response, oldToken misc.UUID) func(newdata internal.SessionImpl) error {
|
|
// return func(newdata internal.SessionImpl) (err error) {
|
|
// newToken := newdata.FToken
|
|
// tokenNotChanged := oldToken.Equal(newToken)
|
|
// if tokenNotChanged {
|
|
// // do nothing
|
|
// } else if internalError := sessionKeyWriter(w, r.Host(), newToken); internalError != nil {
|
|
// logger.Debug("cannot generate cookie, error:", internalError)
|
|
// err = errors.Wrap(internalError, "cannot generate cookie")
|
|
// return
|
|
// }
|
|
//
|
|
// if newToken.IsZero() {
|
|
// if !tokenNotChanged {
|
|
// deleteErr := sessionDataDeleter(oldToken)
|
|
// logger.Debug("cannot delete session, error:", deleteErr)
|
|
// }
|
|
// } else if user := newdata.FUser; user == nil {
|
|
// err = sessionDataUpdater(newToken, nil, newdata.FData)
|
|
// } else {
|
|
// userId := user.Id()
|
|
// err = sessionDataUpdater(newToken, &userId, newdata.FData)
|
|
// }
|
|
// if err != nil {
|
|
// logger.Debug("cannot save session data, error:", err)
|
|
// err = errors.Wrap(err, "cannot save session data")
|
|
// }
|
|
// return
|
|
// }
|
|
// }
|
|
//}
|
|
//
|
|
//func NewSessionMiddleware(
|
|
// box rmisc.RouterSecretBox,
|
|
// sessionConfig bootstrap.SessionConfig,
|
|
// parentLogger rmisc.RouterLogger,
|
|
// sessionService service.SessionService,
|
|
// userService service.UserService) (rmisc.SessionMiddleware, error) {
|
|
// return SessionFunc(
|
|
// box,
|
|
// sessionConfig.CookieName(),
|
|
// sessionConfig.ExpireTTL(),
|
|
// sessionConfig.Secure(),
|
|
// parentLogger,
|
|
// sessionService,
|
|
// userService,
|
|
// )
|
|
//}
|