Files
mtusi2026lab5/app/internal/cache/history.go
T

479 lines
13 KiB
Go

package cache
import (
"context"
"crypto/rand"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"log/slog"
"os"
"strconv"
"strings"
"sync"
"sync/atomic"
"time"
"github.com/redis/go-redis/v9"
"golang.org/x/sync/singleflight"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/config"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/store"
)
const (
ModeOff = "off"
ModeNaive = "naive"
ModeSafe = "safe"
)
type Source interface {
store.MessageStore
IsMember(ctx context.Context, chatID, userID string) (bool, error)
HistoryPage(ctx context.Context, chatID, cursor string, limit int) (domain.Page[domain.Message], error)
}
// Outbox хранит долг инвалидации в источнике истины, чтобы он пережил
// рестарт API. Без него отложенная инвалидация живёт только в памяти.
type Outbox interface {
AddPendingInvalidation(ctx context.Context, chatID string) (int64, error)
PendingInvalidations(ctx context.Context) (map[string]int64, error)
ResolvePendingInvalidation(ctx context.Context, chatID string, gen int64) error
}
type Options struct {
Mode string
Outbox Outbox
PageTTL time.Duration
LockTTL time.Duration
FillDelay time.Duration
Logger *slog.Logger
}
var _ store.MessageStore = (*Messages)(nil)
// pendingEntry — несброшенная версия чата. seq меняется при каждом новом
// сбое: повтор снимает запись, только если seq не изменился с его снимка.
// gen — поколение строки в Outbox (0 — не записана).
type pendingEntry struct {
seq uint64
gen int64
}
type Messages struct {
src Source
rdb *redis.Client
opt Options
group singleflight.Group
log *slog.Logger
downUntil atomic.Int64
// loaded: долг инвалидации из Outbox прочитан. До этого любой чат может
// иметь устаревшую версию, поэтому все чтения идут мимо кэша.
loaded atomic.Bool
mu sync.Mutex
pending map[string]pendingEntry
seq uint64
stop chan struct{}
done chan struct{}
}
const (
memberTTL = 24 * time.Hour
versionTTL = 24 * time.Hour
breakerPause = time.Second
retryInterval = 200 * time.Millisecond
pollInterval = 5 * time.Millisecond
defaultPageTTL = 30 * time.Second
defaultLockTTL = 500 * time.Millisecond
)
func New(src Source, rdb *redis.Client, opt Options) *Messages {
if opt.PageTTL <= 0 {
opt.PageTTL = defaultPageTTL
}
if opt.LockTTL <= 0 {
opt.LockTTL = defaultLockTTL
}
if opt.Logger == nil {
opt.Logger = slog.Default()
}
m := &Messages{
src: src,
rdb: rdb,
opt: opt,
log: opt.Logger,
pending: make(map[string]pendingEntry),
stop: make(chan struct{}),
done: make(chan struct{}),
}
m.loaded.Store(opt.Outbox == nil || opt.Mode != ModeSafe)
go m.retryLoop()
return m
}
func Connect(cfg config.HistoryCache) (*redis.Client, error) {
url := cfg.URL
if cfg.URLFile != "" {
b, err := os.ReadFile(cfg.URLFile)
if err != nil {
return nil, fmt.Errorf("cache: read HISTORY_CACHE_URL_FILE: %w", err)
}
url = strings.TrimSpace(string(b))
}
if url == "" {
return nil, errors.New("cache: HISTORY_CACHE_URL_FILE or HISTORY_CACHE_URL is required unless HISTORY_CACHE=off")
}
opts, err := redis.ParseURL(url)
if err != nil {
return nil, errors.New("cache: invalid HISTORY_CACHE_URL")
}
timeout := time.Duration(cfg.TimeoutMs) * time.Millisecond
opts.PoolSize = cfg.PoolSize
opts.DialTimeout = timeout
opts.ReadTimeout = timeout
opts.WriteTimeout = timeout
opts.PoolTimeout = timeout
opts.MaxRetries = -1 // без повторов: промах кэша дешевле ожидания
return redis.NewClient(opts), nil
}
func (m *Messages) Close() {
close(m.stop)
<-m.done
}
func (m *Messages) AddMessage(ctx context.Context, callerID, chatID, idempotencyKey, text string, attachmentIDs []string) (domain.Message, error) {
msg, err := m.src.AddMessage(ctx, callerID, chatID, idempotencyKey, text, attachmentIDs)
if err != nil {
return msg, err
}
// Инвалидация нужна и при повторе: реплика, выполнившая COMMIT, могла упасть до
// сброса кэша, и тогда ответ 201 на повтор — первое подтверждение этого сообщения.
ictx := context.WithoutCancel(ctx)
switch m.opt.Mode {
case ModeNaive:
m.naiveInvalidate(ictx, chatID)
case ModeSafe:
if err := m.rdb.Del(ictx, verKey(chatID)).Err(); err != nil {
m.markDown(err)
m.addPending(ictx, chatID)
}
}
return msg, nil
}
func (m *Messages) ListMessages(ctx context.Context, callerID, chatID, cursor string, limit int) (domain.Page[domain.Message], error) {
if m.opt.Mode == ModeOff || m.bypass(chatID) {
return m.src.ListMessages(ctx, callerID, chatID, cursor, limit)
}
if err := m.checkMember(ctx, chatID, callerID); err != nil {
return domain.Page[domain.Message]{}, err
}
if m.opt.Mode == ModeNaive {
return m.naiveList(ctx, chatID, cursor, limit)
}
return m.safeList(ctx, chatID, cursor, limit)
}
func (m *Messages) checkMember(ctx context.Context, chatID, userID string) error {
key := "hc:member:" + chatID + ":" + userID
if !m.isDown() {
v, err := m.rdb.Get(ctx, key).Result()
if err == nil && v == "1" {
return nil
}
m.markDown(err)
}
ok, err := m.src.IsMember(ctx, chatID, userID)
if err != nil {
return err
}
if !ok {
// Отрицательный ответ не кэшируем.
return domain.ErrNotFound
}
if !m.isDown() {
m.markDown(m.rdb.Set(ctx, key, "1", memberTTL).Err())
}
return nil
}
func (m *Messages) naiveList(ctx context.Context, chatID, cursor string, limit int) (domain.Page[domain.Message], error) {
key := pageKey("hc:naive:"+chatID, cursor, limit)
if page, ok := m.getPage(ctx, key); ok {
return page, nil
}
page, err := m.src.HistoryPage(ctx, chatID, cursor, limit)
if err != nil {
return page, err
}
m.sleepFill(ctx)
if b, err := encodePage(page); err == nil {
setKey := "hc:naive:keys:" + chatID
_, err := m.rdb.TxPipelined(ctx, func(p redis.Pipeliner) error {
p.Set(ctx, key, b, m.opt.PageTTL)
p.SAdd(ctx, setKey, key)
p.Expire(ctx, setKey, m.opt.PageTTL)
return nil
})
m.markDown(err)
}
return page, nil
}
func (m *Messages) naiveInvalidate(ctx context.Context, chatID string) {
setKey := "hc:naive:keys:" + chatID
keys, err := m.rdb.SMembers(ctx, setKey).Result()
if err != nil {
m.markDown(err)
return
}
m.markDown(m.rdb.Del(ctx, append(keys, setKey)...).Err())
}
func (m *Messages) safeList(ctx context.Context, chatID, cursor string, limit int) (domain.Page[domain.Message], error) {
ver, err := m.version(ctx, chatID)
if err != nil {
m.markDown(err)
return m.src.HistoryPage(ctx, chatID, cursor, limit)
}
key := pageKey("hc:page:"+chatID+":"+ver, cursor, limit)
if page, ok := m.getPage(ctx, key); ok {
return page, nil
}
v, err, _ := m.group.Do(key, func() (any, error) {
return m.fill(context.WithoutCancel(ctx), key, chatID, cursor, limit)
})
if err != nil {
return domain.Page[domain.Message]{}, err
}
return v.(domain.Page[domain.Message]), nil
}
func (m *Messages) version(ctx context.Context, chatID string) (string, error) {
key := verKey(chatID)
v, err := m.rdb.Get(ctx, key).Result()
if err == nil {
return v, nil
}
if !errors.Is(err, redis.Nil) {
return "", err
}
fresh := randomVersion()
old, err := m.rdb.SetArgs(ctx, key, fresh, redis.SetArgs{Mode: "NX", Get: true, TTL: versionTTL}).Result()
if errors.Is(err, redis.Nil) {
return fresh, nil
}
if err != nil {
return "", err
}
return old, nil
}
var unlockScript = redis.NewScript(`
if redis.call("GET", KEYS[1]) == ARGV[1] then return redis.call("DEL", KEYS[1]) end
return 0`)
func (m *Messages) fill(ctx context.Context, key, chatID, cursor string, limit int) (domain.Page[domain.Message], error) {
lockKey := "hc:lock:" + key
token := randomVersion()
locked, err := m.rdb.SetNX(ctx, lockKey, token, m.opt.LockTTL).Result()
if err != nil {
m.markDown(err)
return m.src.HistoryPage(ctx, chatID, cursor, limit)
}
if !locked {
deadline := time.Now().Add(m.opt.LockTTL)
for time.Now().Before(deadline) {
time.Sleep(pollInterval)
if page, ok := m.getPage(ctx, key); ok {
return page, nil
}
}
return m.src.HistoryPage(ctx, chatID, cursor, limit)
}
defer unlockScript.Run(ctx, m.rdb, []string{lockKey}, token)
page, err := m.src.HistoryPage(ctx, chatID, cursor, limit)
if err != nil {
return page, err
}
m.sleepFill(ctx)
if b, err := encodePage(page); err == nil {
m.markDown(m.rdb.Set(ctx, key, b, m.opt.PageTTL).Err())
}
return page, nil
}
// addPending вызывается до ответа 201: после него чат читается мимо кэша,
// пока версия не будет сброшена, в том числе после рестарта API.
func (m *Messages) addPending(ctx context.Context, chatID string) {
m.markPending(chatID, 0)
if m.opt.Outbox == nil {
m.log.Warn("history cache invalidation deferred", slog.String("chat_id", chatID))
return
}
gen, err := m.opt.Outbox.AddPendingInvalidation(ctx, chatID)
if err != nil {
m.log.Error("history cache invalidation deferred in memory only, lost on restart",
slog.String("chat_id", chatID), slog.Any("err", err))
return
}
m.markPending(chatID, gen)
m.log.Warn("history cache invalidation deferred",
slog.String("chat_id", chatID), slog.Int64("gen", gen))
}
// markPending всегда выдаёт новый seq, чтобы повтор, начатый раньше, не снял
// запись. gen не уменьшается.
func (m *Messages) markPending(chatID string, gen int64) {
m.mu.Lock()
m.seq++
e := m.pending[chatID]
e.seq = m.seq
e.gen = max(e.gen, gen)
m.pending[chatID] = e
m.mu.Unlock()
}
func (m *Messages) bypass(chatID string) bool {
if m.isDown() || !m.loaded.Load() {
return true
}
m.mu.Lock()
_, ok := m.pending[chatID]
m.mu.Unlock()
return ok
}
func (m *Messages) loadPending() {
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
rows, err := m.opt.Outbox.PendingInvalidations(ctx)
if err != nil {
m.log.Warn("history cache: pending invalidations not loaded, bypassing", slog.Any("err", err))
return
}
for id, gen := range rows {
m.markPending(id, gen)
}
m.loaded.Store(true)
if len(rows) > 0 {
m.log.Info("history cache: pending invalidations loaded", slog.Int("chats", len(rows)))
}
}
func (m *Messages) retryLoop() {
defer close(m.done)
t := time.NewTicker(retryInterval)
defer t.Stop()
for {
if !m.loaded.Load() {
m.loadPending()
}
m.retryPending()
select {
case <-m.stop:
return
case <-t.C:
}
}
}
func (m *Messages) retryPending() {
m.mu.Lock()
chats := make(map[string]pendingEntry, len(m.pending))
for id, e := range m.pending {
chats[id] = e
}
m.mu.Unlock()
for id, e := range chats {
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
err := m.rdb.Del(ctx, verKey(id)).Err()
if err == nil && e.gen > 0 {
err = m.opt.Outbox.ResolvePendingInvalidation(ctx, id, e.gen)
}
cancel()
if err != nil {
return
}
m.resolved(id, e)
}
}
// resolved снимает запись, если после снимка e не было нового сбоя.
func (m *Messages) resolved(chatID string, e pendingEntry) {
m.mu.Lock()
if m.pending[chatID].seq == e.seq {
delete(m.pending, chatID)
}
m.mu.Unlock()
}
func (m *Messages) isDown() bool {
return time.Now().UnixNano() < m.downUntil.Load()
}
func (m *Messages) markDown(err error) {
if err == nil || errors.Is(err, redis.Nil) {
return
}
if !m.isDown() {
m.log.Warn("history cache unavailable, bypassing", slog.Any("err", err))
}
m.downUntil.Store(time.Now().Add(breakerPause).UnixNano())
}
func (m *Messages) getPage(ctx context.Context, key string) (domain.Page[domain.Message], bool) {
b, err := m.rdb.Get(ctx, key).Bytes()
if err != nil {
m.markDown(err)
return domain.Page[domain.Message]{}, false
}
page, err := decodePage(b)
return page, err == nil
}
func (m *Messages) sleepFill(ctx context.Context) {
if m.opt.FillDelay <= 0 {
return
}
select {
case <-time.After(m.opt.FillDelay):
case <-ctx.Done():
}
}
func verKey(chatID string) string { return "hc:ver:" + chatID }
func pageKey(prefix, cursor string, limit int) string {
return prefix + ":" + strconv.Itoa(limit) + ":" + cursor
}
func randomVersion() string {
var b [8]byte
_, _ = rand.Read(b[:])
return hex.EncodeToString(b[:])
}
type cachedPage struct {
Items []domain.Message `json:"items"`
NextCursor string `json:"next_cursor"`
}
func encodePage(p domain.Page[domain.Message]) ([]byte, error) {
return json.Marshal(cachedPage{Items: p.Items, NextCursor: p.NextCursor})
}
func decodePage(b []byte) (domain.Page[domain.Message], error) {
var c cachedPage
if err := json.Unmarshal(b, &c); err != nil {
return domain.Page[domain.Message]{}, err
}
return domain.Page[domain.Message]{Items: c.Items, NextCursor: c.NextCursor}, nil
}