Files
mtusi2026lab3/internal/session/session.go
T

174 lines
4.4 KiB
Go

// Package session хранит непрозрачные Bearer-сессии.
// В стенде это Redis: ключ живёт ровно до expires_at, рестарт TTL не сдвигает.
package session
import (
"context"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"errors"
"sync"
"time"
"github.com/redis/go-redis/v9"
)
var (
ErrNotFound = errors.New("session not found")
ErrUnavailable = errors.New("session store unavailable")
)
// Store — срок жизни сессии задаёт вызывающий, хранилище его не продлевает.
type Store interface {
Create(ctx context.Context, token, userID string, expiresAt time.Time) error
Lookup(ctx context.Context, token string) (userID string, expiresAt time.Time, err error)
Revoke(ctx context.Context, token string) error
Ping(ctx context.Context) error
Close() error
}
type record struct {
UserID string `json:"user_id"`
ExpUnix int64 `json:"exp_unix"`
}
// key — хеш токена. Сам токен в Redis не пишется: утечка дампа не равна утечке Bearer.
func key(token string) string {
sum := sha256.Sum256([]byte(token))
return "sess:" + hex.EncodeToString(sum[:])
}
// Memory — сессии процесса. Нужна юнит-тестам без Docker.
type Memory struct {
mu sync.Mutex
items map[string]record
}
func NewMemory() *Memory {
return &Memory{items: make(map[string]record)}
}
func (m *Memory) Create(_ context.Context, token, userID string, expiresAt time.Time) error {
if token == "" || userID == "" {
return ErrNotFound
}
m.mu.Lock()
defer m.mu.Unlock()
m.items[key(token)] = record{UserID: userID, ExpUnix: expiresAt.UTC().UnixMicro()}
return nil
}
func (m *Memory) Lookup(_ context.Context, token string) (string, time.Time, error) {
m.mu.Lock()
defer m.mu.Unlock()
rec, ok := m.items[key(token)]
if !ok {
return "", time.Time{}, ErrNotFound
}
exp := time.UnixMicro(rec.ExpUnix).UTC()
if !time.Now().Before(exp) {
delete(m.items, key(token))
return "", time.Time{}, ErrNotFound
}
return rec.UserID, exp, nil
}
func (m *Memory) Revoke(_ context.Context, token string) error {
m.mu.Lock()
defer m.mu.Unlock()
k := key(token)
if _, ok := m.items[k]; !ok {
return ErrNotFound
}
delete(m.items, k)
return nil
}
func (m *Memory) Ping(ctx context.Context) error {
if err := ctx.Err(); err != nil {
return ErrUnavailable
}
return nil
}
func (m *Memory) Close() error { return nil }
// Redis — единственное хранилище сессий стенда.
type Redis struct {
client *redis.Client
}
func OpenRedis(rawURL string) (*Redis, error) {
opt, err := redis.ParseURL(rawURL)
if err != nil {
return nil, err
}
opt.DialTimeout = 500 * time.Millisecond
opt.ReadTimeout = 500 * time.Millisecond
opt.WriteTimeout = 500 * time.Millisecond
opt.PoolSize = 10
opt.MinIdleConns = 1
return &Redis{client: redis.NewClient(opt)}, nil
}
func (r *Redis) Create(ctx context.Context, token, userID string, expiresAt time.Time) error {
if token == "" || userID == "" {
return ErrNotFound
}
ttl := time.Until(expiresAt)
if ttl < time.Millisecond {
return ErrNotFound
}
body, err := json.Marshal(record{UserID: userID, ExpUnix: expiresAt.UTC().UnixMicro()})
if err != nil {
return err
}
if err := r.client.Set(ctx, key(token), body, ttl).Err(); err != nil {
return ErrUnavailable
}
return nil
}
func (r *Redis) Lookup(ctx context.Context, token string) (string, time.Time, error) {
raw, err := r.client.Get(ctx, key(token)).Bytes()
if errors.Is(err, redis.Nil) {
return "", time.Time{}, ErrNotFound
}
if err != nil {
return "", time.Time{}, ErrUnavailable
}
var rec record
if err := json.Unmarshal(raw, &rec); err != nil || rec.UserID == "" {
return "", time.Time{}, ErrNotFound
}
exp := time.UnixMicro(rec.ExpUnix).UTC()
if !time.Now().Before(exp) {
_ = r.client.Del(ctx, key(token)).Err()
return "", time.Time{}, ErrNotFound
}
return rec.UserID, exp, nil
}
func (r *Redis) Revoke(ctx context.Context, token string) error {
n, err := r.client.Del(ctx, key(token)).Result()
if err != nil {
return ErrUnavailable
}
if n == 0 {
return ErrNotFound
}
return nil
}
func (r *Redis) Ping(ctx context.Context) error {
if err := r.client.Ping(ctx).Err(); err != nil {
return ErrUnavailable
}
return nil
}
func (r *Redis) Close() error {
return r.client.Close()
}