forked from mtusi2026/mtusi2026lab5
105 lines
2.4 KiB
Go
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())
|
|
}
|
|
}
|