Skip to content

armgit / cua

Public Imported from GitHub
0

Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.

feat(cyclops-cs): unify PostgreSQL migrations (#6708)

r33drichardsf20edd32f8ff
diff --git a/libs/fleet/backend/Dockerfile b/libs/fleet/backend/Dockerfile
index 9d9e79edaf..7137b23aa0 100644
--- a/libs/fleet/backend/Dockerfile
+++ b/libs/fleet/backend/Dockerfile
@@ -9,7 +9,8 @@ RUN go mod download
RUN go mod tidy
RUN go install github.com/swaggo/swag/cmd/[email protected] && \
/go/bin/swag init -g main.go -o ./docs --parseDependency --parseInternal
-RUN CGO_ENABLED=1 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/cyclops-cs-backend .
+RUN CGO_ENABLED=1 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/cyclops-cs-backend . \
+ && CGO_ENABLED=1 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/cyclops-db-migrate ./cmd/db-migrate
FROM --platform=linux/amd64 rust:1.94-bookworm AS rust-builder
WORKDIR /src/k8s-state-query
@@ -21,6 +22,7 @@ RUN cargo build --release --locked --bin k8s-state-projector && \
FROM gcr.io/distroless/cc-debian12:nonroot AS runtime
WORKDIR /app
COPY --from=go-builder /out/cyclops-cs-backend /app/cyclops-cs-backend
+COPY --from=go-builder /out/cyclops-db-migrate /app/cyclops-db-migrate
COPY --from=rust-builder /out-k8s-state-projector /app/k8s-state-projector
USER nonroot:nonroot
EXPOSE 8080
diff --git a/libs/fleet/backend/cmd/db-migrate/main.go b/libs/fleet/backend/cmd/db-migrate/main.go
new file mode 100644
index 0000000000..9bb8d7f1f1
--- /dev/null
+++ b/libs/fleet/backend/cmd/db-migrate/main.go
@@ -0,0 +1,38 @@
+package main
+
+import (
+ "context"
+ "log/slog"
+ "os"
+
+ "cyclops-cs-backend/database"
+)
+
+func required(name string) string {
+ value := os.Getenv(name)
+ if value == "" {
+ slog.Error("required migration environment variable is unset", "name", name)
+ os.Exit(2)
+ }
+ return value
+}
+
+func main() {
+ slog.SetDefault(slog.New(slog.NewJSONHandler(os.Stdout, nil)))
+
+ config := database.Config{
+ MigrationURL: required("MIGRATION_DATABASE_URL"),
+ Credentials: database.CredentialURLs{
+ Application: required("DATABASE_URL"),
+ Writer: required("STATE_WRITER_DATABASE_URL"),
+ Exporter: required("STATE_EXPORTER_DATABASE_URL"),
+ RoleAdmin: required("STATE_ROLE_ADMIN_DATABASE_URL"),
+ Metabase: required("METABASE_DATABASE_URL"),
+ },
+ }
+ if err := database.Run(context.Background(), config); err != nil {
+ slog.Error("database migration failed", "err", err)
+ os.Exit(1)
+ }
+ slog.Info("database migrations complete")
+}
diff --git a/libs/fleet/backend/database/migrations/.keep b/libs/fleet/backend/database/migrations/.keep
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/libs/fleet/backend/database/migrations/000001_initial_schema.sql b/libs/fleet/backend/database/migrations/000001_initial_schema.sql
new file mode 100644
index 0000000000..edf15ab7a0
--- /dev/null
+++ b/libs/fleet/backend/database/migrations/000001_initial_schema.sql
@@ -0,0 +1,404 @@
+-- 1. Static roles.
+CREATE ROLE cyclops_app LOGIN NOINHERIT NOCREATEROLE NOSUPERUSER NOCREATEDB NOREPLICATION NOBYPASSRLS;
+CREATE ROLE k8s_state_owner NOLOGIN INHERIT NOCREATEROLE NOSUPERUSER NOCREATEDB NOREPLICATION NOBYPASSRLS;
+CREATE ROLE k8s_state_writer LOGIN NOINHERIT NOCREATEROLE NOSUPERUSER NOCREATEDB NOREPLICATION NOBYPASSRLS;
+CREATE ROLE k8s_state_exporter LOGIN NOINHERIT NOCREATEROLE NOSUPERUSER NOCREATEDB NOREPLICATION NOBYPASSRLS;
+CREATE ROLE k8s_query_tenant NOLOGIN INHERIT NOCREATEROLE NOSUPERUSER NOCREATEDB NOREPLICATION NOBYPASSRLS;
+CREATE ROLE k8s_query_admin NOLOGIN INHERIT NOCREATEROLE NOSUPERUSER NOCREATEDB NOREPLICATION NOBYPASSRLS;
+CREATE ROLE k8s_role_admin LOGIN NOINHERIT CREATEROLE NOSUPERUSER NOCREATEDB NOREPLICATION NOBYPASSRLS;
+CREATE ROLE k8s_reporting_owner NOLOGIN INHERIT NOCREATEROLE NOSUPERUSER NOCREATEDB NOREPLICATION NOBYPASSRLS;
+CREATE ROLE k8s_metabase LOGIN NOINHERIT NOCREATEROLE NOSUPERUSER NOCREATEDB NOREPLICATION NOBYPASSRLS;
+
+-- 2. Fixed PostgreSQL 16 role memberships.
+GRANT k8s_state_owner TO CURRENT_USER WITH INHERIT FALSE, SET TRUE;
+GRANT k8s_reporting_owner TO CURRENT_USER WITH INHERIT FALSE, SET TRUE;
+GRANT k8s_query_tenant TO k8s_role_admin WITH ADMIN TRUE, INHERIT FALSE, SET FALSE;
+GRANT k8s_query_admin TO k8s_reporting_owner WITH INHERIT TRUE, SET FALSE;
+
+-- 3. GitHub trust state.
+CREATE TABLE public.github_trust_policies (
+ id text PRIMARY KEY,
+ owner_sub text NOT NULL,
+ name text NOT NULL,
+ repository text NOT NULL,
+ allowed_namespaces text[] NOT NULL,
+ enabled boolean NOT NULL DEFAULT false,
+ created_at timestamptz NOT NULL,
+ updated_at timestamptz NOT NULL
+);
+CREATE INDEX idx_github_trust_policies_owner_sub ON public.github_trust_policies (owner_sub);
+CREATE INDEX idx_github_trust_policies_repository ON public.github_trust_policies (repository);
+REVOKE ALL ON TABLE public.github_trust_policies FROM PUBLIC;
+GRANT SELECT, INSERT, UPDATE, DELETE ON TABLE public.github_trust_policies TO cyclops_app;
+
+-- 4. State storage, tenant query API, and RLS boundary.
+CREATE SCHEMA k8s_state AUTHORIZATION k8s_state_owner;
+CREATE SCHEMA k8s_api AUTHORIZATION k8s_state_owner;
+REVOKE CREATE ON SCHEMA public FROM PUBLIC;
+SET LOCAL ROLE k8s_state_owner;
+REVOKE CREATE ON SCHEMA k8s_state, k8s_api FROM PUBLIC;
+CREATE TABLE k8s_state.resource_state (
+ cluster_id text NOT NULL,
+ api_group text NOT NULL,
+ resource text NOT NULL,
+ namespace text NOT NULL,
+ name text NOT NULL,
+ capsule_tenant text,
+ uid text,
+ resource_version text,
+ schema_hash text NOT NULL,
+ watch_epoch bigint NOT NULL,
+ observed_sequence bigint NOT NULL,
+ labels jsonb NOT NULL DEFAULT '{}'::jsonb,
+ object jsonb NOT NULL,
+ source_time timestamptz,
+ ingested_at timestamptz NOT NULL DEFAULT clock_timestamp(),
+ PRIMARY KEY (cluster_id, api_group, resource, namespace, name),
+ CHECK (jsonb_typeof(labels) = 'object'),
+ CHECK (jsonb_typeof(object) = 'object')
+);
+
+CREATE INDEX resource_state_tenant_gvr_namespace_idx
+ ON k8s_state.resource_state
+ (capsule_tenant, cluster_id, api_group, resource, namespace, name);
+
+CREATE INDEX resource_state_labels_gin_idx
+ ON k8s_state.resource_state USING gin (labels jsonb_path_ops);
+
+CREATE TABLE k8s_state.watch_checkpoint (
+ cluster_id text NOT NULL,
+ api_group text NOT NULL,
+ resource text NOT NULL,
+ watch_epoch bigint NOT NULL,
+ last_resource_version text NOT NULL,
+ last_observed_sequence bigint NOT NULL,
+ initial_list_complete boolean NOT NULL,
+ updated_at timestamptz NOT NULL DEFAULT clock_timestamp(),
+ PRIMARY KEY (cluster_id, api_group, resource)
+);
+
+CREATE TABLE k8s_state.resource_event_outbox (
+ event_id uuid PRIMARY KEY,
+ cluster_id text NOT NULL,
+ api_group text NOT NULL,
+ resource text NOT NULL,
+ namespace text NOT NULL,
+ name text NOT NULL,
+ capsule_tenant text,
+ uid text,
+ resource_version text,
+ schema_hash text NOT NULL,
+ event_type text NOT NULL CHECK (event_type IN ('ADDED', 'MODIFIED', 'DELETED')),
+ watch_epoch bigint NOT NULL,
+ observed_sequence bigint NOT NULL,
+ object jsonb NOT NULL,
+ observed_at timestamptz NOT NULL,
+ claimed_at timestamptz,
+ claim_id uuid,
+ exported_at timestamptz,
+ UNIQUE (cluster_id, api_group, resource, watch_epoch, observed_sequence),
+ CHECK (jsonb_typeof(object) = 'object')
+);
+
+CREATE INDEX resource_event_outbox_pending_idx
+ ON k8s_state.resource_event_outbox (observed_at, event_id)
+ WHERE exported_at IS NULL;
+
+CREATE TABLE k8s_state.resource_schema (
+ schema_hash text PRIMARY KEY,
+ api_group text NOT NULL,
+ api_version text NOT NULL,
+ kind text NOT NULL,
+ resource text NOT NULL,
+ structural_schema jsonb NOT NULL,
+ first_seen_at timestamptz NOT NULL DEFAULT clock_timestamp(),
+ CHECK (jsonb_typeof(structural_schema) = 'object')
+);
+
+CREATE TABLE k8s_state.query_tenant_role (
+ role_name name PRIMARY KEY,
+ capsule_tenant text NOT NULL UNIQUE,
+ credential_fingerprint text NOT NULL,
+ created_at timestamptz NOT NULL DEFAULT clock_timestamp()
+);
+
+CREATE FUNCTION k8s_state.tenant_for_role(role_name name)
+RETURNS text
+LANGUAGE sql
+STABLE
+SECURITY DEFINER
+SET search_path = k8s_state, pg_catalog
+AS $$
+ SELECT capsule_tenant
+ FROM k8s_state.query_tenant_role
+ WHERE query_tenant_role.role_name = tenant_for_role.role_name
+$$;
+
+REVOKE ALL ON FUNCTION k8s_state.tenant_for_role(name) FROM PUBLIC;
+GRANT EXECUTE ON FUNCTION k8s_state.tenant_for_role(name) TO k8s_query_tenant;
+
+ALTER TABLE k8s_state.resource_state ENABLE ROW LEVEL SECURITY;
+ALTER TABLE k8s_state.resource_state FORCE ROW LEVEL SECURITY;
+
+CREATE POLICY writer_current_state ON k8s_state.resource_state
+FOR ALL TO k8s_state_writer
+USING (true)
+WITH CHECK (true);
+
+CREATE POLICY tenant_current_state ON k8s_state.resource_state
+FOR SELECT TO k8s_query_tenant
+USING (
+ capsule_tenant = k8s_state.tenant_for_role(current_user)
+ AND (
+ namespace <> ''
+ OR (api_group = '' AND resource = 'namespaces')
+ )
+);
+
+CREATE POLICY admin_current_state ON k8s_state.resource_state
+FOR SELECT TO k8s_query_admin
+USING (true);
+
+CREATE VIEW k8s_api.current_resources
+WITH (security_barrier = true, security_invoker = true) AS
+SELECT
+ cluster_id,
+ api_group,
+ resource,
+ namespace,
+ name,
+ uid,
+ resource_version,
+ schema_hash,
+ labels,
+ object,
+ source_time,
+ ingested_at
+FROM k8s_state.resource_state;
+
+REVOKE ALL ON ALL TABLES IN SCHEMA k8s_state FROM PUBLIC;
+REVOKE ALL ON ALL TABLES IN SCHEMA k8s_api FROM PUBLIC;
+GRANT USAGE ON SCHEMA k8s_state TO k8s_state_writer, k8s_state_exporter;
+GRANT SELECT, INSERT, UPDATE, DELETE ON k8s_state.resource_state TO k8s_state_writer;
+GRANT SELECT, INSERT, UPDATE ON k8s_state.watch_checkpoint TO k8s_state_writer;
+GRANT SELECT, INSERT, UPDATE ON k8s_state.resource_schema TO k8s_state_writer;
+GRANT SELECT, INSERT ON k8s_state.resource_event_outbox TO k8s_state_writer;
+GRANT SELECT, UPDATE, DELETE ON k8s_state.resource_event_outbox TO k8s_state_exporter;
+GRANT USAGE ON SCHEMA k8s_api TO k8s_query_tenant, k8s_query_admin;
+GRANT SELECT ON k8s_state.resource_state TO k8s_query_tenant, k8s_query_admin;
+GRANT SELECT ON k8s_api.current_resources TO k8s_query_tenant, k8s_query_admin;
+
+CREATE FUNCTION k8s_state.register_tenant_role(p_role_name name, p_capsule_tenant text, p_credential_fingerprint text)
+RETURNS void
+LANGUAGE sql
+VOLATILE
+SECURITY DEFINER
+SET search_path = k8s_state, pg_catalog
+AS $$
+ INSERT INTO k8s_state.query_tenant_role (role_name, capsule_tenant, credential_fingerprint)
+ VALUES (p_role_name, p_capsule_tenant, p_credential_fingerprint)
+ ON CONFLICT (role_name) DO UPDATE
+ SET capsule_tenant = EXCLUDED.capsule_tenant,
+ credential_fingerprint = EXCLUDED.credential_fingerprint
+$$;
+
+CREATE FUNCTION k8s_state.unregister_tenant_role(p_role_name name)
+RETURNS void
+LANGUAGE sql
+VOLATILE
+SECURITY DEFINER
+SET search_path = k8s_state, pg_catalog
+AS $$
+ DELETE FROM k8s_state.query_tenant_role
+ WHERE role_name = p_role_name
+$$;
+
+REVOKE ALL ON FUNCTION k8s_state.register_tenant_role(name, text, text) FROM PUBLIC;
+REVOKE ALL ON FUNCTION k8s_state.unregister_tenant_role(name) FROM PUBLIC;
+GRANT USAGE ON SCHEMA k8s_state TO k8s_role_admin;
+GRANT SELECT ON k8s_state.query_tenant_role TO k8s_role_admin;
+GRANT EXECUTE ON FUNCTION k8s_state.register_tenant_role(name, text, text) TO k8s_role_admin;
+GRANT EXECUTE ON FUNCTION k8s_state.unregister_tenant_role(name) TO k8s_role_admin;
+GRANT USAGE ON SCHEMA k8s_state TO k8s_reporting_owner;
+GRANT SELECT ON k8s_state.resource_state TO k8s_reporting_owner;
+RESET ROLE;
+
+-- 5. Read-only reporting boundary for Metabase.
+
+DO $$
+DECLARE
+ membership record;
+ schema_name text;
+ relation record;
+ function_oid oid;
+BEGIN
+ FOR membership IN
+ SELECT parent.rolname
+ FROM pg_auth_members AS member
+ JOIN pg_roles AS parent ON parent.oid = member.roleid
+ WHERE member.member = 'k8s_metabase'::regrole
+ LOOP
+ EXECUTE format('REVOKE %I FROM k8s_metabase', membership.rolname);
+ END LOOP;
+
+ FOR schema_name IN
+ SELECT namespace.nspname
+ FROM pg_namespace AS namespace
+ JOIN LATERAL aclexplode(namespace.nspacl) AS acl ON true
+ WHERE namespace.nspname !~ '^pg_'
+ AND namespace.nspname <> 'information_schema'
+ AND acl.grantee = 'k8s_metabase'::regrole
+ LOOP
+ EXECUTE format('REVOKE ALL ON SCHEMA %I FROM k8s_metabase', schema_name);
+ END LOOP;
+
+ FOR relation IN
+ SELECT namespace.nspname, class.relname
+ FROM pg_class AS class
+ JOIN pg_namespace AS namespace ON namespace.oid = class.relnamespace
+ JOIN LATERAL aclexplode(class.relacl) AS acl ON true
+ WHERE namespace.nspname !~ '^pg_'
+ AND namespace.nspname <> 'information_schema'
+ AND class.relkind IN ('r', 'p', 'v', 'm', 'f')
+ AND acl.grantee = 'k8s_metabase'::regrole
+ LOOP
+ EXECUTE format('REVOKE ALL ON TABLE %I.%I FROM k8s_metabase', relation.nspname, relation.relname);
+ END LOOP;
+
+ FOR relation IN
+ SELECT namespace.nspname, class.relname
+ FROM pg_class AS class
+ JOIN pg_namespace AS namespace ON namespace.oid = class.relnamespace
+ JOIN LATERAL aclexplode(class.relacl) AS acl ON true
+ WHERE namespace.nspname !~ '^pg_'
+ AND namespace.nspname <> 'information_schema'
+ AND class.relkind = 'S'
+ AND acl.grantee = 'k8s_metabase'::regrole
+ LOOP
+ EXECUTE format('REVOKE ALL ON SEQUENCE %I.%I FROM k8s_metabase', relation.nspname, relation.relname);
+ END LOOP;
+
+ FOR function_oid IN
+ SELECT procedure.oid
+ FROM pg_proc AS procedure
+ JOIN pg_namespace AS namespace ON namespace.oid = procedure.pronamespace
+ JOIN LATERAL aclexplode(procedure.proacl) AS acl ON true
+ WHERE namespace.nspname !~ '^pg_'
+ AND namespace.nspname <> 'information_schema'
+ AND acl.grantee = 'k8s_metabase'::regrole
+ LOOP
+ EXECUTE format('REVOKE ALL ON ROUTINE %s FROM k8s_metabase', function_oid::regprocedure);
+ END LOOP;
+END
+$$;
+RESET ROLE;
+
+ALTER ROLE k8s_metabase SET default_transaction_read_only = on;
+ALTER ROLE k8s_metabase SET statement_timeout = '20000ms';
+ALTER ROLE k8s_metabase SET idle_in_transaction_session_timeout = '20000ms';
+CREATE SCHEMA k8s_reporting AUTHORIZATION k8s_reporting_owner;
+SET LOCAL ROLE k8s_reporting_owner;
+REVOKE ALL ON SCHEMA k8s_reporting FROM PUBLIC;
+CREATE VIEW k8s_reporting.current_resources
+WITH (security_barrier = true, security_invoker = false) AS
+SELECT
+ cluster_id,
+ api_group,
+ resource,
+ namespace,
+ name,
+ uid,
+ resource_version,
+ schema_hash,
+ labels,
+ object,
+ source_time,
+ ingested_at
+FROM k8s_state.resource_state;
+REVOKE ALL ON ALL TABLES IN SCHEMA k8s_reporting FROM PUBLIC;
+ALTER DEFAULT PRIVILEGES IN SCHEMA k8s_reporting REVOKE ALL ON TABLES FROM PUBLIC;
+ALTER DEFAULT PRIVILEGES IN SCHEMA k8s_reporting REVOKE ALL ON SEQUENCES FROM PUBLIC;
+ALTER DEFAULT PRIVILEGES IN SCHEMA k8s_reporting REVOKE EXECUTE ON FUNCTIONS FROM PUBLIC;
+GRANT USAGE ON SCHEMA k8s_reporting TO k8s_metabase;
+GRANT SELECT ON k8s_reporting.current_resources TO k8s_metabase;
+RESET ROLE;
+
+-- 6. Runtime roles may inspect, but never modify, migration state.
+REVOKE ALL ON SCHEMA cyclops_migrations FROM PUBLIC;
+REVOKE ALL ON TABLE cyclops_migrations.applied_migrations FROM PUBLIC;
+GRANT USAGE ON SCHEMA cyclops_migrations TO cyclops_app, k8s_state_writer, k8s_state_exporter, k8s_role_admin, k8s_metabase;
+GRANT SELECT ON TABLE cyclops_migrations.applied_migrations TO cyclops_app, k8s_state_writer, k8s_state_exporter, k8s_role_admin, k8s_metabase;
+
+-- 7. Fail closed if reporting reaches state or application data.
+SET LOCAL ROLE k8s_state_owner;
+DO $$
+BEGIN
+ IF EXISTS (
+ SELECT 1
+ FROM pg_auth_members AS member
+ WHERE member.member = 'k8s_metabase'::regrole
+ ) THEN
+ RAISE EXCEPTION 'k8s_metabase retained role memberships';
+ END IF;
+
+ IF EXISTS (
+ SELECT 1
+ FROM pg_proc AS procedure
+ JOIN pg_namespace AS namespace ON namespace.oid = procedure.pronamespace
+ JOIN LATERAL aclexplode(
+ COALESCE(procedure.proacl, acldefault('f'::"char", procedure.proowner))
+ ) AS acl ON true
+ WHERE namespace.nspname !~ '^pg_'
+ AND namespace.nspname <> 'information_schema'
+ AND procedure.prokind IN ('f', 'p')
+ AND procedure.prosecdef
+ AND acl.grantee = 0
+ AND acl.privilege_type = 'EXECUTE'
+ ) THEN
+ RAISE EXCEPTION 'PUBLIC-executable SECURITY DEFINER routine blocks reporting access';
+ END IF;
+
+ IF EXISTS (
+ SELECT 1
+ FROM pg_namespace AS namespace
+ JOIN LATERAL aclexplode(namespace.nspacl) AS acl ON true
+ WHERE namespace.nspname !~ '^pg_'
+ AND namespace.nspname <> 'information_schema'
+ AND namespace.nspname <> 'k8s_reporting'
+ AND namespace.nspname <> 'cyclops_migrations'
+ AND acl.grantee = 'k8s_metabase'::regrole
+ ) OR EXISTS (
+ SELECT 1
+ FROM pg_class AS relation
+ JOIN pg_namespace AS namespace ON namespace.oid = relation.relnamespace
+ JOIN LATERAL aclexplode(relation.relacl) AS acl ON true
+ WHERE namespace.nspname !~ '^pg_'
+ AND namespace.nspname <> 'information_schema'
+ AND namespace.nspname <> 'k8s_reporting'
+ AND namespace.nspname <> 'cyclops_migrations'
+ AND relation.relkind IN ('r', 'p', 'v', 'm', 'f', 'S')
+ AND acl.grantee = 'k8s_metabase'::regrole
+ ) OR EXISTS (
+ SELECT 1
+ FROM pg_proc AS procedure
+ JOIN pg_namespace AS namespace ON namespace.oid = procedure.pronamespace
+ JOIN LATERAL aclexplode(procedure.proacl) AS acl ON true
+ WHERE namespace.nspname !~ '^pg_'
+ AND namespace.nspname <> 'information_schema'
+ AND namespace.nspname <> 'k8s_reporting'
+ AND namespace.nspname <> 'cyclops_migrations'
+ AND acl.grantee = 'k8s_metabase'::regrole
+ ) THEN
+ RAISE EXCEPTION 'k8s_metabase retained direct non-reporting ACLs';
+ END IF;
+
+ IF has_schema_privilege('k8s_metabase', 'k8s_state', 'USAGE')
+ OR has_schema_privilege('k8s_metabase', 'k8s_api', 'USAGE')
+ OR has_table_privilege('k8s_metabase', 'k8s_state.resource_state', 'SELECT')
+ OR has_table_privilege('k8s_metabase', 'k8s_api.current_resources', 'SELECT')
+ OR has_table_privilege('k8s_metabase', 'public.github_trust_policies', 'SELECT') THEN
+ RAISE EXCEPTION 'k8s_metabase retained known source or application access';
+ END IF;
+END
+$$;
+RESET ROLE;
diff --git a/libs/fleet/backend/database/migrator.go b/libs/fleet/backend/database/migrator.go
new file mode 100644
index 0000000000..7bd894a034
--- /dev/null
+++ b/libs/fleet/backend/database/migrator.go
@@ -0,0 +1,1179 @@
+package database
+
+import (
+ "context"
+ "crypto/sha256"
+ "embed"
+ "encoding/hex"
+ "errors"
+ "fmt"
+ "io/fs"
+ "log/slog"
+ "sort"
+ "strconv"
+ "strings"
+ "time"
+
+ "github.com/jackc/pgx/v5"
+ "github.com/jackc/pgx/v5/pgconn"
+)
+
+//go:embed all:migrations
+var migrationFS embed.FS
+
+type Config struct {
+ MigrationURL string
+ Credentials CredentialURLs
+}
+
+type CredentialURLs struct {
+ Application string
+ Writer string
+ Exporter string
+ RoleAdmin string
+ Metabase string
+}
+
+type migrationFile struct {
+ Version int64
+ Name string
+ SQL string
+ SHA256 string
+}
+
+type appliedMigration struct {
+ Version int64
+ Name string
+ SHA256 string
+}
+
+type credential struct {
+ Role string
+ Password string
+}
+
+type migrationEvent struct {
+ Version int64
+ Filename string
+ SHA256 string
+ DurationMS int64
+}
+
+type credentialEvent struct {
+ Role string
+ DurationMS int64
+}
+
+type staticRoleContract struct {
+ role string
+ login bool
+ inherit bool
+ createRole bool
+ createDB bool
+ connectionLimit int
+ validUntil string
+}
+
+type staticRoleAttributes struct {
+ login bool
+ inherit bool
+ createRole bool
+ createDB bool
+ connectionLimit int
+ validUntil string
+ super bool
+ replication bool
+ bypassRLS bool
+}
+
+type staticMembershipContract struct {
+ role, member string
+ admin, inherit, set bool
+}
+
+type staticMembershipGrant struct {
+ grantor string
+ grantorSuperuser bool
+ admin, inherit, set bool
+}
+
+type dynamicTenantRole struct {
+ name string
+ registered bool
+ login bool
+ inherit bool
+ createRole bool
+ createDB bool
+ super bool
+ replication bool
+ bypassRLS bool
+ connectionLimit int
+ validUntil string
+}
+
+type roleReconciliationEvent struct {
+ Role string
+ DurationMS int64
+}
+
+type membershipReconciliationEvent struct {
+ Role string
+ DurationMS int64
+}
+type migrationSummary struct {
+ DatabaseHost string
+ DatabaseName string
+ Current int64
+ Target int64
+ Pending int
+ Applied int
+ Skipped int
+ Started time.Time
+ Result string
+}
+
+var expectedCredentialRoles = map[string]string{
+ "application": "cyclops_app",
+ "writer": "k8s_state_writer",
+ "exporter": "k8s_state_exporter",
+ "role-admin": "k8s_role_admin",
+ "metabase": "k8s_metabase",
+}
+
+const createAppliedMigrationsTableStatement = `create table if not exists cyclops_migrations.applied_migrations (
+ application_order bigint generated always as identity unique,
+ version bigint primary key,
+ filename text not null unique,
+ sha256 text not null,
+ applied_at timestamptz not null default clock_timestamp()
+)`
+
+const selectAppliedMigrationsStatement = `select version, filename, sha256 from cyclops_migrations.applied_migrations order by application_order`
+
+const insertAppliedMigrationStatement = `insert into cyclops_migrations.applied_migrations (version, filename, sha256) values ($1, $2, $3)`
+
+func embeddedMigrations() ([]migrationFile, error) {
+ entries, err := fs.ReadDir(migrationFS, "migrations")
+ if err != nil {
+ return nil, fmt.Errorf("list database migrations: %w", err)
+ }
+
+ files := make([]migrationFile, 0, len(entries))
+ for _, entry := range entries {
+ if entry.IsDir() || !strings.HasSuffix(entry.Name(), ".sql") {
+ continue
+ }
+
+ prefix, _, ok := strings.Cut(entry.Name(), "_")
+ if !ok || len(prefix) != 6 {
+ return nil, fmt.Errorf("migration %q must start with a six-digit version", entry.Name())
+ }
+ version, err := strconv.ParseInt(prefix, 10, 64)
+ if err != nil || version < 1 {
+ return nil, fmt.Errorf("migration %q has invalid version", entry.Name())
+ }
+
+ contents, err := migrationFS.ReadFile("migrations/" + entry.Name())
+ if err != nil {
+ return nil, fmt.Errorf("read migration %s: %w", entry.Name(), err)
+ }
+ digest := sha256.Sum256(contents)
+ files = append(files, migrationFile{
+ Version: version,
+ Name: entry.Name(),
+ SQL: string(contents),
+ SHA256: hex.EncodeToString(digest[:]),
+ })
+ }
+
+ sort.Slice(files, func(i, j int) bool { return files[i].Version < files[j].Version })
+ for index, file := range files {
+ expected := int64(index + 1)
+ if file.Version != expected {
+ return nil, fmt.Errorf("migration sequence gap: expected %06d, got %06d", expected, file.Version)
+ }
+ }
+ return files, nil
+}
+
+func checkAppliedMigration(file migrationFile, applied appliedMigration) error {
+ if applied.Name != file.Name {
+ return fmt.Errorf("migration %06d filename changed after application: recorded %s, current %s", file.Version, applied.Name, file.Name)
+ }
+ if applied.SHA256 != file.SHA256 {
+ return fmt.Errorf("migration %s changed after application: recorded %s, current %s", file.Name, applied.SHA256, file.SHA256)
+ }
+ return nil
+}
+
+func validateAppliedMigrations(files []migrationFile, applied []appliedMigration) error {
+ filesByVersion := make(map[int64]migrationFile, len(files))
+ for _, file := range files {
+ filesByVersion[file.Version] = file
+ }
+ for _, row := range applied {
+ file, ok := filesByVersion[row.Version]
+ if !ok {
+ return fmt.Errorf("migration ledger contains applied version %06d with no embedded migration", row.Version)
+ }
+ if err := checkAppliedMigration(file, row); err != nil {
+ return err
+ }
+ }
+
+ for index := 1; index < len(applied); index++ {
+ previous := applied[index-1].Version
+ current := applied[index].Version
+ if current == previous {
+ return fmt.Errorf("migration ledger contains duplicate version %06d", current)
+ }
+ if current < previous {
+ return fmt.Errorf("migration ledger rows are out of order: version %06d follows %06d", current, previous)
+ }
+ }
+
+ for index, row := range applied {
+ expected := int64(index + 1)
+ if row.Version != expected {
+ return fmt.Errorf("migration ledger version gap: expected %06d, got %06d", expected, row.Version)
+ }
+ }
+ return nil
+}
+
+func migrationTargetVersion(files []migrationFile) int64 {
+ if len(files) == 0 {
+ return 0
+ }
+ return files[len(files)-1].Version
+}
+
+func migrationCurrentVersion(applied []appliedMigration) int64 {
+ var current int64
+ for _, row := range applied {
+ if row.Version > current {
+ current = row.Version
+ }
+ }
+ return current
+}
+
+func databaseTarget(connectionConfig *pgx.ConnConfig) string {
+ if connectionConfig.Host == "" && connectionConfig.Database == "" {
+ return ""
+ }
+ return fmt.Sprintf(" (database_host=%s database_name=%s)", connectionConfig.Host, connectionConfig.Database)
+}
+
+func parseMigrationConfig(url string) (*pgx.ConnConfig, error) {
+ connectionConfig, err := pgx.ParseConfig(url)
+ if err != nil {
+ return nil, errors.New("parse migration database URL")
+ }
+ return connectionConfig, nil
+}
+
+func logMigrationSummary(summary migrationSummary) {
+ slog.Info("database migration summary",
+ "database_host", summary.DatabaseHost,
+ "database_name", summary.DatabaseName,
+ "current_version", summary.Current,
+ "target_version", summary.Target,
+ "pending", summary.Pending,
+ "applied", summary.Applied,
+ "skipped", summary.Skipped,
+ "duration_ms", time.Since(summary.Started).Milliseconds(),
+ "result", summary.Result,
+ )
+}
+
+func Run(ctx context.Context, config Config) (runErr error) {
+ credentials, err := parseCredentialURLs(config.Credentials)
+ if err != nil {
+ return err
+ }
+ files, err := embeddedMigrations()
+ if err != nil {
+ return err
+ }
+
+ connectionConfig, err := parseMigrationConfig(config.MigrationURL)
+ if err != nil {
+ return err
+ }
+ summary := migrationSummary{
+ DatabaseHost: connectionConfig.Host,
+ DatabaseName: connectionConfig.Database,
+ Target: migrationTargetVersion(files),
+ Pending: len(files),
+ Started: time.Now(),
+ Result: "failed",
+ }
+ defer func() { logMigrationSummary(summary) }()
+
+ connection, err := pgx.ConnectConfig(ctx, connectionConfig)
+ if err != nil {
+ return fmt.Errorf("connect migration database%s", databaseTarget(connectionConfig))
+ }
+ defer connection.Close(ctx)
+
+ transaction, err := connection.Begin(ctx)
+ if err != nil {
+ return fmt.Errorf("begin database migrations: %w", err)
+ }
+ defer transaction.Rollback(ctx)
+
+ ledgerStatements := []string{
+ `select pg_advisory_xact_lock(hashtext('cyclops-database-migrations'))`,
+ `create schema if not exists cyclops_migrations`,
+ createAppliedMigrationsTableStatement,
+ }
+ for index, statement := range ledgerStatements {
+ started := time.Now()
+ if _, err := transaction.Exec(ctx, statement); err != nil {
+ return fmt.Errorf("prepare migration ledger: %w", err)
+ }
+ if index == 0 {
+ slog.Info("database migration advisory lock acquired",
+ "database_host", connectionConfig.Host,
+ "database_name", connectionConfig.Database,
+ "duration_ms", time.Since(started).Milliseconds(),
+ )
+ }
+ }
+
+ rows, err := transaction.Query(ctx, selectAppliedMigrationsStatement)
+ if err != nil {
+ return fmt.Errorf("read migration ledger: %w", err)
+ }
+ applied := make([]appliedMigration, 0)
+ for rows.Next() {
+ var row appliedMigration
+ if err := rows.Scan(&row.Version, &row.Name, &row.SHA256); err != nil {
+ rows.Close()
+ return fmt.Errorf("read migration ledger: %w", err)
+ }
+ applied = append(applied, row)
+ }
+ if err := rows.Err(); err != nil {
+ rows.Close()
+ return fmt.Errorf("read migration ledger: %w", err)
+ }
+ rows.Close()
+ if err := validateAppliedMigrations(files, applied); err != nil {
+ return err
+ }
+
+ appliedByVersion := make(map[int64]appliedMigration, len(applied))
+ for _, row := range applied {
+ appliedByVersion[row.Version] = row
+ }
+ summary.Current = migrationCurrentVersion(applied)
+ summary.Pending = len(files) - len(applied)
+
+ migrationEvents := make([]migrationEvent, 0, summary.Pending)
+ for _, file := range files {
+ started := time.Now()
+ if _, ok := appliedByVersion[file.Version]; ok {
+ summary.Skipped++
+ slog.Info("database migration",
+ "version", file.Version,
+ "filename", file.Name,
+ "sha256", file.SHA256,
+ "duration_ms", time.Since(started).Milliseconds(),
+ "result", "skipped",
+ )
+ continue
+ }
+
+ if _, err := transaction.Exec(ctx, file.SQL); err != nil {
+ return fmt.Errorf("apply migration %s: %w", file.Name, err)
+ }
+ if _, err := transaction.Exec(ctx,
+ insertAppliedMigrationStatement,
+ file.Version, file.Name, file.SHA256,
+ ); err != nil {
+ return fmt.Errorf("record migration %s: %w", file.Name, err)
+ }
+ migrationEvents = append(migrationEvents, migrationEvent{
+ Version: file.Version,
+ Filename: file.Name,
+ SHA256: file.SHA256,
+ DurationMS: time.Since(started).Milliseconds(),
+ })
+ }
+
+ roleEvents, membershipEvents, err := reconcileStaticRoleContracts(ctx, transaction)
+ if err != nil {
+ return err
+ }
+ credentialEvents, err := reconcilePasswords(ctx, transaction, credentials)
+ if err != nil {
+ return err
+ }
+ if err := transaction.Commit(ctx); err != nil {
+ return fmt.Errorf("commit database migrations: %w", err)
+ }
+
+ for _, event := range migrationEvents {
+ slog.Info("database migration",
+ "version", event.Version,
+ "filename", event.Filename,
+ "sha256", event.SHA256,
+ "duration_ms", event.DurationMS,
+ "result", "applied",
+ )
+ }
+ for _, event := range roleEvents {
+ slog.Info("database role reconciled",
+ "role", event.Role,
+ "duration_ms", event.DurationMS,
+ "result", "reconciled",
+ )
+ }
+ for _, event := range membershipEvents {
+ slog.Info("database role membership reconciled",
+ "role", event.Role,
+ "duration_ms", event.DurationMS,
+ "result", "reconciled",
+ )
+ }
+ for _, event := range credentialEvents {
+ slog.Info("database credential reconciled",
+ "role", event.Role,
+ "duration_ms", event.DurationMS,
+ "result", "reconciled",
+ )
+ }
+ summary.Applied = len(migrationEvents)
+ summary.Result = "success"
+ return nil
+}
+
+func parseCredentialURLs(urls CredentialURLs) ([]credential, error) {
+ inputs := []struct {
+ Name string
+ URL string
+ }{
+ {Name: "application", URL: urls.Application},
+ {Name: "writer", URL: urls.Writer},
+ {Name: "exporter", URL: urls.Exporter},
+ {Name: "role-admin", URL: urls.RoleAdmin},
+ {Name: "metabase", URL: urls.Metabase},
+ }
+
+ credentials := make([]credential, 0, len(inputs))
+ for _, input := range inputs {
+ connectionConfig, err := pgx.ParseConfig(input.URL)
+ if err != nil {
+ return nil, fmt.Errorf("parse %s credential database URL", input.Name)
+ }
+ expectedRole := expectedCredentialRoles[input.Name]
+ if connectionConfig.User != expectedRole {
+ return nil, fmt.Errorf("%s credential database URL must use the expected role", input.Name)
+ }
+ if connectionConfig.Password == "" {
+ return nil, fmt.Errorf("%s credential database URL must include a password", input.Name)
+ }
+ credentials = append(credentials, credential{Role: expectedRole, Password: connectionConfig.Password})
+ }
+ return credentials, nil
+}
+
+func staticRoleContracts() []staticRoleContract {
+ return []staticRoleContract{
+ {role: "cyclops_app", login: true, connectionLimit: -1, validUntil: "infinity"},
+ {role: "k8s_state_owner", inherit: true, connectionLimit: -1, validUntil: "infinity"},
+ {role: "k8s_state_writer", login: true, connectionLimit: -1, validUntil: "infinity"},
+ {role: "k8s_state_exporter", login: true, connectionLimit: -1, validUntil: "infinity"},
+ {role: "k8s_query_tenant", inherit: true, connectionLimit: -1, validUntil: "infinity"},
+ {role: "k8s_query_admin", inherit: true, connectionLimit: -1, validUntil: "infinity"},
+ {role: "k8s_role_admin", login: true, createRole: true, connectionLimit: -1, validUntil: "infinity"},
+ {role: "k8s_reporting_owner", inherit: true, connectionLimit: -1, validUntil: "infinity"},
+ {role: "k8s_metabase", login: true, connectionLimit: -1, validUntil: "infinity"},
+ }
+}
+
+func staticRoleSettingsContracts() map[string]map[string]string {
+ return map[string]map[string]string{
+ "k8s_metabase": {
+ "default_transaction_read_only": "on",
+ "statement_timeout": "20000ms",
+ "idle_in_transaction_session_timeout": "20000ms",
+ },
+ }
+}
+
+func staticMembershipContracts(migrationOwner string) []staticMembershipContract {
+ return []staticMembershipContract{
+ {role: "k8s_state_owner", member: migrationOwner, admin: false, inherit: false, set: true},
+ {role: "k8s_reporting_owner", member: migrationOwner, admin: false, inherit: false, set: true},
+ {role: "k8s_query_tenant", member: "k8s_role_admin", admin: true, inherit: false, set: false},
+ {role: "k8s_query_admin", member: "k8s_reporting_owner", admin: false, inherit: true, set: false},
+ }
+}
+
+func postgresBoolean(value bool) string {
+ if value {
+ return "TRUE"
+ }
+ return "FALSE"
+}
+
+func staticRoleAlterClauses(contract staticRoleContract, attributes staticRoleAttributes) (string, error) {
+ unsafeAttributes := make([]string, 0, 4)
+ if attributes.createDB {
+ unsafeAttributes = append(unsafeAttributes, "rolcreatedb=true")
+ }
+ if attributes.super {
+ unsafeAttributes = append(unsafeAttributes, "rolsuper=true")
+ }
+ if attributes.replication {
+ unsafeAttributes = append(unsafeAttributes, "rolreplication=true")
+ }
+ if attributes.bypassRLS {
+ unsafeAttributes = append(unsafeAttributes, "rolbypassrls=true")
+ }
+ if len(unsafeAttributes) != 0 {
+ return "", fmt.Errorf("static role %s has unsafe privileged drift: %s; the migration owner cannot safely repair these attributes", contract.role, strings.Join(unsafeAttributes, ", "))
+ }
+
+ clauses := make([]string, 0, 6)
+ if attributes.login != contract.login {
+ clauses = append(clauses, map[bool]string{true: "LOGIN", false: "NOLOGIN"}[contract.login])
+ }
+ if attributes.inherit != contract.inherit {
+ clauses = append(clauses, map[bool]string{true: "INHERIT", false: "NOINHERIT"}[contract.inherit])
+ }
+ if attributes.createRole != contract.createRole {
+ clauses = append(clauses, map[bool]string{true: "CREATEROLE", false: "NOCREATEROLE"}[contract.createRole])
+ }
+ if attributes.connectionLimit != contract.connectionLimit {
+ clauses = append(clauses, "CONNECTION LIMIT "+strconv.Itoa(contract.connectionLimit))
+ }
+ if attributes.validUntil != contract.validUntil {
+ clauses = append(clauses, "VALID UNTIL '"+contract.validUntil+"'")
+ }
+ return strings.Join(clauses, " "), nil
+}
+
+func readStaticRoleAttributes(ctx context.Context, transaction pgx.Tx, role string) (staticRoleAttributes, error) {
+ var attributes staticRoleAttributes
+ err := transaction.QueryRow(ctx, `
+ select rolcanlogin, rolinherit, rolcreaterole, rolcreatedb, rolconnlimit, coalesce(rolvaliduntil::text, 'infinity'), rolsuper, rolreplication, rolbypassrls
+ from pg_roles
+ where rolname = $1`, role).Scan(
+ &attributes.login,
+ &attributes.inherit,
+ &attributes.createRole,
+ &attributes.createDB,
+ &attributes.connectionLimit,
+ &attributes.validUntil,
+ &attributes.super,
+ &attributes.replication,
+ &attributes.bypassRLS,
+ )
+ if err != nil {
+ return staticRoleAttributes{}, fmt.Errorf("read static role %s attributes: %w", role, err)
+ }
+ return attributes, nil
+}
+
+func reconcileStaticRoleContracts(ctx context.Context, transaction pgx.Tx) ([]roleReconciliationEvent, []membershipReconciliationEvent, error) {
+ var migrationOwner string
+ if err := transaction.QueryRow(ctx, `select current_user`).Scan(&migrationOwner); err != nil {
+ return nil, nil, fmt.Errorf("read migration role: %w", err)
+ }
+ membershipContracts := staticMembershipContracts(migrationOwner)
+ if err := validateStaticRoleMemberships(ctx, transaction, migrationOwner, membershipContracts); err != nil {
+ return nil, nil, err
+ }
+
+ roleEvents := make([]roleReconciliationEvent, 0, len(staticRoleContracts()))
+ for _, contract := range staticRoleContracts() {
+ started := time.Now()
+ attributes, err := readStaticRoleAttributes(ctx, transaction, contract.role)
+ if err != nil {
+ return nil, nil, err
+ }
+ clauses, err := staticRoleAlterClauses(contract, attributes)
+ if err != nil {
+ return nil, nil, err
+ }
+ if clauses != "" {
+ if _, err := transaction.Exec(ctx, "alter role "+pgx.Identifier{contract.role}.Sanitize()+" "+clauses); err != nil {
+ return nil, nil, fmt.Errorf("reconcile static role %s: %w", contract.role, err)
+ }
+ }
+ roleEvents = append(roleEvents, roleReconciliationEvent{Role: contract.role, DurationMS: time.Since(started).Milliseconds()})
+ }
+
+ membershipEvents := make([]membershipReconciliationEvent, 0, len(membershipContracts))
+ for _, contract := range membershipContracts {
+ started := time.Now()
+ grants, err := readStaticMembershipGrants(ctx, transaction, contract)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ var migrationOwnerGrant *staticMembershipGrant
+ for index := range grants {
+ grant := &grants[index]
+ if grant.grantor == migrationOwner {
+ migrationOwnerGrant = grant
+ continue
+ }
+ if allowsImplicitCreatorAdminMembership(contract.role, contract.member, migrationOwner, *grant) {
+ continue
+ }
+ return nil, nil, foreignStaticMembershipGrantError(contract, grant.grantor, migrationOwner)
+ }
+
+ if migrationOwnerGrant == nil || migrationOwnerGrant.admin != contract.admin || migrationOwnerGrant.inherit != contract.inherit || migrationOwnerGrant.set != contract.set {
+ roleIdentifier := pgx.Identifier{contract.role}.Sanitize()
+ memberIdentifier := pgx.Identifier{contract.member}.Sanitize()
+ grantorIdentifier := pgx.Identifier{migrationOwner}.Sanitize()
+ if migrationOwnerGrant != nil {
+ statement := "revoke " + roleIdentifier + " from " + memberIdentifier + " granted by " + grantorIdentifier + " restrict"
+ if _, err := transaction.Exec(ctx, statement); err != nil {
+ return nil, nil, fmt.Errorf("remove drifted static role membership %s -> %s: %w", contract.role, contract.member, err)
+ }
+ }
+ statement := "grant " + roleIdentifier + " to " + memberIdentifier +
+ " with admin " + postgresBoolean(contract.admin) +
+ ", inherit " + postgresBoolean(contract.inherit) +
+ ", set " + postgresBoolean(contract.set) +
+ " granted by " + grantorIdentifier
+ if _, err := transaction.Exec(ctx, statement); err != nil {
+ return nil, nil, fmt.Errorf("reconcile static role membership %s -> %s: %w", contract.role, contract.member, err)
+ }
+ }
+ membershipEvents = append(membershipEvents, membershipReconciliationEvent{Role: contract.role, DurationMS: time.Since(started).Milliseconds()})
+ }
+
+ if err := reconcileStaticRoleSettings(ctx, transaction); err != nil {
+ return nil, nil, err
+ }
+ return roleEvents, membershipEvents, nil
+}
+
+func foreignStaticMembershipGrantError(contract staticMembershipContract, grantor, migrationOwner string) error {
+ return fmt.Errorf("static role membership %s -> %s has grantor %s instead of migration owner %s; revoke the foreign grant without CASCADE before rerunning the migration", contract.role, contract.member, grantor, migrationOwner)
+}
+
+func validateStaticRoleMemberships(ctx context.Context, transaction pgx.Tx, migrationOwner string, contracts []staticMembershipContract) error {
+ for _, contract := range contracts {
+ grants, err := readStaticMembershipGrants(ctx, transaction, contract)
+ if err != nil {
+ return err
+ }
+ for _, grant := range grants {
+ if grant.grantor != migrationOwner && contract.member != migrationOwner && !allowsImplicitCreatorAdminMembership(contract.role, contract.member, migrationOwner, grant) {
+ return foreignStaticMembershipGrantError(contract, grant.grantor, migrationOwner)
+ }
+ }
+ }
+
+ dynamicTenants, err := validateQueryTenantRoleMembers(ctx, transaction, migrationOwner, contracts)
+ if err != nil {
+ return err
+ }
+ for _, contract := range staticRoleContracts() {
+ if contract.role == "k8s_query_tenant" {
+ continue
+ }
+ if err := validateStaticRoleMembers(ctx, transaction, migrationOwner, contract.role, contracts); err != nil {
+ return err
+ }
+ }
+
+ for _, contract := range staticRoleContracts() {
+ if err := validateStaticRoleParents(ctx, transaction, contract.role, contracts, dynamicTenants); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func validateStaticRoleMembers(ctx context.Context, transaction pgx.Tx, migrationOwner, role string, contracts []staticMembershipContract) error {
+ creatorGrants, err := readStaticMembershipGrants(ctx, transaction, staticMembershipContract{role: role, member: migrationOwner})
+ if err != nil {
+ return err
+ }
+ allowMigrationOwnerGrant := isDeclaredStaticMembership(role, migrationOwner, contracts)
+ if !staticCreatorAdminMembershipsAreExact(migrationOwner, creatorGrants, allowMigrationOwnerGrant) {
+ return staticCreatorAdminMembershipError(role, migrationOwner)
+ }
+
+ rows, err := transaction.Query(ctx, `
+ select member_role.rolname, grantor_role.rolname, grantor_role.rolsuper, membership.admin_option, membership.inherit_option, membership.set_option
+ from pg_auth_members as membership
+ join pg_roles as member_role on member_role.oid = membership.member
+ join pg_roles as grantor_role on grantor_role.oid = membership.grantor
+ where membership.roleid = $1::regrole
+ order by member_role.rolname, grantor_role.rolname`, role)
+ if err != nil {
+ return fmt.Errorf("read static role members for %s: %w", role, err)
+ }
+ defer rows.Close()
+
+ unexpected := map[string]struct{}{}
+ for rows.Next() {
+ var member string
+ var grant staticMembershipGrant
+ if err := rows.Scan(&member, &grant.grantor, &grant.grantorSuperuser, &grant.admin, &grant.inherit, &grant.set); err != nil {
+ return fmt.Errorf("scan static role member for %s: %w", role, err)
+ }
+ if member == migrationOwner || isDeclaredStaticMembership(role, member, contracts) {
+ continue
+ }
+ unexpected[member] = struct{}{}
+ }
+ if err := rows.Err(); err != nil {
+ return fmt.Errorf("iterate static role members for %s: %w", role, err)
+ }
+ if len(unexpected) != 0 {
+ return fmt.Errorf("static role %s has unexpected members %s; revoke them without CASCADE before rerunning the migration", role, sortedRoleNames(unexpected))
+ }
+ return nil
+}
+
+func validateQueryTenantRoleMembers(ctx context.Context, transaction pgx.Tx, migrationOwner string, contracts []staticMembershipContract) (map[string]dynamicTenantRole, error) {
+ if _, err := transaction.Exec(ctx, `set local role k8s_state_owner`); err != nil {
+ return nil, fmt.Errorf("validate k8s_query_tenant memberships requires SET ROLE k8s_state_owner; restore the declared migration-owner membership before rerunning the migration: %w", err)
+ }
+ dynamicTenants, err := readRegisteredDynamicTenantRoles(ctx, transaction)
+ if err != nil {
+ _, _ = transaction.Exec(ctx, `reset role`)
+ return nil, err
+ }
+ rows, err := transaction.Query(ctx, `
+ select member_role.rolname
+ from pg_auth_members as membership
+ join pg_roles as member_role on member_role.oid = membership.member
+ where membership.roleid = 'k8s_query_tenant'::regrole
+ order by member_role.rolname`)
+ if err != nil {
+ _, _ = transaction.Exec(ctx, `reset role`)
+ return nil, fmt.Errorf("read k8s_query_tenant members: %w", err)
+ }
+
+ unexpected := map[string]struct{}{}
+ for rows.Next() {
+ var member string
+ if err := rows.Scan(&member); err != nil {
+ rows.Close()
+ _, _ = transaction.Exec(ctx, `reset role`)
+ return nil, fmt.Errorf("scan k8s_query_tenant member: %w", err)
+ }
+ if member == migrationOwner || isDeclaredStaticMembership("k8s_query_tenant", member, contracts) {
+ continue
+ }
+ if _, ok := dynamicTenants[member]; ok {
+ continue
+ }
+ unexpected[member] = struct{}{}
+ }
+ if err := rows.Err(); err != nil {
+ rows.Close()
+ _, _ = transaction.Exec(ctx, `reset role`)
+ return nil, fmt.Errorf("iterate k8s_query_tenant members: %w", err)
+ }
+ rows.Close()
+ if _, err := transaction.Exec(ctx, `reset role`); err != nil {
+ return nil, fmt.Errorf("reset role after validating k8s_query_tenant memberships: %w", err)
+ }
+ if len(unexpected) != 0 {
+ return nil, fmt.Errorf("k8s_query_tenant has unregistered dynamic tenant member %s; remove the membership without CASCADE or register it through k8s_role_admin before rerunning the migration", sortedRoleNames(unexpected))
+ }
+
+ creatorGrants, err := readStaticMembershipGrants(ctx, transaction, staticMembershipContract{role: "k8s_query_tenant", member: migrationOwner})
+ if err != nil {
+ return nil, err
+ }
+ if !staticCreatorAdminMembershipsAreExact(migrationOwner, creatorGrants, false) {
+ return nil, staticCreatorAdminMembershipError("k8s_query_tenant", migrationOwner)
+ }
+ for _, tenant := range dynamicTenants {
+ if err := validateRegisteredTenantRoleMemberships(ctx, transaction, tenant); err != nil {
+ return nil, err
+ }
+ }
+ return dynamicTenants, nil
+}
+
+func readRegisteredDynamicTenantRoles(ctx context.Context, transaction pgx.Tx) (map[string]dynamicTenantRole, error) {
+ rows, err := transaction.Query(ctx, `
+ select tenant_role.role_name::text,
+ member_role.rolname,
+ coalesce(member_role.rolcanlogin, false),
+ coalesce(member_role.rolinherit, false),
+ coalesce(member_role.rolcreaterole, false),
+ coalesce(member_role.rolcreatedb, false),
+ coalesce(member_role.rolsuper, false),
+ coalesce(member_role.rolreplication, false),
+ coalesce(member_role.rolbypassrls, false),
+ coalesce(member_role.rolconnlimit, -1),
+ coalesce(member_role.rolvaliduntil::text, 'infinity')
+ from k8s_state.query_tenant_role as tenant_role
+ left join pg_roles as member_role on member_role.rolname = tenant_role.role_name::text
+ order by tenant_role.role_name`)
+ if err != nil {
+ return nil, fmt.Errorf("read registered tenant roles: %w", err)
+ }
+ defer rows.Close()
+
+ tenants := map[string]dynamicTenantRole{}
+ for rows.Next() {
+ var tenant dynamicTenantRole
+ var roleName *string
+ if err := rows.Scan(&tenant.name, &roleName, &tenant.login, &tenant.inherit, &tenant.createRole, &tenant.createDB, &tenant.super, &tenant.replication, &tenant.bypassRLS, &tenant.connectionLimit, &tenant.validUntil); err != nil {
+ return nil, fmt.Errorf("scan registered tenant role: %w", err)
+ }
+ if roleName == nil {
+ return nil, fmt.Errorf("registered tenant role %s does not exist; restore or unregister it before rerunning the migration", tenant.name)
+ }
+ tenant.registered = true
+ tenants[tenant.name] = tenant
+ }
+ if err := rows.Err(); err != nil {
+ return nil, fmt.Errorf("iterate registered tenant roles: %w", err)
+ }
+ return tenants, nil
+}
+
+func validateRegisteredTenantRoleMemberships(ctx context.Context, transaction pgx.Tx, tenant dynamicTenantRole) error {
+ creatorGrants, err := readStaticMembershipGrants(ctx, transaction, staticMembershipContract{role: tenant.name, member: "k8s_role_admin"})
+ if err != nil {
+ return err
+ }
+ controllerGrants, err := readStaticMembershipGrants(ctx, transaction, staticMembershipContract{role: "k8s_query_tenant", member: tenant.name})
+ if err != nil {
+ return err
+ }
+ var inboundCount, parentCount int
+ if err := transaction.QueryRow(ctx, `select count(*) from pg_auth_members where roleid = $1::regrole`, tenant.name).Scan(&inboundCount); err != nil {
+ return fmt.Errorf("count registered tenant %s members: %w", tenant.name, err)
+ }
+ if err := transaction.QueryRow(ctx, `select count(*) from pg_auth_members where member = $1::regrole`, tenant.name).Scan(&parentCount); err != nil {
+ return fmt.Errorf("count registered tenant %s parent roles: %w", tenant.name, err)
+ }
+ if inboundCount != 1 || parentCount != 1 || !registeredTenantMembershipsAreExact(tenant, creatorGrants, controllerGrants) {
+ return fmt.Errorf("registered tenant role %s has memberships outside the controller contract; remove the drift without CASCADE before rerunning the migration", tenant.name)
+ }
+ return nil
+}
+
+func staticCreatorAdminMembershipsAreExact(member string, grants []staticMembershipGrant, allowOwnerGrant bool) bool {
+ foreignCount := 0
+ ownerCount := 0
+ for _, grant := range grants {
+ if grant.grantor == member {
+ ownerCount++
+ continue
+ }
+ foreignCount++
+ if !grant.grantorSuperuser || !grant.admin || grant.inherit || grant.set {
+ return false
+ }
+ }
+ return foreignCount == 1 && ownerCount <= 1 && (allowOwnerGrant || ownerCount == 0)
+}
+
+func staticCreatorAdminMembershipError(role, member string) error {
+ return fmt.Errorf("role %s must have exactly one foreign creator-admin membership for %s granted by a true PostgreSQL superuser with admin=true inherit=false set=false", role, member)
+}
+
+func creatorAdminMembershipsAreExact(member string, grants []staticMembershipGrant) bool {
+ return len(grants) == 1 &&
+ grants[0].grantor != member &&
+ grants[0].grantorSuperuser &&
+ grants[0].admin && !grants[0].inherit && !grants[0].set
+}
+
+func registeredTenantMembershipsAreExact(tenant dynamicTenantRole, inbound, parents []staticMembershipGrant) bool {
+ return dynamicTenantRoleMatchesControllerContract(tenant) &&
+ creatorAdminMembershipsAreExact("k8s_role_admin", inbound) &&
+ len(parents) == 1 &&
+ parents[0].grantor == "k8s_role_admin" &&
+ !parents[0].admin && parents[0].inherit && !parents[0].set
+}
+
+func creatorAdminMembershipError(role, member string) error {
+ return fmt.Errorf("role %s must have exactly one implicit creator-admin membership for %s granted by a true PostgreSQL superuser with admin=true inherit=false set=false", role, member)
+}
+
+func dynamicTenantRoleMatchesControllerContract(tenant dynamicTenantRole) bool {
+ return tenant.registered &&
+ len(tenant.name) == len("k8s_tenant_")+32 &&
+ strings.HasPrefix(tenant.name, "k8s_tenant_") &&
+ isLowerHex(tenant.name[len("k8s_tenant_"):]) &&
+ tenant.login && tenant.inherit && !tenant.createRole && !tenant.createDB && !tenant.super && !tenant.replication && !tenant.bypassRLS &&
+ tenant.connectionLimit == -1 && tenant.validUntil == "infinity"
+}
+
+func allowsRegisteredTenantCreatorAdminMembership(tenant dynamicTenantRole, member string, grant staticMembershipGrant) bool {
+ return dynamicTenantRoleMatchesControllerContract(tenant) &&
+ member == "k8s_role_admin" &&
+ grant.grantor != member &&
+ grant.grantorSuperuser &&
+ grant.admin && !grant.inherit && !grant.set
+}
+
+func isDeclaredStaticMembership(role, member string, contracts []staticMembershipContract) bool {
+ for _, contract := range contracts {
+ if contract.role == role && contract.member == member {
+ return true
+ }
+ }
+ return false
+}
+
+func isLowerHex(value string) bool {
+ for _, character := range value {
+ if (character < '0' || character > '9') && (character < 'a' || character > 'f') {
+ return false
+ }
+ }
+ return true
+}
+
+func validateStaticRoleParents(ctx context.Context, transaction pgx.Tx, role string, contracts []staticMembershipContract, dynamicTenants map[string]dynamicTenantRole) error {
+ rows, err := transaction.Query(ctx, `
+ select parent_role.rolname, grantor_role.rolname, grantor_role.rolsuper, membership.admin_option, membership.inherit_option, membership.set_option
+ from pg_auth_members as membership
+ join pg_roles as parent_role on parent_role.oid = membership.roleid
+ join pg_roles as grantor_role on grantor_role.oid = membership.grantor
+ where membership.member = $1::regrole
+ order by parent_role.rolname`, role)
+ if err != nil {
+ return fmt.Errorf("read static role parents for %s: %w", role, err)
+ }
+ defer rows.Close()
+
+ unexpected := map[string]struct{}{}
+ for rows.Next() {
+ var parent string
+ var grant staticMembershipGrant
+ if err := rows.Scan(&parent, &grant.grantor, &grant.grantorSuperuser, &grant.admin, &grant.inherit, &grant.set); err != nil {
+ return fmt.Errorf("scan static role parent for %s: %w", role, err)
+ }
+ if isDeclaredStaticMembership(parent, role, contracts) || allowsRegisteredTenantCreatorAdminMembership(dynamicTenants[parent], role, grant) {
+ continue
+ }
+ unexpected[parent] = struct{}{}
+ }
+ if err := rows.Err(); err != nil {
+ return fmt.Errorf("iterate static role parents for %s: %w", role, err)
+ }
+ if len(unexpected) != 0 {
+ return fmt.Errorf("static role %s has unexpected parent roles %s; revoke them without CASCADE before rerunning the migration", role, sortedRoleNames(unexpected))
+ }
+ return nil
+}
+
+func sortedRoleNames(names map[string]struct{}) string {
+ ordered := make([]string, 0, len(names))
+ for name := range names {
+ ordered = append(ordered, name)
+ }
+ sort.Strings(ordered)
+ return strings.Join(ordered, ", ")
+}
+
+func reconcileStaticRoleSettings(ctx context.Context, transaction pgx.Tx) error {
+ contracts := staticRoleSettingsContracts()
+ for _, roleContract := range staticRoleContracts() {
+ actual, err := readStaticRoleSettings(ctx, transaction, roleContract.role)
+ if err != nil {
+ return err
+ }
+ desired := contracts[roleContract.role]
+ if staticRoleSettingsMatch(actual, desired) {
+ continue
+ }
+
+ roleIdentifier := pgx.Identifier{roleContract.role}.Sanitize()
+ for _, setting := range actual {
+ statement := "alter role " + roleIdentifier
+ if setting.database != "" {
+ statement += " in database " + pgx.Identifier{setting.database}.Sanitize()
+ }
+ statement += " reset all"
+ if _, err := transaction.Exec(ctx, statement); err != nil {
+ return fmt.Errorf("reset static role settings for %s: %w", roleContract.role, err)
+ }
+ }
+
+ settingNames := make([]string, 0, len(desired))
+ for name := range desired {
+ settingNames = append(settingNames, name)
+ }
+ sort.Strings(settingNames)
+ for _, name := range settingNames {
+ var value string
+ if err := transaction.QueryRow(ctx, `select format('%L', $1::text)`, desired[name]).Scan(&value); err != nil {
+ return fmt.Errorf("quote static role setting %s for %s: %w", name, roleContract.role, err)
+ }
+ if _, err := transaction.Exec(ctx, "alter role "+roleIdentifier+" set "+name+" = "+value); err != nil {
+ return fmt.Errorf("reconcile static role setting %s for %s: %w", name, roleContract.role, err)
+ }
+ }
+ }
+ return nil
+}
+
+type staticRoleSetting struct {
+ database string
+ values map[string]string
+}
+
+func readStaticRoleSettings(ctx context.Context, transaction pgx.Tx, role string) ([]staticRoleSetting, error) {
+ rows, err := transaction.Query(ctx, `
+ select coalesce(database.datname, ''), setting.setconfig
+ from pg_db_role_setting as setting
+ join pg_roles as configured_role on configured_role.oid = setting.setrole
+ left join pg_database as database on database.oid = setting.setdatabase
+ where configured_role.rolname = $1
+ order by setting.setdatabase`, role)
+ if err != nil {
+ return nil, fmt.Errorf("read static role settings for %s: %w", role, err)
+ }
+ defer rows.Close()
+
+ settings := []staticRoleSetting{}
+ for rows.Next() {
+ var setting staticRoleSetting
+ var values []string
+ if err := rows.Scan(&setting.database, &values); err != nil {
+ return nil, fmt.Errorf("scan static role settings for %s: %w", role, err)
+ }
+ setting.values = make(map[string]string, len(values))
+ for _, value := range values {
+ name, configuredValue, ok := strings.Cut(value, "=")
+ if !ok {
+ return nil, fmt.Errorf("static role %s has malformed setting %q", role, value)
+ }
+ setting.values[name] = configuredValue
+ }
+ settings = append(settings, setting)
+ }
+ if err := rows.Err(); err != nil {
+ return nil, fmt.Errorf("iterate static role settings for %s: %w", role, err)
+ }
+ return settings, nil
+}
+
+func staticRoleSettingsMatch(actual []staticRoleSetting, desired map[string]string) bool {
+ if len(desired) == 0 {
+ return len(actual) == 0
+ }
+ return len(actual) == 1 && actual[0].database == "" && mapsEqual(actual[0].values, desired)
+}
+
+func mapsEqual(left, right map[string]string) bool {
+ if len(left) != len(right) {
+ return false
+ }
+ for key, leftValue := range left {
+ if right[key] != leftValue {
+ return false
+ }
+ }
+ return true
+}
+
+func isMigrationOwnedStaticRole(role string) bool {
+ for _, contract := range staticRoleContracts() {
+ if contract.role == role {
+ return true
+ }
+ }
+ return false
+}
+
+func allowsImplicitCreatorAdminMembership(role, member, migrationOwner string, grant staticMembershipGrant) bool {
+ return isMigrationOwnedStaticRole(role) &&
+ member == migrationOwner &&
+ grant.grantor != migrationOwner &&
+ grant.grantorSuperuser &&
+ grant.admin &&
+ !grant.inherit &&
+ !grant.set
+}
+
+func readStaticMembershipGrants(ctx context.Context, transaction pgx.Tx, contract staticMembershipContract) ([]staticMembershipGrant, error) {
+ rows, err := transaction.Query(ctx, `
+ select grantor_role.rolname, grantor_role.rolsuper, membership.admin_option, membership.inherit_option, membership.set_option
+ from pg_auth_members as membership
+ join pg_roles as grantor_role on grantor_role.oid = membership.grantor
+ where membership.roleid = $1::regrole and membership.member = $2::regrole
+ order by grantor_role.rolname`, contract.role, contract.member)
+ if err != nil {
+ return nil, fmt.Errorf("read static role membership %s -> %s: %w", contract.role, contract.member, err)
+ }
+ defer rows.Close()
+
+ var grants []staticMembershipGrant
+ for rows.Next() {
+ var grant staticMembershipGrant
+ if err := rows.Scan(&grant.grantor, &grant.grantorSuperuser, &grant.admin, &grant.inherit, &grant.set); err != nil {
+ return nil, fmt.Errorf("scan static role membership %s -> %s: %w", contract.role, contract.member, err)
+ }
+ grants = append(grants, grant)
+ }
+ if err := rows.Err(); err != nil {
+ return nil, fmt.Errorf("iterate static role membership %s -> %s: %w", contract.role, contract.member, err)
+ }
+ return grants, nil
+}
+
+func reconcilePasswords(ctx context.Context, transaction pgx.Tx, credentials []credential) ([]credentialEvent, error) {
+ events := make([]credentialEvent, 0, len(credentials))
+ for _, credential := range credentials {
+ started := time.Now()
+ var quotedPassword string
+ if err := transaction.QueryRow(ctx, `select format('%L', $1::text)`, credential.Password).Scan(&quotedPassword); err != nil {
+ return nil, fmt.Errorf("quote password for role %s: %w", credential.Role, err)
+ }
+ if _, err := transaction.Exec(ctx, "alter role "+pgx.Identifier{credential.Role}.Sanitize()+" password "+quotedPassword); err != nil {
+ return nil, fmt.Errorf("reconcile password for role %s: %w", credential.Role, err)
+ }
+ events = append(events, credentialEvent{Role: credential.Role, DurationMS: time.Since(started).Milliseconds()})
+ }
+ return events, nil
+}
+
+func CurrentVersion(ctx context.Context, url string) (int64, error) {
+ connectionConfig, err := pgx.ParseConfig(url)
+ if err != nil {
+ return 0, errors.New("parse database URL")
+ }
+ connection, err := pgx.ConnectConfig(ctx, connectionConfig)
+ if err != nil {
+ return 0, fmt.Errorf("connect database%s", databaseTarget(connectionConfig))
+ }
+ defer connection.Close(ctx)
+
+ var version int64
+ err = connection.QueryRow(ctx, `select coalesce(max(version), 0) from cyclops_migrations.applied_migrations`).Scan(&version)
+ if err != nil {
+ var databaseError *pgconn.PgError
+ if errors.As(err, &databaseError) && (databaseError.Code == "42P01" || databaseError.Code == "3F000") {
+ return 0, nil
+ }
+ return 0, fmt.Errorf("read database schema version: %w", err)
+ }
+ return version, nil
+}
+
+func RequireVersion(ctx context.Context, url string, minimum int64) error {
+ current, err := CurrentVersion(ctx, url)
+ if err != nil {
+ return err
+ }
+ if current < minimum {
+ return fmt.Errorf("database schema version %d is older than required version %d", current, minimum)
+ }
+ return nil
+}
diff --git a/libs/fleet/backend/database/migrator_pg_test.go b/libs/fleet/backend/database/migrator_pg_test.go
new file mode 100644
index 0000000000..58571d5722
--- /dev/null
+++ b/libs/fleet/backend/database/migrator_pg_test.go
@@ -0,0 +1,1398 @@
+package database
+
+import (
+ "context"
+ "crypto/rand"
+ "encoding/hex"
+ "net/url"
+ "os"
+ "reflect"
+ "strings"
+ "testing"
+ "time"
+
+ "github.com/jackc/pgx/v5"
+)
+
+const migratorIntegrationOptIn = "CYCLOPS_TEST_DATABASE_MIGRATOR_ISOLATED_CLUSTER"
+
+const tenantCredentialFingerprintLookup = `select credential_fingerprint from k8s_state.query_tenant_role where role_name = $1`
+
+var staticMigrationRoles = []string{
+ "cyclops_app",
+ "k8s_state_owner",
+ "k8s_state_writer",
+ "k8s_state_exporter",
+ "k8s_query_tenant",
+ "k8s_query_admin",
+ "k8s_role_admin",
+ "k8s_reporting_owner",
+ "k8s_metabase",
+}
+
+func TestInitialMigrationBuildsCompleteDatabase(t *testing.T) {
+ maintenanceURL := os.Getenv("CYCLOPS_TEST_DATABASE_URL")
+ if maintenanceURL == "" {
+ t.Skip("set CYCLOPS_TEST_DATABASE_URL to run PostgreSQL migration tests")
+ }
+ if os.Getenv(migratorIntegrationOptIn) != "1" {
+ t.Skipf("set %s=1 to run against a dedicated empty PostgreSQL cluster", migratorIntegrationOptIn)
+ }
+
+ ctx := context.Background()
+ migrationURL, credentials := isolatedMigrationDatabase(t, ctx, maintenanceURL)
+ inspectionURL := maintenanceURLForDatabase(t, maintenanceURL, migrationURL)
+ assertMigrationOwnerFixture(t, ctx, migrationURL)
+ if err := Run(ctx, Config{MigrationURL: migrationURL, Credentials: credentials}); err != nil {
+ t.Fatal(err)
+ }
+ before := migrationLedgerRows(t, ctx, migrationURL)
+ if err := Run(ctx, Config{MigrationURL: migrationURL, Credentials: credentials}); err != nil {
+ t.Fatalf("second migration run must be a no-op: %v", err)
+ }
+ if after := migrationLedgerRows(t, ctx, migrationURL); !reflect.DeepEqual(after, before) {
+ t.Fatalf("second migration run changed migration ledger: before=%+v after=%+v", before, after)
+ }
+
+ assertRoleContract(t, ctx, migrationURL)
+ assertStaticCreatorAdminMemberships(t, ctx, migrationURL)
+ bootstrapGrantor := currentRole(t, ctx, maintenanceURL)
+ assertImplicitCreatorAdminMembership(t, ctx, migrationURL, "k8s_state_owner", bootstrapGrantor)
+ assertImplicitCreatorAdminMembership(t, ctx, migrationURL, "k8s_reporting_owner", bootstrapGrantor)
+ assertNoQueryBroker(t, ctx, migrationURL)
+ assertOwnershipAndPublicACLs(t, ctx, inspectionURL, currentRole(t, ctx, migrationURL))
+ assertRLSContract(t, ctx, inspectionURL)
+ assertSecurityDefinerContract(t, ctx, inspectionURL)
+ assertRuntimeLedgerAccess(t, ctx, credentials)
+
+ tenantRole := "k8s_tenant_" + testToken(t)[:12]
+ tenantPassword := testToken(t)
+ t.Cleanup(func() {
+ unregisterTenantRole(t, context.Background(), credentials.RoleAdmin, tenantRole)
+ dropRole(t, context.Background(), maintenanceURL, tenantRole)
+ })
+ tenantURL := createTenantRolePath(t, ctx, credentials.RoleAdmin, tenantRole, tenantPassword, "tenant-alice")
+ seedStateBoundaryData(t, ctx, inspectionURL)
+
+ assertWriterBoundary(t, ctx, credentials.Writer)
+ assertExporterBoundary(t, ctx, credentials.Exporter)
+ assertTenantReadPath(t, ctx, tenantURL)
+ assertMetabaseBoundary(t, ctx, credentials.Metabase)
+ assertApplicationBoundary(t, ctx, credentials.Application)
+}
+
+func TestRunReconcilesStaticRoleContractDrift(t *testing.T) {
+ maintenanceURL := os.Getenv("CYCLOPS_TEST_DATABASE_URL")
+ if maintenanceURL == "" {
+ t.Skip("set CYCLOPS_TEST_DATABASE_URL to run PostgreSQL migration tests")
+ }
+ if os.Getenv(migratorIntegrationOptIn) != "1" {
+ t.Skipf("set %s=1 to run against a dedicated empty PostgreSQL cluster", migratorIntegrationOptIn)
+ }
+
+ ctx := context.Background()
+ adminURL, credentials := isolatedMigrationDatabase(t, ctx, maintenanceURL)
+ if err := Run(ctx, Config{MigrationURL: adminURL, Credentials: credentials}); err != nil {
+ t.Fatal(err)
+ }
+ connection := connect(t, ctx, adminURL)
+ defer connection.Close(ctx)
+ if _, err := connection.Exec(ctx, `alter role cyclops_app createrole; grant k8s_query_tenant to k8s_role_admin with admin false, inherit true, set true`); err != nil {
+ t.Fatal("introduce static role contract drift")
+ }
+ if err := Run(ctx, Config{MigrationURL: adminURL, Credentials: credentials}); err != nil {
+ t.Fatal(err)
+ }
+ assertRoleContract(t, ctx, adminURL)
+}
+
+func TestRunFailsClosedForUnsafeStaticRoleAttributeDrift(t *testing.T) {
+ maintenanceURL := os.Getenv("CYCLOPS_TEST_DATABASE_URL")
+ if maintenanceURL == "" {
+ t.Skip("set CYCLOPS_TEST_DATABASE_URL to run PostgreSQL migration tests")
+ }
+ if os.Getenv(migratorIntegrationOptIn) != "1" {
+ t.Skipf("set %s=1 to run against a dedicated empty PostgreSQL cluster", migratorIntegrationOptIn)
+ }
+
+ ctx := context.Background()
+ migrationURL, credentials := isolatedMigrationDatabase(t, ctx, maintenanceURL)
+ if err := Run(ctx, Config{MigrationURL: migrationURL, Credentials: credentials}); err != nil {
+ t.Fatal(err)
+ }
+ maintenance := connect(t, ctx, maintenanceURL)
+ defer maintenance.Close(ctx)
+ if _, err := maintenance.Exec(ctx, `alter role cyclops_app superuser`); err != nil {
+ t.Fatal("introduce unsafe static role drift")
+ }
+
+ err := Run(ctx, Config{MigrationURL: migrationURL, Credentials: credentials})
+ if err == nil || !strings.Contains(err.Error(), "unsafe privileged drift") || !strings.Contains(err.Error(), "rolsuper=true") {
+ t.Fatalf("Run() error = %v, want unsafe rolsuper drift fail-closed error", err)
+ }
+}
+
+func TestRunFailsClosedForStaticRoleCreateDBDrift(t *testing.T) {
+ maintenanceURL := os.Getenv("CYCLOPS_TEST_DATABASE_URL")
+ if maintenanceURL == "" {
+ t.Skip("set CYCLOPS_TEST_DATABASE_URL to run PostgreSQL migration tests")
+ }
+ if os.Getenv(migratorIntegrationOptIn) != "1" {
+ t.Skipf("set %s=1 to run against a dedicated empty PostgreSQL cluster", migratorIntegrationOptIn)
+ }
+
+ ctx := context.Background()
+ migrationURL, credentials := isolatedMigrationDatabase(t, ctx, maintenanceURL)
+ if err := Run(ctx, Config{MigrationURL: migrationURL, Credentials: credentials}); err != nil {
+ t.Fatal(err)
+ }
+ maintenance := connect(t, ctx, maintenanceURL)
+ defer maintenance.Close(ctx)
+ if _, err := maintenance.Exec(ctx, `alter role cyclops_app nologin createdb`); err != nil {
+ t.Fatal("introduce static role createdb drift")
+ }
+
+ err := Run(ctx, Config{MigrationURL: migrationURL, Credentials: credentials})
+ const want = "static role cyclops_app has unsafe privileged drift: rolcreatedb=true; the migration owner cannot safely repair these attributes"
+ if err == nil || err.Error() != want {
+ t.Fatalf("Run() error = %v, want %q", err, want)
+ }
+
+ var login, createDB bool
+ if err := maintenance.QueryRow(ctx, `select rolcanlogin, rolcreatedb from pg_roles where rolname = 'cyclops_app'`).Scan(&login, &createDB); err != nil {
+ t.Fatal("read static role after rejected createdb drift")
+ }
+ if login || !createDB {
+ t.Fatalf("static role changed after rejected createdb drift: login:%t createdb:%t", login, createDB)
+ }
+}
+
+func TestRunFailsClosedForForeignGrantorMembership(t *testing.T) {
+ maintenanceURL := os.Getenv("CYCLOPS_TEST_DATABASE_URL")
+ if maintenanceURL == "" {
+ t.Skip("set CYCLOPS_TEST_DATABASE_URL to run PostgreSQL migration tests")
+ }
+ if os.Getenv(migratorIntegrationOptIn) != "1" {
+ t.Skipf("set %s=1 to run against a dedicated empty PostgreSQL cluster", migratorIntegrationOptIn)
+ }
+
+ ctx := context.Background()
+ adminURL, credentials := isolatedMigrationDatabase(t, ctx, maintenanceURL)
+ if err := Run(ctx, Config{MigrationURL: adminURL, Credentials: credentials}); err != nil {
+ t.Fatal(err)
+ }
+ foreignGrantor := "foreign_grantor_" + testToken(t)[:12]
+ connection := connect(t, ctx, adminURL)
+ defer connection.Close(ctx)
+ maintenance := connect(t, ctx, maintenanceURL)
+ t.Cleanup(func() { maintenance.Close(context.Background()) })
+ foreignIdentifier := pgx.Identifier{foreignGrantor}.Sanitize()
+ t.Cleanup(func() {
+ cleanupCtx := context.Background()
+ if _, err := maintenance.Exec(cleanupCtx, "revoke k8s_query_tenant from k8s_role_admin granted by "+foreignIdentifier+" restrict"); err != nil {
+ t.Errorf("revoke foreign-grantor static membership: %v", err)
+ }
+ if _, err := maintenance.Exec(cleanupCtx, "revoke k8s_query_tenant from "+foreignIdentifier+" restrict"); err != nil {
+ t.Errorf("revoke foreign-grantor admin membership: %v", err)
+ }
+ dropRole(t, cleanupCtx, maintenanceURL, foreignGrantor)
+ })
+ if _, err := maintenance.Exec(ctx, "create role "+foreignIdentifier); err != nil {
+ t.Fatal("create foreign grantor role")
+ }
+ if _, err := maintenance.Exec(ctx, "grant k8s_query_tenant to "+foreignIdentifier+" with admin true, inherit false, set false"); err != nil {
+ t.Fatal("grant query tenant admin to foreign grantor")
+ }
+ if _, err := maintenance.Exec(ctx, "set role "+foreignIdentifier); err != nil {
+ t.Fatal("set foreign grantor role")
+ }
+ if _, err := maintenance.Exec(ctx, `grant k8s_query_tenant to k8s_role_admin with admin true, inherit false, set false`); err != nil {
+ t.Fatal("create foreign-grantor static membership")
+ }
+ if _, err := maintenance.Exec(ctx, `reset role`); err != nil {
+ t.Fatal("reset foreign grantor role")
+ }
+
+ var membershipGrantCount, foreignGrantCount int
+ if err := connection.QueryRow(ctx, `
+ select count(*), count(*) filter (where grantor_role.rolname = $1)
+ from pg_auth_members as membership
+ join pg_roles as grantor_role on grantor_role.oid = membership.grantor
+ where membership.roleid = 'k8s_query_tenant'::regrole
+ and membership.member = 'k8s_role_admin'::regrole`, foreignGrantor).Scan(&membershipGrantCount, &foreignGrantCount); err != nil || membershipGrantCount != 2 || foreignGrantCount != 1 {
+ t.Fatalf("static membership grantor rows = total:%d foreign:%d err=%v, want total:2 foreign:1", membershipGrantCount, foreignGrantCount, err)
+ }
+
+ err := Run(ctx, Config{MigrationURL: adminURL, Credentials: credentials})
+ if err == nil || !strings.Contains(err.Error(), "has grantor") {
+ t.Fatalf("Run() error = %v, want foreign-grantor fail-closed error", err)
+ }
+}
+
+func TestRunFailsClosedForNonSuperuserStaticCreatorAdminGrantor(t *testing.T) {
+ maintenanceURL := requireMigratorIntegration(t)
+ ctx := context.Background()
+ migrationURL, credentials := isolatedMigrationDatabase(t, ctx, maintenanceURL)
+ if err := Run(ctx, Config{MigrationURL: migrationURL, Credentials: credentials}); err != nil {
+ t.Fatal(err)
+ }
+
+ connection := connect(t, ctx, migrationURL)
+ defer connection.Close(ctx)
+ maintenance := connect(t, ctx, maintenanceURL)
+ defer maintenance.Close(ctx)
+ foreignGrantor := "foreign_creator_" + testToken(t)[:12]
+ foreignIdentifier := pgx.Identifier{foreignGrantor}.Sanitize()
+ migrationOwner := currentRole(t, ctx, migrationURL)
+ migrationOwnerIdentifier := pgx.Identifier{migrationOwner}.Sanitize()
+ if _, err := maintenance.Exec(ctx, "create role "+foreignIdentifier); err != nil {
+ t.Fatal("create non-superuser foreign grantor")
+ }
+ if _, err := maintenance.Exec(ctx, "grant k8s_state_owner to "+foreignIdentifier+" with admin true, inherit false, set false"); err != nil {
+ t.Fatal("grant static role admin to foreign grantor")
+ }
+ if _, err := maintenance.Exec(ctx, "set role "+foreignIdentifier); err != nil {
+ t.Fatal("set non-superuser foreign grantor")
+ }
+ if _, err := maintenance.Exec(ctx, "grant k8s_state_owner to "+migrationOwnerIdentifier+" with admin true, inherit false, set false"); err != nil {
+ t.Fatal("create non-superuser creator-shaped membership")
+ }
+ if _, err := maintenance.Exec(ctx, `reset role`); err != nil {
+ t.Fatal("reset non-superuser foreign grantor")
+ }
+ if _, err := maintenance.Exec(ctx, `alter role cyclops_app inherit`); err != nil {
+ t.Fatal("introduce static role repair sentinel")
+ }
+
+ assertRunFailsBeforeStaticRoleRepair(t, ctx, migrationURL, credentials, "true PostgreSQL superuser")
+}
+
+func TestRunFailsClosedForRegisteredTenantMembershipDrift(t *testing.T) {
+ maintenanceURL := requireMigratorIntegration(t)
+ ctx := context.Background()
+
+ for _, testCase := range []struct {
+ name string
+ introduce func(t *testing.T, maintenanceURL string, credentials CredentialURLs, tenantRole string)
+ }{
+ {
+ name: "arbitrary inbound member",
+ introduce: func(t *testing.T, _ string, credentials CredentialURLs, tenantRole string) {
+ connection := connect(t, context.Background(), credentials.RoleAdmin)
+ defer connection.Close(context.Background())
+ arbitraryMember := pgx.Identifier{"arbitrary_tenant_member_" + testToken(t)[:12]}.Sanitize()
+ if _, err := connection.Exec(context.Background(), "create role "+arbitraryMember); err != nil {
+ t.Fatal("create arbitrary tenant member")
+ }
+ if _, err := connection.Exec(context.Background(), "grant "+pgx.Identifier{tenantRole}.Sanitize()+" to "+arbitraryMember+" with admin false, inherit true, set false"); err != nil {
+ t.Fatal("grant registered tenant to arbitrary member")
+ }
+ },
+ },
+ {
+ name: "extra parent role",
+ introduce: func(t *testing.T, maintenanceURL string, _ CredentialURLs, tenantRole string) {
+ connection := connect(t, context.Background(), maintenanceURL)
+ defer connection.Close(context.Background())
+ if _, err := connection.Exec(context.Background(), "grant pg_read_all_data to "+pgx.Identifier{tenantRole}.Sanitize()+" with admin false, inherit true, set false"); err != nil {
+ t.Fatal("grant pg_read_all_data to registered tenant")
+ }
+ },
+ },
+ } {
+ t.Run(testCase.name, func(t *testing.T) {
+ migrationURL, credentials := isolatedMigrationDatabase(t, ctx, maintenanceURL)
+ if err := Run(ctx, Config{MigrationURL: migrationURL, Credentials: credentials}); err != nil {
+ t.Fatal(err)
+ }
+ tenantRole := "k8s_tenant_" + testToken(t)[:32]
+ t.Cleanup(func() {
+ unregisterTenantRole(t, context.Background(), credentials.RoleAdmin, tenantRole)
+ dropRole(t, context.Background(), maintenanceURL, tenantRole)
+ })
+ createTenantRolePath(t, ctx, credentials.RoleAdmin, tenantRole, testToken(t), "tenant-registered")
+ testCase.introduce(t, maintenanceURL, credentials, tenantRole)
+
+ connection := connect(t, ctx, migrationURL)
+ defer connection.Close(ctx)
+ if _, err := connection.Exec(ctx, `alter role cyclops_app inherit`); err != nil {
+ t.Fatal("introduce static role repair sentinel")
+ }
+ assertRunFailsBeforeStaticRoleRepair(t, ctx, migrationURL, credentials, "registered tenant")
+ })
+ }
+}
+
+func TestRunFailsClosedForUnexpectedExclusiveStaticRoleMember(t *testing.T) {
+ maintenanceURL := os.Getenv("CYCLOPS_TEST_DATABASE_URL")
+ if maintenanceURL == "" {
+ t.Skip("set CYCLOPS_TEST_DATABASE_URL to run PostgreSQL migration tests")
+ }
+ if os.Getenv(migratorIntegrationOptIn) != "1" {
+ t.Skipf("set %s=1 to run against a dedicated empty PostgreSQL cluster", migratorIntegrationOptIn)
+ }
+
+ ctx := context.Background()
+ adminURL, credentials := isolatedMigrationDatabase(t, ctx, maintenanceURL)
+ if err := Run(ctx, Config{MigrationURL: adminURL, Credentials: credentials}); err != nil {
+ t.Fatal(err)
+ }
+ unexpectedMember := "unexpected_member_" + testToken(t)[:12]
+ connection := connect(t, ctx, adminURL)
+ defer connection.Close(ctx)
+ t.Cleanup(func() { dropRole(t, context.Background(), adminURL, unexpectedMember) })
+ memberIdentifier := pgx.Identifier{unexpectedMember}.Sanitize()
+ if _, err := connection.Exec(ctx, "create role "+memberIdentifier); err != nil {
+ t.Fatal("create unexpected member role")
+ }
+ if _, err := connection.Exec(ctx, "grant k8s_query_admin to "+memberIdentifier); err != nil {
+ t.Fatal("create unexpected exclusive static membership")
+ }
+
+ err := Run(ctx, Config{MigrationURL: adminURL, Credentials: credentials})
+ if err == nil || !strings.Contains(err.Error(), "static role k8s_query_admin has unexpected members") {
+ t.Fatalf("Run() error = %v, want unexpected-member fail-closed error", err)
+ }
+}
+
+func TestRunFailsClosedForUnexpectedStaticRoleMembers(t *testing.T) {
+ maintenanceURL := requireMigratorIntegration(t)
+ ctx := context.Background()
+
+ for _, role := range []string{"cyclops_app", "k8s_state_writer"} {
+ t.Run(role, func(t *testing.T) {
+ migrationURL, credentials := isolatedMigrationDatabase(t, ctx, maintenanceURL)
+ if err := Run(ctx, Config{MigrationURL: migrationURL, Credentials: credentials}); err != nil {
+ t.Fatal(err)
+ }
+
+ connection := connect(t, ctx, migrationURL)
+ defer connection.Close(ctx)
+ attacker := "unexpected_member_" + testToken(t)[:12]
+ attackerIdentifier := pgx.Identifier{attacker}.Sanitize()
+ t.Cleanup(func() { dropRole(t, context.Background(), maintenanceURL, attacker) })
+ if _, err := connection.Exec(ctx, "create role "+attackerIdentifier); err != nil {
+ t.Fatal("create unexpected static role member")
+ }
+ if _, err := connection.Exec(ctx, "grant "+pgx.Identifier{role}.Sanitize()+" to "+attackerIdentifier); err != nil {
+ t.Fatal("grant unexpected static role membership")
+ }
+ if _, err := connection.Exec(ctx, `alter role cyclops_app inherit`); err != nil {
+ t.Fatal("introduce repairable role drift")
+ }
+
+ err := Run(ctx, Config{MigrationURL: migrationURL, Credentials: credentials})
+ if err == nil || !strings.Contains(err.Error(), "static role "+role+" has unexpected members") {
+ t.Fatalf("Run() error = %v, want unexpected-member fail-closed error", err)
+ }
+ var inherit bool
+ if err := connection.QueryRow(ctx, `select rolinherit from pg_roles where rolname = 'cyclops_app'`).Scan(&inherit); err != nil {
+ t.Fatal("read role after rejected membership drift")
+ }
+ if !inherit {
+ t.Fatal("role reconciliation changed a role before rejecting membership drift")
+ }
+ })
+ }
+}
+
+func TestRunFailsClosedForUnexpectedStaticRoleParent(t *testing.T) {
+ maintenanceURL := requireMigratorIntegration(t)
+ ctx := context.Background()
+ migrationURL, credentials := isolatedMigrationDatabase(t, ctx, maintenanceURL)
+ if err := Run(ctx, Config{MigrationURL: migrationURL, Credentials: credentials}); err != nil {
+ t.Fatal(err)
+ }
+
+ maintenance := connect(t, ctx, maintenanceURL)
+ t.Cleanup(func() {
+ cleanupConnection := connect(t, context.Background(), maintenanceURL)
+ defer cleanupConnection.Close(context.Background())
+ if _, err := cleanupConnection.Exec(context.Background(), `revoke pg_read_all_data from k8s_metabase restrict`); err != nil {
+ t.Errorf("revoke unexpected static role parent: %v", err)
+ }
+ })
+ defer maintenance.Close(ctx)
+ if _, err := maintenance.Exec(ctx, `grant pg_read_all_data to k8s_metabase`); err != nil {
+ t.Fatal("grant unexpected static role parent")
+ }
+
+ connection := connect(t, ctx, migrationURL)
+ defer connection.Close(ctx)
+ if _, err := connection.Exec(ctx, `alter role cyclops_app inherit`); err != nil {
+ t.Fatal("introduce repairable role drift")
+ }
+ err := Run(ctx, Config{MigrationURL: migrationURL, Credentials: credentials})
+ if err == nil || !strings.Contains(err.Error(), "static role k8s_metabase has unexpected parent roles pg_read_all_data") {
+ t.Fatalf("Run() error = %v, want unexpected-parent fail-closed error", err)
+ }
+ var inherit bool
+ if err := connection.QueryRow(ctx, `select rolinherit from pg_roles where rolname = 'cyclops_app'`).Scan(&inherit); err != nil {
+ t.Fatal("read role after rejected parent drift")
+ }
+ if !inherit {
+ t.Fatal("role reconciliation changed a role before rejecting parent drift")
+ }
+}
+
+func TestRunAllowsRegisteredDynamicTenantMembership(t *testing.T) {
+ maintenanceURL := requireMigratorIntegration(t)
+ ctx := context.Background()
+ migrationURL, credentials := isolatedMigrationDatabase(t, ctx, maintenanceURL)
+ if err := Run(ctx, Config{MigrationURL: migrationURL, Credentials: credentials}); err != nil {
+ t.Fatal(err)
+ }
+
+ tenantRole := "k8s_tenant_" + testToken(t)[:32]
+ t.Cleanup(func() {
+ unregisterTenantRole(t, context.Background(), credentials.RoleAdmin, tenantRole)
+ dropRole(t, context.Background(), maintenanceURL, tenantRole)
+ })
+ createTenantRolePath(t, ctx, credentials.RoleAdmin, tenantRole, testToken(t), "tenant-registered")
+ assertRegisteredTenantCreatorAdminMembership(t, ctx, migrationURL, tenantRole)
+ if err := Run(ctx, Config{MigrationURL: migrationURL, Credentials: credentials}); err != nil {
+ t.Fatalf("registered dynamic tenant membership must remain allowed: %v", err)
+ }
+}
+
+func TestRunFailsClosedForUnregisteredDynamicTenantMembership(t *testing.T) {
+ maintenanceURL := requireMigratorIntegration(t)
+ ctx := context.Background()
+ migrationURL, credentials := isolatedMigrationDatabase(t, ctx, maintenanceURL)
+ if err := Run(ctx, Config{MigrationURL: migrationURL, Credentials: credentials}); err != nil {
+ t.Fatal(err)
+ }
+
+ connection := connect(t, ctx, migrationURL)
+ defer connection.Close(ctx)
+ tenantRole := "k8s_tenant_" + testToken(t)[:32]
+ tenantIdentifier := pgx.Identifier{tenantRole}.Sanitize()
+ t.Cleanup(func() { dropRole(t, context.Background(), maintenanceURL, tenantRole) })
+ if _, err := connection.Exec(ctx, "create role "+tenantIdentifier+" login inherit nocreaterole nocreatedb noreplication nobypassrls nosuperuser"); err != nil {
+ t.Fatal("create unregistered tenant role")
+ }
+ if _, err := connection.Exec(ctx, "grant k8s_query_tenant to "+tenantIdentifier+" with admin false, inherit true, set false"); err != nil {
+ t.Fatal("grant unregistered tenant membership")
+ }
+ err := Run(ctx, Config{MigrationURL: migrationURL, Credentials: credentials})
+ if err == nil || !strings.Contains(err.Error(), "k8s_query_tenant has unregistered dynamic tenant member") {
+ t.Fatalf("Run() error = %v, want unregistered-tenant fail-closed error", err)
+ }
+}
+
+func TestRunReconcilesStaticRoleAvailabilityContract(t *testing.T) {
+ maintenanceURL := requireMigratorIntegration(t)
+ ctx := context.Background()
+ migrationURL, credentials := isolatedMigrationDatabase(t, ctx, maintenanceURL)
+ if err := Run(ctx, Config{MigrationURL: migrationURL, Credentials: credentials}); err != nil {
+ t.Fatal(err)
+ }
+
+ connection := connect(t, ctx, migrationURL)
+ defer connection.Close(ctx)
+ if _, err := connection.Exec(ctx, `alter role cyclops_app connection limit 1 valid until '2000-01-01 00:00:00+00'`); err != nil {
+ t.Fatal("introduce static role availability drift")
+ }
+ if err := Run(ctx, Config{MigrationURL: migrationURL, Credentials: credentials}); err != nil {
+ t.Fatalf("reconcile static role availability drift: %v", err)
+ }
+ var connectionLimit int
+ var validUntil string
+ if err := connection.QueryRow(ctx, `select rolconnlimit, coalesce(rolvaliduntil::text, 'infinity') from pg_roles where rolname = 'cyclops_app'`).Scan(&connectionLimit, &validUntil); err != nil {
+ t.Fatal("read reconciled static role availability")
+ }
+ if connectionLimit != -1 || validUntil != "infinity" {
+ t.Fatalf("static role availability = connection_limit:%d valid_until:%q, want connection_limit:-1 valid_until:infinity", connectionLimit, validUntil)
+ }
+}
+
+func TestRunReconcilesStaticRoleSettingsContract(t *testing.T) {
+ maintenanceURL := requireMigratorIntegration(t)
+ ctx := context.Background()
+ migrationURL, credentials := isolatedMigrationDatabase(t, ctx, maintenanceURL)
+ if err := Run(ctx, Config{MigrationURL: migrationURL, Credentials: credentials}); err != nil {
+ t.Fatal(err)
+ }
+
+ connection := connect(t, ctx, migrationURL)
+ defer connection.Close(ctx)
+ for _, statement := range []string{
+ `alter role k8s_metabase set default_transaction_read_only = off`,
+ `alter role k8s_metabase set search_path = public`,
+ `alter role k8s_metabase in database ` + pgx.Identifier{connection.Config().Database}.Sanitize() + ` set work_mem = '64MB'`,
+ } {
+ if _, err := connection.Exec(ctx, statement); err != nil {
+ t.Fatalf("introduce static role setting drift %q: %v", statement, err)
+ }
+ }
+ if err := Run(ctx, Config{MigrationURL: migrationURL, Credentials: credentials}); err != nil {
+ t.Fatalf("reconcile static role setting drift: %v", err)
+ }
+ assertStaticRoleSettings(t, ctx, connection, "k8s_metabase", map[string]string{
+ "default_transaction_read_only": "on",
+ "statement_timeout": "20000ms",
+ "idle_in_transaction_session_timeout": "20000ms",
+ })
+ for _, role := range staticMigrationRoles {
+ if role == "k8s_metabase" {
+ continue
+ }
+ assertStaticRoleSettings(t, ctx, connection, role, map[string]string{})
+ }
+}
+
+func requireMigratorIntegration(t *testing.T) string {
+ t.Helper()
+ maintenanceURL := os.Getenv("CYCLOPS_TEST_DATABASE_URL")
+ if maintenanceURL == "" {
+ t.Skip("set CYCLOPS_TEST_DATABASE_URL to run PostgreSQL migration tests")
+ }
+ if os.Getenv(migratorIntegrationOptIn) != "1" {
+ t.Skipf("set %s=1 to run against a dedicated empty PostgreSQL cluster", migratorIntegrationOptIn)
+ }
+ return maintenanceURL
+}
+
+func assertRegisteredTenantCreatorAdminMembership(t *testing.T, ctx context.Context, migrationURL, tenantRole string) {
+ t.Helper()
+ connection := connect(t, ctx, migrationURL)
+ defer connection.Close(ctx)
+ rows, err := connection.Query(ctx, `
+ select grantor_role.rolname, membership.admin_option, membership.inherit_option, membership.set_option
+ from pg_auth_members as membership
+ join pg_roles as grantor_role on grantor_role.oid = membership.grantor
+ where membership.roleid = $1::regrole and membership.member = 'k8s_role_admin'::regrole
+ order by grantor_role.rolname`, tenantRole)
+ if err != nil {
+ t.Fatalf("read tenant creator-admin membership: %v", err)
+ }
+ defer rows.Close()
+
+ count := 0
+ for rows.Next() {
+ var grantor string
+ var admin, inherit, set bool
+ if err := rows.Scan(&grantor, &admin, &inherit, &set); err != nil {
+ t.Fatalf("scan tenant creator-admin membership: %v", err)
+ }
+ if grantor == "k8s_role_admin" || !admin || inherit || set {
+ t.Fatalf("tenant creator-admin membership = grantor:%s admin:%t inherit:%t set:%t, want foreign grantor and admin:true inherit:false set:false", grantor, admin, inherit, set)
+ }
+ count++
+ }
+ if err := rows.Err(); err != nil {
+ t.Fatalf("iterate tenant creator-admin membership: %v", err)
+ }
+ if count == 0 {
+ t.Fatal("registered tenant is missing its PG16 creator-admin membership for k8s_role_admin")
+ }
+}
+
+func assertStaticRoleSettings(t *testing.T, ctx context.Context, connection *pgx.Conn, role string, want map[string]string) {
+ t.Helper()
+ rows, err := connection.Query(ctx, `
+ select setting.setdatabase, setting.setconfig
+ from pg_db_role_setting as setting
+ join pg_roles as configured_role on configured_role.oid = setting.setrole
+ where configured_role.rolname = $1
+ order by setting.setdatabase`, role)
+ if err != nil {
+ t.Fatalf("read role settings for %s: %v", role, err)
+ }
+ defer rows.Close()
+
+ got := map[string]string{}
+ for rows.Next() {
+ var databaseOID uint32
+ var settings []string
+ if err := rows.Scan(&databaseOID, &settings); err != nil {
+ t.Fatalf("scan role settings for %s: %v", role, err)
+ }
+ if databaseOID != 0 {
+ t.Fatalf("role %s has database-specific settings for database OID %d: %v", role, databaseOID, settings)
+ }
+ for _, setting := range settings {
+ name, value, ok := strings.Cut(setting, "=")
+ if !ok {
+ t.Fatalf("role %s has malformed setting %q", role, setting)
+ }
+ got[name] = value
+ }
+ }
+ if err := rows.Err(); err != nil {
+ t.Fatalf("iterate role settings for %s: %v", role, err)
+ }
+ if !reflect.DeepEqual(got, want) {
+ t.Fatalf("role %s settings = %#v, want %#v", role, got, want)
+ }
+}
+
+type ledgerRow struct {
+ Version int64
+ ApplicationOrder int64
+ Filename string
+ SHA256 string
+ AppliedAt time.Time
+}
+
+func isolatedMigrationDatabase(t *testing.T, ctx context.Context, maintenanceURL string) (string, CredentialURLs) {
+ t.Helper()
+ parsed, err := url.Parse(maintenanceURL)
+ if err != nil {
+ t.Fatal("parse CYCLOPS_TEST_DATABASE_URL")
+ }
+ if parsed.Scheme != "postgres" && parsed.Scheme != "postgresql" {
+ t.Fatal("CYCLOPS_TEST_DATABASE_URL must be a PostgreSQL URL")
+ }
+ if parsed.Path != "/postgres" {
+ t.Fatalf("%s=1 requires CYCLOPS_TEST_DATABASE_URL to use the /postgres maintenance database", migratorIntegrationOptIn)
+ }
+
+ maintenance, err := pgx.Connect(ctx, maintenanceURL)
+ if err != nil {
+ t.Fatal("connect maintenance database")
+ }
+ if _, err := maintenance.Exec(ctx, `select pg_advisory_lock(hashtext($1))`, "cyclops-database-migrator-integration"); err != nil {
+ maintenance.Close(ctx)
+ t.Fatal("lock migration integration setup")
+ }
+
+ var existingDatabases []string
+ if err := maintenance.QueryRow(ctx, `
+ select coalesce(array_agg(datname order by datname), '{}')
+ from pg_database
+ where datallowconn and not datistemplate and datname <> 'postgres'`).Scan(&existingDatabases); err != nil {
+ maintenance.Close(ctx)
+ t.Fatal("verify isolated PostgreSQL cluster databases")
+ }
+ if len(existingDatabases) != 0 {
+ maintenance.Close(ctx)
+ t.Fatalf("%s=1 requires an empty PostgreSQL cluster; found connectable databases: %s", migratorIntegrationOptIn, strings.Join(existingDatabases, ", "))
+ }
+
+ var existing []string
+ if err := maintenance.QueryRow(ctx, `select coalesce(array_agg(rolname order by rolname), '{}') from pg_roles where rolname = any($1)`, staticMigrationRoles).Scan(&existing); err != nil {
+ maintenance.Close(ctx)
+ t.Fatal("check static migration roles")
+ }
+ if len(existing) != 0 {
+ maintenance.Close(ctx)
+ t.Fatalf("%s=1 requires no pre-existing static migration roles; found: %s", migratorIntegrationOptIn, strings.Join(existing, ", "))
+ }
+
+ migrationOwner := "cyclops_migrator_" + testToken(t)[:12]
+ migrationPassword := testToken(t)
+ migrationOwnerIdentifier := pgx.Identifier{migrationOwner}.Sanitize()
+ if _, err := maintenance.Exec(ctx, "create role "+migrationOwnerIdentifier+" login createrole password "+quoteLiteral(migrationPassword)); err != nil {
+ maintenance.Close(ctx)
+ t.Fatal("create isolated migration owner")
+ }
+
+ databaseName := "cyclops_migrate_" + testToken(t)[:16]
+ if _, err := maintenance.Exec(ctx, "create database "+pgx.Identifier{databaseName}.Sanitize()+" owner "+migrationOwnerIdentifier); err != nil {
+ maintenance.Close(ctx)
+ t.Fatal("create isolated migration database")
+ }
+ t.Cleanup(func() {
+ cleanupCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+ defer cancel()
+ if _, err := maintenance.Exec(cleanupCtx, "drop database if exists "+pgx.Identifier{databaseName}.Sanitize()+" with (force)"); err != nil {
+ t.Errorf("drop isolated migration database: %v", err)
+ }
+ for _, role := range staticMigrationRoles {
+ if _, err := maintenance.Exec(cleanupCtx, "drop role if exists "+pgx.Identifier{role}.Sanitize()); err != nil {
+ t.Errorf("drop static migration role %s: %v", role, err)
+ }
+ }
+ if _, err := maintenance.Exec(cleanupCtx, "drop role if exists "+migrationOwnerIdentifier); err != nil {
+ t.Errorf("drop isolated migration owner: %v", err)
+ }
+ maintenance.Close(cleanupCtx)
+ })
+
+ parsed.Path = "/" + databaseName
+ parsed.RawPath = ""
+ parsed.User = url.UserPassword(migrationOwner, migrationPassword)
+ migrationURL := parsed.String()
+ return migrationURL, testCredentialURLs(t, migrationURL)
+}
+
+func maintenanceURLForDatabase(t *testing.T, maintenanceURL, databaseURL string) string {
+ t.Helper()
+ maintenance, err := url.Parse(maintenanceURL)
+ if err != nil {
+ t.Fatal("parse maintenance database URL")
+ }
+ database, err := url.Parse(databaseURL)
+ if err != nil {
+ t.Fatal("parse migration database URL")
+ }
+ maintenance.Path = database.Path
+ maintenance.RawPath = database.RawPath
+ return maintenance.String()
+}
+
+func quoteLiteral(value string) string {
+ return "'" + strings.ReplaceAll(value, "'", "''") + "'"
+}
+
+func testCredentialURLs(t *testing.T, adminURL string) CredentialURLs {
+ t.Helper()
+ parsed, err := url.Parse(adminURL)
+ if err != nil {
+ t.Fatal("parse migration database URL")
+ }
+ withRole := func(role string) string {
+ copy := *parsed
+ copy.User = url.UserPassword(role, testToken(t))
+ return copy.String()
+ }
+ return CredentialURLs{
+ Application: withRole("cyclops_app"),
+ Writer: withRole("k8s_state_writer"),
+ Exporter: withRole("k8s_state_exporter"),
+ RoleAdmin: withRole("k8s_role_admin"),
+ Metabase: withRole("k8s_metabase"),
+ }
+}
+
+func testToken(t *testing.T) string {
+ t.Helper()
+ bytes := make([]byte, 16)
+ if _, err := rand.Read(bytes); err != nil {
+ t.Fatal("generate test database token")
+ }
+ return hex.EncodeToString(bytes)
+}
+
+func migrationLedgerRows(t *testing.T, ctx context.Context, adminURL string) []ledgerRow {
+ t.Helper()
+ connection := connect(t, ctx, adminURL)
+ defer connection.Close(ctx)
+ rows, err := connection.Query(ctx, `select version, application_order, filename, sha256, applied_at from cyclops_migrations.applied_migrations order by application_order`)
+ if err != nil {
+ t.Fatal("read migration ledger")
+ }
+ defer rows.Close()
+ var ledger []ledgerRow
+ for rows.Next() {
+ var row ledgerRow
+ if err := rows.Scan(&row.Version, &row.ApplicationOrder, &row.Filename, &row.SHA256, &row.AppliedAt); err != nil {
+ t.Fatal("scan migration ledger")
+ }
+ ledger = append(ledger, row)
+ }
+ if err := rows.Err(); err != nil {
+ t.Fatal("iterate migration ledger")
+ }
+ if len(ledger) != 1 {
+ t.Fatalf("migration ledger row count = %d, want 1", len(ledger))
+ }
+ return ledger
+}
+
+func assertMigrationOwnerFixture(t *testing.T, ctx context.Context, migrationURL string) {
+ t.Helper()
+ connection := connect(t, ctx, migrationURL)
+ defer connection.Close(ctx)
+ var createRole, super bool
+ if err := connection.QueryRow(ctx, `select rolcreaterole, rolsuper from pg_roles where rolname = current_user`).Scan(&createRole, &super); err != nil {
+ t.Fatal("read isolated migration owner attributes")
+ }
+ if !createRole || super {
+ t.Fatalf("isolated migration owner attributes = createrole:%t super:%t, want createrole:true super:false", createRole, super)
+ }
+}
+
+func currentRole(t *testing.T, ctx context.Context, databaseURL string) string {
+ t.Helper()
+ connection := connect(t, ctx, databaseURL)
+ defer connection.Close(ctx)
+ var role string
+ if err := connection.QueryRow(ctx, `select current_user`).Scan(&role); err != nil {
+ t.Fatal("read current database role")
+ }
+ return role
+}
+
+func assertStaticCreatorAdminMemberships(t *testing.T, ctx context.Context, migrationURL string) {
+ t.Helper()
+ connection := connect(t, ctx, migrationURL)
+ defer connection.Close(ctx)
+ migrationOwner := currentRole(t, ctx, migrationURL)
+ for _, role := range staticMigrationRoles {
+ rows, err := connection.Query(ctx, `
+ select grantor_role.rolname, grantor_role.rolsuper, membership.admin_option, membership.inherit_option, membership.set_option
+ from pg_auth_members as membership
+ join pg_roles as grantor_role on grantor_role.oid = membership.grantor
+ where membership.roleid = $1::regrole and membership.member = current_user::regrole
+ order by grantor_role.rolname`, role)
+ if err != nil {
+ t.Fatalf("read static creator memberships for %s: %v", role, err)
+ }
+ var grants []staticMembershipGrant
+ for rows.Next() {
+ var grant staticMembershipGrant
+ if err := rows.Scan(&grant.grantor, &grant.grantorSuperuser, &grant.admin, &grant.inherit, &grant.set); err != nil {
+ rows.Close()
+ t.Fatalf("scan static creator membership for %s: %v", role, err)
+ }
+ grants = append(grants, grant)
+ }
+ if err := rows.Err(); err != nil {
+ rows.Close()
+ t.Fatalf("iterate static creator memberships for %s: %v", role, err)
+ }
+ rows.Close()
+ allowOwnerGrant := role == "k8s_state_owner" || role == "k8s_reporting_owner"
+ if !staticCreatorAdminMembershipsAreExact(migrationOwner, grants, allowOwnerGrant) {
+ t.Fatalf("static creator memberships for %s = %+v", role, grants)
+ }
+ }
+}
+
+func assertImplicitCreatorAdminMembership(t *testing.T, ctx context.Context, migrationURL, role, bootstrapGrantor string) {
+ t.Helper()
+ connection := connect(t, ctx, migrationURL)
+ defer connection.Close(ctx)
+ rows, err := connection.Query(ctx, `
+ select grantor_role.rolname, membership.admin_option, membership.inherit_option, membership.set_option
+ from pg_auth_members as membership
+ join pg_roles as grantor_role on grantor_role.oid = membership.grantor
+ where membership.roleid = $1::regrole
+ and membership.member = current_user::regrole
+ order by grantor_role.rolname`, role)
+ if err != nil {
+ t.Fatalf("read creator-admin memberships for %s: %v", role, err)
+ }
+ defer rows.Close()
+ var memberships []struct {
+ grantor string
+ admin, inherit, set bool
+ }
+ for rows.Next() {
+ var membership struct {
+ grantor string
+ admin, inherit, set bool
+ }
+ if err := rows.Scan(&membership.grantor, &membership.admin, &membership.inherit, &membership.set); err != nil {
+ t.Fatalf("scan creator-admin membership for %s: %v", role, err)
+ }
+ memberships = append(memberships, membership)
+ }
+ if err := rows.Err(); err != nil {
+ t.Fatalf("iterate creator-admin memberships for %s: %v", role, err)
+ }
+ currentUser := currentRole(t, ctx, migrationURL)
+ want := map[string]struct{ admin, inherit, set bool }{
+ bootstrapGrantor: {true, false, false},
+ currentUser: {false, false, true},
+ }
+ if len(memberships) != len(want) {
+ t.Fatalf("creator-admin membership count for %s = %d, want %d (%+v)", role, len(memberships), len(want), memberships)
+ }
+ for _, membership := range memberships {
+ expected, ok := want[membership.grantor]
+ if !ok || membership.admin != expected.admin || membership.inherit != expected.inherit || membership.set != expected.set {
+ t.Fatalf("creator-admin membership for %s = %+v, want %+v", role, membership, want)
+ }
+ delete(want, membership.grantor)
+ }
+ if len(want) != 0 {
+ t.Fatalf("creator-admin membership for %s omitted %+v", role, want)
+ }
+}
+
+func assertRoleContract(t *testing.T, ctx context.Context, adminURL string) {
+ t.Helper()
+ connection := connect(t, ctx, adminURL)
+ defer connection.Close(ctx)
+
+ expected := map[string]struct{ login, inherit, createRole bool }{
+ "cyclops_app": {true, false, false},
+ "k8s_state_owner": {false, true, false},
+ "k8s_state_writer": {true, false, false},
+ "k8s_state_exporter": {true, false, false},
+ "k8s_query_tenant": {false, true, false},
+ "k8s_query_admin": {false, true, false},
+ "k8s_role_admin": {true, false, true},
+ "k8s_reporting_owner": {false, true, false},
+ "k8s_metabase": {true, false, false},
+ }
+ for role, want := range expected {
+ var login, inherit, createRole, super, createDB, replication, bypassRLS bool
+ if err := connection.QueryRow(ctx, `select rolcanlogin, rolinherit, rolcreaterole, rolsuper, rolcreatedb, rolreplication, rolbypassrls from pg_roles where rolname = $1`, role).Scan(&login, &inherit, &createRole, &super, &createDB, &replication, &bypassRLS); err != nil {
+ t.Fatalf("read role %s: %v", role, err)
+ }
+ if login != want.login || inherit != want.inherit || createRole != want.createRole || super || createDB || replication || bypassRLS {
+ t.Errorf("role %s attributes = login:%t inherit:%t createrole:%t super:%t createdb:%t replication:%t bypassrls:%t", role, login, inherit, createRole, super, createDB, replication, bypassRLS)
+ }
+ }
+
+ var currentUser string
+ if err := connection.QueryRow(ctx, `select current_user`).Scan(&currentUser); err != nil {
+ t.Fatal("read migration user")
+ }
+ for _, want := range []struct {
+ role, member string
+ admin, inherit, set bool
+ }{
+ {"k8s_state_owner", currentUser, false, false, true},
+ {"k8s_reporting_owner", currentUser, false, false, true},
+ {"k8s_query_tenant", "k8s_role_admin", true, false, false},
+ {"k8s_query_admin", "k8s_reporting_owner", false, true, false},
+ } {
+ rows, err := connection.Query(ctx, `
+ select grantor_role.rolname, membership.admin_option, membership.inherit_option, membership.set_option
+ from pg_auth_members as membership
+ join pg_roles as grantor_role on grantor_role.oid = membership.grantor
+ where membership.roleid = $1::regrole and membership.member = $2::regrole
+ order by grantor_role.rolname`, want.role, want.member)
+ if err != nil {
+ t.Errorf("read membership %s -> %s: %v", want.role, want.member, err)
+ continue
+ }
+
+ var grants []struct {
+ grantor string
+ admin, inherit, set bool
+ }
+ for rows.Next() {
+ var grant struct {
+ grantor string
+ admin, inherit, set bool
+ }
+ if err := rows.Scan(&grant.grantor, &grant.admin, &grant.inherit, &grant.set); err != nil {
+ t.Errorf("scan membership %s -> %s: %v", want.role, want.member, err)
+ break
+ }
+ grants = append(grants, grant)
+ }
+ if err := rows.Err(); err != nil {
+ t.Errorf("iterate membership %s -> %s: %v", want.role, want.member, err)
+ }
+ rows.Close()
+
+ var explicitGrantFound bool
+ var bootstrapGrantCount int
+ for _, grant := range grants {
+ if grant.grantor == currentUser {
+ if explicitGrantFound || grant.admin != want.admin || grant.inherit != want.inherit || grant.set != want.set {
+ t.Errorf("membership %s -> %s = grantor:%s admin:%t inherit:%t set:%t, want one explicit grantor:%s admin:%t inherit:%t set:%t", want.role, want.member, grant.grantor, grant.admin, grant.inherit, grant.set, currentUser, want.admin, want.inherit, want.set)
+ }
+ explicitGrantFound = true
+ continue
+ }
+ if want.member == currentUser && grant.admin && !grant.inherit && !grant.set {
+ bootstrapGrantCount++
+ continue
+ }
+ t.Errorf("membership %s -> %s has unexpected grantor:%s admin:%t inherit:%t set:%t", want.role, want.member, grant.grantor, grant.admin, grant.inherit, grant.set)
+ }
+ if !explicitGrantFound {
+ t.Errorf("membership %s -> %s is missing the explicit migration-owner grant", want.role, want.member)
+ }
+ wantBootstrapGrants := 0
+ if want.member == currentUser {
+ wantBootstrapGrants = 1
+ }
+ if bootstrapGrantCount != wantBootstrapGrants {
+ t.Errorf("membership %s -> %s has %d bootstrap grantor rows, want %d", want.role, want.member, bootstrapGrantCount, wantBootstrapGrants)
+ }
+ }
+}
+
+func assertNoQueryBroker(t *testing.T, ctx context.Context, adminURL string) {
+ t.Helper()
+ connection := connect(t, ctx, adminURL)
+ defer connection.Close(ctx)
+ var exists bool
+ if err := connection.QueryRow(ctx, `select exists(select 1 from pg_roles where rolname = 'k8s_query_broker')`).Scan(&exists); err != nil || exists {
+ t.Errorf("shared query broker exists=%t err=%v", exists, err)
+ }
+}
+
+func assertOwnershipAndPublicACLs(t *testing.T, ctx context.Context, adminURL, migrationOwner string) {
+ t.Helper()
+ connection := connect(t, ctx, adminURL)
+ defer connection.Close(ctx)
+ for _, want := range []struct{ schema, name, owner string }{
+ {"public", "github_trust_policies", migrationOwner},
+ {"k8s_state", "resource_state", "k8s_state_owner"},
+ {"k8s_state", "resource_event_outbox", "k8s_state_owner"},
+ {"k8s_api", "current_resources", "k8s_state_owner"},
+ {"k8s_reporting", "current_resources", "k8s_reporting_owner"},
+ } {
+ var owner string
+ if err := connection.QueryRow(ctx, `select relation.relowner::regrole::text from pg_class relation join pg_namespace namespace on namespace.oid = relation.relnamespace where namespace.nspname = $1 and relation.relname = $2`, want.schema, want.name).Scan(&owner); err != nil {
+ t.Errorf("read owner for %s.%s: %v", want.schema, want.name, err)
+ } else if owner != want.owner {
+ t.Errorf("owner for %s.%s = %s, want %s", want.schema, want.name, owner, want.owner)
+ }
+ }
+ for _, want := range []struct{ schema, owner string }{
+ {"k8s_state", "k8s_state_owner"},
+ {"k8s_api", "k8s_state_owner"},
+ {"k8s_reporting", "k8s_reporting_owner"},
+ {"cyclops_migrations", migrationOwner},
+ } {
+ var owner string
+ if err := connection.QueryRow(ctx, `select nspowner::regrole::text from pg_namespace where nspname = $1`, want.schema).Scan(&owner); err != nil {
+ t.Errorf("read schema owner for %s: %v", want.schema, err)
+ } else if owner != want.owner {
+ t.Errorf("schema owner for %s = %s, want %s", want.schema, owner, want.owner)
+ }
+ }
+ for _, schema := range []string{"public", "k8s_state", "k8s_api", "k8s_reporting", "cyclops_migrations"} {
+ assertNoPublicSchemaPrivilege(t, ctx, connection, schema, "CREATE")
+ }
+ for _, schema := range []string{"k8s_state", "k8s_api", "k8s_reporting", "cyclops_migrations"} {
+ assertNoPublicSchemaPrivilege(t, ctx, connection, schema, "USAGE")
+ }
+ for _, relation := range []string{"public.github_trust_policies", "k8s_state.resource_state", "k8s_state.resource_event_outbox", "k8s_api.current_resources", "k8s_reporting.current_resources", "cyclops_migrations.applied_migrations"} {
+ assertNoPublicTablePrivilege(t, ctx, connection, relation)
+ }
+}
+
+func assertRLSContract(t *testing.T, ctx context.Context, adminURL string) {
+ t.Helper()
+ connection := connect(t, ctx, adminURL)
+ defer connection.Close(ctx)
+ var enabled, forced bool
+ if err := connection.QueryRow(ctx, `select relrowsecurity, relforcerowsecurity from pg_class where oid = 'k8s_state.resource_state'::regclass`).Scan(&enabled, &forced); err != nil || !enabled || !forced {
+ t.Errorf("resource_state RLS flags = enabled:%t forced:%t err=%v", enabled, forced, err)
+ }
+ var predicate string
+ if err := connection.QueryRow(ctx, `select pg_get_expr(policy.polqual, policy.polrelid) from pg_policy policy where policy.polname = 'tenant_current_state' and policy.polrelid = 'k8s_state.resource_state'::regclass`).Scan(&predicate); err != nil {
+ t.Errorf("read tenant RLS predicate: %v", err)
+ } else if !strings.Contains(predicate, "capsule_tenant = k8s_state.tenant_for_role(CURRENT_USER)") || !strings.Contains(predicate, "namespace") || !strings.Contains(predicate, "resource = 'namespaces'") {
+ t.Errorf("tenant RLS predicate = %q", predicate)
+ }
+}
+
+func assertSecurityDefinerContract(t *testing.T, ctx context.Context, adminURL string) {
+ t.Helper()
+ connection := connect(t, ctx, adminURL)
+ defer connection.Close(ctx)
+ for _, function := range []struct {
+ identity, allowedRole string
+ }{
+ {"k8s_state.tenant_for_role(name)", "k8s_query_tenant"},
+ {"k8s_state.register_tenant_role(name,text,text)", "k8s_role_admin"},
+ {"k8s_state.unregister_tenant_role(name)", "k8s_role_admin"},
+ } {
+ var securityDefiner bool
+ var config string
+ var owner string
+ if err := connection.QueryRow(ctx, `select prosecdef, coalesce(array_to_string(proconfig, ','), ''), proowner::regrole::text from pg_proc where oid = $1::regprocedure`, function.identity).Scan(&securityDefiner, &config, &owner); err != nil {
+ t.Fatalf("read function %s: %v", function.identity, err)
+ }
+ if !securityDefiner || owner != "k8s_state_owner" || !strings.Contains(config, "search_path=k8s_state, pg_catalog") {
+ t.Errorf("function %s security contract = definer:%t owner:%s config:%q", function.identity, securityDefiner, owner, config)
+ }
+ assertNoPublicFunctionExecute(t, ctx, connection, function.identity)
+ var allowed bool
+ if err := connection.QueryRow(ctx, `select has_function_privilege($1, $2::regprocedure, 'EXECUTE')`, function.allowedRole, function.identity).Scan(&allowed); err != nil || !allowed {
+ t.Errorf("role %s cannot execute %s: allowed=%t err=%v", function.allowedRole, function.identity, allowed, err)
+ }
+ }
+}
+
+func assertRuntimeLedgerAccess(t *testing.T, ctx context.Context, credentials CredentialURLs) {
+ t.Helper()
+ for role, databaseURL := range map[string]string{
+ "application": credentials.Application,
+ "writer": credentials.Writer,
+ "exporter": credentials.Exporter,
+ "role-admin": credentials.RoleAdmin,
+ "metabase": credentials.Metabase,
+ } {
+ connection := connect(t, ctx, databaseURL)
+ var count int
+ err := connection.QueryRow(ctx, `select count(*) from cyclops_migrations.applied_migrations`).Scan(&count)
+ connection.Close(ctx)
+ if err != nil || count != 1 {
+ t.Errorf("%s ledger select = count:%d err:%v", role, count, err)
+ }
+ assertStatementFails(t, ctx, databaseURL, `insert into cyclops_migrations.applied_migrations (version, filename, sha256) values (99, 'invalid.sql', 'invalid')`)
+ assertStatementFails(t, ctx, databaseURL, `update cyclops_migrations.applied_migrations set filename = 'invalid.sql' where version = 1`)
+ assertStatementFails(t, ctx, databaseURL, `delete from cyclops_migrations.applied_migrations where version = 1`)
+ }
+}
+
+func createTenantRolePath(t *testing.T, ctx context.Context, roleAdminURL, tenantRole, tenantPassword, tenant string) string {
+ t.Helper()
+ connection := connect(t, ctx, roleAdminURL)
+ defer connection.Close(ctx)
+ transaction, err := connection.Begin(ctx)
+ if err != nil {
+ t.Fatal("begin tenant role transaction")
+ }
+ defer transaction.Rollback(ctx)
+ identifier := pgx.Identifier{tenantRole}.Sanitize()
+ var quotedPassword string
+ if err := transaction.QueryRow(ctx, `select format('%L', $1::text)`, tenantPassword).Scan(&quotedPassword); err != nil {
+ t.Fatal("quote tenant role password")
+ }
+ for _, statement := range []string{
+ "create role " + identifier + " login inherit nocreaterole nocreatedb noreplication nobypassrls nosuperuser password " + quotedPassword,
+ "grant k8s_query_tenant to " + identifier + " with admin false, inherit true, set false",
+ } {
+ if _, err := transaction.Exec(ctx, statement); err != nil {
+ t.Fatalf("role admin expected tenant path %q: %v", statement, err)
+ }
+ }
+ if _, err := transaction.Exec(ctx, `select k8s_state.register_tenant_role($1, $2, $3)`, tenantRole, tenant, "test-fingerprint"); err != nil {
+ t.Fatalf("role admin register tenant role: %v", err)
+ }
+ if err := transaction.Commit(ctx); err != nil {
+ t.Fatal("commit tenant role transaction")
+ }
+ var login, inherit, createRole, super, createDB, replication, bypassRLS bool
+ if err := connection.QueryRow(ctx, `select rolcanlogin, rolinherit, rolcreaterole, rolsuper, rolcreatedb, rolreplication, rolbypassrls from pg_roles where rolname = $1`, tenantRole).Scan(&login, &inherit, &createRole, &super, &createDB, &replication, &bypassRLS); err != nil {
+ t.Fatal("read tenant role attributes")
+ }
+ if !login || !inherit || createRole || super || createDB || replication || bypassRLS {
+ t.Fatalf("tenant role attributes = login:%t inherit:%t createrole:%t super:%t createdb:%t replication:%t bypassrls:%t", login, inherit, createRole, super, createDB, replication, bypassRLS)
+ }
+ var admin, membershipInherit, set bool
+ if err := connection.QueryRow(ctx, `select admin_option, inherit_option, set_option from pg_auth_members where roleid = 'k8s_query_tenant'::regrole and member = $1::regrole`, tenantRole).Scan(&admin, &membershipInherit, &set); err != nil {
+ t.Fatal("read tenant query membership")
+ }
+ if admin || !membershipInherit || set {
+ t.Fatalf("tenant query membership = admin:%t inherit:%t set:%t, want admin:false inherit:true set:false", admin, membershipInherit, set)
+ }
+ var fingerprint string
+ if err := connection.QueryRow(ctx, tenantCredentialFingerprintLookup, tenantRole).Scan(&fingerprint); err != nil || fingerprint != "test-fingerprint" {
+ t.Fatalf("registered tenant fingerprint = %q err=%v", fingerprint, err)
+ }
+ assertStatementFails(t, ctx, roleAdminURL, "grant k8s_query_admin to "+identifier)
+ parsed, err := url.Parse(roleAdminURL)
+ if err != nil {
+ t.Fatal("parse role-admin database URL")
+ }
+ parsed.User = url.UserPassword(tenantRole, tenantPassword)
+ return parsed.String()
+}
+
+func seedStateBoundaryData(t *testing.T, ctx context.Context, adminURL string) {
+ t.Helper()
+ connection := connect(t, ctx, adminURL)
+ defer connection.Close(ctx)
+ _, err := connection.Exec(ctx, `
+ insert into k8s_state.resource_state
+ (cluster_id, api_group, resource, namespace, name, capsule_tenant, schema_hash, watch_epoch, observed_sequence, labels, object)
+ values
+ ('migration-test', '', 'namespaces', '', 'alice-ns', 'tenant-alice', 'schema', 1, 1, '{}', '{"kind":"Namespace"}'),
+ ('migration-test', '', 'pods', 'alice-ns', 'pod-a', 'tenant-alice', 'schema', 1, 2, '{}', '{"kind":"Pod"}'),
+ ('migration-test', '', 'nodes', '', 'node-a', 'tenant-alice', 'schema', 1, 3, '{}', '{"kind":"Node"}'),
+ ('migration-test', '', 'pods', 'bob-ns', 'pod-b', 'tenant-bob', 'schema', 1, 4, '{}', '{"kind":"Pod"}');
+ insert into k8s_state.resource_event_outbox
+ (event_id, cluster_id, api_group, resource, namespace, name, capsule_tenant, schema_hash, event_type, watch_epoch, observed_sequence, object, observed_at)
+ values ('00000000-0000-0000-0000-000000000001', 'migration-test', '', 'pods', 'alice-ns', 'pod-a', 'tenant-alice', 'schema', 'ADDED', 1, 2, '{}', clock_timestamp())`)
+ if err != nil {
+ t.Fatal("seed access-boundary state")
+ }
+}
+
+func assertWriterBoundary(t *testing.T, ctx context.Context, writerURL string) {
+ t.Helper()
+ connection := connect(t, ctx, writerURL)
+ defer connection.Close(ctx)
+ transaction, err := connection.Begin(ctx)
+ if err != nil {
+ t.Fatal("begin writer transaction")
+ }
+ defer transaction.Rollback(ctx)
+ _, err = transaction.Exec(ctx, `insert into k8s_state.resource_state (cluster_id, api_group, resource, namespace, name, schema_hash, watch_epoch, observed_sequence, labels, object) values ('writer-test', '', 'pods', 'default', 'pod', 'schema', 1, 1, '{}', '{}')`)
+ if err != nil {
+ t.Fatalf("writer cannot write current state: %v", err)
+ }
+ assertStatementFails(t, ctx, writerURL, `insert into k8s_state.query_tenant_role (role_name, capsule_tenant, credential_fingerprint) values ('writer_forbidden', 'writer', 'forbidden')`)
+ assertStatementFails(t, ctx, writerURL, `set role k8s_state_owner`)
+}
+
+func assertExporterBoundary(t *testing.T, ctx context.Context, exporterURL string) {
+ t.Helper()
+ connection := connect(t, ctx, exporterURL)
+ defer connection.Close(ctx)
+ var count int
+ if err := connection.QueryRow(ctx, `select count(*) from k8s_state.resource_event_outbox where cluster_id = 'migration-test'`).Scan(&count); err != nil || count != 1 {
+ t.Errorf("exporter cannot read outbox boundary: count=%d err=%v", count, err)
+ }
+ transaction, err := connection.Begin(ctx)
+ if err != nil {
+ t.Fatal("begin exporter transaction")
+ }
+ defer transaction.Rollback(ctx)
+ if _, err := transaction.Exec(ctx, `update k8s_state.resource_event_outbox set claimed_at = clock_timestamp() where event_id = '00000000-0000-0000-0000-000000000001'`); err != nil {
+ t.Errorf("exporter cannot claim outbox event: %v", err)
+ }
+ assertStatementFails(t, ctx, exporterURL, `select 1 from k8s_state.resource_state limit 1`)
+}
+
+func assertTenantReadPath(t *testing.T, ctx context.Context, tenantURL string) {
+ t.Helper()
+ if names := tenantResourceNames(t, ctx, tenantURL); strings.Join(names, ",") != "alice-ns,pod-a" {
+ t.Errorf("tenant RLS predicate results = %v, want [alice-ns pod-a]", names)
+ }
+}
+
+func tenantResourceNames(t *testing.T, ctx context.Context, tenantURL string) []string {
+ t.Helper()
+ connection := connect(t, ctx, tenantURL)
+ defer connection.Close(ctx)
+ rows, err := connection.Query(ctx, `select name from k8s_api.current_resources where cluster_id = 'migration-test' order by name`)
+ if err != nil {
+ t.Fatalf("query directly as tenant role: %v", err)
+ }
+ defer rows.Close()
+ var names []string
+ for rows.Next() {
+ var name string
+ if err := rows.Scan(&name); err != nil {
+ t.Fatal("scan tenant result")
+ }
+ names = append(names, name)
+ }
+ if err := rows.Err(); err != nil {
+ t.Fatal("read tenant result")
+ }
+ return names
+}
+
+func assertMetabaseBoundary(t *testing.T, ctx context.Context, metabaseURL string) {
+ t.Helper()
+ connection := connect(t, ctx, metabaseURL)
+ defer connection.Close(ctx)
+ var count int
+ if err := connection.QueryRow(ctx, `select count(*) from k8s_reporting.current_resources where cluster_id = 'migration-test'`).Scan(&count); err != nil || count != 4 {
+ t.Errorf("metabase cannot read reporting view: count=%d err=%v", count, err)
+ }
+ for _, statement := range []string{
+ `select 1 from k8s_state.resource_state limit 1`,
+ `select 1 from k8s_api.current_resources limit 1`,
+ `select 1 from public.github_trust_policies limit 1`,
+ `delete from k8s_reporting.current_resources`,
+ } {
+ assertStatementFails(t, ctx, metabaseURL, statement)
+ }
+}
+
+func assertApplicationBoundary(t *testing.T, ctx context.Context, applicationURL string) {
+ t.Helper()
+ connection := connect(t, ctx, applicationURL)
+ defer connection.Close(ctx)
+ const policyID = "migration-application-boundary"
+ if _, err := connection.Exec(ctx, `
+ insert into public.github_trust_policies
+ (id, owner_sub, name, repository, allowed_namespaces, enabled, created_at, updated_at)
+ values ($1, 'owner', 'initial', 'example/repository', array['default'], false, clock_timestamp(), clock_timestamp())`, policyID); err != nil {
+ t.Fatalf("application cannot insert github trust policy: %v", err)
+ }
+ if _, err := connection.Exec(ctx, `update public.github_trust_policies set name = 'updated', updated_at = clock_timestamp() where id = $1`, policyID); err != nil {
+ t.Fatalf("application cannot update github trust policy: %v", err)
+ }
+ var name string
+ if err := connection.QueryRow(ctx, `select name from public.github_trust_policies where id = $1`, policyID).Scan(&name); err != nil || name != "updated" {
+ t.Fatalf("application cannot read github trust policy: name=%q err=%v", name, err)
+ }
+ if _, err := connection.Exec(ctx, `delete from public.github_trust_policies where id = $1`, policyID); err != nil {
+ t.Fatalf("application cannot delete github trust policy: %v", err)
+ }
+ for _, statement := range []string{
+ `select 1 from k8s_state.resource_state limit 1`,
+ `select 1 from k8s_api.current_resources limit 1`,
+ `select 1 from k8s_reporting.current_resources limit 1`,
+ } {
+ assertStatementFails(t, ctx, applicationURL, statement)
+ }
+}
+
+func connect(t *testing.T, ctx context.Context, databaseURL string) *pgx.Conn {
+ t.Helper()
+ connection, err := pgx.Connect(ctx, databaseURL)
+ if err != nil {
+ t.Fatal(err)
+ }
+ return connection
+}
+
+func assertRunFailsBeforeStaticRoleRepair(t *testing.T, ctx context.Context, migrationURL string, credentials CredentialURLs, wantError string) {
+ t.Helper()
+ err := Run(ctx, Config{MigrationURL: migrationURL, Credentials: credentials})
+ if err == nil || !strings.Contains(err.Error(), wantError) {
+ t.Fatalf("Run() error = %v, want fail-closed error containing %q", err, wantError)
+ }
+ connection := connect(t, ctx, migrationURL)
+ defer connection.Close(ctx)
+ var inherit bool
+ if err := connection.QueryRow(ctx, `select rolinherit from pg_roles where rolname = 'cyclops_app'`).Scan(&inherit); err != nil {
+ t.Fatal("read static role after rejected membership drift")
+ }
+ if !inherit {
+ t.Fatal("role reconciliation changed a role before rejecting membership drift")
+ }
+}
+
+func assertStatementFails(t *testing.T, ctx context.Context, databaseURL, statement string) {
+ t.Helper()
+ connection := connect(t, ctx, databaseURL)
+ defer connection.Close(ctx)
+ if _, err := connection.Exec(ctx, statement); err == nil {
+ t.Errorf("statement unexpectedly succeeded: %s", statement)
+ }
+}
+
+func assertNoPublicSchemaPrivilege(t *testing.T, ctx context.Context, connection *pgx.Conn, schema, privilege string) {
+ t.Helper()
+ var exists bool
+ err := connection.QueryRow(ctx, `select exists(select 1 from pg_namespace namespace join lateral aclexplode(coalesce(namespace.nspacl, acldefault('n', namespace.nspowner))) acl on true where namespace.nspname = $1 and acl.grantee = 0 and acl.privilege_type = $2)`, schema, privilege).Scan(&exists)
+ if err != nil || exists {
+ t.Errorf("PUBLIC %s on schema %s = %t err=%v", privilege, schema, exists, err)
+ }
+}
+
+func assertNoPublicTablePrivilege(t *testing.T, ctx context.Context, connection *pgx.Conn, relation string) {
+ t.Helper()
+ var exists bool
+ err := connection.QueryRow(ctx, `select exists(select 1 from pg_class relation join lateral aclexplode(coalesce(relation.relacl, acldefault('r', relation.relowner))) acl on true where relation.oid = $1::regclass and acl.grantee = 0)`, relation).Scan(&exists)
+ if err != nil || exists {
+ t.Errorf("PUBLIC table privileges on %s = %t err=%v", relation, exists, err)
+ }
+}
+
+func assertNoPublicFunctionExecute(t *testing.T, ctx context.Context, connection *pgx.Conn, function string) {
+ t.Helper()
+ var exists bool
+ err := connection.QueryRow(ctx, `select exists(select 1 from pg_proc procedure join lateral aclexplode(coalesce(procedure.proacl, acldefault('f', procedure.proowner))) acl on true where procedure.oid = $1::regprocedure and acl.grantee = 0 and acl.privilege_type = 'EXECUTE')`, function).Scan(&exists)
+ if err != nil || exists {
+ t.Errorf("PUBLIC execute on %s = %t err=%v", function, exists, err)
+ }
+}
+
+func unregisterTenantRole(t *testing.T, ctx context.Context, roleAdminURL, tenantRole string) {
+ t.Helper()
+ connection, err := pgx.Connect(ctx, roleAdminURL)
+ if err != nil {
+ t.Errorf("connect to unregister dynamic role %s: %v", tenantRole, err)
+ return
+ }
+ defer connection.Close(ctx)
+ if _, err := connection.Exec(ctx, `select k8s_state.unregister_tenant_role($1)`, tenantRole); err != nil {
+ t.Errorf("unregister dynamic role %s: %v", tenantRole, err)
+ }
+}
+
+func dropRole(t *testing.T, ctx context.Context, adminURL, role string) {
+ t.Helper()
+ connection, err := pgx.Connect(ctx, adminURL)
+ if err != nil {
+ t.Errorf("connect to drop dynamic role %s: %v", role, err)
+ return
+ }
+ defer connection.Close(ctx)
+ if _, err := connection.Exec(ctx, "drop role if exists "+pgx.Identifier{role}.Sanitize()); err != nil {
+ t.Errorf("drop dynamic role %s: %v", role, err)
+ }
+}
diff --git a/libs/fleet/backend/database/migrator_test.go b/libs/fleet/backend/database/migrator_test.go
new file mode 100644
index 0000000000..9f52033351
--- /dev/null
+++ b/libs/fleet/backend/database/migrator_test.go
@@ -0,0 +1,579 @@
+package database
+
+import (
+ "bytes"
+ "crypto/sha256"
+ "encoding/hex"
+ "log/slog"
+ "os"
+ "reflect"
+ "strings"
+ "testing"
+ "time"
+
+ "github.com/jackc/pgx/v5"
+)
+
+func TestBackendImageBuildsMigrationCommand(t *testing.T) {
+ contents, err := os.ReadFile("../Dockerfile")
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ dockerfile := strings.ReplaceAll(string(contents), "\\\n", " ")
+ var buildsMigrator, copiesMigrator bool
+ for _, line := range strings.Split(dockerfile, "\n") {
+ fields := strings.Fields(strings.TrimSpace(line))
+ if len(fields) == 0 {
+ continue
+ }
+
+ switch fields[0] {
+ case "RUN":
+ for _, command := range strings.Split(strings.Join(fields[1:], " "), "&&") {
+ command = strings.NewReplacer("\"", "", "'", "").Replace(command)
+ buildsMigrator = buildsMigrator ||
+ strings.Contains(command, "CGO_ENABLED=1") &&
+ strings.Contains(command, "GOOS=linux") &&
+ strings.Contains(command, "go build") &&
+ strings.Contains(command, "-trimpath") &&
+ strings.Contains(command, "-ldflags=") &&
+ strings.Contains(command, "-o /out/cyclops-db-migrate") &&
+ strings.Contains(command, "./cmd/db-migrate")
+ }
+ case "COPY":
+ copiesMigrator = copiesMigrator ||
+ len(fields) == 4 &&
+ fields[1] == "--from=go-builder" &&
+ fields[2] == "/out/cyclops-db-migrate" &&
+ fields[3] == "/app/cyclops-db-migrate"
+ }
+ }
+
+ if !buildsMigrator {
+ t.Fatal("Dockerfile does not build /out/cyclops-db-migrate with the backend build flags")
+ }
+ if !copiesMigrator {
+ t.Fatal("Dockerfile does not copy /app/cyclops-db-migrate from go-builder")
+ }
+}
+
+func TestTenantCredentialFingerprintLookupIsParameterized(t *testing.T) {
+ const expected = `select credential_fingerprint from k8s_state.query_tenant_role where role_name = $1`
+ if tenantCredentialFingerprintLookup != expected {
+ t.Fatalf("tenant credential fingerprint lookup = %q, want %q", tenantCredentialFingerprintLookup, expected)
+ }
+}
+
+func TestStaticRoleAlterClausesOnlyContainPermittedDrift(t *testing.T) {
+ contract := staticRoleContract{role: "cyclops_app", login: true, connectionLimit: -1, validUntil: "infinity"}
+ clauses, err := staticRoleAlterClauses(contract, staticRoleAttributes{
+ login: false,
+ inherit: true,
+ createRole: true,
+ connectionLimit: 1,
+ validUntil: "2026-08-10 00:00:00+00",
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+ if clauses != "LOGIN NOINHERIT NOCREATEROLE CONNECTION LIMIT -1 VALID UNTIL 'infinity'" {
+ t.Fatalf("static role alter clauses = %q", clauses)
+ }
+ if strings.Contains(clauses, "SUPERUSER") || strings.Contains(clauses, "REPLICATION") || strings.Contains(clauses, "BYPASSRLS") {
+ t.Fatalf("static role alter clauses contain a superuser-only attribute: %q", clauses)
+ }
+}
+
+func TestStaticRoleSettingsContractsAreExact(t *testing.T) {
+ want := map[string]map[string]string{
+ "k8s_metabase": {
+ "default_transaction_read_only": "on",
+ "statement_timeout": "20000ms",
+ "idle_in_transaction_session_timeout": "20000ms",
+ },
+ }
+ if !reflect.DeepEqual(staticRoleSettingsContracts(), want) {
+ t.Fatalf("static role settings contracts = %#v, want %#v", staticRoleSettingsContracts(), want)
+ }
+}
+
+func TestStaticRoleAlterClausesRejectCreateDBDrift(t *testing.T) {
+ _, err := staticRoleAlterClauses(staticRoleContract{role: "cyclops_app", login: true}, staticRoleAttributes{
+ login: true,
+ createDB: true,
+ })
+ if err == nil || !strings.Contains(err.Error(), "rolcreatedb=true") {
+ t.Fatalf("static role createdb drift error = %v, want fail-closed rolcreatedb error", err)
+ }
+}
+
+func TestStaticRoleAlterClausesRejectUnsafeSuperuserOnlyDrift(t *testing.T) {
+ _, err := staticRoleAlterClauses(staticRoleContract{role: "cyclops_app", login: true}, staticRoleAttributes{
+ login: true,
+ super: true,
+ replication: true,
+ bypassRLS: true,
+ })
+ if err == nil {
+ t.Fatal("expected unsafe superuser-only role drift to fail closed")
+ }
+ for _, attribute := range []string{"rolsuper", "rolreplication", "rolbypassrls"} {
+ if !strings.Contains(err.Error(), attribute) {
+ t.Errorf("unsafe role drift error = %q, want %s", err, attribute)
+ }
+ }
+}
+
+func TestAllowsRegisteredTenantCreatorAdminMembership(t *testing.T) {
+ validTenant := dynamicTenantRole{
+ name: "k8s_tenant_0123456789abcdef0123456789abcdef",
+ registered: true,
+ login: true,
+ inherit: true,
+ connectionLimit: -1,
+ validUntil: "infinity",
+ }
+ grant := staticMembershipGrant{grantor: "bootstrap_owner", grantorSuperuser: true, admin: true, inherit: false, set: false}
+ if !allowsRegisteredTenantCreatorAdminMembership(validTenant, "k8s_role_admin", grant) {
+ t.Fatal("expected registered tenant creator-admin membership to be allowed")
+ }
+
+ for _, testCase := range []struct {
+ name string
+ tenant dynamicTenantRole
+ member string
+ grant staticMembershipGrant
+ }{
+ {name: "unregistered tenant", tenant: dynamicTenantRole{name: validTenant.name, login: true, inherit: true, connectionLimit: -1, validUntil: "infinity"}, member: "k8s_role_admin", grant: grant},
+ {name: "wrong name", tenant: dynamicTenantRole{name: "tenant", registered: true, login: true, inherit: true, connectionLimit: -1, validUntil: "infinity"}, member: "k8s_role_admin", grant: grant},
+ {name: "wrong role attributes", tenant: dynamicTenantRole{name: validTenant.name, registered: true, login: true, connectionLimit: -1, validUntil: "infinity"}, member: "k8s_role_admin", grant: grant},
+ {name: "member is not role admin", tenant: validTenant, member: "cyclops_app", grant: grant},
+ {name: "self grantor", tenant: validTenant, member: "k8s_role_admin", grant: staticMembershipGrant{grantor: "k8s_role_admin", admin: true, inherit: false, set: false}},
+ {name: "wrong admin option", tenant: validTenant, member: "k8s_role_admin", grant: staticMembershipGrant{grantor: "bootstrap_owner", inherit: false, set: false}},
+ {name: "wrong inherit option", tenant: validTenant, member: "k8s_role_admin", grant: staticMembershipGrant{grantor: "bootstrap_owner", admin: true, inherit: true, set: false}},
+ {name: "wrong set option", tenant: validTenant, member: "k8s_role_admin", grant: staticMembershipGrant{grantor: "bootstrap_owner", admin: true, inherit: false, set: true}},
+ } {
+ t.Run(testCase.name, func(t *testing.T) {
+ if allowsRegisteredTenantCreatorAdminMembership(testCase.tenant, testCase.member, testCase.grant) {
+ t.Fatal("unexpectedly allowed tenant creator-admin membership")
+ }
+ })
+ }
+}
+
+func TestStaticCreatorAdminMembershipsRequireOneForeignSuperuserGrant(t *testing.T) {
+ foreign := staticMembershipGrant{grantor: "bootstrap_owner", grantorSuperuser: true, admin: true, inherit: false, set: false}
+ ownerDrift := staticMembershipGrant{grantor: "migration_owner", admin: true, inherit: true, set: true}
+ if !staticCreatorAdminMembershipsAreExact("migration_owner", []staticMembershipGrant{foreign}, false) {
+ t.Fatal("expected one foreign superuser creator row to be allowed")
+ }
+ if !staticCreatorAdminMembershipsAreExact("migration_owner", []staticMembershipGrant{foreign, ownerDrift}, true) {
+ t.Fatal("expected one repairable migration-owner row to be allowed")
+ }
+
+ for _, testCase := range []struct {
+ name string
+ grants []staticMembershipGrant
+ allowOwnerGrant bool
+ }{
+ {name: "missing foreign creator", grants: nil},
+ {name: "non-superuser foreign creator", grants: []staticMembershipGrant{{grantor: "foreign_owner", admin: true, inherit: false, set: false}}},
+ {name: "wrong foreign options", grants: []staticMembershipGrant{{grantor: "bootstrap_owner", grantorSuperuser: true, admin: true, inherit: true, set: false}}},
+ {name: "second foreign creator", grants: []staticMembershipGrant{foreign, {grantor: "other_bootstrap_owner", grantorSuperuser: true, admin: true, inherit: false, set: false}}},
+ {name: "owner row is not declared", grants: []staticMembershipGrant{foreign, ownerDrift}},
+ {name: "duplicate owner row", grants: []staticMembershipGrant{foreign, ownerDrift, {grantor: "migration_owner", admin: false, inherit: false, set: true}}, allowOwnerGrant: true},
+ } {
+ t.Run(testCase.name, func(t *testing.T) {
+ if staticCreatorAdminMembershipsAreExact("migration_owner", testCase.grants, testCase.allowOwnerGrant) {
+ t.Fatal("unexpectedly allowed static creator-admin memberships")
+ }
+ })
+ }
+}
+
+func TestCreatorAdminMembershipsRequireOneForeignSuperuserGrant(t *testing.T) {
+ valid := staticMembershipGrant{grantor: "bootstrap_owner", grantorSuperuser: true, admin: true, inherit: false, set: false}
+ if !creatorAdminMembershipsAreExact("migration_owner", []staticMembershipGrant{valid}) {
+ t.Fatal("expected one creator-admin membership from a superuser to be allowed")
+ }
+
+ for _, testCase := range []struct {
+ name string
+ grants []staticMembershipGrant
+ }{
+ {name: "missing", grants: nil},
+ {name: "non-superuser", grants: []staticMembershipGrant{{grantor: "foreign_owner", admin: true, inherit: false, set: false}}},
+ {name: "self grantor", grants: []staticMembershipGrant{{grantor: "migration_owner", grantorSuperuser: true, admin: true, inherit: false, set: false}}},
+ {name: "wrong options", grants: []staticMembershipGrant{{grantor: "bootstrap_owner", grantorSuperuser: true, admin: true, inherit: true, set: false}}},
+ {name: "duplicate", grants: []staticMembershipGrant{valid, {grantor: "other_bootstrap_owner", grantorSuperuser: true, admin: true, inherit: false, set: false}}},
+ } {
+ t.Run(testCase.name, func(t *testing.T) {
+ if creatorAdminMembershipsAreExact("migration_owner", testCase.grants) {
+ t.Fatal("unexpectedly allowed creator-admin memberships")
+ }
+ })
+ }
+}
+
+func TestRegisteredTenantMembershipsAreExactInBothDirections(t *testing.T) {
+ tenant := dynamicTenantRole{
+ name: "k8s_tenant_0123456789abcdef0123456789abcdef",
+ registered: true,
+ login: true,
+ inherit: true,
+ connectionLimit: -1,
+ validUntil: "infinity",
+ }
+ creator := staticMembershipGrant{grantor: "bootstrap_owner", grantorSuperuser: true, admin: true, inherit: false, set: false}
+ controller := staticMembershipGrant{grantor: "k8s_role_admin", admin: false, inherit: true, set: false}
+ if !registeredTenantMembershipsAreExact(tenant, []staticMembershipGrant{creator}, []staticMembershipGrant{controller}) {
+ t.Fatal("expected healthy registered tenant memberships to be allowed")
+ }
+
+ for _, testCase := range []struct {
+ name string
+ inbound []staticMembershipGrant
+ parents []staticMembershipGrant
+ }{
+ {name: "arbitrary member", inbound: []staticMembershipGrant{creator, {grantor: "bootstrap_owner", grantorSuperuser: true, admin: true, inherit: false, set: false}}, parents: []staticMembershipGrant{controller}},
+ {name: "non-superuser creator", inbound: []staticMembershipGrant{{grantor: "foreign_owner", admin: true, inherit: false, set: false}}, parents: []staticMembershipGrant{controller}},
+ {name: "extra creator", inbound: []staticMembershipGrant{creator, {grantor: "other_bootstrap_owner", grantorSuperuser: true, admin: true, inherit: false, set: false}}, parents: []staticMembershipGrant{controller}},
+ {name: "extra parent", inbound: []staticMembershipGrant{creator}, parents: []staticMembershipGrant{controller, {grantor: "bootstrap_owner", grantorSuperuser: true, admin: false, inherit: true, set: false}}},
+ {name: "wrong controller", inbound: []staticMembershipGrant{creator}, parents: []staticMembershipGrant{{grantor: "k8s_role_admin", admin: true, inherit: true, set: false}}},
+ } {
+ t.Run(testCase.name, func(t *testing.T) {
+ if registeredTenantMembershipsAreExact(tenant, testCase.inbound, testCase.parents) {
+ t.Fatal("unexpectedly allowed registered tenant memberships")
+ }
+ })
+ }
+}
+
+func TestAllowsImplicitCreatorAdminMembership(t *testing.T) {
+ contract := staticMembershipContract{role: "k8s_state_owner", member: "migration_owner"}
+ if !allowsImplicitCreatorAdminMembership(contract.role, contract.member, "migration_owner", staticMembershipGrant{
+ grantor: "postgres", grantorSuperuser: true, admin: true, inherit: false, set: false,
+ }) {
+ t.Fatal("expected the PostgreSQL creator-admin membership to be allowed")
+ }
+
+ for _, testCase := range []struct {
+ name string
+ role string
+ member string
+ grant staticMembershipGrant
+ }{
+ {name: "non-static parent", role: "unrelated_role", member: "migration_owner", grant: staticMembershipGrant{grantor: "postgres", admin: true}},
+ {name: "unrelated member", role: "k8s_state_owner", member: "other", grant: staticMembershipGrant{grantor: "postgres", admin: true}},
+ {name: "non-admin", role: contract.role, member: contract.member, grant: staticMembershipGrant{grantor: "postgres", inherit: false, set: false}},
+ {name: "inherits", role: contract.role, member: contract.member, grant: staticMembershipGrant{grantor: "postgres", admin: true, inherit: true, set: false}},
+ {name: "sets", role: contract.role, member: contract.member, grant: staticMembershipGrant{grantor: "postgres", admin: true, inherit: false, set: true}},
+ {name: "self grant", role: contract.role, member: contract.member, grant: staticMembershipGrant{grantor: "migration_owner", admin: true, inherit: false, set: false}},
+ } {
+ t.Run(testCase.name, func(t *testing.T) {
+ if allowsImplicitCreatorAdminMembership(testCase.role, testCase.member, "migration_owner", testCase.grant) {
+ t.Fatal("unexpectedly allowed foreign membership")
+ }
+ })
+ }
+}
+
+func TestEmbeddedMigrationsAreOrderedAndImmutable(t *testing.T) {
+ files, err := embeddedMigrations()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(files) != 1 {
+ t.Fatalf("expected exactly one initial migration, got %d", len(files))
+ }
+ file := files[0]
+ if file.Version != 1 || file.Name != "000001_initial_schema.sql" {
+ t.Fatalf("expected version 1 initial schema migration, got version=%d name=%q", file.Version, file.Name)
+ }
+ digest := sha256.Sum256([]byte(file.SQL))
+ if file.SHA256 != hex.EncodeToString(digest[:]) {
+ t.Fatal("embedded initial schema migration digest does not match its contents")
+ }
+ for _, expected := range []string{
+ "credential_fingerprint text NOT NULL",
+ "CREATE FUNCTION k8s_state.register_tenant_role(p_role_name name, p_capsule_tenant text, p_credential_fingerprint text)",
+ "CREATE FUNCTION k8s_state.unregister_tenant_role(p_role_name name)",
+ "GRANT EXECUTE ON FUNCTION k8s_state.register_tenant_role(name, text, text) TO k8s_role_admin",
+ "GRANT EXECUTE ON FUNCTION k8s_state.unregister_tenant_role(name) TO k8s_role_admin",
+ } {
+ if !strings.Contains(file.SQL, expected) {
+ t.Errorf("initial schema is missing direct tenant role contract %q", expected)
+ }
+ }
+ if strings.Contains(file.SQL, "k8s_query_broker") {
+ t.Fatal("initial schema must not create or grant a shared query broker role")
+ }
+}
+
+func TestAppliedMigrationLedgerUsesApplicationOrder(t *testing.T) {
+ if !strings.Contains(createAppliedMigrationsTableStatement, "application_order bigint generated always as identity unique") {
+ t.Fatalf("ledger schema must define a unique identity application order: %s", createAppliedMigrationsTableStatement)
+ }
+ if !strings.HasSuffix(selectAppliedMigrationsStatement, "order by application_order") {
+ t.Fatalf("ledger query must preserve application order: %s", selectAppliedMigrationsStatement)
+ }
+ if strings.Contains(insertAppliedMigrationStatement, "application_order") {
+ t.Fatalf("ledger insert must allow the identity application order to be generated: %s", insertAppliedMigrationStatement)
+ }
+}
+
+func TestCheckAppliedMigrationRejectsChangedChecksum(t *testing.T) {
+ err := checkAppliedMigration(
+ migrationFile{Version: 1, Name: "000001_initial_schema.sql", SHA256: "current"},
+ appliedMigration{Version: 1, Name: "000001_initial_schema.sql", SHA256: "recorded"},
+ )
+ if err == nil {
+ t.Fatal("expected checksum mismatch")
+ }
+}
+
+func TestValidateAppliedMigrationsRejectsFilenameMismatch(t *testing.T) {
+ err := validateAppliedMigrations(
+ []migrationFile{{Version: 1, Name: "000001_initial_schema.sql", SHA256: "checksum"}},
+ []appliedMigration{{Version: 1, Name: "000001_renamed.sql", SHA256: "checksum"}},
+ )
+ if err == nil || !strings.Contains(err.Error(), "filename changed") {
+ t.Fatalf("expected filename mismatch, got %v", err)
+ }
+}
+
+func TestValidateAppliedMigrationsRejectsOrphanedLedgerRow(t *testing.T) {
+ err := validateAppliedMigrations(
+ []migrationFile{{Version: 1, Name: "000001_initial_schema.sql", SHA256: "checksum"}},
+ []appliedMigration{{Version: 2, Name: "000002_deleted.sql", SHA256: "checksum"}},
+ )
+ if err == nil || !strings.Contains(err.Error(), "no embedded migration") {
+ t.Fatalf("expected orphaned ledger row, got %v", err)
+ }
+}
+
+func TestValidateAppliedMigrationsRejectsNonContiguousLedger(t *testing.T) {
+ files := []migrationFile{
+ {Version: 1, Name: "000001_initial_schema.sql", SHA256: "first"},
+ {Version: 2, Name: "000002_add_roles.sql", SHA256: "second"},
+ {Version: 3, Name: "000003_add_widgets.sql", SHA256: "third"},
+ }
+ tests := []struct {
+ name string
+ applied []appliedMigration
+ message string
+ }{
+ {
+ name: "gap",
+ applied: []appliedMigration{
+ {Version: 1, Name: "000001_initial_schema.sql", SHA256: "first"},
+ {Version: 3, Name: "000003_add_widgets.sql", SHA256: "third"},
+ },
+ message: "migration ledger version gap: expected 000002, got 000003",
+ },
+ {
+ name: "out of order",
+ applied: []appliedMigration{
+ {Version: 1, Name: "000001_initial_schema.sql", SHA256: "first"},
+ {Version: 3, Name: "000003_add_widgets.sql", SHA256: "third"},
+ {Version: 2, Name: "000002_add_roles.sql", SHA256: "second"},
+ },
+ message: "migration ledger rows are out of order: version 000002 follows 000003",
+ },
+ {
+ name: "duplicate",
+ applied: []appliedMigration{
+ {Version: 1, Name: "000001_initial_schema.sql", SHA256: "first"},
+ {Version: 1, Name: "000001_initial_schema.sql", SHA256: "first"},
+ },
+ message: "migration ledger contains duplicate version 000001",
+ },
+ }
+
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ err := validateAppliedMigrations(files, test.applied)
+ if err == nil || err.Error() != test.message {
+ t.Fatalf("expected %q, got %v", test.message, err)
+ }
+ })
+ }
+}
+
+func TestValidateAppliedMigrationsAcceptsMatchingLedger(t *testing.T) {
+ files := []migrationFile{
+ {Version: 1, Name: "000001_initial_schema.sql", SHA256: "first"},
+ {Version: 2, Name: "000002_add_roles.sql", SHA256: "second"},
+ }
+ applied := []appliedMigration{
+ {Version: 1, Name: "000001_initial_schema.sql", SHA256: "first"},
+ {Version: 2, Name: "000002_add_roles.sql", SHA256: "second"},
+ }
+ if err := validateAppliedMigrations(files, applied); err != nil {
+ t.Fatal(err)
+ }
+ if current := migrationCurrentVersion(applied); current != 2 {
+ t.Fatalf("expected current version 2, got %d", current)
+ }
+}
+
+func TestCredentialURLsExcludeDynamicTenantRoles(t *testing.T) {
+ credentials, err := parseCredentialURLs(CredentialURLs{
+ Application: "postgres://cyclops_app:pw@db/cyclops",
+ Writer: "postgres://k8s_state_writer:pw@db/cyclops",
+ Exporter: "postgres://k8s_state_exporter:pw@db/cyclops",
+ RoleAdmin: "postgres://k8s_role_admin:pw@db/cyclops",
+ Metabase: "postgres://k8s_metabase:pw@db/cyclops",
+ })
+ if err != nil {
+ t.Fatalf("parse fixed runtime credentials: %v", err)
+ }
+ if len(credentials) != 5 {
+ t.Fatalf("credential count = %d, want 5", len(credentials))
+ }
+ for _, credential := range credentials {
+ if credential.Role == "k8s_query_broker" || strings.HasPrefix(credential.Role, "k8s_tenant_") {
+ t.Fatalf("migrator must not reconcile dynamic tenant query credentials: %q", credential.Role)
+ }
+ }
+}
+
+func TestStaticRoleContractsAreAllowlistedAndFixed(t *testing.T) {
+ contracts := staticRoleContracts()
+ want := map[string]struct {
+ login, inherit, createRole, createDB bool
+ connectionLimit int
+ validUntil string
+ }{
+ "cyclops_app": {true, false, false, false, -1, "infinity"},
+ "k8s_state_owner": {false, true, false, false, -1, "infinity"},
+ "k8s_state_writer": {true, false, false, false, -1, "infinity"},
+ "k8s_state_exporter": {true, false, false, false, -1, "infinity"},
+ "k8s_query_tenant": {false, true, false, false, -1, "infinity"},
+ "k8s_query_admin": {false, true, false, false, -1, "infinity"},
+ "k8s_role_admin": {true, false, true, false, -1, "infinity"},
+ "k8s_reporting_owner": {false, true, false, false, -1, "infinity"},
+ "k8s_metabase": {true, false, false, false, -1, "infinity"},
+ }
+ if len(contracts) != len(want) {
+ t.Fatalf("static role contract count = %d, want %d", len(contracts), len(want))
+ }
+ for _, contract := range contracts {
+ expected, ok := want[contract.role]
+ if !ok {
+ t.Fatalf("static role contract includes non-allowlisted role %q", contract.role)
+ }
+ if contract.login != expected.login || contract.inherit != expected.inherit || contract.createRole != expected.createRole || contract.createDB != expected.createDB || contract.connectionLimit != expected.connectionLimit || contract.validUntil != expected.validUntil {
+ t.Errorf("role %s contract = login:%t inherit:%t createrole:%t createdb:%t connection_limit:%d valid_until:%q, want login:%t inherit:%t createrole:%t createdb:%t connection_limit:%d valid_until:%q", contract.role, contract.login, contract.inherit, contract.createRole, contract.createDB, contract.connectionLimit, contract.validUntil, expected.login, expected.inherit, expected.createRole, expected.createDB, expected.connectionLimit, expected.validUntil)
+ }
+ delete(want, contract.role)
+ }
+ if len(want) != 0 {
+ t.Fatalf("static role contract omitted roles: %v", want)
+ }
+}
+
+func TestStaticMembershipContractsUsePG16Options(t *testing.T) {
+ contracts := staticMembershipContracts("migration_owner")
+ want := []staticMembershipContract{
+ {role: "k8s_state_owner", member: "migration_owner", admin: false, inherit: false, set: true},
+ {role: "k8s_reporting_owner", member: "migration_owner", admin: false, inherit: false, set: true},
+ {role: "k8s_query_tenant", member: "k8s_role_admin", admin: true, inherit: false, set: false},
+ {role: "k8s_query_admin", member: "k8s_reporting_owner", admin: false, inherit: true, set: false},
+ }
+ if !reflect.DeepEqual(contracts, want) {
+ t.Fatalf("static membership contracts = %#v, want %#v", contracts, want)
+ }
+}
+
+func TestStaticRolesAreAllMembershipValidationTargets(t *testing.T) {
+ for _, contract := range staticRoleContracts() {
+ if !isMigrationOwnedStaticRole(contract.role) {
+ t.Errorf("static role %q is omitted from membership validation", contract.role)
+ }
+ }
+}
+
+func TestCredentialURLsRequireExpectedRoleNames(t *testing.T) {
+ _, err := parseCredentialURLs(CredentialURLs{
+ Application: "postgres://wrong:pw@db/cyclops",
+ Writer: "postgres://k8s_state_writer:pw@db/cyclops",
+ Exporter: "postgres://k8s_state_exporter:pw@db/cyclops",
+ RoleAdmin: "postgres://k8s_role_admin:pw@db/cyclops",
+ Metabase: "postgres://k8s_metabase:pw@db/cyclops",
+ })
+ if err == nil {
+ t.Fatal("expected application role-name validation")
+ }
+ if strings.Contains(err.Error(), "wrong") || strings.Contains(err.Error(), "cyclops_app") {
+ t.Fatalf("credential error leaked a username: %v", err)
+ }
+}
+
+func TestCredentialURLsRejectEmptyPassword(t *testing.T) {
+ _, err := parseCredentialURLs(CredentialURLs{
+ Application: "postgres://cyclops_app:@db/cyclops",
+ Writer: "postgres://k8s_state_writer:pw@db/cyclops",
+ Exporter: "postgres://k8s_state_exporter:pw@db/cyclops",
+ RoleAdmin: "postgres://k8s_role_admin:pw@db/cyclops",
+ Metabase: "postgres://k8s_metabase:pw@db/cyclops",
+ })
+ if err == nil || err.Error() != "application credential database URL must include a password" {
+ t.Fatalf("expected empty password rejection, got %v", err)
+ }
+}
+
+func TestCredentialURLParseErrorsAreSafe(t *testing.T) {
+ const username = "leaked-user"
+ const password = "leaked-password"
+ _, err := parseCredentialURLs(CredentialURLs{
+ Application: "postgres://" + username + ":" + password + "@%zz/cyclops",
+ Writer: "postgres://k8s_state_writer:pw@db/cyclops",
+ Exporter: "postgres://k8s_state_exporter:pw@db/cyclops",
+ RoleAdmin: "postgres://k8s_role_admin:pw@db/cyclops",
+ Metabase: "postgres://k8s_metabase:pw@db/cyclops",
+ })
+ if err == nil || err.Error() != "parse application credential database URL" {
+ t.Fatalf("expected safe credential parse error, got %v", err)
+ }
+ if strings.Contains(err.Error(), username) || strings.Contains(err.Error(), password) {
+ t.Fatalf("credential parse error leaked secret data: %v", err)
+ }
+}
+
+func TestMigrationConfigAndLoggingAreSafe(t *testing.T) {
+ const username = "leaked-user"
+ const password = "leaked-password"
+ const databaseURL = "postgres://" + username + ":" + password + "@db.example.test/cyclops"
+
+ connectionConfig, err := pgx.ParseConfig(databaseURL)
+ if err != nil {
+ t.Fatal(err)
+ }
+ target := databaseTarget(connectionConfig)
+ if !strings.Contains(target, "db.example.test") || !strings.Contains(target, "cyclops") {
+ t.Fatalf("expected database target, got %q", target)
+ }
+ if strings.Contains(target, username) || strings.Contains(target, password) || strings.Contains(target, databaseURL) {
+ t.Fatalf("database target leaked secret data: %q", target)
+ }
+
+ if _, err := parseMigrationConfig("postgres://" + username + ":" + password + "@%zz/cyclops"); err == nil || err.Error() != "parse migration database URL" {
+ t.Fatalf("expected safe migration parse error, got %v", err)
+ }
+
+ var output bytes.Buffer
+ previous := slog.Default()
+ slog.SetDefault(slog.New(slog.NewJSONHandler(&output, nil)))
+ t.Cleanup(func() { slog.SetDefault(previous) })
+ logMigrationSummary(migrationSummary{
+ DatabaseHost: connectionConfig.Host,
+ DatabaseName: connectionConfig.Database,
+ Started: time.Now(),
+ Result: "success",
+ })
+ if strings.Contains(output.String(), username) || strings.Contains(output.String(), password) || strings.Contains(output.String(), databaseURL) {
+ t.Fatalf("migration summary leaked secret data: %s", output.String())
+ }
+}