forked from mtusi2026/mtusi2026lab4
174 lines
4.4 KiB
Go
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()
|
|
}
|