[auth] add users cache

Author: capcom6

internal/sms-gateway/modules/auth/service.go

@@ -1,12 +1,16 @@
 package auth
 
 import (
+	"crypto/sha256"
+	"encoding/hex"
 	"fmt"
+	"time"
 
 	"github.com/capcom6/sms-gateway/internal/sms-gateway/models"
 	"github.com/capcom6/sms-gateway/internal/sms-gateway/modules/devices"
 	"github.com/capcom6/sms-gateway/internal/sms-gateway/repositories"
 	"github.com/capcom6/sms-gateway/pkg/crypto"
+	"github.com/capcom6/sms-gateway/pkg/types/cache"
 	"github.com/jaevor/go-nanoid"
 	"go.uber.org/fx"
 	"go.uber.org/zap"
@@ -32,6 +36,8 @@ type Service struct {
 	config Config
 
 	users      *repositories.UsersRepository
+	usersCache *cache.Cache[models.User]
+
 	devicesSvc *devices.Service
 
 	logger *zap.Logger
@@ -48,6 +54,8 @@ func New(params Params) *Service {
 		devicesSvc: params.DevicesSvc,
 		logger:     params.Logger.Named("Service"),
 		idgen:      idgen,
+
+		usersCache: cache.New[models.User](cache.Config{TTL: 1 * time.Hour}),
 	}
 }
 
@@ -111,10 +119,26 @@ func (s *Service) AuthorizeDevice(token string) (models.Device, error) {
 }
 
 func (s *Service) AuthorizeUser(username, password string) (models.User, error) {
-	user, err := s.users.GetByLogin(username)
+	hash := sha256.Sum256([]byte(username + password))
+	cacheKey := hex.EncodeToString(hash[:])
+
+	user, err := s.usersCache.Get(cacheKey)
+	if err == nil {
+		return user, nil
+	}
+
+	user, err = s.users.GetByLogin(username)
 	if err != nil {
 		return user, err
 	}
 
-	return user, crypto.CompareBCryptHash(user.PasswordHash, password)
+	if err := crypto.CompareBCryptHash(user.PasswordHash, password); err != nil {
+		return models.User{}, err
+	}
+
+	if err := s.usersCache.Set(cacheKey, user); err != nil {
+		s.logger.Error("can't cache user", zap.Error(err))
+	}
+
+	return user, nil
 }

internal/sms-gateway/modules/push/service.go

@@ -2,6 +2,7 @@ package push
 
 import (
 	"context"
+	"fmt"
 	"time"
 
 	"github.com/capcom6/sms-gateway/pkg/types/cache"
@@ -60,7 +61,7 @@ func New(params Params) *Service {
 	return &Service{
 		config:          params.Config,
 		client:          params.Client,
-		cache:           cache.New[Event](),
+		cache:           cache.New[Event](cache.Config{}),
 		enqueuedCounter: enqueuedCounter,
 		logger:          params.Logger,
 	}
@@ -83,7 +84,9 @@ func (s *Service) Run(ctx context.Context) {
 
 // Enqueue adds the data to the cache and immediately sends all messages if the debounce is 0.
 func (s *Service) Enqueue(token string, event *Event) error {
-	s.cache.Set(token, *event)
+	if err := s.cache.Set(token, *event); err != nil {
+		return fmt.Errorf("can't add message to cache: %w", err)
+	}
 
 	s.enqueuedCounter.WithLabelValues(string(event.Event)).Inc()
 

pkg/types/cache/cache.go

@@ -1,32 +1,94 @@
 package cache
 
-import "sync"
+import (
+	"sync"
+	"time"
+)
+
+type item[T any] struct {
+	value      T
+	validUntil time.Time
+}
+
+func (i *item[T]) isExpired(now time.Time) bool {
+	return !i.validUntil.IsZero() && now.After(i.validUntil)
+}
 
 type Cache[T any] struct {
-	storage map[string]T
-	mux     sync.RWMutex
+	items map[string]*item[T]
+	ttl   time.Duration
+	empty T
+
+	mux sync.RWMutex
 }
 
-func New[T any]() *Cache[T] {
+func New[T any](cfg Config) *Cache[T] {
 	return &Cache[T]{
-		storage: make(map[string]T),
+		items: make(map[string]*item[T]),
+		ttl:   cfg.TTL,
 	}
 }
 
-func (c *Cache[T]) Set(key string, value T) {
+func (c *Cache[T]) Set(key string, value T) error {
+	var validUntil time.Time
+	if c.ttl > 0 {
+		validUntil = time.Now().Add(c.ttl)
+	}
+
 	c.mux.Lock()
-	defer c.mux.Unlock()
+	c.items[key] = &item[T]{
+		value:      value,
+		validUntil: validUntil,
+	}
+	c.mux.Unlock()
 
-	c.storage[key] = value
+	return nil
+}
+
+func (c *Cache[T]) Get(key string) (T, error) {
+	c.mux.RLock()
+	item, ok := c.items[key]
+	c.mux.RUnlock()
+
+	if !ok {
+		return c.empty, ErrKeyNotFound
+	}
+
+	if item.isExpired(time.Now()) {
+		return c.empty, ErrKeyExpired
+	}
+
+	return item.value, nil
 }
 
 func (c *Cache[T]) Drain() map[string]T {
+	t := time.Now()
+
 	c.mux.Lock()
-	defer c.mux.Unlock()
+	copy := c.items
+	c.items = make(map[string]*item[T], len(copy))
+	c.mux.Unlock()
+
+	items := make(map[string]T, len(copy))
+	for key, item := range copy {
+		if item.isExpired(t) {
+			continue
+		}
+		items[key] = item.value
+	}
+
+	return items
+}
 
-	storage := c.storage
+func (c *Cache[T]) Cleanup() {
+	t := time.Now()
 
-	c.storage = make(map[string]T)
+	c.mux.Lock()
+	defer c.mux.Unlock()
 
-	return storage
+	for key, item := range c.items {
+		if item.isExpired(t) {
+			delete(c.items, key)
+		}
+	}
 }