forked from mtusi2026/mtusi2026lab2
fixed read-after-write after failed cache invalidation and API restart
This commit is contained in:
@@ -72,6 +72,7 @@ func main() {
|
||||
defer hcClient.Close()
|
||||
hc := cache.New(storage.Messages, hcClient, cache.Options{
|
||||
Mode: cfg.HistoryCache.Mode,
|
||||
Outbox: storage.Messages,
|
||||
PageTTL: time.Duration(cfg.HistoryCache.PageTTLSeconds) * time.Second,
|
||||
FillDelay: time.Duration(cfg.HistoryCache.FillDelayMs) * time.Millisecond,
|
||||
Logger: logger,
|
||||
|
||||
@@ -136,6 +136,23 @@ func compose(t *testing.T, env map[string]string, args ...string) {
|
||||
}
|
||||
}
|
||||
|
||||
// waitHealthy ждёт healthcheck сервиса: после unpause он остаётся unhealthy
|
||||
// до следующей успешной проверки, и compose up --wait сразу падает.
|
||||
func waitHealthy(t *testing.T, service string) {
|
||||
t.Helper()
|
||||
deadline := time.Now().Add(30 * time.Second)
|
||||
for time.Now().Before(deadline) {
|
||||
cmd := exec.Command("docker", "compose", "--env-file", ".env", "ps", "--format", "{{.Health}}", service)
|
||||
cmd.Dir = root
|
||||
out, _ := cmd.Output()
|
||||
if strings.TrimSpace(string(out)) == "healthy" {
|
||||
return
|
||||
}
|
||||
time.Sleep(500 * time.Millisecond)
|
||||
}
|
||||
t.Fatalf("%s не стал healthy за 30 с", service)
|
||||
}
|
||||
|
||||
func randHex(n int) string {
|
||||
b := make([]byte, n)
|
||||
_, _ = rand.Read(b)
|
||||
@@ -326,4 +343,34 @@ func TestFailures(t *testing.T) {
|
||||
t.Error("ожидали две одинаковые полные страницы с сообщением, записанным при упавшем кэше")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("инвалидация не удалась, API перезапущен: сообщение с 201 сразу видно в истории", func(t *testing.T) {
|
||||
// Прогреваем страницу в кэше, затем замораживаем Valkey-кэш: данные
|
||||
// (и старая версия) остаются, но DEL версии падает по таймауту.
|
||||
c.call(http.MethodGet, messagesPath+"?limit=100", token, nil, nil)
|
||||
c.call(http.MethodGet, messagesPath+"?limit=100", token, nil, nil)
|
||||
compose(t, nil, "pause", "valkey-cache")
|
||||
paused := true
|
||||
t.Cleanup(func() {
|
||||
if paused {
|
||||
compose(t, nil, "unpause", "valkey-cache")
|
||||
}
|
||||
waitHealthy(t, "valkey-cache")
|
||||
})
|
||||
send := c.call(http.MethodPost, messagesPath, token, map[string]string{"text": "до рестарта API"}, nil)
|
||||
if send.status != 201 {
|
||||
t.Fatalf("ожидали 201, получили %d", send.status)
|
||||
}
|
||||
compose(t, nil, "restart", "api")
|
||||
c.waitReady(t)
|
||||
compose(t, nil, "unpause", "valkey-cache")
|
||||
paused = false
|
||||
for i := 0; i < 3; i++ {
|
||||
list := c.call(http.MethodGet, messagesPath+"?limit=100", token, nil, nil)
|
||||
if list.status != 200 || !slices.Contains(list.itemIDs(), send.str("id")) {
|
||||
t.Fatalf("чтение %d после рестарта: status %d, подтверждённого сообщения нет в истории", i+1, list.status)
|
||||
}
|
||||
time.Sleep(300 * time.Millisecond)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
Vendored
+104
-24
@@ -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()
|
||||
}
|
||||
|
||||
Vendored
+159
@@ -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("актуальный повтор должен снять запись")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -175,3 +175,45 @@ func TestNULRoundTrip(t *testing.T) {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestPendingInvalidationCAS(t *testing.T) {
|
||||
d, _ := testDB(t)
|
||||
ctx := context.Background()
|
||||
u, _ := d.CreateUser(ctx, "pi_"+suffix(), "U", "$argon2id$test")
|
||||
chat, err := d.CreateChat(ctx, u.ID, "pi-"+suffix(), []string{u.ID})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
g1, err := d.AddPendingInvalidation(ctx, chat.ID)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
g2, err := d.AddPendingInvalidation(ctx, chat.ID)
|
||||
if err != nil || g2 <= g1 {
|
||||
t.Fatalf("gen %d → %d, err=%v; ожидался рост", g1, g2, err)
|
||||
}
|
||||
// Повтор, начатый до второго сбоя, не должен снять новый долг.
|
||||
if err := d.ResolvePendingInvalidation(ctx, chat.ID, g1); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
rows, err := d.PendingInvalidations(ctx)
|
||||
if err != nil || rows[chat.ID] != g2 {
|
||||
t.Fatalf("после устаревшего resolve: %v, err=%v; ожидался gen %d", rows[chat.ID], err, g2)
|
||||
}
|
||||
if err := d.ResolvePendingInvalidation(ctx, chat.ID, g2); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
rows, _ = d.PendingInvalidations(ctx)
|
||||
if _, ok := rows[chat.ID]; ok {
|
||||
t.Fatal("актуальный resolve не удалил запись")
|
||||
}
|
||||
// Новый сбой после удаления строки: gen не начинается заново, иначе
|
||||
// запоздалый повтор с g1 снял бы и его.
|
||||
g3, err := d.AddPendingInvalidation(ctx, chat.ID)
|
||||
if err != nil || g3 <= g2 {
|
||||
t.Fatalf("gen после удаления строки = %d, err=%v; ожидался > %d", g3, err, g2)
|
||||
}
|
||||
if err := d.ResolvePendingInvalidation(ctx, chat.ID, g3); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,63 @@
|
||||
package db
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
)
|
||||
|
||||
// AddPendingInvalidation фиксирует, что версия кэша чата не сброшена.
|
||||
// Возвращает поколение записи для последующего compare-and-delete.
|
||||
func (m *Messages) AddPendingInvalidation(ctx context.Context, chatID string) (int64, error) {
|
||||
ctx, cancel := m.withTimeout(ctx)
|
||||
defer cancel()
|
||||
|
||||
var gen int64
|
||||
err := m.pool.QueryRow(ctx, `
|
||||
INSERT INTO cache_invalidations (chat_id) VALUES ($1)
|
||||
ON CONFLICT (chat_id) DO UPDATE
|
||||
SET gen = nextval('cache_invalidations_gen_seq'), updated_at = now()
|
||||
RETURNING gen`,
|
||||
chatID,
|
||||
).Scan(&gen)
|
||||
if err != nil {
|
||||
return 0, mapErr(err)
|
||||
}
|
||||
return gen, nil
|
||||
}
|
||||
|
||||
func (m *Messages) PendingInvalidations(ctx context.Context) (map[string]int64, error) {
|
||||
ctx, cancel := m.withTimeout(ctx)
|
||||
defer cancel()
|
||||
|
||||
rows, err := m.pool.Query(ctx, `SELECT chat_id::text, gen FROM cache_invalidations`)
|
||||
if err != nil {
|
||||
return nil, mapErr(err)
|
||||
}
|
||||
out := map[string]int64{}
|
||||
var (
|
||||
id string
|
||||
gen int64
|
||||
)
|
||||
_, err = pgx.ForEachRow(rows, []any{&id, &gen}, func() error {
|
||||
out[id] = gen
|
||||
return nil
|
||||
})
|
||||
if err != nil {
|
||||
return nil, mapErr(err)
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// ResolvePendingInvalidation удаляет запись, только если с момента чтения
|
||||
// не случилось нового сбоя (gen не изменился).
|
||||
func (m *Messages) ResolvePendingInvalidation(ctx context.Context, chatID string, gen int64) error {
|
||||
ctx, cancel := m.withTimeout(ctx)
|
||||
defer cancel()
|
||||
|
||||
_, err := m.pool.Exec(ctx,
|
||||
`DELETE FROM cache_invalidations WHERE chat_id = $1 AND gen = $2`,
|
||||
chatID, gen,
|
||||
)
|
||||
return mapErr(err)
|
||||
}
|
||||
Reference in New Issue
Block a user