Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.
Rust agentai-agentapplecomputer-usecomputer-use-agentcontainerizationcuadesktop-automationhacktoberfestlumemacosmanusoperatorswiftvirtualizationvirtualization-frameworkwindowswindows-sandbox
feat(cyclops-cs): unify PostgreSQL migrations (#6708)
r33drichardsf20edd32f8ff
diff --git a/libs/fleet/backend/Dockerfile b/libs/fleet/backend/Dockerfileindex 9d9e79edaf..7137b23aa0 100644--- a/libs/fleet/backend/Dockerfile+++ b/libs/fleet/backend/Dockerfile@@ -9,7 +9,8 @@ RUN go mod downloadRUN go mod tidyRUN 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-migrateFROM --platform=linux/amd64 rust:1.94-bookworm AS rust-builderWORKDIR /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 runtimeWORKDIR /appCOPY --from=go-builder /out/cyclops-cs-backend /app/cyclops-cs-backend+COPY --from=go-builder /out/cyclops-db-migrate /app/cyclops-db-migrateCOPY --from=rust-builder /out-k8s-state-projector /app/k8s-state-projectorUSER nonroot:nonrootEXPOSE 8080diff --git a/libs/fleet/backend/cmd/db-migrate/main.go b/libs/fleet/backend/cmd/db-migrate/main.gonew file mode 100644index 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/.keepnew file mode 100644index 0000000000..e69de29bb2diff --git a/libs/fleet/backend/database/migrations/000001_initial_schema.sql b/libs/fleet/backend/database/migrations/000001_initial_schema.sqlnew file mode 100644index 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.gonew file mode 100644index 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("edPassword); 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.gonew file mode 100644index 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(¤tUser); 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("edPassword); 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.gonew file mode 100644index 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())+ }+}