123 lines
3.4 KiB
Go
123 lines
3.4 KiB
Go
// Package db owns the SQLite connection, schema migrations, and all queries
|
|
// used by the Control API. It is the only package in the system that talks
|
|
// to the database directly — agents and probers never connect to it.
|
|
package db
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
_ "embed"
|
|
"fmt"
|
|
"time"
|
|
|
|
_ "modernc.org/sqlite"
|
|
)
|
|
|
|
//go:embed migrations/0001_init.sql
|
|
var initSchema string
|
|
|
|
//go:embed migrations/0002_dynamic_config.sql
|
|
var dynamicConfigSchema string
|
|
|
|
//go:embed migrations/0003_fip_settle_delay.sql
|
|
var fipSettleDelaySchema string
|
|
|
|
//go:embed migrations/0004_inbound_checks_admin.sql
|
|
var inboundChecksAdminSchema string
|
|
|
|
//go:embed migrations/0005_unbounded_sites.sql
|
|
var unboundedSitesSchema string
|
|
|
|
//go:embed migrations/0006_prober_heartbeat.sql
|
|
var proberHeartbeatSchema string
|
|
|
|
// migrations is the ordered list of schema versions. Each entry's SQL is
|
|
// applied, in order, for any version greater than the database's current
|
|
// PRAGMA user_version — so a fresh database walks the whole list and an
|
|
// existing one only picks up what's new.
|
|
var migrations = []struct {
|
|
version int
|
|
sql string
|
|
}{
|
|
{1, initSchema},
|
|
{2, dynamicConfigSchema},
|
|
{3, fipSettleDelaySchema},
|
|
{4, inboundChecksAdminSchema},
|
|
{5, unboundedSitesSchema},
|
|
{6, proberHeartbeatSchema},
|
|
}
|
|
|
|
type DB struct {
|
|
*sql.DB
|
|
}
|
|
|
|
// Open opens (creating if necessary) the SQLite database at path, applies
|
|
// pragmas suited to a single-writer WAL workload, and runs any pending
|
|
// schema migrations.
|
|
func Open(ctx context.Context, path string) (*DB, error) {
|
|
sqlDB, err := sql.Open("sqlite", path+"?_pragma=busy_timeout(5000)")
|
|
if err != nil {
|
|
return nil, fmt.Errorf("open sqlite: %w", err)
|
|
}
|
|
// Control API is the sole writer; one connection avoids SQLITE_BUSY
|
|
// entirely for writes while still allowing concurrent reads via WAL.
|
|
sqlDB.SetMaxOpenConns(1)
|
|
|
|
for _, pragma := range []string{
|
|
"PRAGMA journal_mode=WAL",
|
|
"PRAGMA synchronous=NORMAL",
|
|
"PRAGMA foreign_keys=ON",
|
|
"PRAGMA busy_timeout=5000",
|
|
} {
|
|
if _, err := sqlDB.ExecContext(ctx, pragma); err != nil {
|
|
sqlDB.Close()
|
|
return nil, fmt.Errorf("apply pragma %q: %w", pragma, err)
|
|
}
|
|
}
|
|
|
|
d := &DB{DB: sqlDB}
|
|
if err := d.migrate(ctx); err != nil {
|
|
sqlDB.Close()
|
|
return nil, fmt.Errorf("migrate: %w", err)
|
|
}
|
|
return d, nil
|
|
}
|
|
|
|
// migrate applies every pending migration in order, tracked via
|
|
// PRAGMA user_version so repeated startups only apply what's new (and a
|
|
// fresh database walks the whole list once).
|
|
func (d *DB) migrate(ctx context.Context) error {
|
|
var version int
|
|
if err := d.QueryRowContext(ctx, "PRAGMA user_version").Scan(&version); err != nil {
|
|
return fmt.Errorf("read user_version: %w", err)
|
|
}
|
|
|
|
for _, m := range migrations {
|
|
if m.version <= version {
|
|
continue
|
|
}
|
|
tx, err := d.BeginTx(ctx, nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if _, err := tx.ExecContext(ctx, m.sql); err != nil {
|
|
tx.Rollback()
|
|
return fmt.Errorf("apply migration %d: %w", m.version, err)
|
|
}
|
|
if _, err := tx.ExecContext(ctx, fmt.Sprintf("PRAGMA user_version=%d", m.version)); err != nil {
|
|
tx.Rollback()
|
|
return fmt.Errorf("set user_version=%d: %w", m.version, err)
|
|
}
|
|
if err := tx.Commit(); err != nil {
|
|
return fmt.Errorf("commit migration %d: %w", m.version, err)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Now returns the current time truncated to millisecond precision, the
|
|
// granularity used consistently for all timestamp columns.
|
|
func Now() time.Time {
|
|
return time.Now().UTC().Truncate(time.Millisecond)
|
|
}
|