feat(cli): persist proposed tuning results in SQLite
Co-authored-by: GPT-6 <gpt-6@openai.com>
This commit is contained in:
1 parent
043df9ff77
commit
e868266de6
11 files changed
+768
-17
No files matched your search
@@ -0,0 +1,215 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/url"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
_ "modernc.org/sqlite"
|
||||
)
|
||||
|
||||
func databasePath() string {
|
||||
if path := os.Getenv("ZAPRET_AUTOTUNE_DB"); path != "" {
|
||||
return path
|
||||
}
|
||||
return "/var/lib/zapret-autotune/autotune.db"
|
||||
}
|
||||
|
||||
func openStore(path string) (*sql.DB, error) {
|
||||
// Configuration is a filesystem path, never a caller-supplied SQLite DSN.
|
||||
if path == "" || path == ":memory:" || strings.HasPrefix(path, ":memory:?") || strings.HasPrefix(strings.ToLower(path), "file:") {
|
||||
return nil, fmt.Errorf("database location must be a filesystem path, not a SQLite DSN")
|
||||
}
|
||||
path, err := filepath.Abs(path)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := os.MkdirAll(filepath.Dir(path), 0700); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
file, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE, 0600)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := file.Chmod(0600); err != nil {
|
||||
file.Close()
|
||||
return nil, err
|
||||
}
|
||||
if err := file.Close(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
// Escape path characters so they cannot become URI options or fragments.
|
||||
dsn := (&url.URL{Scheme: "file", Path: filepath.ToSlash(path)}).String()
|
||||
db, err := sql.Open("sqlite", dsn)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
db.SetMaxOpenConns(1)
|
||||
if _, err = db.Exec("PRAGMA foreign_keys = ON; PRAGMA busy_timeout = 5000;"); err == nil {
|
||||
err = migrate(db)
|
||||
}
|
||||
if err != nil {
|
||||
db.Close()
|
||||
return nil, err
|
||||
}
|
||||
return db, nil
|
||||
}
|
||||
|
||||
func migrate(db *sql.DB) error {
|
||||
ctx := context.Background()
|
||||
conn, err := db.Conn(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer conn.Close()
|
||||
// Serialize migrations before reading the version; a deferred transaction
|
||||
// cannot wait via busy_timeout when upgrading a contended read lock.
|
||||
if _, err = conn.ExecContext(ctx, "BEGIN IMMEDIATE"); err != nil {
|
||||
return err
|
||||
}
|
||||
defer conn.ExecContext(ctx, "ROLLBACK")
|
||||
var version int
|
||||
if err = conn.QueryRowContext(ctx, "PRAGMA user_version").Scan(&version); err != nil {
|
||||
return err
|
||||
}
|
||||
if version > 1 {
|
||||
return fmt.Errorf("unsupported database schema version %d", version)
|
||||
}
|
||||
if version == 0 {
|
||||
_, err = conn.ExecContext(ctx, `
|
||||
CREATE TABLE tune_runs (
|
||||
id INTEGER PRIMARY KEY,
|
||||
started_at TEXT NOT NULL,
|
||||
finished_at TEXT NOT NULL,
|
||||
target TEXT NOT NULL CHECK (target = 'youtube.com'),
|
||||
state TEXT NOT NULL CHECK (state IN ('PROPOSED', 'FAILED')),
|
||||
args TEXT,
|
||||
output TEXT,
|
||||
error TEXT,
|
||||
CHECK ((state = 'PROPOSED' AND args IS NOT NULL AND length(args) > 0 AND output IS NOT NULL AND length(output) > 0 AND error IS NULL)
|
||||
OR (state = 'FAILED' AND args IS NULL AND output IS NULL AND error IS NOT NULL AND length(error) > 0))
|
||||
);
|
||||
CREATE TABLE protocol_results (
|
||||
run_id INTEGER NOT NULL REFERENCES tune_runs(id) ON DELETE CASCADE,
|
||||
protocol TEXT NOT NULL CHECK (protocol IN ('tls12', 'tls13')),
|
||||
passes_ok INTEGER NOT NULL CHECK (passes_ok = 3),
|
||||
passes_total INTEGER NOT NULL CHECK (passes_total = 3),
|
||||
PRIMARY KEY (run_id, protocol)
|
||||
);
|
||||
CREATE TRIGGER proposed_results_only BEFORE INSERT ON protocol_results
|
||||
WHEN (SELECT state FROM tune_runs WHERE id = NEW.run_id) != 'PROPOSED'
|
||||
BEGIN SELECT RAISE(ABORT, 'protocol results require a proposed run'); END;
|
||||
PRAGMA user_version = 1;`)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
_, err = conn.ExecContext(ctx, "COMMIT")
|
||||
return err
|
||||
}
|
||||
|
||||
type storedRun struct {
|
||||
ID int64
|
||||
StartedAt, FinishedAt, State string
|
||||
Args, Output, Error sql.NullString
|
||||
}
|
||||
|
||||
// Validation is shared with tune's output path; only combined 3/3 evidence is stored.
|
||||
func saveRun(db *sql.DB, started time.Time, args, output string, report []byte, runErr error) error {
|
||||
var evidence struct {
|
||||
Strategies []struct {
|
||||
Protocol string `json:"protocol"`
|
||||
PassesOK int `json:"passes_ok"`
|
||||
PassesTotal int `json:"passes_total"`
|
||||
} `json:"strategies"`
|
||||
}
|
||||
state := "FAILED"
|
||||
var savedArgs, savedOutput, savedError interface{}
|
||||
if runErr == nil {
|
||||
verifiedOutput, err := combinedBlockcheckOutput(bytes.NewReader(report), args)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if output != verifiedOutput {
|
||||
return fmt.Errorf("output does not match verified candidate")
|
||||
}
|
||||
if err := json.Unmarshal(report, &evidence); err != nil {
|
||||
return err
|
||||
}
|
||||
state, savedArgs, savedOutput = "PROPOSED", args, output
|
||||
} else {
|
||||
savedError = runErr.Error()
|
||||
}
|
||||
tx, err := db.Begin()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer tx.Rollback()
|
||||
result, err := tx.Exec(`INSERT INTO tune_runs (started_at, finished_at, target, state, args, output, error) VALUES (?, ?, 'youtube.com', ?, ?, ?, ?)`,
|
||||
started.UTC().Format(time.RFC3339Nano), time.Now().UTC().Format(time.RFC3339Nano), state, savedArgs, savedOutput, savedError)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
id, err := result.LastInsertId()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for _, row := range evidence.Strategies {
|
||||
if _, err := tx.Exec(`INSERT INTO protocol_results (run_id, protocol, passes_ok, passes_total) VALUES (?, ?, ?, ?)`, id, normalizeProtocol(row.Protocol), row.PassesOK, row.PassesTotal); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return tx.Commit()
|
||||
}
|
||||
|
||||
func latestRun(db *sql.DB) (storedRun, error) {
|
||||
var r storedRun
|
||||
err := db.QueryRow(`SELECT id, started_at, finished_at, state, args, output, error FROM tune_runs ORDER BY id DESC LIMIT 1`).Scan(
|
||||
&r.ID, &r.StartedAt, &r.FinishedAt, &r.State, &r.Args, &r.Output, &r.Error)
|
||||
if err == nil && r.State == "PROPOSED" {
|
||||
var results int
|
||||
err = db.QueryRow(`SELECT count(*) FROM protocol_results WHERE run_id = ? AND protocol IN ('tls12', 'tls13') AND passes_ok = 3 AND passes_total = 3`, r.ID).Scan(&results)
|
||||
if err == nil && results != 2 {
|
||||
err = fmt.Errorf("proposed run %d has incomplete protocol evidence", r.ID)
|
||||
}
|
||||
}
|
||||
return r, err
|
||||
}
|
||||
|
||||
func status(stdout, stderr io.Writer) int {
|
||||
db, err := openStore(databasePath())
|
||||
if err != nil {
|
||||
fmt.Fprintln(stderr, "error: status database:", err)
|
||||
return 1
|
||||
}
|
||||
defer db.Close()
|
||||
r, err := latestRun(db)
|
||||
var text string
|
||||
if err == sql.ErrNoRows {
|
||||
text = "Status: no recorded tune run.\n"
|
||||
} else if err != nil {
|
||||
fmt.Fprintln(stderr, "error: status database:", err)
|
||||
return 1
|
||||
} else {
|
||||
text = fmt.Sprintf("Latest tune run: %d; youtube.com frontend only; %s; finished %s\n", r.ID, r.State, r.FinishedAt)
|
||||
if r.State == "PROPOSED" {
|
||||
text += "Candidate: PROPOSED, not active; verified TLS1.2 3/3 and TLS1.3 3/3.\n" + r.Output.String + "\n"
|
||||
} else {
|
||||
text += "No proposed candidate from this run. Error: " + r.Error.String + "\n"
|
||||
}
|
||||
}
|
||||
text += "apply: BLOCKED (not implemented). No configuration applied.\nProduction ss-zapret2 and Xray health: NOT CHECKED.\n"
|
||||
if _, err := fmt.Fprint(stdout, text); err != nil {
|
||||
fmt.Fprintln(stderr, "error: cannot write status:", err)
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
Reference in new issue
Block a user