From 0c51fd01961996fe3fc55602a8e233368f56245d Mon Sep 17 00:00:00 2001 From: Zeusina Date: Sat, 10 Oct 2026 08:04:48 +0300 Subject: [PATCH] feat(monitor): persist health and recovery cooldown Co-authored-by: GPT-6 --- PROGRESS.md | 1 + README.md | 19 +- cmd/zapret-autotune/candidates_test.go | 4 +- cmd/zapret-autotune/fingerprint_test.go | 2 +- cmd/zapret-autotune/googlevideo_test.go | 2 +- cmd/zapret-autotune/monitor.go | 142 +++++++++++ cmd/zapret-autotune/monitor_test.go | 325 ++++++++++++++++++++++++ cmd/zapret-autotune/store.go | 7 +- cmd/zapret-autotune/store_test.go | 4 +- 9 files changed, 497 insertions(+), 9 deletions(-) create mode 100644 cmd/zapret-autotune/monitor.go create mode 100644 cmd/zapret-autotune/monitor_test.go diff --git a/PROGRESS.md b/PROGRESS.md index 35dd209..382e560 100644 --- a/PROGRESS.md +++ b/PROGRESS.md @@ -4,6 +4,7 @@ ## Готово +- Добавлена foundation schema v4: durable policy state по stable service ID, last probe/streak, recovery lock и cooldown. Внутренние операции с injected time атомарно записывают probe и захватывают recovery только при threshold/истёкшем cooldown/свободном lock; завершение любого исхода запускает cooldown от completion time и требует точный ownership token, возвращённый acquisition. Stale/duplicate finish не меняет новую lease или cooldown; добавлен regression A → finish A → acquire B → stale finish A. Crash сохраняет lock (reconciliation пока не реализован). Добавлены unit-тесты streak/reset, threshold, concurrent writes/acquisition, reload/cooldown и сохранения v3 history/candidates при миграции. Проверки tests/build отложены оркестратору; здесь не запускались. Это только foundation: CLI health/recover не подключены, daemon/apply/network/container/Xray не затронуты. - Добавлен одноразовый `health youtube`: bounded Player API-запрос только через явно заданный loopback SOCKS (`ZAPRET_AUTOTUNE_SOCKS_PROXY`, default `socks5://127.0.0.1:11080`), без ambient proxy/direct fallback. Health требует только `playabilityStatus.status=OK`, не streaming URL и не playback. Config валидирует video ID (default `dQw4w9WgXcQ`) и будущую policy: interval `5m`, failure threshold `3`, cooldown `30m`. Добавлены injectable unit-тесты config/health/CLI; проверки этого increment отложены оркестратору, тесты/build/network здесь не запускались. Autonomous monitor/apply/rollback не добавлены, контейнеры не изменены. - Завершён удалённый ручной GGC scan для `rr16---sn-n8v7znsz.googlevideo.com`: TLS 1.2 — 1 525 рабочих стратегий, TLS 1.3 — 800. Shortlist check нашёл 20 проходящих вариантов; точная объединённая стратегия `--lua-init=fake_default_tls=tls_mod(fake_default_tls,'rnd') --payload=tls_client_hello --lua-desync=multidisorder:pos=2,midsld:seqovl=1:seqovl_pattern=fake_default_tls --in-range=-s1 --lua-desync=oob:urp=midsld` прошла по 3/3 для TLS 1.2 и TLS 1.3. Результат относится только к указанному hostname; не означает playback/SABR и не применялся. - Добавлена proposal-only команда `recover googlevideo --video-id ID --proxy socks5://HOST:PORT`: discovery одного свежего exact host → qualified schema-v3 сценарии newest-first → combined TLS1.2/1.3 3/3 точных сохранённых args. Первый успешный сценарий сохраняется новым immutable candidate/run и выдаётся как NOT ACTIVE без scan. Только отсутствие eligible candidates или валидные non-pass результаты разрешают обычный scan на уже найденном host; infrastructure/malformed-report ошибки fail closed. Apply/monitor и удалённый scan не затронуты. diff --git a/README.md b/README.md index febb266..380c76e 100644 --- a/README.md +++ b/README.md @@ -35,7 +35,7 @@ threshold and cooldown are validated future recovery policy settings only: The future managed target is a **brand-new prod-like zapret2-ss container in the test environment only**, not the existing container. Its stable configurable SOCKS endpoint must be loopback-accessible to this probe and same-host Xray. -This increment does not create or change any container, persist health, apply +The one-shot command does not persist health. This increment does not create or change any container, apply configuration, restart services or roll back anything. Xray configuration is out of scope and will be configured separately by the user. Run this command in the host network context where that loopback endpoint is reachable; Docker @@ -142,9 +142,24 @@ it must be writable. In Docker, mount that directory to retain history: docker run --rm -v autotune-data:/var/lib/zapret-autotune zapret-autotune status ``` -Schema version 3 is initialized transactionally on `tune` and `status`; subsequent +Schema version 4 is initialized transactionally on `tune` and `status`; subsequent opens are idempotent and newer, unsupported schema versions are rejected. +Schema v4 adds a policy-state foundation keyed by stable service ID (not a cache +hostname or SOCKS address): last probe time, consecutive failures, recovery lock +and cooldown expiry. Internal operations accept injected time: success resets the +streak, failures increment it, and an atomic recovery acquisition requires the +configured threshold, an elapsed cooldown and no running recovery. Completion, +successful or failed, requires the exact per-acquisition ownership token returned +by acquisition, clears the lock and starts cooldown from completion time. Stale +or duplicate completion is rejected without changing the lock, token or cooldown, +even after a newer acquisition starts. A crash still leaves the durable lock held; +the token does not introduce automatic expiry or crash reconciliation. +State survives reopening the database; a crash during recovery leaves the lock +held, pending future explicit crash reconciliation. Existing history/candidates +are unchanged. These operations are not wired to `health youtube` or recovery: +**no daemon, autonomous probe, apply or container/Xray changes are added**. + Schema v3 adds immutable strategy candidate definitions (group, declared exact endpoints, args and normalized-args fingerprint) and endpoint/protocol evidence. Each newly successful tune saves its exact verified combined frontend profile for diff --git a/cmd/zapret-autotune/candidates_test.go b/cmd/zapret-autotune/candidates_test.go index 3cac085..604d987 100644 --- a/cmd/zapret-autotune/candidates_test.go +++ b/cmd/zapret-autotune/candidates_test.go @@ -58,7 +58,7 @@ func populatedV2Store(t *testing.T) *sql.DB { if err := migrate(db); err != nil { t.Fatal(err) } - if _, err := db.Exec(`DROP TABLE candidate_evidence; DROP TABLE strategy_candidates; PRAGMA user_version = 2;`); err != nil { + if _, err := db.Exec(`DROP TABLE monitor_state; DROP TABLE candidate_evidence; DROP TABLE strategy_candidates; PRAGMA user_version = 2;`); err != nil { t.Fatal(err) } return db @@ -99,7 +99,7 @@ func TestPopulatedV2CandidateMigration(t *testing.T) { } } var version int - if err := db.QueryRow("PRAGMA user_version").Scan(&version); err != nil || version != 3 { + if err := db.QueryRow("PRAGMA user_version").Scan(&version); err != nil || version != 4 { t.Fatalf("version=%d err=%v", version, err) } if before != legacySnapshot(t, db) { diff --git a/cmd/zapret-autotune/fingerprint_test.go b/cmd/zapret-autotune/fingerprint_test.go index 0c4b6af..58391c2 100644 --- a/cmd/zapret-autotune/fingerprint_test.go +++ b/cmd/zapret-autotune/fingerprint_test.go @@ -117,7 +117,7 @@ func TestPopulatedV1FingerprintMigration(t *testing.T) { } assertRowCounts(t, db, 3, 4) var version int - if err := db.QueryRow("PRAGMA user_version").Scan(&version); err != nil || version != 3 { + if err := db.QueryRow("PRAGMA user_version").Scan(&version); err != nil || version != 4 { t.Fatalf("version=%d err=%v", version, err) } for id, input := range map[int]string{7: "--lua-desync=fake", 9: args} { diff --git a/cmd/zapret-autotune/googlevideo_test.go b/cmd/zapret-autotune/googlevideo_test.go index 7dba0c4..901576c 100644 --- a/cmd/zapret-autotune/googlevideo_test.go +++ b/cmd/zapret-autotune/googlevideo_test.go @@ -154,7 +154,7 @@ fi if err := db.QueryRow(`PRAGMA user_version`).Scan(&version); err != nil { t.Fatal(err) } - if evidence != 2 || legacy != 0 || version != 3 { + if evidence != 2 || legacy != 0 || version != 4 { t.Fatalf("evidence=%d legacy=%d version=%d", evidence, legacy, version) } for _, command := range [][]string{{"history"}, {"strategies", "youtube"}} { diff --git a/cmd/zapret-autotune/monitor.go b/cmd/zapret-autotune/monitor.go new file mode 100644 index 0000000..773cb3e --- /dev/null +++ b/cmd/zapret-autotune/monitor.go @@ -0,0 +1,142 @@ +package main + +import ( + "crypto/rand" + "database/sql" + "encoding/hex" + "fmt" + "strings" + "time" +) + +// Policy foundation only; service_id identifies a service, not a rotating host +// or proxy address. No probe, scheduler or configuration changes happen here. +const monitorSchema = ` +CREATE TABLE monitor_state ( + service_id TEXT PRIMARY KEY NOT NULL CHECK (typeof(service_id) = 'text' AND length(trim(service_id)) > 0), + consecutive_failures INTEGER NOT NULL DEFAULT 0 CHECK (typeof(consecutive_failures) = 'integer' AND consecutive_failures >= 0), + last_probe_at INTEGER CHECK (last_probe_at IS NULL OR typeof(last_probe_at) = 'integer'), + recovery_running INTEGER NOT NULL DEFAULT 0 CHECK (typeof(recovery_running) = 'integer' AND recovery_running IN (0, 1)), + recovery_token TEXT CHECK (recovery_token IS NULL OR (typeof(recovery_token) = 'text' AND length(recovery_token) = 64)), + cooldown_until INTEGER CHECK (cooldown_until IS NULL OR typeof(cooldown_until) = 'integer'), + CHECK ((recovery_running = 0 AND recovery_token IS NULL) OR (recovery_running = 1 AND recovery_token IS NOT NULL)), + CHECK (last_probe_at IS NOT NULL OR consecutive_failures = 0) +); +PRAGMA user_version = 4;` + +type monitorState struct { + ConsecutiveFailures int + LastProbeAt time.Time + RecoveryRunning bool + CooldownUntil time.Time +} + +func (s monitorState) healthStatus() string { + if s.LastProbeAt.IsZero() { + return "UNKNOWN" + } + if s.ConsecutiveFailures > 0 { + return "UNHEALTHY" + } + return "HEALTHY" +} + +func validateMonitorTime(serviceID string, now time.Time) error { + if strings.TrimSpace(serviceID) == "" || strings.TrimSpace(serviceID) != serviceID || strings.ContainsRune(serviceID, '\x00') { + return fmt.Errorf("invalid monitor service ID") + } + // Reject zero/overflowing timestamps rather than silently wrapping UnixNano. + if now.IsZero() || !time.Unix(0, now.UnixNano()).Equal(now) { + return fmt.Errorf("invalid monitor timestamp") + } + return nil +} + +func recordMonitorProbe(db *sql.DB, serviceID string, success bool, now time.Time) error { + if err := validateMonitorTime(serviceID, now); err != nil { + return err + } + failures := 1 + if success { + failures = 0 + } + // One UPSERT serializes increments and leaves the recovery lock/cooldown intact. + _, err := db.Exec(`INSERT INTO monitor_state (service_id, consecutive_failures, last_probe_at) + VALUES (?, ?, ?) ON CONFLICT(service_id) DO UPDATE SET + consecutive_failures = CASE WHEN excluded.consecutive_failures = 0 THEN 0 ELSE monitor_state.consecutive_failures + 1 END, + last_probe_at = excluded.last_probe_at`, serviceID, failures, now.UnixNano()) + return err +} + +func readMonitorState(db *sql.DB, serviceID string) (monitorState, error) { + var state monitorState + var probe, cooldown sql.NullInt64 + err := db.QueryRow(`SELECT consecutive_failures, last_probe_at, recovery_running, cooldown_until + FROM monitor_state WHERE service_id = ?`, serviceID).Scan(&state.ConsecutiveFailures, &probe, &state.RecoveryRunning, &cooldown) + if err == sql.ErrNoRows { + return state, nil // A service without recorded probes has unknown health. + } + if probe.Valid { + state.LastProbeAt = time.Unix(0, probe.Int64).UTC() + } + if cooldown.Valid { + state.CooldownUntil = time.Unix(0, cooldown.Int64).UTC() + } + return state, err +} + +// A nonempty token identifies this acquisition only; an empty token means busy +// or ineligible. The caller must retain it for finalization, including after reopen. +func beginMonitorRecovery(db *sql.DB, serviceID string, threshold int, now time.Time) (string, error) { + if err := validateMonitorTime(serviceID, now); err != nil { + return "", err + } + if threshold <= 0 { + return "", fmt.Errorf("failure threshold must be positive") + } + var ownership [32]byte + if _, err := rand.Read(ownership[:]); err != nil { + return "", err + } + token := hex.EncodeToString(ownership[:]) + // Compare-and-set in one SQLite write, including across independent processes. + result, err := db.Exec(`UPDATE monitor_state SET recovery_running = 1, recovery_token = ? + WHERE service_id = ? AND consecutive_failures >= ? AND recovery_running = 0 + AND (cooldown_until IS NULL OR cooldown_until <= ?)`, token, serviceID, threshold, now.UnixNano()) + if err != nil { + return "", err + } + count, err := result.RowsAffected() + if err != nil || count != 1 { + return "", err + } + return token, nil +} + +// Call on either success or failure. A crash leaves the durable lock held; +// automatic crash reconciliation is deliberately not part of this foundation. +func finishMonitorRecovery(db *sql.DB, serviceID, token string, completed time.Time, cooldown time.Duration) error { + if err := validateMonitorTime(serviceID, completed); err != nil { + return err + } + if cooldown <= 0 { + return fmt.Errorf("recovery cooldown must be positive") + } + if len(token) != 64 { + return fmt.Errorf("invalid recovery ownership token") + } + expires := completed.Add(cooldown) + if err := validateMonitorTime(serviceID, expires); err != nil { + return err + } + result, err := db.Exec(`UPDATE monitor_state SET recovery_running = 0, recovery_token = NULL, cooldown_until = ? + WHERE service_id = ? AND recovery_running = 1 AND recovery_token = ?`, expires.UnixNano(), serviceID, token) + if err != nil { + return err + } + count, err := result.RowsAffected() + if err == nil && count != 1 { + return fmt.Errorf("no recovery owned by this token for service %q", serviceID) + } + return err +} diff --git a/cmd/zapret-autotune/monitor_test.go b/cmd/zapret-autotune/monitor_test.go new file mode 100644 index 0000000..850f5d6 --- /dev/null +++ b/cmd/zapret-autotune/monitor_test.go @@ -0,0 +1,325 @@ +package main + +import ( + "database/sql" + "fmt" + "path/filepath" + "sync" + "testing" + "time" +) + +var monitorTestTime = time.Date(2026, 10, 10, 12, 0, 0, 123, time.UTC) + +func requireMonitorBegin(t *testing.T, db *sql.DB, id string, now time.Time, want bool) string { + t.Helper() + got, err := beginMonitorRecovery(db, id, 3, now) + if err != nil || (got != "") != want { + t.Fatalf("begin %s: got=%v want=%v err=%v", id, got, want, err) + } + return got +} + +func TestMonitorProbeStreakAndThreshold(t *testing.T) { + db := testStore(t) + now := monitorTestTime + state, err := readMonitorState(db, "new-test-service") + if err != nil || state.healthStatus() != "UNKNOWN" { + t.Fatalf("initial=%+v err=%v", state, err) + } + requireMonitorBegin(t, db, "new-test-service", now, false) + for i := 1; i <= 3; i++ { + if err := recordMonitorProbe(db, "new-test-service", false, now); err != nil { + t.Fatal(err) + } + state, err := readMonitorState(db, "new-test-service") + if err != nil || state.ConsecutiveFailures != i || state.healthStatus() != "UNHEALTHY" || !state.LastProbeAt.Equal(now) { + t.Fatalf("probe %d: %+v err=%v", i, state, err) + } + if i < 3 { + requireMonitorBegin(t, db, "new-test-service", now, false) + } + } + requireMonitorBegin(t, db, "other-service", now, false) + token := requireMonitorBegin(t, db, "new-test-service", now, true) + requireMonitorBegin(t, db, "new-test-service", now, false) + if err := recordMonitorProbe(db, "new-test-service", true, now.Add(time.Minute)); err != nil { + t.Fatal(err) + } + state, err = readMonitorState(db, "new-test-service") + if err != nil || state.ConsecutiveFailures != 0 || state.healthStatus() != "HEALTHY" || !state.RecoveryRunning { + t.Fatalf("success=%+v err=%v", state, err) + } + if err := finishMonitorRecovery(db, "new-test-service", token, now.Add(2*time.Minute), 30*time.Minute); err != nil { + t.Fatal(err) + } + requireMonitorBegin(t, db, "new-test-service", now.Add(time.Hour), false) + if err := recordMonitorProbe(db, "new-test-service", false, now.Add(time.Hour)); err != nil { + t.Fatal(err) + } + state, err = readMonitorState(db, "new-test-service") + if err != nil || state.ConsecutiveFailures != 1 || state.CooldownUntil.IsZero() { + t.Fatalf("new streak=%+v err=%v", state, err) + } +} + +func TestMonitorRecoveryDurableCooldownForEitherOutcome(t *testing.T) { + for _, outcome := range []string{"success", "failure"} { + t.Run(outcome, func(t *testing.T) { + path := filepath.Join(t.TempDir(), "monitor.db") + db, err := openStore(path) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { db.Close() }) + reopen := func() { + t.Helper() + if err := db.Close(); err != nil { + t.Fatal(err) + } + db, err = openStore(path) + if err != nil { + t.Fatal(err) + } + } + now := monitorTestTime + for i := 0; i < 3; i++ { + if err := recordMonitorProbe(db, "service", false, now); err != nil { + t.Fatal(err) + } + } + token := requireMonitorBegin(t, db, "service", now, true) + reopen() + requireMonitorBegin(t, db, "service", now.Add(time.Hour), false) + // Outcome deliberately does not affect cooldown; completion time does. + completed := now.Add(10 * time.Minute) + if err := finishMonitorRecovery(db, "service", token, completed, 30*time.Minute); err != nil { + t.Fatal(err) + } + if err := finishMonitorRecovery(db, "service", token, completed.Add(time.Minute), 30*time.Minute); err == nil { + t.Fatal("repeated finish accepted") + } + reopen() + state, err := readMonitorState(db, "service") + expires := completed.Add(30 * time.Minute) + if err != nil || state.RecoveryRunning || state.ConsecutiveFailures != 3 || !state.CooldownUntil.Equal(expires) { + t.Fatalf("reloaded=%+v err=%v", state, err) + } + requireMonitorBegin(t, db, "service", expires.Add(-time.Nanosecond), false) + requireMonitorBegin(t, db, "service", expires, true) + }) + } +} + +func TestMonitorStaleFinishCannotReleaseNewRecovery(t *testing.T) { + db := testStore(t) + now := monitorTestTime + for i := 0; i < 3; i++ { + if err := recordMonitorProbe(db, "service", false, now); err != nil { + t.Fatal(err) + } + } + tokenA := requireMonitorBegin(t, db, "service", now, true) + if err := finishMonitorRecovery(db, "service", tokenA, now, time.Minute); err != nil { + t.Fatal(err) + } + tokenB := requireMonitorBegin(t, db, "service", now.Add(time.Minute), true) + if tokenA == tokenB { + t.Fatal("new acquisition reused ownership token") + } + before, err := readMonitorState(db, "service") + if err != nil || !before.RecoveryRunning { + t.Fatalf("before stale finish: %+v err=%v", before, err) + } + for _, token := range []string{tokenA, ""} { + if err := finishMonitorRecovery(db, "service", token, now.Add(2*time.Minute), time.Hour); err == nil { + t.Fatal("unowned finish accepted") + } + after, err := readMonitorState(db, "service") + if err != nil || after != before { + t.Fatalf("unowned finish changed state: before=%+v after=%+v err=%v", before, after, err) + } + var storedToken string + if err := db.QueryRow("SELECT recovery_token FROM monitor_state WHERE service_id = ?", "service").Scan(&storedToken); err != nil || storedToken != tokenB { + t.Fatalf("new ownership changed: token=%q err=%v", storedToken, err) + } + requireMonitorBegin(t, db, "service", now.Add(24*time.Hour), false) + } + if err := finishMonitorRecovery(db, "service", tokenB, now.Add(2*time.Minute), time.Minute); err != nil { + t.Fatalf("current owner cannot finish: %v", err) + } +} + +func TestMonitorConcurrentWrites(t *testing.T) { + path := filepath.Join(t.TempDir(), "monitor.db") + stores := make([]*sql.DB, 2) + for i := range stores { + db, err := openStore(path) + if err != nil { + t.Fatal(err) + } + defer db.Close() + stores[i] = db + } + const callers = 12 + var wg sync.WaitGroup + for i := 0; i < callers; i++ { + wg.Add(1) + go func(db *sql.DB) { + defer wg.Done() + if err := recordMonitorProbe(db, "service", false, monitorTestTime); err != nil { + t.Error(err) + } + }(stores[i%2]) + } + wg.Wait() + state, err := readMonitorState(stores[0], "service") + if err != nil || state.ConsecutiveFailures != callers { + t.Fatalf("increments lost: %+v err=%v", state, err) + } + results := make(chan bool, callers) + start := make(chan struct{}) + for i := 0; i < callers; i++ { + wg.Add(1) + go func(db *sql.DB) { + defer wg.Done() + <-start + got, err := beginMonitorRecovery(db, "service", 3, monitorTestTime) + if err != nil { + t.Error(err) + } + results <- got != "" + }(stores[i%2]) + } + close(start) + wg.Wait() + close(results) + winners := 0 + for got := range results { + if got { + winners++ + } + } + if winners != 1 { + t.Fatalf("recovery winners=%d", winners) + } +} + +func TestMonitorValidationAndConstraints(t *testing.T) { + db := testStore(t) + for _, id := range []string{"", " ", " service", "service\x00"} { + if err := recordMonitorProbe(db, id, false, monitorTestTime); err == nil { + t.Fatalf("accepted ID %q", id) + } + } + for _, now := range []time.Time{{}, time.Date(2500, 1, 1, 0, 0, 0, 0, time.UTC)} { + if err := recordMonitorProbe(db, "service", false, now); err == nil { + t.Fatal("accepted invalid timestamp") + } + } + for _, threshold := range []int{0, -1} { + if _, err := beginMonitorRecovery(db, "service", threshold, monitorTestTime); err == nil { + t.Fatal("accepted invalid threshold") + } + } + for _, cooldown := range []time.Duration{0, -time.Minute} { + if err := finishMonitorRecovery(db, "service", "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef", monitorTestTime, cooldown); err == nil { + t.Fatal("accepted invalid cooldown") + } + } + if err := finishMonitorRecovery(db, "missing", "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef", monitorTestTime, time.Minute); err == nil { + t.Fatal("finished nonexistent recovery") + } + for _, statement := range []string{ + `INSERT INTO monitor_state (service_id) VALUES ('')`, + `INSERT INTO monitor_state (service_id) VALUES (NULL)`, + `INSERT INTO monitor_state (service_id, consecutive_failures) VALUES ('x', -1)`, + `INSERT INTO monitor_state (service_id, consecutive_failures) VALUES ('x', 1)`, + `INSERT INTO monitor_state (service_id, recovery_running) VALUES ('x', 2)`, + `INSERT INTO monitor_state (service_id, recovery_running) VALUES ('x', 1)`, + `INSERT INTO monitor_state (service_id, recovery_token) VALUES ('x', 'bad')`, + `INSERT INTO monitor_state (service_id, recovery_token) VALUES ('x', '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef')`, + `INSERT INTO monitor_state (service_id, last_probe_at) VALUES ('x', 'bad')`, + `INSERT INTO monitor_state (service_id, cooldown_until) VALUES ('x', 'bad')`, + } { + if _, err := db.Exec(statement); err == nil { + t.Fatalf("constraint accepted %s", statement) + } + } +} + +func monitorMigrationSnapshot(t *testing.T, db *sql.DB) string { + t.Helper() + snapshot := legacySnapshot(t, db) + for _, table := range []string{"strategy_candidates", "candidate_evidence", "googlevideo_tune_runs"} { + rows, err := db.Query("SELECT * FROM " + table + " ORDER BY 1, 2, 3") + if err != nil { + t.Fatal(err) + } + columns, err := rows.Columns() + if err != nil { + rows.Close() + t.Fatal(err) + } + values := make([]interface{}, len(columns)) + pointers := make([]interface{}, len(columns)) + for i := range values { + pointers[i] = &values[i] + } + for rows.Next() { + if err := rows.Scan(pointers...); err != nil { + rows.Close() + t.Fatal(err) + } + snapshot += fmt.Sprintf("%s:%#v;", table, values) + } + err = rows.Err() + rows.Close() + if err != nil { + t.Fatal(err) + } + } + return snapshot +} + +func TestMonitorV3MigrationPreservesHistory(t *testing.T) { + db := testStore(t) + saveProposal(t, db, "--lua-desync=fake") + if _, err := db.Exec(`INSERT INTO googlevideo_tune_runs (started_at, finished_at, state, error) + VALUES ('start', 'finish', 'FAILED', 'original failure'); + DROP TABLE monitor_state; PRAGMA user_version = 3;`); err != nil { + t.Fatal(err) + } + before := monitorMigrationSnapshot(t, db) + for i := 0; i < 2; i++ { + if err := migrate(db); err != nil { + t.Fatal(err) + } + } + var version, count int + if err := db.QueryRow("PRAGMA user_version").Scan(&version); err != nil || version != 4 { + t.Fatalf("version=%d err=%v", version, err) + } + if err := db.QueryRow("SELECT count(*) FROM monitor_state").Scan(&count); err != nil || count != 0 { + t.Fatalf("monitor count=%d err=%v", count, err) + } + if after := monitorMigrationSnapshot(t, db); before != after { + t.Fatal("v3 history/candidate data changed") + } +} + +func TestMonitorV3MigrationRollback(t *testing.T) { + db := testStore(t) + saveProposal(t, db, "--lua-desync=fake") + if _, err := db.Exec(`DROP TABLE monitor_state; CREATE TABLE monitor_state (conflict INTEGER); PRAGMA user_version = 3;`); err != nil { + t.Fatal(err) + } + before := monitorMigrationSnapshot(t, db) + if err := migrate(db); err == nil { + t.Fatal("expected conflicting v4 schema failure") + } + var version int + if err := db.QueryRow("PRAGMA user_version").Scan(&version); err != nil || version != 3 || before != monitorMigrationSnapshot(t, db) { + t.Fatalf("failed migration changed data/version: %d err=%v", version, err) + } +} diff --git a/cmd/zapret-autotune/store.go b/cmd/zapret-autotune/store.go index cdb95c1..098965e 100644 --- a/cmd/zapret-autotune/store.go +++ b/cmd/zapret-autotune/store.go @@ -114,7 +114,7 @@ func migrate(db *sql.DB) error { if err = conn.QueryRowContext(ctx, "PRAGMA user_version").Scan(&version); err != nil { return err } - if version > 3 { + if version > 4 { return fmt.Errorf("unsupported database schema version %d", version) } if version == 0 { @@ -231,6 +231,11 @@ PRAGMA user_version = 1;`) if _, err := conn.ExecContext(ctx, googlevideoRunSchema); err != nil { return err } + if version < 4 { + if _, err := conn.ExecContext(ctx, monitorSchema); err != nil { + return err + } + } _, err = conn.ExecContext(ctx, "COMMIT") return err } diff --git a/cmd/zapret-autotune/store_test.go b/cmd/zapret-autotune/store_test.go index 085f85d..2f9b535 100644 --- a/cmd/zapret-autotune/store_test.go +++ b/cmd/zapret-autotune/store_test.go @@ -224,7 +224,7 @@ func TestConcurrentFirstOpens(t *testing.T) { } for _, db := range stores { var version, objects int - if err := db.QueryRow("PRAGMA user_version").Scan(&version); err != nil || version != 3 { + if err := db.QueryRow("PRAGMA user_version").Scan(&version); err != nil || version != 4 { t.Fatalf("version=%d err=%v", version, err) } if err := db.QueryRow(`SELECT count(*) FROM sqlite_master WHERE @@ -377,7 +377,7 @@ func TestSchemaConstraintsAndIncompleteEvidence(t *testing.T) { func TestUnsupportedSchemaVersion(t *testing.T) { db := testStore(t) - if _, err := db.Exec("PRAGMA user_version = 4"); err != nil { + if _, err := db.Exec("PRAGMA user_version = 5"); err != nil { t.Fatal(err) } if err := migrate(db); err == nil || !strings.Contains(err.Error(), "unsupported") {