523 lines
14 KiB
Go
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
|
|
})
|
|
}
|