feat(apply): add transactional target config core

Co-authored-by: GPT-6 <gpt-6@openai.com>
This commit is contained in:
ZeusinaandGPT-6 Bot committed 2026-10-10 08:20:08 +03:00
1 parent 537d0bd696
commit 71e37ffaef
5 files changed
+860 -4

No files matched your search

+41
View File
@@ -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`.
+6 -4
View File
@@ -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.
+56
View File
@@ -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
}
+378
View File
@@ -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
})
}
@@ -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")
}
})
}
}