From 71e37ffaef536ec809ff26b3842b42e93d9dca23 Mon Sep 17 00:00:00 2001 From: Zeusina Date: Sat, 10 Oct 2026 08:20:08 +0300 Subject: [PATCH] feat(apply): add transactional target config core Co-authored-by: GPT-6 --- MANAGED_TARGET.md | 41 ++ PROGRESS.md | 10 +- cmd/zapret-autotune/managed_config.go | 56 +++ cmd/zapret-autotune/managed_transaction.go | 378 +++++++++++++++++ .../managed_transaction_test.go | 379 ++++++++++++++++++ 5 files changed, 860 insertions(+), 4 deletions(-) create mode 100644 MANAGED_TARGET.md create mode 100644 cmd/zapret-autotune/managed_config.go create mode 100644 cmd/zapret-autotune/managed_transaction.go create mode 100644 cmd/zapret-autotune/managed_transaction_test.go diff --git a/MANAGED_TARGET.md b/MANAGED_TARGET.md new file mode 100644 index 0000000..a086bd8 --- /dev/null +++ b/MANAGED_TARGET.md @@ -0,0 +1,41 @@ +# Local managed-target transaction core (not deployed) + +`managedTransaction` is intentionally not wired to the CLI. No container, remote, +production, existing `zapret2-ss-autotune`, or Xray configuration is changed. +The caller explicitly provisions a private persistent target-owned directory and +existing regular config, then calls `Initialize` once to adopt that config. +Missing/corrupt journals never trigger automatic adoption. The journal is the +source of truth; the DB provides immutable candidate definitions and qualification +evidence only. Call `Reconcile` before accepting work after every process startup. + +Apply uses candidate IDs, distinct profiles and exact `^host` GGC filters. Shell +syntax is rejected, not interpreted. Journal/backup/config updates use same-dir +staging, file fsync, rename and directory fsync. An advisory lock serializes engine +instances; the directory must not be writable by untrusted processes. Hash checks +reject external drift (including during recovery). This is not protection against +a hostile writer racing a hash check or renaming directory ancestors. Crash-left +temporary files are inert, never adopted or promoted. Failed recovery blocks apply; +an operator must resolve drift/corruption explicitly, without deleting the journal +to silently adopt a different config. + +Reload and health are injected no-argument functions. The future adapter must bind +reload ONLY to `/opt/zapret2/init.d/sysv/zapret2 restart-daemons`, never `start` or +firewall restart, and health ONLY to existing `health youtube` through the target's +configured host-loopback SOCKS, returning `OK` only for its successful status. +No command strings or shell scripts are persisted in transaction metadata. +On activation failure the prior config is atomically restored and reloaded; a +rollback reload failure retains a pending journal and is a distinct error. Recovery +always restores pending transactions, even after a successful pre-crash probe. +It marks recovery committed only after the injected reloader succeeds. + +Pending remote acceptance: create ONLY a new test prod-like `zapret2-ss` target +using the pinned image digest; verify config variable names, shell include loading, +payload/Lua dependencies, profile semantics and `restart-daemons` behavior against +the image's v0.9.0 scripts/blockcheckw. No actual compatibility is asserted here. +Later integration must preserve the stable loopback SOCKS interface for Xray, +own only this target's NFQWS2 config/process, and reuse DB v4 health state with +policy env defaults of 5 minutes / 3 failures / 30 minutes. Scheduling, environment +parsing, adapters, target creation and user-facing CLI are deliberately deferred. + +Local checks for the orchestrator (not executed in this increment): +`go test ./cmd/zapret-autotune -run TestManaged` and `go build ./cmd/zapret-autotune`. diff --git a/PROGRESS.md b/PROGRESS.md index 4bc4e8e..0b36e46 100644 --- a/PROGRESS.md +++ b/PROGRESS.md @@ -6,6 +6,7 @@ - Добавлена foundation schema v4: durable policy state по stable service ID, last probe/streak, recovery lock и cooldown. Операции с injected time атомарно записывают probe и захватывают recovery только при threshold/истёкшем cooldown/свободном lock; завершение требует точный ownership token и запускает cooldown от completion time. Stale/duplicate finish не меняет новую lease; crash сохраняет lock fail-closed (reconciliation пока не реализован). Unit-тесты streak/reset, threshold, competing acquisition, reload/cooldown и v3 migration прошли. - Добавлен одноразовый `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`), interval `5m`, failure threshold `3`, cooldown `30m`. `go test ./...`, `go build` и `git diff --check` прошли для обоих последних increments. +- Добавлена тестируемая transaction foundation для target-owned config: только квалифицированные stored candidates, separate frontend/exact-GGC profiles, versioned durable journal/backup, atomic replace, injected daemon reload + Player API post-check, rollback и crash reconciliation; external config drift fail-closed. Renderer не сохраняет wildcard GGC scope. CLI пока не вызывает apply, target config/runtime ещё не проверены. `go build` и повторный `go test ./...` прошли; первый test run поймал прежний flaky `TestRunBlockcheckCancellation/kill` process-state race. - Завершён удалённый ручной 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 не затронуты. - Unit-тесты recovery порядка, fresh-host scope, short-circuit, fallback и fail-closed ошибок прошли; локальные `go test ./...`, `go build` и `git diff --check` успешны. @@ -35,13 +36,14 @@ ## Не готово - Проверка реального YouTube video-transfer/SABR. Прямой GET `serverAbrStreamingUrl` возвращает `sabr.malformed_config`; hostname discovery и `blockcheckw` data-transfer checks не равны проверке воспроизведения видео. -- Управляемое применение конфигурации, проверка после применения, rollback, активный профиль и автономный health monitor сервиса. Одноразовый Player API health и config policy уже есть, но interval/threshold/cooldown пока не запускают автоматизацию. Пользователь подтвердил целевую модель: новый отдельный prod-like zapret2-ss контейнер только в тестовой среде; существующий контейнер не трогать. Target должен иметь стабильный настраиваемый loopback SOCKS endpoint для same-host Xray; Xray config вне scope, пользователь настроит отдельно. Перед реализацией/запуском контроллера пройти deployment/route/rollback gates из `Architecture.md`. +- Применение пока не подключено к CLI/контейнеру: disk transaction core есть, но нет proven zapret2 config/render/reload adapter, active profile integration, supervisor/recovery loop и реально запущенного managed target. Одноразовый Player API health и persisted policy пока не запускают automation. Цель: новый отдельный prod-like zapret2-ss контейнер только в тестовой среде; существующий контейнер не трогать. Стабильный настраиваемый loopback SOCKS для Xray; Xray config вне scope. Перед runtime пройти route/rollback gates. - Полный сервис из требований: YAML-конфигурация сервисов, endpoint-история/покрытие, daemon/периодический мониторинг, API/метрики и multi-service режим. ## Открытые ограничения и следующие шаги 1. Проверить новый `tune googlevideo` и `recover googlevideo` end-to-end на удалённом сервере; отдельно решить, как импортировать или переиспользовать уже полученные scan результаты без повторного перебора. 2. Подготовить воспроизводимое описание отдельного prod-like target с закреплённым image digest, собственной bridge-сетью, независимой конфигурацией/секретами и только loopback-портами. До запуска проверить формат baseline-конфига и правила NFQUEUE внутри container network namespace; текущие mounts, сеть, порты и конфиг не переиспользовать. -3. Реализовать ограниченный apply helper с backup, проверкой активной конфигурации, post-apply probe и автоматическим rollback; затем подключить уже настраиваемые health interval/failure threshold/cooldown к monitor recovery. -4. До включения автоматического apply доказать safety gates из `Architecture.md`: изоляцию target, эквивалентность сетевого пути, версионирование, atomic activation/rollback и crash recovery. -5. Отдельно определить реальную video/SABR-проверку и traffic budget; не считать Selectel speedtest или blockcheck TLS тест заменой YouTube playback. +3. Подключить transaction core к target-specific CLI/agent; подтвердить shell config rendering, daemon-only reload и pre/post health на новом изолированном target. +4. Подключить persistent monitor policy к supervisor, recovery через сохранённые сценарии перед новым scan и crash reconciliation. +5. До autonomous mode доказать safety gates из `Architecture.md`: изоляцию target, эквивалентность managed SOCKS пути, версионирование, atomic activation/rollback и crash recovery. +6. Отдельно определить реальную video/SABR-проверку и traffic budget; API health не равен playback и не обнаруживает все GGC playback failures. diff --git a/cmd/zapret-autotune/managed_config.go b/cmd/zapret-autotune/managed_config.go new file mode 100644 index 0000000..2e9c156 --- /dev/null +++ b/cmd/zapret-autotune/managed_config.go @@ -0,0 +1,56 @@ +package main + +import ( + "database/sql" + "fmt" + "strings" +) + +// renderManagedConfig accepts identifiers, not caller-supplied strategies or scope. +// Qualification is the existing complete endpoint × TLS evidence rule. +func renderManagedConfig(db *sql.DB, ids []int64) ([]byte, error) { + var profiles []string + groups := map[string]bool{} + seen := map[int64]bool{} + for _, id := range ids { + if seen[id] { + return nil, fmt.Errorf("duplicate candidate %d", id) + } + seen[id] = true + c, err := readStrategyCandidate(db, id) + if err != nil { + return nil, err + } + if !c.Qualified { + return nil, fmt.Errorf("candidate %d is not qualified", id) + } + v := candidate{Group: c.Group, Domains: append([]string(nil), c.Endpoints...), Args: c.Args} + if err := v.validate(); err != nil { + return nil, err + } + fingerprint, err := strategyFingerprint(c.Args) + if err != nil || fingerprint != c.Fingerprint { + return nil, fmt.Errorf("candidate %d fingerprint mismatch", id) + } + domains := append([]string(nil), v.Domains...) + for i, host := range domains { + if c.Group == "googlevideo" { + if !strings.HasSuffix(host, ".googlevideo.com") { + return nil, fmt.Errorf("GGC scope must be an exact googlevideo host") + } + domains[i] = "^" + host + } + } + groups[c.Group] = true + profiles = append(profiles, "--filter-tcp=443 --filter-l7=tls --hostlist-domains="+strings.Join(domains, ",")+" "+c.Args) + } + if !groups["frontend"] || !groups["googlevideo"] { + return nil, fmt.Errorf("qualified frontend and googlevideo candidates required") + } + // All values are shell-inert after validateArgs; no shell evaluation/escaping + // contract is extended here. QNUM is intentionally left at the target default. + return []byte("# Autotuner-owned standalone config; runtime acceptance pending.\n" + + "NFQWS2_ENABLE=1\nNFQWS2_PORTS_TCP=80,443\nNFQWS2_PORTS_UDP=443\n" + + "NFQWS2_TCP_PKT_OUT=15\nNFQWS2_TCP_PKT_IN=15\nNFQWS2_UDP_PKT_OUT=15\nNFQWS2_UDP_PKT_IN=15\n" + + "INIT_APPLY_FW=1\nNFQWS2_OPT='" + strings.Join(profiles, " --new ") + "'\n"), nil +} diff --git a/cmd/zapret-autotune/managed_transaction.go b/cmd/zapret-autotune/managed_transaction.go new file mode 100644 index 0000000..b7ffca0 --- /dev/null +++ b/cmd/zapret-autotune/managed_transaction.go @@ -0,0 +1,378 @@ +package main + +import ( + "crypto/rand" + "crypto/sha256" + "database/sql" + "encoding/hex" + "encoding/json" + "errors" + "fmt" + "io" + "os" + "path/filepath" + "strings" + "syscall" +) + +var errManagedDrift = errors.New("managed config drift: refusing overwrite") + +type managedRollbackError struct{ Cause, Rollback error } + +func (e *managedRollbackError) Error() string { + return fmt.Sprintf("apply failed: %v; rollback failed: %v", e.Cause, e.Rollback) +} +func (e *managedRollbackError) Unwrap() error { return e.Cause } + +type managedJournal struct { + Version int `json:"version"` + Generation uint64 `json:"generation"` + ID string `json:"transaction_id"` + State string `json:"state"` + Hash string `json:"committed_hash"` + Next string `json:"pending_hash,omitempty"` +} + +// Hooks take no commands or arguments. The future target adapter must bind Reload +// exclusively to /opt/zapret2/init.d/sysv/zapret2 restart-daemons and Health to +// health youtube over its configured loopback SOCKS, returning exactly "OK". +// This engine does not manage firewall, SOCKS, health scheduling or DB active state. +type managedTransaction struct { + Dir, Name string + Reload func() error + Health func() (string, error) + // Tests may simulate process death after durable boundaries. Such errors leave + // the journal intact for Reconcile, deliberately bypassing normal rollback. + fault func(string) error +} + +const managedJournalName = ".autotune-journal.json" +const managedBackupName = ".autotune-last-good" + +func managedHash(b []byte) string { h := sha256.Sum256(b); return hex.EncodeToString(h[:]) } + +func (m *managedTransaction) locked(fn func() error) error { + if m.Reload == nil || m.Health == nil || !filepath.IsAbs(m.Dir) || filepath.Clean(m.Dir) != m.Dir || m.Dir == "/" || m.Name == "" || filepath.Base(m.Name) != m.Name || strings.HasPrefix(m.Name, ".") { + return fmt.Errorf("explicit target-owned directory, regular config basename and hooks required") + } + // Reject symlinked ancestors as well as managed entries. The directory must be + // privately owned: hostile concurrent directory renames are outside this API. + for p := m.Dir; ; p = filepath.Dir(p) { + info, err := os.Lstat(p) + if err != nil { + return err + } + if !info.IsDir() || info.Mode()&os.ModeSymlink != 0 { + return fmt.Errorf("unsafe config directory") + } + if p == "/" { + break + } + } + fd, err := syscall.Open(filepath.Join(m.Dir, ".autotune-lock"), syscall.O_CREAT|syscall.O_RDWR|syscall.O_NOFOLLOW|syscall.O_NONBLOCK, 0600) + if err != nil { + return err + } + lock := os.NewFile(uintptr(fd), "managed lock") + defer lock.Close() + info, err := lock.Stat() + if err != nil { + return err + } + if !info.Mode().IsRegular() { + return fmt.Errorf("non-regular lock") + } + if err := syscall.Flock(fd, syscall.LOCK_EX|syscall.LOCK_NB); err != nil { + return err + } + defer syscall.Flock(fd, syscall.LOCK_UN) + for _, name := range []string{m.Name, managedBackupName, managedJournalName} { + info, err := os.Lstat(filepath.Join(m.Dir, name)) + if os.IsNotExist(err) { + continue + } + if err != nil { + return err + } + if !info.Mode().IsRegular() { + return fmt.Errorf("non-regular managed file: %s", name) + } + } + return fn() +} + +func (m *managedTransaction) read(name string) ([]byte, error) { + fd, err := syscall.Open(filepath.Join(m.Dir, name), syscall.O_RDONLY|syscall.O_NOFOLLOW|syscall.O_NONBLOCK, 0) + if err != nil { + return nil, err + } + f := os.NewFile(uintptr(fd), name) + defer f.Close() + info, err := f.Stat() + if err != nil { + return nil, err + } + if !info.Mode().IsRegular() { + return nil, fmt.Errorf("non-regular %s", name) + } + return io.ReadAll(f) +} + +func (m *managedTransaction) syncDir() error { + d, err := os.Open(m.Dir) + if err != nil { + return err + } + defer d.Close() + return d.Sync() +} + +func (m *managedTransaction) stage(b []byte) (string, error) { + f, err := os.CreateTemp(m.Dir, ".autotune-stage-") + if err != nil { + return "", err + } + name := f.Name() + if _, err = f.Write(b); err == nil { + err = f.Sync() + } + closeErr := f.Close() + if err == nil { + err = closeErr + } + if err != nil { + os.Remove(name) + return "", err + } + return name, nil +} + +func (m *managedTransaction) replace(name string, b []byte) error { + stage, err := m.stage(b) + if err != nil { + return err + } + defer os.Remove(stage) + if err := os.Rename(stage, filepath.Join(m.Dir, name)); err != nil { + return err + } + return m.syncDir() +} + +func (m *managedTransaction) journal(j managedJournal) error { + b, err := json.Marshal(j) + if err != nil { + return err + } + return m.replace(managedJournalName, b) +} + +func (m *managedTransaction) load() (managedJournal, error) { + var j managedJournal + b, err := m.read(managedJournalName) + if err != nil { + return j, err + } + if err := json.Unmarshal(b, &j); err != nil { + return j, err + } + validHash := func(s string) bool { + b, err := hex.DecodeString(s) + return err == nil && len(b) == 32 && strings.ToLower(s) == s + } + if j.Version != 1 || j.ID == "" || !validHash(j.Hash) || (j.State != "committed" && j.State != "prepared") || (j.State == "prepared" && !validHash(j.Next)) || (j.State == "committed" && j.Next != "") { + return j, fmt.Errorf("invalid managed journal") + } + return j, nil +} + +// Initialize is an explicit one-time adoption of an existing target-owned file. +// Apply never silently adopts a missing journal or externally changed config. +func (m *managedTransaction) Initialize() error { + return m.locked(func() error { + if _, err := os.Lstat(filepath.Join(m.Dir, managedJournalName)); !os.IsNotExist(err) { + return fmt.Errorf("journal already exists or inaccessible") + } + b, err := m.read(m.Name) + if err != nil { + return err + } + if err := m.replace(managedBackupName, b); err != nil { + return err + } + return m.journal(managedJournal{Version: 1, ID: "bootstrap", State: "committed", Hash: managedHash(b)}) + }) +} + +func (m *managedTransaction) checkpoint(point string) error { + if m.fault != nil { + return m.fault(point) + } + return nil +} + +func (m *managedTransaction) Apply(db *sql.DB, ids []int64) error { + b, err := renderManagedConfig(db, ids) + if err != nil { + return err + } + return m.applyRendered(b) +} + +func (m *managedTransaction) applyRendered(b []byte) error { + return m.locked(func() error { + j, err := m.load() + if err != nil { + return err + } + if j.State != "committed" { + return fmt.Errorf("incomplete transaction: reconcile first") + } + prior, err := m.read(m.Name) + if err != nil { + return err + } + if managedHash(prior) != j.Hash { + return errManagedDrift + } + id := make([]byte, 16) + if _, err := rand.Read(id); err != nil { + return err + } + if j.Generation == ^uint64(0) { + return fmt.Errorf("generation exhausted") + } + stage, err := m.stage(b) + if err != nil { + return err + } + defer os.Remove(stage) + if err := m.checkpoint("staged"); err != nil { + return err + } + if err := m.replace(managedBackupName, prior); err != nil { + return err + } + if err := m.checkpoint("backup"); err != nil { + return err + } + j.Generation++ + j.ID, j.State, j.Next = hex.EncodeToString(id), "prepared", managedHash(b) + if err := m.journal(j); err != nil { + return err + } + if err := m.checkpoint("prepared"); err != nil { + return err + } + current, err := m.read(m.Name) + if err != nil { + return err + } + if managedHash(current) != j.Hash { + return errManagedDrift + } + err = os.Rename(stage, filepath.Join(m.Dir, m.Name)) + if err == nil { + err = m.syncDir() + } + if err == nil { + if fault := m.checkpoint("replaced"); fault != nil { + return fault + } + } + if err == nil { + err = m.Reload() + } + if err == nil { + if fault := m.checkpoint("reloaded"); fault != nil { + return fault + } + } + if err == nil { + var status string + status, err = m.Health() + if err == nil && status != "OK" { + err = fmt.Errorf("unhealthy status: %q", status) + } + } + if err == nil { + if fault := m.checkpoint("healthy"); fault != nil { + return fault + } + } + if err == nil { + committed := j + committed.State, committed.Hash, committed.Next = "committed", j.Next, "" + current, err = m.read(m.Name) + if err == nil && managedHash(current) != j.Next { + return errManagedDrift + } + if err == nil { + err = m.journal(committed) + } + } + if err == nil { + return nil + } + if rollback := m.restore(j); rollback != nil { + return &managedRollbackError{Cause: err, Rollback: rollback} + } + return err + }) +} + +func (m *managedTransaction) restore(j managedJournal) error { + current, err := m.read(m.Name) + if err != nil { + return err + } + hash := managedHash(current) + if hash != j.Hash && hash != j.Next { + return errManagedDrift + } + prior, err := m.read(managedBackupName) + if err != nil { + return err + } + if managedHash(prior) != j.Hash { + return fmt.Errorf("last-known-good backup corrupted") + } + // A failed commit fsync may have left the committed journal visible. Record + // rollback intent durably before restoring bytes, so recovery stays coherent. + if err := m.journal(j); err != nil { + return err + } + if err := m.replace(m.Name, prior); err != nil { + return err + } + if err := m.Reload(); err != nil { + return err + } + j.State, j.Next = "committed", "" + return m.journal(j) +} + +// Reconcile never promotes a pending config, even if a probe had passed before +// death. A failed restore/reload retains the pending journal and blocks Apply. +func (m *managedTransaction) Reconcile() error { + return m.locked(func() error { + j, err := m.load() + if err != nil { + return err + } + if j.State == "prepared" { + if err := m.restore(j); err != nil { + return &managedRollbackError{Cause: errors.New("incomplete transaction"), Rollback: err} + } + return nil + } + b, err := m.read(m.Name) + if err != nil { + return err + } + if managedHash(b) != j.Hash { + return errManagedDrift + } + return nil + }) +} diff --git a/cmd/zapret-autotune/managed_transaction_test.go b/cmd/zapret-autotune/managed_transaction_test.go new file mode 100644 index 0000000..02638c7 --- /dev/null +++ b/cmd/zapret-autotune/managed_transaction_test.go @@ -0,0 +1,379 @@ +package main + +import ( + "database/sql" + "errors" + "os" + "path/filepath" + "strings" + "testing" +) + +func managedCandidateFixture(t *testing.T, db *sql.DB, group, host, args string, qualified bool) int64 { + t.Helper() + tx, err := db.Begin() + if err != nil { + t.Fatal(err) + } + defer tx.Rollback() + id, err := insertStrategyCandidate(tx, group, []string{host}, args, nil) + if err != nil { + t.Fatal(err) + } + if qualified { + for _, protocol := range []string{"tls12", "tls13"} { + _, err := tx.Exec(`INSERT INTO candidate_evidence + (candidate_id, endpoint, protocol, passes_ok, passes_total, success_rate, coverage, median_latency_ms, median_speed_kbps, checked_at, raw_measurement) + VALUES (?, ?, ?, 3, 3, 1, 1, 1, 1, 'fixture', '{}')`, id, host, protocol) + if err != nil { + t.Fatal(err) + } + } + } + if err := tx.Commit(); err != nil { + t.Fatal(err) + } + return id +} + +func TestManagedRender(t *testing.T) { + db := testStore(t) + front := managedCandidateFixture(t, db, "frontend", "www.youtube.com", "--lua-desync=multisplit", true) + ggc := managedCandidateFixture(t, db, "googlevideo", "rr1---sn-test.googlevideo.com", "--lua-desync=fake", true) + b, err := renderManagedConfig(db, []int64{front, ggc}) + if err != nil { + t.Fatal(err) + } + s := string(b) + for _, want := range []string{"NFQWS2_ENABLE=1\n", "INIT_APPLY_FW=1\n", "NFQWS2_PORTS_TCP=80,443\n", "NFQWS2_PORTS_UDP=443\n", "--hostlist-domains=www.youtube.com --lua-desync=multisplit --new --filter-tcp=443 --filter-l7=tls --hostlist-domains=^rr1---sn-test.googlevideo.com --lua-desync=fake"} { + if !strings.Contains(s, want) { + t.Fatalf("missing %q in %s", want, s) + } + } + if strings.Contains(s, "QNUM=") { + t.Fatal("queue default overridden") + } + unqualified := managedCandidateFixture(t, db, "frontend", "youtube.com", "--lua-desync=fake", false) + wildcard := managedCandidateFixture(t, db, "googlevideo", "googlevideo.com", "--lua-desync=fake", true) + for _, ids := range [][]int64{{unqualified, ggc}, {front, wildcard}, {front}, {front, ggc, ggc}, {99999, ggc}} { + if _, err := renderManagedConfig(db, ids); err == nil { + t.Fatalf("accepted %v", ids) + } + } +} + +func TestManagedRenderRejectsUnsafeArgs(t *testing.T) { + for _, args := range []string{"--lua-desync=fake'", "--lua-desync=fake\n", "--lua-desync=fake;touch /tmp/x", "--lua-desync=$(id)", "--lua-desync=fake`id`", "--lua-desync=fake\"", "--lua-desync=fake --new", "--hostlist-domains=googlevideo.com"} { + t.Run(args, func(t *testing.T) { + v := candidate{Args: args} + if err := v.validateArgs(); err == nil { + t.Fatal("unsafe strategy accepted by shared validator") + } + db := testStore(t) + // Exercise validation even if legacy fingerprint normalization accepts + // shell syntax: the renderer must never extend its inert args contract. + fingerprint, err := strategyFingerprint(args) + if err != nil { + return + } + result, err := db.Exec(`INSERT INTO strategy_candidates (strategy_group, endpoints, args, fingerprint) VALUES ('frontend', '["youtube.com"]', ?, ?)`, args, fingerprint) + if err != nil { + t.Fatal(err) + } + id, err := result.LastInsertId() + if err != nil { + t.Fatal(err) + } + for _, protocol := range []string{"tls12", "tls13"} { + if _, err := db.Exec(`INSERT INTO candidate_evidence VALUES (?, 'youtube.com', ?, 3, 3, 1, 1, 1, 1, 'fixture', '{}')`, id, protocol); err != nil { + t.Fatal(err) + } + } + ggc := managedCandidateFixture(t, db, "googlevideo", "rr1.googlevideo.com", "--lua-desync=fake", true) + if _, err := renderManagedConfig(db, []int64{id, ggc}); err == nil { + t.Fatal("unsafe config accepted") + } + }) + } +} + +func managedFixture(t *testing.T) (*managedTransaction, *int) { + t.Helper() + reloads := new(int) + m := &managedTransaction{Dir: t.TempDir(), Name: "config", Reload: func() error { *reloads++; return nil }, Health: func() (string, error) { return "OK", nil }} + if err := os.WriteFile(filepath.Join(m.Dir, m.Name), []byte("prior\n"), 0600); err != nil { + t.Fatal(err) + } + if err := m.Initialize(); err != nil { + t.Fatal(err) + } + return m, reloads +} + +func assertManagedContent(t *testing.T, m *managedTransaction, want string) { + t.Helper() + b, err := os.ReadFile(filepath.Join(m.Dir, m.Name)) + if err != nil || string(b) != want { + t.Fatalf("content=%q err=%v want=%q", b, err, want) + } +} + +func TestManagedApplyDurableFlow(t *testing.T) { + m, reloads := managedFixture(t) + inode, err := os.Stat(filepath.Join(m.Dir, m.Name)) + if err != nil { + t.Fatal(err) + } + m.fault = func(point string) error { + if point == "prepared" { + assertManagedContent(t, m, "prior\n") + backup, err := m.read(managedBackupName) + if err != nil || string(backup) != "prior\n" { + t.Fatalf("backup=%q err=%v", backup, err) + } + j, err := m.load() + if err != nil || j.State != "prepared" || j.Generation != 1 || j.Next != managedHash([]byte("next\n")) { + t.Fatalf("journal=%+v err=%v", j, err) + } + } + return nil + } + if err := m.applyRendered([]byte("next\n")); err != nil { + t.Fatal(err) + } + assertManagedContent(t, m, "next\n") + after, err := os.Stat(filepath.Join(m.Dir, m.Name)) + if err != nil || os.SameFile(inode, after) { + t.Fatal("config was not atomically replaced") + } + j, err := m.load() + if err != nil || j.State != "committed" || j.Hash != managedHash([]byte("next\n")) || *reloads != 1 { + t.Fatalf("journal=%+v reloads=%d err=%v", j, *reloads, err) + } + if err := m.Reconcile(); err != nil || *reloads != 1 { + t.Fatalf("committed recovery reloaded: %v", err) + } + entries, err := filepath.Glob(filepath.Join(m.Dir, ".autotune-stage-*")) + if err != nil || len(entries) != 0 { + t.Fatalf("left stages: %v %v", entries, err) + } +} + +func TestManagedApplyCandidateIDs(t *testing.T) { + db := testStore(t) + front := managedCandidateFixture(t, db, "frontend", "youtube.com", "--lua-desync=fake", true) + ggc := managedCandidateFixture(t, db, "googlevideo", "rr1.googlevideo.com", "--lua-desync=multisplit", true) + m, reloads := managedFixture(t) + if err := m.Apply(db, []int64{front}); err == nil { + t.Fatal("partial qualification accepted") + } + assertManagedContent(t, m, "prior\n") + if *reloads != 0 { + t.Fatal("invalid render reloaded") + } + if err := m.Apply(db, []int64{front, ggc}); err != nil { + t.Fatal(err) + } + want, err := renderManagedConfig(db, []int64{front, ggc}) + if err != nil { + t.Fatal(err) + } + assertManagedContent(t, m, string(want)) +} + +func TestManagedMissingJournalNotAdopted(t *testing.T) { + m, reloads := managedFixture(t) + if err := os.Remove(filepath.Join(m.Dir, managedJournalName)); err != nil { + t.Fatal(err) + } + if err := m.applyRendered([]byte("next")); err == nil { + t.Fatal("missing journal adopted") + } + if err := m.Reconcile(); err == nil { + t.Fatal("missing journal reconciled") + } + assertManagedContent(t, m, "prior\n") + if *reloads != 0 { + t.Fatal("missing journal reloaded") + } +} + +func TestManagedFailures(t *testing.T) { + for _, mode := range []string{"reload", "unhealthy", "probe-error", "rollback-reload"} { + t.Run(mode, func(t *testing.T) { + m, reloads := managedFixture(t) + m.Reload = func() error { + *reloads++ + if mode == "reload" && *reloads == 1 || mode == "rollback-reload" && *reloads == 2 { + return errors.New("reload failed") + } + return nil + } + m.Health = func() (string, error) { + if mode == "probe-error" { + return "OK", errors.New("probe failed") + } + if mode != "reload" { + return "DEGRADED", nil + } + return "OK", nil + } + err := m.applyRendered([]byte("next\n")) + if err == nil { + t.Fatal("failure accepted") + } + assertManagedContent(t, m, "prior\n") + j, loadErr := m.load() + if loadErr != nil || *reloads != 2 { + t.Fatalf("journal=%+v err=%v reloads=%d", j, loadErr, *reloads) + } + var rollback *managedRollbackError + if mode == "rollback-reload" { + if !errors.As(err, &rollback) || j.State != "prepared" { + t.Fatalf("rollback failure not distinct: %v %+v", err, j) + } + m.Reload = func() error { return nil } + if err := m.Reconcile(); err != nil { + t.Fatal(err) + } + } else if j.State != "committed" { + t.Fatalf("rollback incomplete: %+v", j) + } + }) + } +} + +func TestManagedCrashReconciliation(t *testing.T) { + for _, point := range []string{"staged", "backup", "prepared", "replaced", "reloaded", "healthy"} { + t.Run(point, func(t *testing.T) { + m, reloads := managedFixture(t) + m.fault = func(p string) error { + if p == point { + return errors.New("simulated death") + } + return nil + } + if err := m.applyRendered([]byte("next\n")); err == nil { + t.Fatal("fault missed") + } + before := *reloads + m.fault = nil + if err := m.Reconcile(); err != nil { + t.Fatal(err) + } + assertManagedContent(t, m, "prior\n") + want := before + 1 + if point == "staged" || point == "backup" { + want = before + } + if *reloads != want { + t.Fatalf("reloads=%d want=%d", *reloads, want) + } + if err := m.applyRendered([]byte("later\n")); err != nil { + t.Fatal(err) + } + }) + } +} + +func TestManagedRejectsPathsAndDrift(t *testing.T) { + for _, name := range []string{"../config", "/tmp/config", ".autotune-journal.json", ".", ""} { + m, _ := managedFixture(t) + m.Name = name + if err := m.applyRendered([]byte("next")); err == nil { + t.Fatalf("accepted name %q", name) + } + } + for _, entry := range []string{"config", managedBackupName, managedJournalName, ".autotune-lock"} { + m, _ := managedFixture(t) + outside := filepath.Join(t.TempDir(), "outside") + if err := os.WriteFile(outside, []byte("untouched"), 0600); err != nil { + t.Fatal(err) + } + path := filepath.Join(m.Dir, entry) + if err := os.Remove(path); err != nil { + t.Fatal(err) + } + if err := os.Symlink(outside, path); err != nil { + t.Fatal(err) + } + if err := m.applyRendered([]byte("next")); err == nil { + t.Fatalf("accepted symlink %s", entry) + } + b, err := os.ReadFile(outside) + if err != nil || string(b) != "untouched" { + t.Fatal("outside modified") + } + } + m, _ := managedFixture(t) + alias := filepath.Join(t.TempDir(), "alias") + if err := os.Symlink(m.Dir, alias); err != nil { + t.Fatal(err) + } + real := m.Dir + m.Dir = alias + if err := m.Reconcile(); err == nil { + t.Fatal("accepted symlink directory") + } + m.Dir = real + if err := os.WriteFile(filepath.Join(m.Dir, m.Name), []byte("external"), 0600); err != nil { + t.Fatal(err) + } + if err := m.applyRendered([]byte("next")); !errors.Is(err, errManagedDrift) { + t.Fatalf("drift accepted: %v", err) + } + if err := m.Reconcile(); !errors.Is(err, errManagedDrift) { + t.Fatalf("recovery drift accepted: %v", err) + } + assertManagedContent(t, m, "external") +} + +func TestManagedRecoveryFailsClosed(t *testing.T) { + for _, damage := range []string{"drift", "backup", "reload", "journal", "nonregular"} { + t.Run(damage, func(t *testing.T) { + m, _ := managedFixture(t) + m.fault = func(p string) error { + if p == "replaced" { + return errors.New("death") + } + return nil + } + if err := m.applyRendered([]byte("next\n")); err == nil { + t.Fatal("fault missed") + } + switch damage { + case "drift": + if err := os.WriteFile(filepath.Join(m.Dir, m.Name), []byte("external"), 0600); err != nil { + t.Fatal(err) + } + case "backup", "journal": + name := managedBackupName + if damage == "journal" { + name = managedJournalName + } + if err := os.WriteFile(filepath.Join(m.Dir, name), []byte("bad"), 0600); err != nil { + t.Fatal(err) + } + case "reload": + m.Reload = func() error { return errors.New("unavailable") } + case "nonregular": + if err := os.Remove(filepath.Join(m.Dir, m.Name)); err != nil { + t.Fatal(err) + } + if err := os.Mkdir(filepath.Join(m.Dir, m.Name), 0700); err != nil { + t.Fatal(err) + } + } + m.fault = nil + if err := m.Reconcile(); err == nil { + t.Fatal("unsafe recovery accepted") + } + if err := m.applyRendered([]byte("later")); err == nil { + t.Fatal("apply accepted after failed recovery") + } + if damage == "drift" { + assertManagedContent(t, m, "external") + } + }) + } +}