tajniak81andClaude Opus 5
b4fb60a8ab
Scaffolds the server module and everything Phase 0 of PLAN.md calls for: a binary that boots, serves its discovery endpoints and nothing else yet. - config: one YAML file plus per-field WARP_* environment overrides, unknown fields rejected, validation that reports every problem at once - logging and metrics: slog, a Prometheus registry, per-route HTTP instrumentation labelled by pattern rather than path - httputil: the Matrix error envelope, error-returning handlers, CORS, request logging, panic recovery, and a router over http.ServeMux - endpoints: /_matrix/client/versions, /.well-known/matrix/client, /.well-known/matrix/server (gated), /healthz, /metrics, and M_UNRECOGNIZED for everything else - storage: driver registry, shared database/sql base, checksummed migration runner, sqlite and postgres drivers, pocketbase stub - settings: server_settings table behind a cached service, so the federation and registration switches change without a restart - federation: the gate that makes federation a runtime mode - cmd/warp: serve, migrate, generate-keys, version - Makefile, golangci-lint v2, GitHub Actions CI (Linux and Windows tests, race on Linux, storage tests against PostgreSQL, lint, boot smoke test), Dockerfile, example config and docs Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
125 lines
3.3 KiB
Go
125 lines
3.3 KiB
Go
// Package sqlstore holds the parts of a storage driver that are identical
|
|
// for every database/sql backend: the migration plumbing and the
|
|
// server_settings table. The sqlite and postgres drivers differ only in
|
|
// their DSN handling, placeholder style and upsert syntax, all of which
|
|
// they pass in here.
|
|
package sqlstore
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"errors"
|
|
"fmt"
|
|
"io/fs"
|
|
"log/slog"
|
|
|
|
"github.com/dariuszjaniak/warp/server/internal/storage"
|
|
"github.com/dariuszjaniak/warp/server/internal/storage/migrations"
|
|
)
|
|
|
|
// Options describe one database/sql backend.
|
|
type Options struct {
|
|
// DriverName is the Warp driver name, e.g. "sqlite".
|
|
DriverName string
|
|
|
|
// DB is the already-opened pool.
|
|
DB *sql.DB
|
|
|
|
// Dialect supplies the migration bookkeeping statements.
|
|
Dialect migrations.Dialect
|
|
|
|
// MigrationsFS and MigrationsDir locate the embedded .sql files.
|
|
MigrationsFS fs.FS
|
|
MigrationsDir string
|
|
|
|
// Settings holds the statements for the server_settings table.
|
|
Settings SettingsQueries
|
|
|
|
// Logger is used for migration progress.
|
|
Logger *slog.Logger
|
|
}
|
|
|
|
// Store is the shared implementation of storage.Database. Drivers embed it
|
|
// and add their own component stores as those are built.
|
|
type Store struct {
|
|
opts Options
|
|
db *sql.DB
|
|
log *slog.Logger
|
|
settings *Settings
|
|
}
|
|
|
|
// New builds a Store. It does not touch the database.
|
|
func New(opts Options) (*Store, error) {
|
|
if opts.DB == nil {
|
|
return nil, errors.New("sqlstore: DB must not be nil")
|
|
}
|
|
if opts.Logger == nil {
|
|
opts.Logger = slog.Default()
|
|
}
|
|
return &Store{
|
|
opts: opts,
|
|
db: opts.DB,
|
|
log: opts.Logger,
|
|
settings: NewSettings(opts.DB, opts.Settings),
|
|
}, nil
|
|
}
|
|
|
|
// DB exposes the pool for driver-specific code and tests.
|
|
func (s *Store) DB() *sql.DB { return s.db }
|
|
|
|
// Driver implements storage.Database.
|
|
func (s *Store) Driver() string { return s.opts.DriverName }
|
|
|
|
// Ping implements storage.Database.
|
|
func (s *Store) Ping(ctx context.Context) error { return s.db.PingContext(ctx) }
|
|
|
|
// Close implements storage.Database.
|
|
func (s *Store) Close() error { return s.db.Close() }
|
|
|
|
// Settings implements storage.Database.
|
|
func (s *Store) Settings() storage.SettingsStore { return s.settings }
|
|
|
|
// Migrate implements storage.Database.
|
|
func (s *Store) Migrate(ctx context.Context) error {
|
|
ms, err := s.migrations()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
applied, err := migrations.Status(ctx, s.db, s.opts.Dialect)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := migrations.CheckNotAhead(applied, ms); err != nil {
|
|
return err
|
|
}
|
|
n, err := migrations.Run(ctx, s.db, s.opts.Dialect, ms, s.log)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if n == 0 {
|
|
s.log.Debug("database schema is up to date", "migrations", len(ms))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// PendingMigrations implements storage.Database.
|
|
func (s *Store) PendingMigrations(ctx context.Context) ([]string, error) {
|
|
ms, err := s.migrations()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
pending, err := migrations.Pending(ctx, s.db, s.opts.Dialect, ms)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out := make([]string, 0, len(pending))
|
|
for _, m := range pending {
|
|
out = append(out, fmt.Sprintf("%04d_%s", m.Version, m.Name))
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (s *Store) migrations() ([]migrations.Migration, error) {
|
|
return migrations.Load(s.opts.MigrationsFS, s.opts.MigrationsDir)
|
|
}
|