lot of new functionalities

core/utils/storage/sessions.go

@@ -0,0 +1,152 @@
+package storage
+
+import (
+	"context"
+	"encoding/base32"
+	"errors"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/gorilla/securecookie"
+	"github.com/gorilla/sessions"
+	"github.com/rs/zerolog/log"
+)
+
+// Amount of time for cookies/kv keys to expire.
+var sessionExpire = 86400 * 30
+
+type SessionStore struct {
+	KV            KVHandler
+	Codecs        []securecookie.Codec
+	options       *sessions.Options // default configuration
+	DefaultMaxAge int               // default TiKV TTL for a MaxAge == 0 session
+	//maxLength     int
+	keyPrefix string
+	//serializer    SessionSerializer
+}
+
+func NewSessionStore(client KVHandler, keyPairs ...[]byte) *SessionStore {
+	es := &SessionStore{
+		KV:     client,
+		Codecs: securecookie.CodecsFromPairs(keyPairs...),
+		options: &sessions.Options{
+			Path:   "/",
+			MaxAge: sessionExpire,
+		},
+		DefaultMaxAge: sessionExpire, // 20 minutes seems like a reasonable default
+		//maxLength:     4096,
+		keyPrefix: "session/",
+	}
+
+	return es
+}
+
+func (s *SessionStore) Get(r *http.Request, name string) (*sessions.Session, error) {
+	// session := sessions.NewSession(s, name)
+	// ok, err := s.load(r.Context(), session)
+	// if !(err == nil && ok) {
+	// 	if err == nil {
+	// 		err = errors.New("key does not exist")
+	// 	}
+	// }
+	// return session, err
+	return sessions.GetRegistry(r).Get(s, name)
+}
+
+func (s *SessionStore) New(r *http.Request, name string) (*sessions.Session, error) {
+	session := sessions.NewSession(s, name)
+	options := *s.options
+	session.Options = &options
+	session.IsNew = true
+	if c, errCookie := r.Cookie(name); errCookie == nil {
+		err := securecookie.DecodeMulti(name, c.Value, &session.ID, s.Codecs...)
+		if err != nil {
+			return session, err
+		}
+		ok, err := s.load(r.Context(), session)
+		session.IsNew = !(err == nil && ok) // not new if no error and data available
+	}
+	return session, nil
+}
+
+// Save adds a single session to the response.
+func (s *SessionStore) Save(r *http.Request, w http.ResponseWriter, session *sessions.Session) error {
+
+	// Marked for deletion.
+	if session.Options.MaxAge <= 0 {
+		if err := s.delete(r.Context(), session); err != nil {
+			log.Error().Err(err).Msg("")
+			return err
+		}
+		http.SetCookie(w, sessions.NewCookie(session.Name(), "", session.Options))
+	} else {
+		// Build an alphanumeric key for the kv store.
+		if session.ID == "" {
+			session.ID = strings.TrimRight(base32.StdEncoding.EncodeToString(securecookie.GenerateRandomKey(32)), "=")
+		}
+
+		if err := s.save(r.Context(), session); err != nil {
+			log.Error().Err(err).Msg("")
+			return err
+		}
+
+		encoded, err := securecookie.EncodeMulti(session.Name(), session.ID, s.Codecs...)
+		if err != nil {
+			log.Error().Err(err).Msg("")
+			return err
+		}
+		http.SetCookie(w, sessions.NewCookie(session.Name(), encoded, session.Options))
+	}
+	return nil
+}
+
+// save stores the session in kv.
+func (s *SessionStore) save(ctx context.Context, session *sessions.Session) error {
+	m := make(map[string]interface{}, len(session.Values))
+	for k, v := range session.Values {
+		ks, ok := k.(string)
+		if !ok {
+			err := fmt.Errorf("non-string key value, cannot serialize session: %v", k)
+			log.Error().Err(err).Msg("")
+			return err
+		}
+		m[ks] = v
+	}
+
+	age := session.Options.MaxAge
+	if age == 0 {
+		age = s.DefaultMaxAge
+	}
+
+	return s.KV.PutWithTTL(s.keyPrefix+session.ID, m, time.Duration(age)*time.Second)
+}
+
+// load reads the session from kv store.
+// returns true if there is a sessoin data in DB
+func (s *SessionStore) load(ctx context.Context, session *sessions.Session) (bool, error) {
+
+	data, err := s.KV.Get(s.keyPrefix + session.ID)
+	if err != nil {
+		return false, err
+	}
+
+	if data == nil && err == nil {
+		return false, errors.New("key does not exist")
+	}
+
+	for k, v := range data.(map[string]any) {
+		session.Values[k] = v
+	}
+
+	return true, nil
+}
+
+// delete removes keys from tikv if MaxAge<0
+func (s *SessionStore) delete(ctx context.Context, session *sessions.Session) error {
+	if err := s.KV.Delete(s.keyPrefix + session.ID); err != nil {
+		return err
+	}
+	return nil
+}