fix: move sessionstore -> memstore

server/memorystore/providers/inmemory/inmemory.go

@@ -0,0 +1,72 @@
+package inmemory
+
+import "strings"
+
+// ClearStore clears the in-memory store.
+func (c *provider) ClearStore() error {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+	c.sessionStore = map[string]map[string]string{}
+
+	return nil
+}
+
+// GetUserSessions returns all the user session token from the in-memory store.
+func (c *provider) GetUserSessions(userId string) map[string]string {
+	// c.mutex.Lock()
+	// defer c.mutex.Unlock()
+	res := map[string]string{}
+	for k, v := range c.stateStore {
+		split := strings.Split(v, "@")
+		if split[1] == userId {
+			res[k] = split[0]
+		}
+	}
+
+	return res
+}
+
+// DeleteAllUserSession deletes all the user sessions from in-memory store.
+func (c *provider) DeleteAllUserSession(userId string) error {
+	// c.mutex.Lock()
+	// defer c.mutex.Unlock()
+	sessions := c.GetUserSessions(userId)
+	for k := range sessions {
+		c.RemoveState(k)
+	}
+
+	return nil
+}
+
+// SetState sets the state in the in-memory store.
+func (c *provider) SetState(key, state string) error {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+
+	c.stateStore[key] = state
+
+	return nil
+}
+
+// GetState gets the state from the in-memory store.
+func (c *provider) GetState(key string) string {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+
+	state := ""
+	if stateVal, ok := c.stateStore[key]; ok {
+		state = stateVal
+	}
+
+	return state
+}
+
+// RemoveState removes the state from the in-memory store.
+func (c *provider) RemoveState(key string) error {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+
+	delete(c.stateStore, key)
+
+	return nil
+}

server/memorystore/providers/inmemory/provider.go

@@ -0,0 +1,18 @@
+package inmemory
+
+import "sync"
+
+type provider struct {
+	mutex        sync.Mutex
+	sessionStore map[string]map[string]string
+	stateStore   map[string]string
+}
+
+// NewInMemoryStore returns a new in-memory store.
+func NewInMemoryProvider() (*provider, error) {
+	return &provider{
+		mutex:        sync.Mutex{},
+		sessionStore: map[string]map[string]string{},
+		stateStore:   map[string]string{},
+	}, nil
+}

server/memorystore/providers/providers.go

@@ -0,0 +1,17 @@
+package providers
+
+// Provider defines current memory store provider
+type Provider interface {
+	// DeleteAllSessions deletes all the sessions from the session store
+	DeleteAllUserSession(userId string) error
+	// GetUserSessions returns all the user sessions from the session store
+	GetUserSessions(userId string) map[string]string
+	// ClearStore clears the session store for authorizer tokens
+	ClearStore() error
+	// SetState sets the login state (key, value form) in the session store
+	SetState(key, state string) error
+	// GetState returns the state from the session store
+	GetState(key string) string
+	// RemoveState removes the social login state from the session store
+	RemoveState(key string) error
+}

server/memorystore/providers/redis/provider.go

