feat(apply): support staged strategy groups

Co-authored-by: GPT-6 <gpt-6@openai.com>
This commit is contained in:
ZeusinaandGPT-6 Bot committed 2026-10-10 09:24:43 +03:00
1 parent 468532dc8f
commit 2d4e4878ae
9 files changed
+776 -71

No files matched your search

+104 -39
View File
@@ -55,33 +55,35 @@ func managedDependencies(player playerRunner) managedDeps {
}
func managedArguments(args []string) (string, []int64, error) {
if len(args) == 1 && (args[0] == "init" || args[0] == "status") {
invalid := fmt.Errorf("managed accepts init, status, active-ids, or apply with one or both candidate flags (full desired set); no path flags")
if len(args) == 1 && (args[0] == "init" || args[0] == "status" || args[0] == "active-ids") {
return args[0], nil, nil
}
if len(args) == 5 && args[0] == "apply" {
ids := make([]int64, 2)
seen := map[string]bool{}
for i := 1; i < len(args); i += 2 {
key := args[i]
if seen[key] || (key != "--frontend-candidate" && key != "--googlevideo-candidate") || args[i+1] == "" || strings.Trim(args[i+1], "0123456789") != "" {
break
}
seen[key] = true
id, err := strconv.ParseInt(args[i+1], 10, 64)
if err != nil || id <= 0 {
break
}
index := 0
if key == "--googlevideo-candidate" {
index = 1
}
ids[index] = id
if (len(args) != 3 && len(args) != 5) || args[0] != "apply" {
return "", nil, invalid
}
selected := map[string]int64{}
for i := 1; i < len(args); i += 2 {
key := args[i]
if selected[key] != 0 || (key != "--frontend-candidate" && key != "--googlevideo-candidate") || args[i+1] == "" || strings.Trim(args[i+1], "0123456789") != "" {
return "", nil, invalid
}
if ids[0] > 0 && ids[1] > 0 && ids[0] != ids[1] {
return "apply", ids, nil
id, err := strconv.ParseInt(args[i+1], 10, 64)
if err != nil || id <= 0 {
return "", nil, invalid
}
selected[key] = id
}
var ids []int64
for _, key := range []string{"--frontend-candidate", "--googlevideo-candidate"} {
if id := selected[key]; id != 0 {
ids = append(ids, id)
}
}
return "", nil, fmt.Errorf("managed accepts init, status, or apply --frontend-candidate ID --googlevideo-candidate ID (positive distinct IDs); no path flags")
if len(ids) == 2 && ids[0] == ids[1] {
return "", nil, invalid
}
return "apply", ids, nil
}
// Provisioning supplies the directory. Never create it or follow aliases.
@@ -193,27 +195,79 @@ func managedCheckIdentity(m *managedTransaction) error {
return nil
}
func managedStatus(m *managedTransaction, out io.Writer) error {
// Status and supervisor reads share the same locked, DB-validated snapshot.
func managedReport(m *managedTransaction, out io.Writer, openDB func() (*sql.DB, error), activeOnly bool) error {
return m.locked(func() error {
j, err := m.load()
if err != nil {
return err
}
b, err := m.read("config")
b, err := m.read(m.Name)
if err != nil {
return err
}
if j.State != "committed" {
return fmt.Errorf("pending transaction; managed apply must reconcile before activation")
if j.State != "committed" && activeOnly {
return fmt.Errorf("pending transaction; reconcile before reading active IDs")
}
if managedHash(b) != j.Hash {
if managedHash(b) != j.Hash && (j.State != "prepared" || managedHash(b) != j.Next) {
return errManagedDrift
}
groups := "none (disabled)"
if strings.Contains(string(b), "\nNFQWS2_ENABLE=1\n") {
groups = "frontend,googlevideo"
groups := map[string]bool{}
known := j.State == "committed" && j.Version == 2 && string(b) == managedBaseline && len(j.Candidates) == 0
if j.State == "committed" && j.Version == 2 && len(j.Candidates) != 0 {
db, err := openDB()
if db != nil {
defer db.Close()
}
if err == nil && db != nil {
rendered, err := renderManagedConfig(db, j.Candidates)
if err == nil && managedHash(rendered) == j.Hash {
known = true
for _, id := range j.Candidates {
c, err := readStrategyCandidate(db, id)
if err != nil || !c.Qualified {
known = false
break
}
groups[c.Group] = true
}
}
}
}
_, err = fmt.Fprintf(out, "managed-test generation=%d hash=%s groups=%s\nLive health: NOT CHECKED (Player API is not playback)\n", j.Generation, j.Hash, groups)
if !known {
groups = map[string]bool{}
// Unvalidated journal references are not active recovery candidates.
j.Candidates = nil
}
var active, missing []string
for _, group := range []string{"frontend", "googlevideo"} {
if groups[group] {
active = append(active, group)
} else {
missing = append(missing, group)
}
}
if activeOnly {
if !known {
return fmt.Errorf("active candidate IDs unresolved; deployment preserved by hash")
}
return json.NewEncoder(out).Encode(struct {
IDs []int64 `json:"active_candidate_ids"`
Missing []string `json:"unresolved_groups"`
}{append([]int64{}, j.Candidates...), missing})
}
groupText := strings.Join(active, ",")
if groupText == "" {
groupText = "none (disabled)"
if !known {
groupText = "unknown"
}
}
var reportIDs []int64
if known {
reportIDs = j.Candidates
}
_, err = fmt.Fprintf(out, "managed-test generation=%d hash=%s state=%s groups=%s active_candidate_ids=%v unresolved_groups=%s\nLive health: NOT CHECKED (Player API is not GGC/video playback)\n", j.Generation, j.Hash, j.State, groupText, reportIDs, strings.Join(missing, ","))
return err
})
}
@@ -269,25 +323,35 @@ func managedCLI(args []string, stdout, stderr io.Writer, d managedDeps) int {
if command == "init" {
err = managedInitialize(m)
} else if err = managedCheckIdentity(m); err == nil {
if command == "status" {
err = managedStatus(m, stdout)
if command == "status" || command == "active-ids" {
err = managedReport(m, stdout, d.openDB, command == "active-ids")
} else {
err = managedActivate(m, d, ids)
expected := map[int64]string{}
for i := 1; i < len(args); i += 2 {
id, _ := strconv.ParseInt(args[i+1], 10, 64)
expected[id] = strings.TrimSuffix(strings.TrimPrefix(args[i], "--"), "-candidate")
}
err = managedActivate(m, d, ids, expected)
}
}
if err != nil {
fmt.Fprintln(stderr, "error:", err)
return 1
}
if command != "status" {
if command == "init" || command == "apply" {
if _, err := fmt.Fprintln(stdout, "managed-test "+command+": OK"); err != nil {
return 1
}
if command == "apply" {
if _, err := fmt.Fprintln(stdout, "Player API only; not full-profile/GGC/playback health. Use managed status for unresolved groups."); err != nil {
return 1
}
}
}
return 0
}
func managedActivate(m *managedTransaction, d managedDeps, ids []int64) error {
func managedActivate(m *managedTransaction, d managedDeps, ids []int64, expected map[int64]string) error {
info, err := os.Stat(d.script)
if err != nil || !info.Mode().IsRegular() || info.Mode().Perm()&0111 == 0 {
return fmt.Errorf("target zapret daemon init executable unavailable")
@@ -322,8 +386,9 @@ func managedActivate(m *managedTransaction, d managedDeps, ids []int64) error {
return fmt.Errorf("candidate database missing")
}
defer db.Close()
for i, group := range []string{"frontend", "googlevideo"} {
c, err := readStrategyCandidate(db, ids[i])
for _, id := range ids {
group := expected[id]
c, err := readStrategyCandidate(db, id)
if err != nil || c.Group != group {
return fmt.Errorf("invalid %s candidate ID", group)
}
@@ -331,7 +396,7 @@ func managedActivate(m *managedTransaction, d managedDeps, ids []int64) error {
if _, err := renderManagedConfig(db, ids); err != nil {
return err
}
if err := m.Reconcile(); err != nil {
if err := m.Reconcile(db); err != nil {
return err
}
return m.Apply(db, ids)
+62
View File
@@ -4,6 +4,7 @@ import (
"bytes"
"context"
"database/sql"
"encoding/json"
"errors"
"fmt"
"io"
@@ -265,6 +266,7 @@ func TestManagedCLIApplyAndRollback(t *testing.T) {
if !strings.Contains(string(b), "--hostlist-domains=^rr1.googlevideo.com") {
t.Fatalf("wrong applied scope: %s", b)
}
d.openDB = func() (*sql.DB, error) { return openHistoryStore(databasePath()) }
code, out, diagnostic = callManaged(t, d, "status")
if code != 0 || !strings.Contains(out, "generation=1") || !strings.Contains(out, "groups=frontend,googlevideo") || strings.Contains(out, "lua-desync") || strings.Contains(out, "rr1") {
t.Fatalf("status: %d %s %s", code, out, diagnostic)
@@ -391,6 +393,66 @@ func TestManagedCLIFreshTargetContract(t *testing.T) {
}
}
func TestManagedCLIStagedProfiles(t *testing.T) {
for _, group := range []string{"frontend", "googlevideo"} {
t.Run(group, func(t *testing.T) {
d, _, calls := managedCLIFixture(t)
initManagedCLI(t, d)
db := testStore(t)
front := managedCandidateFixture(t, db, "frontend", "youtube.com", "--lua-desync=fake", true)
ggc := managedCandidateFixture(t, db, "googlevideo", "rr1.googlevideo.com", "--lua-desync=fake", true)
id, missing := front, "googlevideo"
if group == "googlevideo" {
id, missing = ggc, "frontend"
}
d.openDB = func() (*sql.DB, error) { return openHistoryStore(databasePath()) }
if code, out, diagnostic := callManaged(t, d, "apply", "--"+group+"-candidate", fmt.Sprint(id)); code != 0 {
t.Fatalf("single group apply: %d %s %s", code, out, diagnostic)
}
if code, out, diagnostic := callManaged(t, d, "status"); code != 0 || !strings.Contains(out, "groups="+group+" ") || !strings.Contains(out, "unresolved_groups="+missing) || !strings.Contains(out, "NOT CHECKED") {
t.Fatalf("partial status: %d %s %s", code, out, diagnostic)
}
code, out, diagnostic := callManaged(t, d, "active-ids")
var state struct {
IDs []int64 `json:"active_candidate_ids"`
Missing []string `json:"unresolved_groups"`
}
if code != 0 || json.Unmarshal([]byte(out), &state) != nil || !reflect.DeepEqual(state.IDs, []int64{id}) || !reflect.DeepEqual(state.Missing, []string{missing}) || *calls != 1 {
t.Fatalf("active IDs: %d %s %s", code, out, diagnostic)
}
if _, err := db.Exec("DELETE FROM candidate_evidence WHERE candidate_id = ?", id); err != nil {
t.Fatal(err)
}
if code, out, diagnostic := callManaged(t, d, "status"); code != 0 || !strings.Contains(out, "groups=unknown ") || !strings.Contains(out, "active_candidate_ids=[] ") || !strings.Contains(out, "unresolved_groups=frontend,googlevideo") {
t.Fatalf("invalid DB status: %d %s %s", code, out, diagnostic)
}
if code, out, diagnostic := callManaged(t, d, "active-ids"); code == 0 || out != "" || !strings.Contains(diagnostic, "active candidate IDs unresolved") || *calls != 1 {
t.Fatalf("invalid DB IDs trusted: %d %s %s", code, out, diagnostic)
}
})
}
}
func TestManagedCLILegacyIDsUnresolved(t *testing.T) {
d, _, calls := managedCLIFixture(t)
initManagedCLI(t, d)
m := &managedTransaction{Dir: d.directory, Name: "config", Reload: func() error { return nil }, Health: func() (string, error) { return "OK", nil }}
j, err := m.load()
if err != nil {
t.Fatal(err)
}
j.Version = 1
if err := m.journal(j); err != nil {
t.Fatal(err)
}
if code, out, diagnostic := callManaged(t, d, "status"); code != 0 || !strings.Contains(out, "groups=unknown") || !strings.Contains(out, "unresolved_groups=frontend,googlevideo") {
t.Fatalf("legacy status: %d %s %s", code, out, diagnostic)
}
if code, out, _ := callManaged(t, d, "active-ids"); code == 0 || out != "" || *calls != 0 {
t.Fatal("legacy IDs inferred")
}
}
func TestManagedMountpoint(t *testing.T) {
for _, path := range []string{"/", filepath.Dir(managedTargetDirectory), managedTargetDirectory + "-other"} {
if managedMountpoint("1 2 0:3 / "+path+" rw - tmpfs tmpfs rw\n", managedTargetDirectory) {
+9 -3
View File
@@ -15,11 +15,14 @@ const managedFirewallConfig = "INIT_APPLY_FW=1\n" +
// 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) {
if db == nil {
return nil, fmt.Errorf("candidate definitions database required")
}
var profiles []string
groups := map[string]bool{}
seen := map[int64]bool{}
for _, id := range ids {
if seen[id] {
if id <= 0 || seen[id] {
return nil, fmt.Errorf("duplicate candidate %d", id)
}
seen[id] = true
@@ -30,6 +33,9 @@ func renderManagedConfig(db *sql.DB, ids []int64) ([]byte, error) {
if !c.Qualified {
return nil, fmt.Errorf("candidate %d is not qualified", id)
}
if groups[c.Group] {
return nil, fmt.Errorf("duplicate candidate group %q", c.Group)
}
v := candidate{Group: c.Group, Domains: append([]string(nil), c.Endpoints...), Args: c.Args}
if err := v.validate(); err != nil {
return nil, err
@@ -50,8 +56,8 @@ func renderManagedConfig(db *sql.DB, ids []int64) ([]byte, error) {
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")
if len(profiles) == 0 {
return nil, fmt.Errorf("qualified candidate required")
}
// All values are shell-inert after validateArgs; no shell evaluation/escaping
// contract is extended here. QNUM is intentionally left at the target default.
+156
View File
@@ -0,0 +1,156 @@
package main
import (
"database/sql"
"encoding/json"
"errors"
"fmt"
"reflect"
"strings"
"testing"
)
func TestManagedSingleGroupCLI(t *testing.T) {
for _, group := range []string{"frontend", "googlevideo"} {
t.Run(group, func(t *testing.T) {
d, _, calls := managedCLIFixture(t)
initManagedCLI(t, d)
db := testStore(t)
host, missing := "youtube.com", "googlevideo"
if group == "googlevideo" {
host, missing = "rr1.googlevideo.com", "frontend"
}
id := managedCandidateFixture(t, db, group, host, "--lua-desync=fake", true)
// Every CLI command owns and closes its own read-only DB handle.
d.openDB = func() (*sql.DB, error) { return openHistoryStore(databasePath()) }
if code, out, diagnostic := callManaged(t, d, "apply", "--"+group+"-candidate", fmt.Sprint(id)); code != 0 {
t.Fatalf("apply: %d %s %s", code, out, diagnostic)
}
code, out, diagnostic := callManaged(t, d, "status")
if code != 0 || !strings.Contains(out, "groups="+group+" ") || !strings.Contains(out, "unresolved_groups="+missing+"\n") || !strings.Contains(out, "Live health: NOT CHECKED") {
t.Fatalf("partial status: %d %s %s", code, out, diagnostic)
}
code, out, diagnostic = callManaged(t, d, "active-ids")
var snapshot struct {
IDs []int64 `json:"active_candidate_ids"`
Missing []string `json:"unresolved_groups"`
}
if err := json.Unmarshal([]byte(out), &snapshot); err != nil || code != 0 || !reflect.DeepEqual(snapshot.IDs, []int64{id}) || !reflect.DeepEqual(snapshot.Missing, []string{missing}) {
t.Fatalf("partial IDs: %d %s %s %v", code, out, diagnostic, err)
}
if *calls != 1 {
t.Fatalf("status/IDs restarted: %d", *calls)
}
})
}
}
func TestManagedStatusUnresolvedSnapshot(t *testing.T) {
for _, mode := range []string{"database", "qualification", "legacy", "pending"} {
t.Run(mode, func(t *testing.T) {
d, _, _ := managedCLIFixture(t)
initManagedCLI(t, d)
db := testStore(t)
front := managedCandidateFixture(t, db, "frontend", "youtube.com", "--lua-desync=fake", true)
ggc := managedCandidateFixture(t, db, "googlevideo", "rr1.googlevideo.com", "--lua-desync=fake", true)
m := &managedTransaction{Dir: d.directory, Name: "config", Reload: func() error { return nil }, Health: func() (string, error) { return "OK", nil }}
if err := m.Apply(db, []int64{front}); err != nil {
t.Fatal(err)
}
d.openDB = func() (*sql.DB, error) { return openHistoryStore(databasePath()) }
switch mode {
case "database":
d.openDB = func() (*sql.DB, error) { return nil, errors.New("private database error") }
case "qualification":
if _, err := db.Exec("DELETE FROM candidate_evidence WHERE candidate_id = ?", front); err != nil {
t.Fatal(err)
}
case "legacy":
j, err := m.load()
if err != nil {
t.Fatal(err)
}
j.Version, j.Candidates = 1, nil
if err := m.journal(j); err != nil {
t.Fatal(err)
}
case "pending":
m.fault = func(point string) error {
if point == "replaced" {
return errors.New("death")
}
return nil
}
if err := m.Apply(db, []int64{ggc}); err == nil {
t.Fatal("crash missed")
}
}
code, out, diagnostic := callManaged(t, d, "status")
if code != 0 || !strings.Contains(out, "groups=unknown active_candidate_ids=[] unresolved_groups=frontend,googlevideo") || !strings.Contains(out, "Live health: NOT CHECKED") || strings.Contains(out+diagnostic, "private") {
t.Fatalf("unresolved status: %d %s %s", code, out, diagnostic)
}
if code, out, _ := callManaged(t, d, "active-ids"); code == 0 || out != "" {
t.Fatalf("unresolved IDs exposed: %d %s", code, out)
}
if mode == "pending" {
m.fault = nil
if err := m.Reconcile(db); err != nil {
t.Fatal(err)
}
assertActiveCandidates(t, m, db, []int64{front})
}
})
}
}
func TestManagedPartialGroupRollback(t *testing.T) {
for _, priorGroup := range []string{"frontend", "googlevideo"} {
for _, point := range []string{"staged", "backup", "prepared", "replaced", "reloaded", "healthy", "unhealthy"} {
t.Run(priorGroup+"/"+point, func(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=fake", true)
prior, next := []int64{front}, []int64{ggc}
if priorGroup == "googlevideo" {
prior, next = next, prior
}
m, _ := managedFixture(t)
if err := m.Apply(db, prior); err != nil {
t.Fatal(err)
}
priorBytes, err := m.read(m.Name)
if err != nil {
t.Fatal(err)
}
m.fault = func(p string) error {
if p == "prepared" {
j, err := m.load()
if err != nil || !reflect.DeepEqual(j.Candidates, prior) || !reflect.DeepEqual(j.PendingCandidates, next) {
t.Fatalf("group sets: %+v %v", j, err)
}
}
if p == point {
return errors.New("death")
}
return nil
}
if point == "unhealthy" {
m.Health = func() (string, error) { return "DEGRADED", nil }
}
if err := m.Apply(db, next); err == nil {
t.Fatal("failure missed")
}
m.fault = nil
if err := m.Reconcile(db); err != nil {
t.Fatal(err)
}
assertManagedContent(t, m, string(priorBytes))
assertActiveCandidates(t, m, db, prior)
j, err := m.load()
if err != nil || len(j.PendingCandidates) != 0 {
t.Fatalf("pending IDs retained: %+v %v", j, err)
}
})
}
}
}
+156 -13
View File
@@ -11,6 +11,7 @@ import (
"io"
"os"
"path/filepath"
"reflect"
"strings"
"syscall"
)
@@ -25,12 +26,14 @@ func (e *managedRollbackError) Error() string {
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"`
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"`
Candidates []int64 `json:"committed_candidate_ids,omitempty"`
PendingCandidates []int64 `json:"pending_candidate_ids,omitempty"`
}
// Hooks take no commands or arguments. The target adapter binds Reload
@@ -181,7 +184,20 @@ func (m *managedTransaction) load() (managedJournal, error) {
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 != "") {
validIDs := func(ids []int64) bool {
if len(ids) > 2 {
return false
}
seen := map[int64]bool{}
for _, id := range ids {
if id <= 0 || seen[id] {
return false
}
seen[id] = true
}
return true
}
if (j.Version != 1 && j.Version != 2) || j.ID == "" || !validHash(j.Hash) || (j.State != "committed" && j.State != "prepared") || (j.State == "prepared" && !validHash(j.Next)) || (j.State == "committed" && (j.Next != "" || len(j.PendingCandidates) != 0)) || !validIDs(j.Candidates) || !validIDs(j.PendingCandidates) || (j.Version == 1 && (len(j.Candidates) != 0 || len(j.PendingCandidates) != 0)) {
return j, fmt.Errorf("invalid managed journal")
}
return j, nil
@@ -201,7 +217,7 @@ func (m *managedTransaction) Initialize() error {
if err := m.replace(managedBackupName, b); err != nil {
return err
}
return m.journal(managedJournal{Version: 1, ID: "bootstrap", State: "committed", Hash: managedHash(b)})
return m.journal(managedJournal{Version: 2, ID: "bootstrap", State: "committed", Hash: managedHash(b)})
})
}
@@ -213,14 +229,94 @@ func (m *managedTransaction) checkpoint(point string) error {
}
func (m *managedTransaction) Apply(db *sql.DB, ids []int64) error {
ids = append([]int64(nil), ids...)
b, err := renderManagedConfig(db, ids)
if err != nil {
return err
}
return m.applyRendered(b)
return m.applyRenderedDB(b, db, ids...)
}
func (m *managedTransaction) applyRendered(b []byte) error {
// ActiveCandidates uses the journal as active-state authority. The DB supplies
// only immutable definitions and qualification; rendering binds refs to bytes.
// Legacy v1/adopted configs have no known active refs, even when their hash matches.
// Apply's complete list replaces all groups: either single group drops the other.
func (m *managedTransaction) ActiveCandidates(db *sql.DB) ([]int64, error) {
var ids []int64
err := m.locked(func() error {
j, err := m.load()
if err != nil {
return err
}
if j.State != "committed" {
return fmt.Errorf("incomplete transaction: reconcile first")
}
b, err := m.read(m.Name)
if err != nil {
return err
}
if managedHash(b) != j.Hash {
return errManagedDrift
}
if len(j.Candidates) == 0 && (j.Version == 1 || string(b) != managedBaseline) {
return fmt.Errorf("active candidate IDs unresolved; deployment preserved by hash")
}
if len(j.Candidates) != 0 {
if db == nil {
return fmt.Errorf("candidate database required")
}
rendered, err := renderManagedConfig(db, j.Candidates)
if err != nil {
return err
}
if managedHash(rendered) != j.Hash {
return fmt.Errorf("active candidates do not match committed config")
}
}
ids = append([]int64(nil), j.Candidates...)
return nil
})
return ids, err
}
func committedManagedJournal(j managedJournal) managedJournal {
j.State, j.Hash, j.Next = "committed", j.Next, ""
j.Candidates, j.PendingCandidates = j.PendingCandidates, nil
return j
}
// A stale transaction must not overwrite another generation's journal, even
// when that generation happens to render identical config bytes.
func (m *managedTransaction) owns(j managedJournal, allowCommitted bool) error {
current, err := m.load()
if err != nil {
return err
}
if !reflect.DeepEqual(current, j) && !(allowCommitted && reflect.DeepEqual(current, committedManagedJournal(j))) {
return fmt.Errorf("stale managed transaction")
}
return nil
}
func (m *managedTransaction) applyRendered(b []byte, ids ...int64) error {
return m.applyRenderedDB(b, nil, ids...)
}
func validateManagedRefs(db *sql.DB, ids []int64, hash string) error {
if len(ids) == 0 {
return nil
}
if db == nil {
return fmt.Errorf("candidate database required")
}
b, err := renderManagedConfig(db, ids)
if err != nil || managedHash(b) != hash {
return fmt.Errorf("managed candidate state unresolved")
}
return nil
}
func (m *managedTransaction) applyRenderedDB(b []byte, db *sql.DB, ids ...int64) error {
return m.locked(func() error {
j, err := m.load()
if err != nil {
@@ -229,6 +325,12 @@ func (m *managedTransaction) applyRendered(b []byte) error {
if j.State != "committed" {
return fmt.Errorf("incomplete transaction: reconcile first")
}
if err := validateManagedRefs(db, j.Candidates, j.Hash); err != nil {
return err
}
if err := validateManagedRefs(db, ids, managedHash(b)); err != nil {
return err
}
prior, err := m.read(m.Name)
if err != nil {
return err
@@ -251,14 +353,26 @@ func (m *managedTransaction) applyRendered(b []byte) error {
if err := m.checkpoint("staged"); err != nil {
return err
}
if err := m.owns(j, false); err != nil {
return err
}
if err := m.replace(managedBackupName, prior); err != nil {
return err
}
if err := m.checkpoint("backup"); err != nil {
return err
}
if err := m.owns(j, false); err != nil {
return err
}
// Check ownership again before replacing the journal's selected set.
if err := m.owns(j, false); err != nil {
return err
}
j.Generation++
j.Version = 2
j.ID, j.State, j.Next = hex.EncodeToString(id), "prepared", managedHash(b)
j.PendingCandidates = append([]int64(nil), ids...)
if err := m.journal(j); err != nil {
return err
}
@@ -272,6 +386,9 @@ func (m *managedTransaction) applyRendered(b []byte) error {
if managedHash(current) != j.Hash {
return errManagedDrift
}
if err := m.owns(j, false); err != nil {
return err
}
err = os.Rename(stage, filepath.Join(m.Dir, m.Name))
if err == nil {
err = m.syncDir()
@@ -302,13 +419,15 @@ func (m *managedTransaction) applyRendered(b []byte) error {
}
}
if err == nil {
committed := j
committed.State, committed.Hash, committed.Next = "committed", j.Next, ""
committed := committedManagedJournal(j)
current, err = m.read(m.Name)
if err == nil && managedHash(current) != j.Next {
return errManagedDrift
}
if err == nil {
if err := m.owns(j, false); err != nil {
return err
}
err = m.journal(committed)
}
}
@@ -323,6 +442,9 @@ func (m *managedTransaction) applyRendered(b []byte) error {
}
func (m *managedTransaction) restore(j managedJournal) error {
if err := m.owns(j, true); err != nil {
return err
}
current, err := m.read(m.Name)
if err != nil {
return err
@@ -349,18 +471,39 @@ func (m *managedTransaction) restore(j managedJournal) error {
if err := m.Reload(); err != nil {
return err
}
if err := m.owns(j, false); err != nil {
return err
}
current, err = m.read(m.Name)
if err != nil {
return err
}
if managedHash(current) != j.Hash {
return errManagedDrift
}
j.State, j.Next = "committed", ""
j.PendingCandidates = nil
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 {
func (m *managedTransaction) Reconcile(databases ...*sql.DB) error {
return m.locked(func() error {
j, err := m.load()
if err != nil {
return err
}
var db *sql.DB
if len(databases) != 0 {
db = databases[0]
}
if err := validateManagedRefs(db, j.Candidates, j.Hash); err != nil {
return err
}
if err := validateManagedRefs(db, j.PendingCandidates, j.Next); err != nil {
return err
}
if j.State == "prepared" {
if err := m.restore(j); err != nil {
return &managedRollbackError{Cause: errors.New("incomplete transaction"), Rollback: err}
+248 -6
View File
@@ -5,6 +5,7 @@ import (
"errors"
"os"
"path/filepath"
"reflect"
"strings"
"testing"
)
@@ -56,11 +57,21 @@ func TestManagedRender(t *testing.T) {
}
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}} {
otherFront := managedCandidateFixture(t, db, "frontend", "youtube.com", "--lua-desync=fake", true)
otherGGC := managedCandidateFixture(t, db, "googlevideo", "rr2.googlevideo.com", "--lua-desync=fake", true)
for _, ids := range [][]int64{{}, {unqualified, ggc}, {front, wildcard}, {front, otherFront}, {front, ggc, otherGGC}, {front, ggc, ggc}, {99999, ggc}, {0}, {-1}} {
if _, err := renderManagedConfig(db, ids); err == nil {
t.Fatalf("accepted %v", ids)
}
}
bootstrap, err := renderManagedConfig(db, []int64{front})
if err != nil || strings.Contains(string(bootstrap), "googlevideo") || strings.Contains(string(bootstrap), "--new") {
t.Fatalf("frontend-only config=%q err=%v", bootstrap, err)
}
cacheOnly, err := renderManagedConfig(db, []int64{ggc})
if err != nil || !strings.Contains(string(cacheOnly), "--hostlist-domains=^rr1---sn-test.googlevideo.com") || strings.Contains(string(cacheOnly), "youtube.com") {
t.Fatalf("GGC-only config=%q err=%v", cacheOnly, err)
}
}
func assertManagedFirewallConfig(t *testing.T, config, enabled string) {
@@ -182,13 +193,17 @@ func TestManagedApplyCandidateIDs(t *testing.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")
if err := m.Apply(db, []int64{ggc}); err != nil {
t.Fatal(err)
}
assertManagedContent(t, m, "prior\n")
if *reloads != 0 {
t.Fatal("invalid render reloaded")
assertActiveCandidates(t, m, db, []int64{ggc})
if *reloads != 1 {
t.Fatal("GGC-only not activated")
}
if err := m.Apply(db, []int64{front}); err != nil {
t.Fatal(err)
}
assertActiveCandidates(t, m, db, []int64{front})
if err := m.Apply(db, []int64{front, ggc}); err != nil {
t.Fatal(err)
}
@@ -197,6 +212,30 @@ func TestManagedApplyCandidateIDs(t *testing.T) {
t.Fatal(err)
}
assertManagedContent(t, m, string(want))
assertActiveCandidates(t, m, db, []int64{front, ggc})
replacement := managedCandidateFixture(t, db, "frontend", "www.youtube.com", "--lua-desync=multisplit", true)
if err := m.Apply(db, []int64{replacement, ggc}); err != nil {
t.Fatal(err)
}
assertActiveCandidates(t, m, db, []int64{replacement, ggc})
if err := m.Apply(db, []int64{replacement}); err != nil {
t.Fatal(err)
}
assertActiveCandidates(t, m, db, []int64{replacement})
b, err := m.read(m.Name)
if err != nil || strings.Contains(string(b), "googlevideo") {
t.Fatalf("GGC was not removed: %q %v", b, err)
}
}
func assertActiveCandidates(t *testing.T, m *managedTransaction, db *sql.DB, want []int64) {
t.Helper()
// Re-create the engine to ensure no process-local active state is consulted.
fresh := &managedTransaction{Dir: m.Dir, Name: m.Name, Reload: m.Reload, Health: m.Health}
got, err := fresh.ActiveCandidates(db)
if err != nil || !reflect.DeepEqual(got, want) {
t.Fatalf("active=%v want=%v err=%v", got, want, err)
}
}
func TestManagedMissingJournalNotAdopted(t *testing.T) {
@@ -395,3 +434,206 @@ func TestManagedRecoveryFailsClosed(t *testing.T) {
})
}
}
func TestManagedCandidateCrashRollback(t *testing.T) {
for _, point := range []string{"staged", "backup", "prepared", "replaced", "reloaded", "healthy", "unhealthy"} {
t.Run(point, func(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=fake", true)
next := managedCandidateFixture(t, db, "frontend", "www.youtube.com", "--lua-desync=multisplit", true)
m, _ := managedFixture(t)
if err := m.Apply(db, []int64{front, ggc}); err != nil {
t.Fatal(err)
}
prior, err := m.read(m.Name)
if err != nil {
t.Fatal(err)
}
m.fault = func(p string) error {
if p == "prepared" {
j, err := m.load()
if err != nil || !reflect.DeepEqual(j.Candidates, []int64{front, ggc}) || !reflect.DeepEqual(j.PendingCandidates, []int64{next}) {
t.Fatalf("prepared refs=%+v err=%v", j, err)
}
}
if p == point {
return errors.New("death")
}
return nil
}
if point == "unhealthy" {
m.Health = func() (string, error) { return "DEGRADED", nil }
}
if err := m.Apply(db, []int64{next}); err == nil {
t.Fatal("failure missed")
}
if point != "staged" && point != "backup" && point != "unhealthy" {
if ids, err := m.ActiveCandidates(db); err == nil || len(ids) != 0 {
t.Fatalf("incomplete transaction exposed IDs: %v %v", ids, err)
}
}
m.fault = nil
if err := m.Reconcile(db); err != nil {
t.Fatal(err)
}
assertManagedContent(t, m, string(prior))
assertActiveCandidates(t, m, db, []int64{front, ggc})
j, err := m.load()
if err != nil || j.Version != 2 || len(j.PendingCandidates) != 0 {
t.Fatalf("rollback journal=%+v err=%v", j, err)
}
})
}
}
func TestManagedActiveCandidatesFailClosed(t *testing.T) {
for _, damage := range []string{"drift", "missing", "unqualified", "wrong-refs", "duplicate", "invalid-id", "duplicate-group", "ggc-only", "pending"} {
t.Run(damage, func(t *testing.T) {
db := testStore(t)
front := managedCandidateFixture(t, db, "frontend", "youtube.com", "--lua-desync=fake", true)
other := managedCandidateFixture(t, db, "frontend", "www.youtube.com", "--lua-desync=multisplit", true)
ggc := managedCandidateFixture(t, db, "googlevideo", "rr1.googlevideo.com", "--lua-desync=fake", true)
m, _ := managedFixture(t)
if err := m.Apply(db, []int64{front, ggc}); err != nil {
t.Fatal(err)
}
j, err := m.load()
if err != nil {
t.Fatal(err)
}
switch damage {
case "drift":
if err := os.WriteFile(filepath.Join(m.Dir, m.Name), []byte("external"), 0600); err != nil {
t.Fatal(err)
}
case "missing":
j.Candidates = []int64{99999, ggc}
case "unqualified":
if _, err := db.Exec("DELETE FROM candidate_evidence WHERE candidate_id = ?", front); err != nil {
t.Fatal(err)
}
case "wrong-refs":
j.Candidates = []int64{other, ggc}
case "duplicate":
j.Candidates = []int64{front, front}
case "invalid-id":
j.Candidates = []int64{-1}
case "duplicate-group":
j.Candidates = []int64{front, other}
case "ggc-only":
j.Candidates = []int64{ggc}
case "pending":
j.PendingCandidates = []int64{other}
}
if err := m.journal(j); err != nil {
t.Fatal(err)
}
if ids, err := m.ActiveCandidates(db); err == nil || len(ids) != 0 {
t.Fatalf("unsafe active refs=%v err=%v", ids, err)
}
})
}
}
func TestManagedLegacyJournal(t *testing.T) {
db := testStore(t)
front := managedCandidateFixture(t, db, "frontend", "youtube.com", "--lua-desync=fake", true)
m, _ := managedFixture(t)
j, err := m.load()
if err != nil {
t.Fatal(err)
}
j.Version = 1
if err := m.journal(j); err != nil {
t.Fatal(err)
}
if _, err := m.ActiveCandidates(db); err == nil {
t.Fatal("legacy IDs inferred")
}
m.fault = func(p string) error {
if p == "replaced" {
return errors.New("death")
}
return nil
}
if err := m.Apply(db, []int64{front}); err == nil {
t.Fatal("fault missed")
}
if err := m.Reconcile(db); err != nil {
t.Fatal(err)
}
assertManagedContent(t, m, "prior\n")
if _, err := m.ActiveCandidates(db); err == nil {
t.Fatal("rollback inferred legacy IDs")
}
m.fault = nil
if err := m.Apply(db, []int64{front}); err != nil {
t.Fatal(err)
}
assertActiveCandidates(t, m, db, []int64{front})
}
func TestManagedStaleTransactionCannotCommitIDs(t *testing.T) {
for _, point := range []string{"staged", "backup", "prepared", "healthy"} {
t.Run(point, func(t *testing.T) {
db := testStore(t)
front := managedCandidateFixture(t, db, "frontend", "youtube.com", "--lua-desync=fake", true)
m, _ := managedFixture(t)
var newer managedJournal
m.fault = func(p string) error {
if p == point {
var err error
newer, err = m.load()
if err != nil {
return err
}
newer.Generation++
newer.ID = "newer-transaction"
return m.journal(newer)
}
return nil
}
if err := m.Apply(db, []int64{front}); err == nil || !strings.Contains(err.Error(), "stale") {
t.Fatalf("stale apply=%v", err)
}
got, err := m.load()
if err != nil || !reflect.DeepEqual(got, newer) || len(got.Candidates) != 0 {
t.Fatalf("stale transaction overwrote journal: %+v %v", got, err)
}
})
}
}
func TestManagedLegacyPreparedJournalRollback(t *testing.T) {
m, _ := managedFixture(t)
m.fault = func(point string) error {
if point == "replaced" {
return errors.New("death")
}
return nil
}
if err := m.applyRendered([]byte("legacy pending\n")); err == nil {
t.Fatal("fault missed")
}
j, err := m.load()
if err != nil {
t.Fatal(err)
}
j.Version = 1
if err := m.journal(j); err != nil {
t.Fatal(err)
}
m.fault = nil
if err := m.Reconcile(); err != nil {
t.Fatal(err)
}
assertManagedContent(t, m, "prior\n")
j, err = m.load()
if err != nil || j.Hash != managedHash([]byte("prior\n")) || j.State != "committed" || len(j.Candidates) != 0 {
t.Fatalf("legacy rollback: %+v %v", j, err)
}
if _, err := m.ActiveCandidates(nil); err == nil {
t.Fatal("legacy IDs inferred")
}
}