Files
mtusi2026lab5/cache.go
T

105 lines
2.4 KiB
Go

package main
import (
"context"
"encoding/json"
"log/slog"
"time"
"github.com/redis/go-redis/v9"
)
type cachedSession struct {
UserID string `json:"user_id"`
ExpiresAt time.Time `json:"expires_at"`
}
type Cache struct {
rdb *redis.Client
log *slog.Logger
}
func openCache(log *slog.Logger) *Cache {
url, err := readSecret("CACHE_URL", "CACHE_URL_FILE")
if err != nil {
log.Warn("cache disabled", "err", err.Error())
return &Cache{log: log}
}
opt, err := redis.ParseURL(url)
if err != nil {
log.Warn("cache parse failed", "err", err.Error())
return &Cache{log: log}
}
opt.DialTimeout = 200 * time.Millisecond
opt.ReadTimeout = 200 * time.Millisecond
opt.WriteTimeout = 200 * time.Millisecond
opt.PoolTimeout = 200 * time.Millisecond
rdb := redis.NewClient(opt)
ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
defer cancel()
if err := rdb.Ping(ctx).Err(); err != nil {
log.Warn("cache ping failed, will bypass", "err", err.Error())
}
return &Cache{rdb: rdb, log: log}
}
func (c *Cache) Close() {
if c.rdb != nil {
_ = c.rdb.Close()
}
}
func sessKey(hashHex string) string {
return "sess:" + hashHex
}
func (c *Cache) GetSession(ctx context.Context, hashHex string) (*cachedSession, bool) {
if c.rdb == nil {
return nil, false
}
ctx, cancel := context.WithTimeout(ctx, 200*time.Millisecond)
defer cancel()
val, err := c.rdb.Get(ctx, sessKey(hashHex)).Result()
if err != nil {
return nil, false
}
var s cachedSession
if err := json.Unmarshal([]byte(val), &s); err != nil {
return nil, false
}
if time.Now().UTC().After(s.ExpiresAt) {
return nil, false
}
return &s, true
}
func (c *Cache) SetSession(ctx context.Context, hashHex string, userID string, expiresAt time.Time) {
if c.rdb == nil {
return
}
ttl := time.Until(expiresAt)
if ttl <= 0 {
return
}
body, err := json.Marshal(cachedSession{UserID: userID, ExpiresAt: expiresAt.UTC()})
if err != nil {
return
}
ctx, cancel := context.WithTimeout(ctx, 200*time.Millisecond)
defer cancel()
if err := c.rdb.Set(ctx, sessKey(hashHex), body, ttl).Err(); err != nil {
c.log.Warn("cache set failed", "err", err.Error())
}
}
func (c *Cache) DelSession(ctx context.Context, hashHex string) {
if c.rdb == nil {
return
}
ctx, cancel := context.WithTimeout(ctx, 200*time.Millisecond)
defer cancel()
if err := c.rdb.Del(ctx, sessKey(hashHex)).Err(); err != nil {
c.log.Warn("cache del failed", "err", err.Error())
}
}