Ilia Denisov
85 lines
2.9 KiB
Go
85 lines
2.9 KiB
Go
// Package postgres opens the backend's primary Postgres pool and applies the
|
|
// embedded migrations.
|
|
//
|
|
// The package is a thin wrapper around galaxy/postgres: it adapts the backend
|
|
// configuration shape to galaxy/postgres.Config, plumbs the OpenTelemetry
|
|
// tracer and meter providers from the telemetry runtime, instruments the
|
|
// pool, and verifies connectivity with a bounded Ping.
|
|
package postgres
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"fmt"
|
|
"time"
|
|
|
|
"galaxy/backend/internal/config"
|
|
"galaxy/backend/internal/postgres/migrations"
|
|
"galaxy/backend/internal/telemetry"
|
|
|
|
pgshared "galaxy/postgres"
|
|
)
|
|
|
|
// connMaxLifetime caps the lifetime of an individual pooled connection. Kept
|
|
// in sync with galaxy/postgres.DefaultConnMaxLifetime so behaviour matches
|
|
// the helper's defaults until backend has reason to deviate.
|
|
const connMaxLifetime = 30 * time.Minute
|
|
|
|
// Open constructs the primary Postgres pool, instruments it, pings it, and
|
|
// returns the *sql.DB. Closing the database is the caller's responsibility.
|
|
func Open(ctx context.Context, cfg config.PostgresConfig, runtime *telemetry.Runtime) (*sql.DB, error) {
|
|
pgCfg := pgshared.Config{
|
|
PrimaryDSN: cfg.DSN,
|
|
OperationTimeout: cfg.OperationTimeout,
|
|
MaxOpenConns: cfg.MaxConns,
|
|
MaxIdleConns: cfg.MinConns,
|
|
ConnMaxLifetime: connMaxLifetime,
|
|
}
|
|
|
|
db, err := pgshared.OpenPrimary(
|
|
ctx,
|
|
pgCfg,
|
|
pgshared.WithTracerProvider(runtime.TracerProvider()),
|
|
pgshared.WithMeterProvider(runtime.MeterProvider()),
|
|
)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("open backend postgres pool: %w", err)
|
|
}
|
|
|
|
if _, err := pgshared.InstrumentDBStats(
|
|
db,
|
|
pgshared.WithTracerProvider(runtime.TracerProvider()),
|
|
pgshared.WithMeterProvider(runtime.MeterProvider()),
|
|
); err != nil {
|
|
_ = db.Close()
|
|
return nil, fmt.Errorf("instrument backend postgres pool: %w", err)
|
|
}
|
|
|
|
if err := pgshared.Ping(ctx, db, cfg.OperationTimeout); err != nil {
|
|
_ = db.Close()
|
|
return nil, fmt.Errorf("ping backend postgres pool: %w", err)
|
|
}
|
|
|
|
return db, nil
|
|
}
|
|
|
|
// schemaName is the Postgres schema owned by the backend service. Every
|
|
// backend table lives here.
|
|
const schemaName = "backend"
|
|
|
|
// ApplyMigrations runs every pending Up migration embedded in the backend
|
|
// binary against db. The schema is created upfront so goose's bookkeeping
|
|
// table (`goose_db_version`, scoped to the DSN `search_path = backend`)
|
|
// has somewhere to land before the first migration runs; migration
|
|
// `00001_init.sql` re-asserts the schema with `IF NOT EXISTS`, so the
|
|
// double-create is idempotent.
|
|
func ApplyMigrations(ctx context.Context, db *sql.DB) error {
|
|
if _, err := db.ExecContext(ctx, "CREATE SCHEMA IF NOT EXISTS "+schemaName); err != nil {
|
|
return fmt.Errorf("ensure backend schema: %w", err)
|
|
}
|
|
if err := pgshared.RunMigrations(ctx, db, migrations.Migrations(), "."); err != nil {
|
|
return fmt.Errorf("apply backend migrations: %w", err)
|
|
}
|
|
return nil
|
|
}
|