@@ -0,0 +1,75 @@
+package redis
+
+import (
+	"context"
+	"strings"
+	"time"
+
+	"github.com/go-redis/redis/v8"
+	log "github.com/sirupsen/logrus"
+)
+
+// RedisClient is the interface for redis client & redis cluster client
+type RedisClient interface {
+	HMSet(ctx context.Context, key string, values ...interface{}) *redis.BoolCmd
+	Del(ctx context.Context, keys ...string) *redis.IntCmd
+	HDel(ctx context.Context, key string, fields ...string) *redis.IntCmd
+	HMGet(ctx context.Context, key string, fields ...string) *redis.SliceCmd
+	HGetAll(ctx context.Context, key string) *redis.StringStringMapCmd
+	Set(ctx context.Context, key string, value interface{}, expiration time.Duration) *redis.StatusCmd
+	Get(ctx context.Context, key string) *redis.StringCmd
+}
+
+type provider struct {
+	ctx   context.Context
+	store RedisClient
+}
+
+// NewRedisProvider returns a new redis provider
+func NewRedisProvider(redisURL string) (*provider, error) {
+	redisURLHostPortsList := strings.Split(redisURL, ",")
+
+	if len(redisURLHostPortsList) > 1 {
+		opt, err := redis.ParseURL(redisURLHostPortsList[0])
+		if err != nil {
+			log.Debug("error parsing redis url: ", err)
+			return nil, err
+		}
+		urls := []string{opt.Addr}
+		urlList := redisURLHostPortsList[1:]
+		urls = append(urls, urlList...)
+		clusterOpt := &redis.ClusterOptions{Addrs: urls}
+
+		rdb := redis.NewClusterClient(clusterOpt)
+		ctx := context.Background()
+		_, err = rdb.Ping(ctx).Result()
+		if err != nil {
+			log.Debug("error connecting to redis: ", err)
+			return nil, err
+		}
+
+		return &provider{
+			ctx:   ctx,
+			store: rdb,
+		}, nil
+	}
+
+	opt, err := redis.ParseURL(redisURL)
+	if err != nil {
+		log.Debug("error parsing redis url: ", err)
+		return nil, err
+	}
+
+	rdb := redis.NewClient(opt)
+	ctx := context.Background()
+	_, err = rdb.Ping(ctx).Result()
+	if err != nil {
+		log.Debug("error connecting to redis: ", err)
+		return nil, err
+	}
+
+	return &provider{
+		ctx:   ctx,
+		store: rdb,
+	}, nil
+}

server/memorystore/providers/redis/reids.go

@@ -0,0 +1,85 @@
+package redis
+
+import (
+	"strings"
+
+	log "github.com/sirupsen/logrus"
+)
+
+// ClearStore clears the redis store for authorizer related tokens
+func (c *provider) ClearStore() error {
+	err := c.store.Del(c.ctx, "authorizer_*").Err()
+	if err != nil {
+		log.Debug("Error clearing redis store: ", err)
+		return err
+	}
+
+	return nil
+}
+
+// GetUserSessions returns all the user session token from the redis store.
+func (c *provider) GetUserSessions(userID string) map[string]string {
+	data, err := c.store.HGetAll(c.ctx, "*").Result()
+	if err != nil {
+		log.Debug("error getting token from redis store: ", err)
+	}
+
+	res := map[string]string{}
+	for k, v := range data {
+		split := strings.Split(v, "@")
+		if split[1] == userID {
+			res[k] = split[0]
+		}
+	}
+
+	return res
+}
+
+// DeleteAllUserSession deletes all the user session from redis
+func (c *provider) DeleteAllUserSession(userId string) error {
+	sessions := c.GetUserSessions(userId)
+	for k, v := range sessions {
+		if k == "token" {
+			err := c.store.Del(c.ctx, v).Err()
+			if err != nil {
+				log.Debug("Error deleting redis token: ", err)
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+// SetState sets the state in redis store.
+func (c *provider) SetState(key, value string) error {
+	err := c.store.Set(c.ctx, "authorizer_"+key, value, 0).Err()
+	if err != nil {
+		log.Debug("Error saving redis token: ", err)
+		return err
+	}
+
+	return nil
+}
+
+// GetState gets the state from redis store.
+func (c *provider) GetState(key string) string {
+	state := ""
+	state, err := c.store.Get(c.ctx, "authorizer_"+key).Result()
+	if err != nil {
+		log.Debug("error getting token from redis store: ", err)
+	}
+
+	return state
+}
+
+// RemoveState removes the state from redis store.
+func (c *provider) RemoveState(key string) error {
+	err := c.store.Del(c.ctx, "authorizer_"+key).Err()
+	if err != nil {
+		log.Fatalln("Error deleting redis token: ", err)
+		return err
+	}
+
+	return nil
+}