fixed read-after-write after failed cache invalidation and API restart

This commit is contained in:
Нурлыгаянова Екатерина
2026-10-29 15:18:44 +03:00
parent 5021df4ea8
commit ee87d17cb9
13 changed files with 510 additions and 78 deletions
+104 -24
View File
@@ -35,8 +35,17 @@ type Source interface {
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
@@ -45,6 +54,14 @@ type Options struct {
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
@@ -53,9 +70,13 @@ type Messages struct {
log *slog.Logger
downUntil atomic.Int64
// loaded: долг инвалидации из Outbox прочитан. До этого любой чат может
// иметь устаревшую версию, поэтому все чтения идут мимо кэша.
loaded atomic.Bool
mu sync.Mutex
pending map[string]struct{}
pending map[string]pendingEntry
seq uint64
stop chan struct{}
done chan struct{}
}
@@ -85,10 +106,11 @@ func New(src Source, rdb *redis.Client, opt Options) *Messages {
rdb: rdb,
opt: opt,
log: opt.Logger,
pending: make(map[string]struct{}),
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
}
@@ -136,7 +158,7 @@ func (m *Messages) AddMessage(ctx context.Context, callerID, chatID, text string
case ModeSafe:
if err := m.rdb.Del(ictx, verKey(chatID)).Err(); err != nil {
m.markDown(err)
m.addPending(chatID)
m.addPending(ictx, chatID)
}
}
return msg, nil
@@ -285,15 +307,39 @@ func (m *Messages) fill(ctx context.Context, key, chatID, cursor string, limit i
return page, nil
}
func (m *Messages) addPending(chatID string) {
// 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.pending[chatID] = struct{}{}
m.seq++
e := m.pending[chatID]
e.seq = m.seq
e.gen = max(e.gen, gen)
m.pending[chatID] = e
m.mu.Unlock()
m.log.Warn("history cache invalidation deferred", slog.String("chat_id", chatID))
}
func (m *Messages) bypass(chatID string) bool {
if m.isDown() {
if m.isDown() || !m.loaded.Load() {
return true
}
m.mu.Lock()
@@ -302,36 +348,70 @@ func (m *Messages) bypass(chatID string) bool {
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:
}
m.mu.Lock()
chats := make([]string, 0, len(m.pending))
for id := range m.pending {
chats = append(chats, id)
}
m.mu.Unlock()
for _, id := range chats {
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
err := m.rdb.Del(ctx, verKey(id)).Err()
cancel()
if err != nil {
break
}
m.mu.Lock()
delete(m.pending, id)
m.mu.Unlock()
}
}
}
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()
}
+159
View File
@@ -264,3 +264,162 @@ func TestCacheDown_Bypass(t *testing.T) {
t.Fatalf("обход кэша не должен пропускать постороннего: %v", err)
}
}
type fakeOutbox struct {
mu sync.Mutex
rows map[string]int64
seq int64 // как cache_invalidations_gen_seq: gen не повторяется
loadErr error
}
func (f *fakeOutbox) AddPendingInvalidation(_ context.Context, chatID string) (int64, error) {
f.mu.Lock()
defer f.mu.Unlock()
f.seq++
f.rows[chatID] = f.seq
return f.seq, nil
}
func (f *fakeOutbox) PendingInvalidations(context.Context) (map[string]int64, error) {
f.mu.Lock()
defer f.mu.Unlock()
if f.loadErr != nil {
return nil, f.loadErr
}
out := make(map[string]int64, len(f.rows))
for k, v := range f.rows {
out[k] = v
}
return out, nil
}
func (f *fakeOutbox) ResolvePendingInvalidation(_ context.Context, chatID string, gen int64) error {
f.mu.Lock()
defer f.mu.Unlock()
if f.rows[chatID] == gen {
delete(f.rows, chatID)
}
return nil
}
func (f *fakeOutbox) len() int {
f.mu.Lock()
defer f.mu.Unlock()
return len(f.rows)
}
// Сброс версии не удался, процесс API перезапущен: новый процесс не знает о
// долге из памяти, но обязан отдать подтверждённое сообщение сразу.
func TestReadAfterWrite_InvalidationFailedThenRestart(t *testing.T) {
ctx := context.Background()
c := testClient(t)
src := &fakeSource{}
outbox := &fakeOutbox{rows: map[string]int64{}}
chat := "chat-restart"
opts := Options{
Mode: ModeSafe,
Outbox: outbox,
PageTTL: time.Minute,
Logger: slog.New(slog.NewTextHandler(io.Discard, nil)),
}
warm := New(src, c, opts)
if _, err := warm.ListMessages(ctx, member, chat, "", 50); err != nil {
t.Fatal(err)
}
warm.Close()
dead := redis.NewClient(&redis.Options{
Addr: "127.0.0.1:1", DialTimeout: 50 * time.Millisecond, MaxRetries: -1,
})
t.Cleanup(func() { dead.Close() })
before := New(src, dead, opts)
msg, err := before.AddMessage(ctx, member, chat, "подтверждено 201")
if err != nil {
t.Fatal(err)
}
before.Close() // рестарт: память процесса потеряна, старая версия в Valkey жива
if outbox.len() != 1 {
t.Fatalf("долг инвалидации не записан в Outbox")
}
after := New(src, c, opts)
t.Cleanup(after.Close)
page, err := after.ListMessages(ctx, member, chat, "", 50)
if err != nil || !contains(page, msg.ID) {
t.Fatalf("после рестарта подтверждённое сообщение не видно: err=%v", err)
}
deadline := time.Now().Add(2 * time.Second)
for outbox.len() != 0 || after.bypass(chat) {
if time.Now().After(deadline) {
t.Fatal("отложенная инвалидация не выполнена после рестарта")
}
time.Sleep(20 * time.Millisecond)
}
for i := 0; i < 2; i++ { // промах, затем попадание с новой версией
page, err = after.ListMessages(ctx, member, chat, "", 50)
if err != nil || !contains(page, msg.ID) {
t.Fatalf("чтение через кэш после инвалидации: err=%v", err)
}
}
}
func TestBypassUntilOutboxLoaded(t *testing.T) {
outbox := &fakeOutbox{rows: map[string]int64{}, loadErr: errors.New("db down")}
h := New(&fakeSource{}, redis.NewClient(&redis.Options{Addr: "127.0.0.1:1"}), Options{
Mode: ModeSafe,
Outbox: outbox,
Logger: slog.New(slog.NewTextHandler(io.Discard, nil)),
})
defer h.Close()
time.Sleep(3 * retryInterval)
if !h.bypass("any") {
t.Fatal("пока долг из Outbox не прочитан, кэш не должен отдавать страницы")
}
outbox.mu.Lock()
outbox.loadErr = nil
outbox.mu.Unlock()
deadline := time.Now().Add(2 * time.Second)
for h.bypass("any") {
if time.Now().After(deadline) {
t.Fatal("после загрузки Outbox чтение через кэш не включилось")
}
time.Sleep(20 * time.Millisecond)
}
}
// Повтор сбросил версию и снял строку Outbox, но до того, как он снял запись
// из памяти, новая запись снова не смогла сбросить версию. Запись в памяти и
// строка Outbox должны остаться, иначе ответ 201 придёт при устаревшем кэше.
func TestRetryDoesNotDropNewerFailure(t *testing.T) {
ctx := context.Background()
outbox := &fakeOutbox{rows: map[string]int64{}}
h := New(&fakeSource{}, redis.NewClient(&redis.Options{Addr: "127.0.0.1:1"}), Options{
Mode: ModeSafe,
Outbox: outbox,
Logger: slog.New(slog.NewTextHandler(io.Discard, nil)),
})
h.Close() // повтор ведём вручную
h.loaded.Store(true)
chat := "chat-retry-race"
h.addPending(ctx, chat)
snap := h.pending[chat] // снимок повтора; DEL версии прошёл
if err := outbox.ResolvePendingInvalidation(ctx, chat, snap.gen); err != nil {
t.Fatal(err)
}
h.addPending(ctx, chat) // новый сбой DEL до ответа 201
h.resolved(chat, snap)
if !h.bypass(chat) {
t.Fatal("повтор снял запись о более новом сбое")
}
if rows, _ := outbox.PendingInvalidations(ctx); rows[chat] <= snap.gen {
t.Fatalf("строка Outbox: gen=%d, ожидался новый gen > %d", rows[chat], snap.gen)
}
h.resolved(chat, h.pending[chat])
if h.bypass(chat) {
t.Fatal("актуальный повтор должен снять запись")
}
}