Files
zapret-autotune/cmd/zapret-autotune/managed_transaction.go
T
2026-10-10 09:24:43 +03:00

523 lines
14 KiB
Go

package main
import (
"crypto/rand"
"crypto/sha256"
"database/sql"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"io"
"os"
"path/filepath"
"reflect"
"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"`
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
// exclusively to /opt/zapret2/init.d/sysv/zapret2 restart and Health to
// health youtube over its configured loopback SOCKS, returning exactly "OK".
// Reload switches target-local firewall and daemons for apply and rollback.
// This engine does not manage 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
}
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
}
// 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: 2, 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 {
ids = append([]int64(nil), ids...)
b, err := renderManagedConfig(db, ids)
if err != nil {
return err
}
return m.applyRenderedDB(b, db, ids...)
}
// 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 {
return err
}
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
}
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.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
}
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
}
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()
}
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 := 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)
}
}
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 {
if err := m.owns(j, true); err != nil {
return err
}
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
}
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(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}
}
return nil
}
b, err := m.read(m.Name)
if err != nil {
return err
}
if managedHash(b) != j.Hash {
return errManagedDrift
}
return nil
})
}