feat(store): run services as a non-superuser role and name every connection (#1857)
Every service connected to PostgreSQL as the database owner, which is a superuser, so anything that compromised an app process owned the cluster, and every connection reached the server with an empty application_name, so pg_stat_activity could not say which service a session belonged to. Split the DB credential into two login roles and name every pool: - archie_migrator owns public and its objects and runs goose. Migrations run on a short-lived pool opened from the new migration_database_url, before the serving pool opens. It is not a superuser. - archie_runtime serves requests with SELECT, INSERT, UPDATE, DELETE, sequence USAGE/SELECT and function EXECUTE only. It has no CREATE privilege, so it cannot change the schema. - Every pool sets application_name: archie-state-store, archie-gateway, and a -migrate / -recovery / -schema / -provision suffix on the transient administrative connections. Existing one-URL installs keep working: an absent migration_database_url falls back to database_url and the migration runs on the serving pool exactly as before. Provisioning is a new idempotent `archie-state-store provision` subcommand: it needs an admin URL the services never hold (database owner or superuser), creates or reconciles both roles, hands every public-schema object to the migration role, revokes PUBLIC's CREATE on public, sets row-level grants, and sets the migration role's default privileges so tables future migrations create are usable without a hand-run grant. It stores SCRAM verifiers, refuses superuser roles, and verifies the boundary before committing. install.sh now provisions the bundled path and separates the credentials: the superuser password the Compose database is created with lives only in a compose-only postgres.env, while the env file the units load holds the non-superuser PGPASSWORD. A bundled install that predates the split is upgraded in place: the roles are created, the superuser password is rotated out of the env file, and config.toml is moved to the runtime and migration URLs. External databases keep their operator-managed credential; the deployments README documents the one-shot provision command. setup writes both bundled URLs, dev:postgres provisions the dev database, the e2e stack provisions its throwaway server, and the deployment templates point at the two roles.
This commit is contained in:
26 files changed
+1252
-101
No files matched your search
@@ -31,6 +31,7 @@ release's per-component sections are labelled beneath its heading.
|
||||
|
||||
- Six foreign keys now have an index on the referencing column, so deleting a parent row looks its children up instead of scanning the child table: identity aliases and subjects, org memberships and agents, installed package requirements, and the task a handoff came from.
|
||||
- The control plane no longer polls the database once per watch subscriber: every watcher shares one version read per 250 ms, so an idle instance drops from roughly 180 transactions a second to a handful while a resource change still reaches every watcher on the same schedule.
|
||||
- The bundled install now runs the services as a least-privilege database role that can read and write rows but cannot change the schema; a separate migration role owns the schema and applies migrations, and every connection names its service in `pg_stat_activity`. The installer provisions both roles, and re-running it moves an existing bundled install onto them, so a compromised service no longer holds a credential that owns the cluster.
|
||||
|
||||
## [1.62.0] - 2026-11-10
|
||||
|
||||
|
||||
+10
-1
@@ -146,7 +146,7 @@ tasks:
|
||||
done
|
||||
|
||||
dev:postgres:
|
||||
desc: Start PostgreSQL and wait for readiness
|
||||
desc: Start PostgreSQL, wait for readiness, provision the database roles
|
||||
cmds:
|
||||
- docker compose up -d postgres
|
||||
- |
|
||||
@@ -160,6 +160,15 @@ tasks:
|
||||
done
|
||||
echo "postgres did not become healthy within 60s" >&2
|
||||
exit 1
|
||||
- |
|
||||
# docker-compose.yml creates the dev database with a superuser named
|
||||
# archie; provision the least-privilege roles deployments/dev.toml
|
||||
# points at. Idempotent, so this also upgrades a volume created before
|
||||
# the role split.
|
||||
go run ./cmd/archie-state-store provision \
|
||||
-admin-url "postgres://archie:archie@127.0.0.1:5432/archie?sslmode=disable" \
|
||||
-runtime-url "postgres://archie_runtime:archie@127.0.0.1:5432/archie?sslmode=disable" \
|
||||
-migration-url "postgres://archie_migrator:archie@127.0.0.1:5432/archie?sslmode=disable"
|
||||
|
||||
dev:wait-state:
|
||||
internal: true
|
||||
|
||||
@@ -19,10 +19,13 @@ import (
|
||||
func main() { os.Exit(run()) }
|
||||
|
||||
func run() int {
|
||||
// A leading non-flag argument selects a recovery subcommand; anything else,
|
||||
// A leading non-flag argument selects a subcommand; anything else,
|
||||
// including no arguments at all, serves the State Store contract. An
|
||||
// unrecognised word is refused rather than ignored, so a mistyped recovery
|
||||
// command never leaves an operator watching a server start instead.
|
||||
// unrecognised word is refused rather than ignored, so a mistyped command
|
||||
// never leaves an operator watching a server start instead.
|
||||
if args := os.Args[1:]; statestore.IsProvisionArgs(args) {
|
||||
return statestore.RunProvision(context.Background(), args[1:], os.Stdout, os.Stderr)
|
||||
}
|
||||
if args := os.Args[1:]; statestore.IsAccessResetArgs(args) {
|
||||
return statestore.RunAccessReset(context.Background(), args[2:], os.Stderr)
|
||||
}
|
||||
@@ -36,7 +39,7 @@ func run() int {
|
||||
flag.StringVar(&options.Listen, "listen", "", "state store gRPC listen address (defaults to [services.state].listen, else 127.0.0.1:9090)")
|
||||
flag.StringVar(&options.ReadyAddr, "ready-addr", "", "optional readiness HTTP listen address (e.g. 127.0.0.1:9091)")
|
||||
flag.Usage = func() {
|
||||
fmt.Fprintf(flag.CommandLine.Output(), "usage: archie-state-store [flags] # serve the State Store gRPC contract\n\noffline recovery: archie-state-store <backup|restore|validate|rollback> -h | access reset -h\n\n")
|
||||
fmt.Fprintf(flag.CommandLine.Output(), "usage: archie-state-store [flags] # serve the State Store gRPC contract\n\ndatabase roles: archie-state-store provision -h\noffline recovery: archie-state-store <backup|restore|validate|rollback> -h | access reset -h\n\n")
|
||||
flag.PrintDefaults()
|
||||
}
|
||||
flag.Parse()
|
||||
|
||||
+6
-1
@@ -7,7 +7,12 @@
|
||||
# Secrets are never written here: each is a {engine, key} reference. The
|
||||
# built-in "env" engine reads key as an environment variable.
|
||||
|
||||
# database_url = "postgres://archie:archie@localhost:5432/archie?sslmode=disable"
|
||||
# The URL the services connect as: a least-privilege role, created by
|
||||
# `archie-state-store provision`. migration_database_url is the role that owns
|
||||
# the schema and runs migrations; when it is absent, database_url does both,
|
||||
# which is what a single-role install does.
|
||||
# database_url = "postgres://archie_runtime:secret@localhost:5432/archie?sslmode=disable"
|
||||
# migration_database_url = "postgres://archie_migrator:secret@localhost:5432/archie?sslmode=disable"
|
||||
# work_dir = "~/.local/share/archie/work"
|
||||
# state_dir = "~/.local/share/archie"
|
||||
|
||||
|
||||
@@ -30,7 +30,10 @@ that reference is on a registry that needs a login -- see
|
||||
(<https://offloaded.dev>) —
|
||||
`standalone.toml` (no forge, the simplest start),
|
||||
`single-forge-github.toml` and `docker-nats-stack.toml` cover the common cases. Every one needs
|
||||
PostgreSQL 18 at `database_url`. Copy whichever fits to:
|
||||
PostgreSQL 18 with the `archie_migrator` and `archie_runtime` roles created
|
||||
once by `archie-state-store provision` (see `deployments/README.md`);
|
||||
`docker compose up -d postgres` plus that command gives the local default.
|
||||
Copy whichever fits to:
|
||||
|
||||
```bash
|
||||
mkdir -p ~/.config/archie
|
||||
|
||||
+32
-1
@@ -42,7 +42,9 @@ systemctl --user start archied
|
||||
|
||||
Start order does not matter: a service waits for its peers and reports them as
|
||||
degraded meanwhile. Every template needs PostgreSQL 18 at `database_url`;
|
||||
`docker compose up -d postgres` provides the default one.
|
||||
`docker compose up -d postgres` provides the default server. Its two login
|
||||
roles are created once per database by `archie-state-store provision` -- see
|
||||
[Database roles](#database-roles).
|
||||
|
||||
The State Store service (`archie-state-store`) owns the task data in the
|
||||
PostgreSQL database `database_url` names and serves the `StateStore` gRPC
|
||||
@@ -54,6 +56,35 @@ gateway address, because a container cannot reach the host's loopback. A
|
||||
non-loopback address needs `[tls]` certificates from your own CA; see
|
||||
`config.example.toml`.
|
||||
|
||||
## Database roles
|
||||
|
||||
The services do not connect as the database owner. `archie-state-store
|
||||
provision` creates, or reconciles, two login roles in an existing PostgreSQL
|
||||
database and hands the schema to one of them:
|
||||
|
||||
- `archie_migrator` owns the schema and its objects and runs the goose
|
||||
migrations;
|
||||
- `archie_runtime` may read and write rows (SELECT, INSERT, UPDATE, DELETE,
|
||||
sequence USAGE, function EXECUTE) and has no CREATE privilege, so it cannot
|
||||
change the schema.
|
||||
|
||||
Run it once per database with a role allowed to create roles and take ownership
|
||||
of the schema (the database owner or a superuser), then point the templates at
|
||||
the two roles: `database_url` is the runtime URL and `migration_database_url`
|
||||
the migration one. The command is idempotent, so re-running it after an upgrade
|
||||
reconciles objects a migration added.
|
||||
|
||||
```bash
|
||||
archie-state-store provision \
|
||||
-admin-url "postgres://owner:secret@db:5432/archie" \
|
||||
-runtime-url "postgres://archie_runtime:secret@db:5432/archie" \
|
||||
-migration-url "postgres://archie_migrator:secret@db:5432/archie"
|
||||
```
|
||||
|
||||
The bundled installer and `task dev` run this for you. A configuration with only
|
||||
`database_url` keeps working exactly as before: that one role applies the
|
||||
schema and serves, which is what an install that has not split the roles does.
|
||||
|
||||
## Running the dashboard
|
||||
|
||||
The dashboard is served by the standalone UI Service (`archie-ui`), not by
|
||||
|
||||
@@ -9,12 +9,16 @@
|
||||
# [web] entirely.
|
||||
|
||||
# `task dev` runs archie-state-store against this overlay, and the State Store
|
||||
# fails closed without a PostgreSQL URL. This must reach the `postgres`
|
||||
# fails closed without a PostgreSQL URL. These must reach the `postgres`
|
||||
# service in docker-compose.yml, which `task dev` brings up first via
|
||||
# dev:postgres -- keep the URL and that service in agreement.
|
||||
# dev:postgres -- keep them and that service in agreement. dev:postgres also
|
||||
# provisions the two roles: the services serve as archie_runtime and migrate
|
||||
# as archie_migrator, while the Compose-created archie role is only the
|
||||
# admin that created them.
|
||||
bot_user = "archie-dev"
|
||||
|
||||
database_url = "postgres://archie:archie@127.0.0.1:5432/archie?sslmode=disable"
|
||||
database_url = "postgres://archie_runtime:archie@127.0.0.1:5432/archie?sslmode=disable"
|
||||
migration_database_url = "postgres://archie_migrator:archie@127.0.0.1:5432/archie?sslmode=disable"
|
||||
|
||||
[web]
|
||||
listen = "127.0.0.1:8484"
|
||||
|
||||
@@ -16,9 +16,12 @@ bot_user = "archie"
|
||||
work_dir = "~/.local/share/archie/work"
|
||||
state_dir = "~/.local/share/archie" # NATS store, task logs
|
||||
# The State Store's PostgreSQL connection (PostgreSQL 18, required).
|
||||
# `docker compose up -d postgres` provides this local default; point it at
|
||||
# your own Postgres 18 server otherwise.
|
||||
database_url = "postgres://archie:archie@127.0.0.1:5432/archie?sslmode=disable"
|
||||
# `docker compose up -d postgres` provides the local default; point it at
|
||||
# your own Postgres 18 server otherwise. The services serve as archie_runtime
|
||||
# and migrations run as archie_migrator; create both once with
|
||||
# `archie-state-store provision -h` (deployments/README.md).
|
||||
database_url = "postgres://archie_runtime:archie@127.0.0.1:5432/archie?sslmode=disable"
|
||||
migration_database_url = "postgres://archie_migrator:archie@127.0.0.1:5432/archie?sslmode=disable"
|
||||
|
||||
[services.gateway]
|
||||
target = "127.0.0.1:8585"
|
||||
|
||||
@@ -8,9 +8,12 @@
|
||||
work_dir = "~/.local/share/archie/work"
|
||||
state_dir = "~/.local/share/archie" # NATS store, task logs
|
||||
# The State Store's PostgreSQL connection (PostgreSQL 18, required).
|
||||
# `docker compose up -d postgres` provides this local default; point it at
|
||||
# your own Postgres 18 server otherwise.
|
||||
database_url = "postgres://archie:archie@127.0.0.1:5432/archie?sslmode=disable"
|
||||
# `docker compose up -d postgres` provides the local default; point it at
|
||||
# your own Postgres 18 server otherwise. The services serve as archie_runtime
|
||||
# and migrations run as archie_migrator; create both once with
|
||||
# `archie-state-store provision -h` (deployments/README.md).
|
||||
database_url = "postgres://archie_runtime:archie@127.0.0.1:5432/archie?sslmode=disable"
|
||||
migration_database_url = "postgres://archie_migrator:archie@127.0.0.1:5432/archie?sslmode=disable"
|
||||
poll_interval = "60s"
|
||||
label = "archie"
|
||||
bot_user = "archie-bot"
|
||||
|
||||
@@ -15,9 +15,12 @@ bot_user = "archie"
|
||||
work_dir = "~/.local/share/archie/work"
|
||||
state_dir = "~/.local/share/archie" # NATS store, task logs
|
||||
# PostgreSQL 18 connection (required).
|
||||
# `docker compose up -d postgres` provides this local default; point it at
|
||||
# your own Postgres 18 server otherwise.
|
||||
database_url = "postgres://archie:archie@127.0.0.1:5432/archie?sslmode=disable"
|
||||
# `docker compose up -d postgres` provides the local default; point it at
|
||||
# your own Postgres 18 server otherwise. The services serve as archie_runtime
|
||||
# and migrations run as archie_migrator; create both once with
|
||||
# `archie-state-store provision -h` (deployments/README.md).
|
||||
database_url = "postgres://archie_runtime:archie@127.0.0.1:5432/archie?sslmode=disable"
|
||||
migration_database_url = "postgres://archie_migrator:archie@127.0.0.1:5432/archie?sslmode=disable"
|
||||
|
||||
[services.gateway]
|
||||
target = "127.0.0.1:8585"
|
||||
|
||||
+3
-2
@@ -19,8 +19,9 @@ services:
|
||||
# The standalone archie-state-store process's database. PostgreSQL 18 is
|
||||
# the required minimum and target; `postgres.Open` refuses anything older.
|
||||
# `task dev` brings this up before the State Store via dev:postgres. The
|
||||
# credentials and database name below are the dev default mirrored by
|
||||
# deployments/dev.toml's database_url -- change both together.
|
||||
# This superuser is the dev database's admin: `task dev` runs archie-state-store
|
||||
# provision after first start to create the least-privilege roles the
|
||||
# mirroring deployments/dev.toml URLs name -- change them together.
|
||||
postgres:
|
||||
image: postgres:18
|
||||
environment:
|
||||
|
||||
+15
-1
@@ -72,7 +72,10 @@ start_pg() {
|
||||
prepare() {
|
||||
mkdir -p "$dir"/{bin,logs,pids} "$XDG_CONFIG_HOME/archie" "$XDG_DATA_HOME" "$XDG_STATE_HOME"
|
||||
[ -f "$XDG_CONFIG_HOME/archie/config.toml" ] || cp "$repo/config.example.toml" "$XDG_CONFIG_HOME/archie/config.toml"
|
||||
sed "s#^database_url = .*#database_url = \"postgres://archie@127.0.0.1:$pgport/archie?sslmode=disable\"#" \
|
||||
# The services serve from the least-privilege role and migrate as the schema
|
||||
# owner; initdb's archie role is the throwaway server's superuser only.
|
||||
sed -e "s#^database_url = .*#database_url = \"postgres://archie_runtime@127.0.0.1:$pgport/archie?sslmode=disable\"#" \
|
||||
-e "s#^migration_database_url = .*#migration_database_url = \"postgres://archie_migrator@127.0.0.1:$pgport/archie?sslmode=disable\"#" \
|
||||
"$repo/deployments/dev.toml" >"$dir/dev.toml"
|
||||
local version
|
||||
version=$(git -C "$repo" describe --tags --exact-match --match 'v[0-9]*' 2>/dev/null || true)
|
||||
@@ -101,6 +104,16 @@ start_service() {
|
||||
spawn "$1" "$repo" "$dir/bin/$1" -config-overlay "$dir/dev.toml"
|
||||
}
|
||||
|
||||
# provision_roles creates the least-privilege roles the stack connects as. The
|
||||
# throwaway server runs with trust auth, so the role URLs' passwords are never
|
||||
# checked; they are here only because provision sets the role password it reads.
|
||||
provision_roles() {
|
||||
"$dir/bin/archie-state-store" provision \
|
||||
-admin-url "postgres://archie@127.0.0.1:$pgport/archie?sslmode=disable" \
|
||||
-runtime-url "postgres://archie_runtime:e2e@127.0.0.1:$pgport/archie?sslmode=disable" \
|
||||
-migration-url "postgres://archie_migrator:e2e@127.0.0.1:$pgport/archie?sslmode=disable"
|
||||
}
|
||||
|
||||
stop_pid() {
|
||||
local f=$1 pid
|
||||
[ -f "$f" ] || return 0
|
||||
@@ -123,6 +136,7 @@ start() {
|
||||
trap 'trap - ERR; stop' ERR
|
||||
prepare
|
||||
start_pg 9>&-
|
||||
provision_roles
|
||||
start_service archie-state-store
|
||||
wait_port 9091 archie-state-store 90
|
||||
local s
|
||||
|
||||
+73
-3
@@ -91,6 +91,17 @@ export ARCHIE_INSTANCE="${INSTANCE}"
|
||||
ARCHIE_CONFIG_DIR="${XDG_CONFIG_HOME}/${INSTANCE}"
|
||||
ARCHIE_DATA_DIR="${XDG_DATA_HOME}/${INSTANCE}"
|
||||
ENV_FILE="${ARCHIE_CONFIG_DIR}/env"
|
||||
# The database roles a bundled install serves from: the least-privilege role
|
||||
# the services connect as, and the role that owns the schema and runs
|
||||
# migrations. The names mirror postgres.RuntimeRole/MigrationRole, which setup
|
||||
# writes into the bundled configuration.
|
||||
RUNTIME_ROLE=archie_runtime
|
||||
MIGRATION_ROLE=archie_migrator
|
||||
# The credential the bundled PostgreSQL is created with and the installer uses
|
||||
# once, to create the two roles. It lives in this Compose-only file, which the
|
||||
# systemd units never load, so no service holds a credential that owns the
|
||||
# cluster.
|
||||
PG_ADMIN_ENV="${ARCHIE_DATA_DIR}/postgres.env"
|
||||
|
||||
# unit maps a base unit name to this instance's: unchanged for the default
|
||||
# instance, suffixed with the name after archie- otherwise.
|
||||
@@ -266,10 +277,55 @@ else
|
||||
echo " [SKIP] ${ARCHIE_CONFIG_DIR}/config.toml already exists. Re-run 'archied setup' to change it."
|
||||
fi
|
||||
|
||||
# provision_database reconciles the two database roles a bundled install
|
||||
# serves from: an archie_migrator that owns the schema and runs goose, and an
|
||||
# archie_runtime with row access only. It also moves the superuser password out
|
||||
# of the env file the units load: a config written before the split connects as
|
||||
# the bundled superuser, so its password is rotated to the Compose-only one
|
||||
# once the roles exist. Idempotent, so re-running the installer reconciles an
|
||||
# already-split install.
|
||||
provision_database() {
|
||||
local role_pw admin_pw connect_pw split=false
|
||||
role_pw="$(sed -n "s/^PGPASSWORD='\([^']*\)'$/\1/p" "${ENV_FILE}" | tail -n1)"
|
||||
admin_pw="$(sed -n "s/^POSTGRES_PASSWORD='\([^']*\)'$/\1/p" "${PG_ADMIN_ENV}" | tail -n1)"
|
||||
if [ -z "${role_pw}" ] || [ -z "${admin_pw}" ]; then
|
||||
echo " [WARN] Cannot provision database roles: ${ENV_FILE} needs PGPASSWORD and ${PG_ADMIN_ENV} needs POSTGRES_PASSWORD." >&2
|
||||
return
|
||||
fi
|
||||
if ! grep -q '^migration_database_url' "${ARCHIE_CONFIG_DIR}/config.toml"; then
|
||||
split=true
|
||||
fi
|
||||
# A pre-split install authenticates as the superuser with the env file's
|
||||
# PGPASSWORD; a split one authenticates with the Compose-only password.
|
||||
if [ "${split}" = true ]; then connect_pw="${role_pw}"; else connect_pw="${admin_pw}"; fi
|
||||
echo "==> Provisioning the database roles..."
|
||||
if ! PGPASSWORD="${connect_pw}" ARCHIE_NEW_ADMIN_PASSWORD="${admin_pw}" \
|
||||
"${ARCHIE_BIN_DIR}/archie-state-store" provision \
|
||||
-admin-url "postgres://archie@/archie?host=${PG_SOCKET_DIR}" \
|
||||
-runtime-url "postgres://${RUNTIME_ROLE}:${role_pw}@/archie?host=${PG_SOCKET_DIR}" \
|
||||
-migration-url "postgres://${MIGRATION_ROLE}:${role_pw}@/archie?host=${PG_SOCKET_DIR}" \
|
||||
-rotate-admin-password-env ARCHIE_NEW_ADMIN_PASSWORD; then
|
||||
echo " [WARN] Database role provisioning failed; not restarting the services until it succeeds. Re-run the installer once the database accepts the admin credential." >&2
|
||||
AUTO_START=false
|
||||
return
|
||||
fi
|
||||
if [ "${split}" = true ]; then
|
||||
if grep -q '^database_url = "postgres://archie@' "${ARCHIE_CONFIG_DIR}/config.toml"; then
|
||||
sed -i "s#^database_url = \"postgres://archie@#database_url = \"postgres://${RUNTIME_ROLE}@#" "${ARCHIE_CONFIG_DIR}/config.toml"
|
||||
sed -i "/^database_url = /a migration_database_url = \"postgres://${MIGRATION_ROLE}@/archie?host=${PG_SOCKET_DIR}\"" "${ARCHIE_CONFIG_DIR}/config.toml"
|
||||
echo " [OK] config.toml now connects as ${RUNTIME_ROLE} and migrates as ${MIGRATION_ROLE}."
|
||||
else
|
||||
echo " [WARN] Could not move database_url to ${RUNTIME_ROLE}; set database_url and migration_database_url by hand." >&2
|
||||
fi
|
||||
fi
|
||||
}
|
||||
|
||||
# 4. PostgreSQL. Every service fails closed without it. The bundled database
|
||||
# has no network at all: the services reach it through its Unix socket,
|
||||
# mounted at PG_SOCKET_DIR, so it publishes no port and cannot collide with
|
||||
# another PostgreSQL. Its password is the PGPASSWORD setup generated.
|
||||
# another PostgreSQL. The superuser it is created with is only the installer's
|
||||
# bootstrap credential; the services connect as the two provisioned roles and
|
||||
# read their password from the env file's PGPASSWORD as before.
|
||||
PG_SOCKET_DIR="${ARCHIE_DATA_DIR}/postgres"
|
||||
PG_COMPOSE="${ARCHIE_DATA_DIR}/postgres.yml"
|
||||
if ! grep -qF "host=${PG_SOCKET_DIR}" "${ARCHIE_CONFIG_DIR}/config.toml"; then
|
||||
@@ -280,6 +336,15 @@ elif ! command -v docker &>/dev/null; then
|
||||
else
|
||||
echo "==> Starting the bundled PostgreSQL 18..."
|
||||
mkdir -p "${PG_SOCKET_DIR}"
|
||||
# The superuser password is generated here rather than reused from setup: it
|
||||
# is the one credential that must never be in the env file the units load.
|
||||
# Written before the first start so a failed run can be retried with it.
|
||||
if [ ! -f "${PG_ADMIN_ENV}" ]; then
|
||||
previous_umask="$(umask)"
|
||||
umask 077
|
||||
printf "POSTGRES_PASSWORD='%s'\n" "$(od -An -N24 -tx1 /dev/urandom | tr -d ' \n')" >"${PG_ADMIN_ENV}"
|
||||
umask "${previous_umask}"
|
||||
fi
|
||||
cat >"${PG_COMPOSE}" <<'EOF'
|
||||
services:
|
||||
postgres:
|
||||
@@ -287,7 +352,7 @@ services:
|
||||
network_mode: none
|
||||
environment:
|
||||
POSTGRES_USER: archie
|
||||
POSTGRES_PASSWORD: ${PGPASSWORD:-}
|
||||
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-}
|
||||
POSTGRES_DB: archie
|
||||
POSTGRES_INITDB_ARGS: --auth-local=scram-sha-256
|
||||
PGDATA: /var/lib/postgresql/data/pgdata
|
||||
@@ -304,10 +369,12 @@ services:
|
||||
volumes:
|
||||
pg_data:
|
||||
EOF
|
||||
if ! docker compose -p "${INSTANCE}" --env-file "${ENV_FILE}" -f "${PG_COMPOSE}" up -d --wait; then
|
||||
if ! docker compose -p "${INSTANCE}" --env-file "${PG_ADMIN_ENV}" -f "${PG_COMPOSE}" up -d --wait; then
|
||||
echo " [WARN] The bundled PostgreSQL did not start, so the services are installed but not started." >&2
|
||||
echo " Check: docker compose -p "${INSTANCE}" -f ${PG_COMPOSE} logs" >&2
|
||||
AUTO_START=false
|
||||
else
|
||||
provision_database
|
||||
fi
|
||||
fi
|
||||
|
||||
@@ -495,6 +562,9 @@ echo "Installation Details:"
|
||||
echo " - Binaries : ${ARCHIE_BIN_DIR}/{archied,archie-state-store,archie-gateway,archie-ui,archie-messaging}"
|
||||
echo " - Config : ${ARCHIE_CONFIG_DIR}/config.toml"
|
||||
echo " - Secrets : ${ENV_FILE}"
|
||||
if [ -f "${PG_ADMIN_ENV}" ]; then
|
||||
echo " - DB admin : ${PG_ADMIN_ENV} # compose-only, never loaded by the units"
|
||||
fi
|
||||
echo " - Data : ${ARCHIE_DATA_DIR}/"
|
||||
echo ""
|
||||
|
||||
|
||||
@@ -21,7 +21,7 @@ import (
|
||||
)
|
||||
|
||||
func (b *server) openChatSessions(ctx context.Context) error {
|
||||
pool, err := postgres.OpenMigrated(ctx, b.cfg.DatabaseURL, "the conversation store")
|
||||
pool, err := postgres.OpenMigrated(ctx, b.cfg.DatabaseURL, b.cfg.MigrationURL(), postgres.AppGateway)
|
||||
if err != nil {
|
||||
return fmt.Errorf("open conversation store: %w", err)
|
||||
}
|
||||
|
||||
@@ -9,13 +9,15 @@ import (
|
||||
// openStateStorePool opens the State Store process's one process-scoped
|
||||
// PostgreSQL pool, applies the schema and claims serve ownership of the
|
||||
// database for the process's life, so a second State Store against the same
|
||||
// database refuses to start. A missing or invalid database_url or a migration
|
||||
// failure is a startup failure.
|
||||
// database refuses to start. The schema is applied through
|
||||
// migration_database_url when the configuration splits the migration role from
|
||||
// the serving one. A missing
|
||||
// or invalid database_url or a migration failure is a startup failure.
|
||||
//
|
||||
// The pool is stored on boot.pg and closed at shutdown; nothing opens a second
|
||||
// pool per subsystem.
|
||||
func (b *server) openStateStorePool(ctx context.Context) error {
|
||||
pool, err := postgres.OpenMigrated(ctx, b.cfg.DatabaseURL, "the State Store")
|
||||
pool, err := postgres.OpenMigrated(ctx, b.cfg.DatabaseURL, b.cfg.MigrationURL(), postgres.AppStateStore)
|
||||
if err != nil {
|
||||
b.log.ErrorContext(ctx, "open state store postgres pool", "err", err)
|
||||
return err
|
||||
|
||||
@@ -0,0 +1,99 @@
|
||||
package statestore
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"flag"
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"strings"
|
||||
|
||||
"github.com/samcharles93/archie-core/internal/infrastructure/postgres"
|
||||
)
|
||||
|
||||
// provisionCommand is the argv[1] token that runs the one-time database role
|
||||
// setup instead of serving. Provisioning has to happen before the first
|
||||
// migration and needs a credential the services never hold, so it cannot be a
|
||||
// migration and is not part of any service's boot.
|
||||
const provisionCommand = "provision"
|
||||
|
||||
// provisionUsage is the whole flag surface of the provisioning command.
|
||||
const provisionUsage = `usage: archie-state-store provision [flags]
|
||||
|
||||
provision reconciles the PostgreSQL roles an install serves from:
|
||||
|
||||
- a migration role that owns the schema and runs goose;
|
||||
- a runtime role with row access only (SELECT, INSERT, UPDATE, DELETE, plus
|
||||
sequence USAGE and function EXECUTE), which the services connect as.
|
||||
|
||||
It creates the two roles when missing, hands every existing public-schema
|
||||
object to the migration role, and sets the default privileges that keep the
|
||||
objects future migrations create usable by the runtime role. It is idempotent:
|
||||
re-running it on a provisioned database reconciles it back to that state.
|
||||
|
||||
The admin URL needs a role that may create roles and take ownership of the
|
||||
schema (the database owner or a superuser). It is a bootstrap credential: it is
|
||||
not one of the two roles above and the services never read it.
|
||||
|
||||
Passwords come from each URL's userinfo, or from PGPASSWORD when the URL does
|
||||
not carry one.
|
||||
|
||||
-admin-url URL role that creates and owns (database owner or superuser)
|
||||
-runtime-url URL least-privilege role the services connect as
|
||||
-migration-url URL role that owns the schema and runs migrations
|
||||
-rotate-admin-password-env NAME
|
||||
replace the admin role's password with the value of
|
||||
environment variable NAME once provisioning succeeds
|
||||
`
|
||||
|
||||
// IsProvisionArgs reports whether args selects the role provisioning command.
|
||||
func IsProvisionArgs(args []string) bool {
|
||||
return len(args) > 0 && args[0] == provisionCommand
|
||||
}
|
||||
|
||||
// RunProvision performs the role provisioning and returns the process exit
|
||||
// code: 0 provisioned, 1 the provisioning failed, 2 the command line was
|
||||
// wrong.
|
||||
func RunProvision(ctx context.Context, args []string, stdout, stderr io.Writer) int {
|
||||
flags := flag.NewFlagSet(provisionCommand, flag.ContinueOnError)
|
||||
flags.SetOutput(stderr)
|
||||
flags.Usage = func() { fmt.Fprint(stderr, provisionUsage) }
|
||||
var options postgres.ProvisionOptions
|
||||
flags.StringVar(&options.AdminURL, "admin-url", "", "PostgreSQL URL of a role allowed to create roles and own the schema (database owner or superuser)")
|
||||
flags.StringVar(&options.RuntimeURL, "runtime-url", "", "PostgreSQL URL of the least-privilege role the services connect as")
|
||||
flags.StringVar(&options.MigrationURL, "migration-url", "", "PostgreSQL URL of the role that owns the schema and runs migrations")
|
||||
rotateEnv := flags.String("rotate-admin-password-env", "", "name of an environment variable holding the admin role's new password")
|
||||
if err := flags.Parse(args); err != nil {
|
||||
// A requested help is not a wrong command line: the usage above is the
|
||||
// answer.
|
||||
if errors.Is(err, flag.ErrHelp) {
|
||||
return 0
|
||||
}
|
||||
return 2
|
||||
}
|
||||
if flags.NArg() > 0 {
|
||||
fmt.Fprintf(stderr, "provision: unexpected argument %q\n", flags.Arg(0))
|
||||
return 2
|
||||
}
|
||||
if *rotateEnv != "" {
|
||||
password, ok := os.LookupEnv(*rotateEnv)
|
||||
if !ok || password == "" {
|
||||
fmt.Fprintf(stderr, "provision: %s is unset or empty\n", *rotateEnv)
|
||||
return 2
|
||||
}
|
||||
options.NewAdminPassword = password
|
||||
}
|
||||
|
||||
result, err := postgres.Provision(ctx, options)
|
||||
if err != nil {
|
||||
fmt.Fprintf(stderr, "provision: %v\n", err)
|
||||
return 1
|
||||
}
|
||||
if len(result.RolesCreated) > 0 {
|
||||
fmt.Fprintf(stdout, "provision: created %s\n", strings.Join(result.RolesCreated, ", "))
|
||||
}
|
||||
fmt.Fprintf(stdout, "provision: %s owns the schema; %s may read and write rows but not change the schema\n", result.MigrationRole, result.RuntimeRole)
|
||||
fmt.Fprintf(stdout, "provision: reconciled %d tables, %d sequences and %d functions\n", result.Tables, result.Sequences, result.Functions)
|
||||
return 0
|
||||
}
|
||||
@@ -4,12 +4,13 @@
|
||||
// starting, and the in-band remedy -- replaying an earlier revision while the
|
||||
// State Store is up -- is unavailable in exactly the case that needs it
|
||||
//
|
||||
// Every operation but import works on the PostgreSQL database database_url
|
||||
// names (state_store_recovery_postgres.go). The ones that write refuse while a
|
||||
// serving process owns the store. Backup is the exception and deliberately so:
|
||||
// the update installer cannot stop the process that runs it, so the snapshot
|
||||
// that makes a failed update recoverable is taken against a serving store
|
||||
// through a consistent copy.
|
||||
// Every operation but import works on the PostgreSQL database
|
||||
// migration_database_url names, or database_url when the install has not split
|
||||
// the roles (state_store_recovery_postgres.go). The ones that write refuse
|
||||
// while a serving process owns the store. Backup is the exception and
|
||||
// deliberately so: the update installer cannot stop the process that runs it,
|
||||
// so the snapshot that makes a failed update recoverable is taken against a
|
||||
// serving store through a consistent copy.
|
||||
//
|
||||
// The control-plane server both validate and rollback read through is built by
|
||||
// openStateStoreControlPlane -- the same root helper the served path uses -- so
|
||||
|
||||
@@ -11,15 +11,18 @@ import (
|
||||
)
|
||||
|
||||
// runPostgresRecovery performs one recovery operation on the PostgreSQL
|
||||
// database the configuration names. There is no automatic schema rollback:
|
||||
// goose Down drops tables, so the way back from a migration is restoring the
|
||||
// snapshot taken before it, which loses every write made after that snapshot.
|
||||
// database the configuration names. It connects as the migration role
|
||||
// (migration_database_url, falling back to database_url): restoring and
|
||||
// rolling back replace schema objects, which only the schema's owner may do.
|
||||
// There is no automatic schema rollback: goose Down drops tables, so the way
|
||||
// back from a migration is restoring the snapshot taken before it, which loses
|
||||
// every write made after that snapshot.
|
||||
func runPostgresRecovery(ctx context.Context, options RecoveryOptions) (string, error) {
|
||||
cfg, err := bootConfig(ctx, options)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
url := cfg.DatabaseURL
|
||||
url := cfg.MigrationURL()
|
||||
if url == "" {
|
||||
return "", errors.New("database_url is required: the configuration names no PostgreSQL database")
|
||||
}
|
||||
@@ -55,7 +58,7 @@ func runPostgresRecovery(ctx context.Context, options RecoveryOptions) (string,
|
||||
// openRecoveryPool opens the database without migrating it: recovery inspects
|
||||
// or repairs the schema it finds, and refuses one newer than this binary.
|
||||
func openRecoveryPool(ctx context.Context, url string) (*pgxpool.Pool, int64, error) {
|
||||
pool, err := postgres.Open(ctx, url)
|
||||
pool, err := postgres.Open(ctx, url, postgres.AppStateStore+"-recovery")
|
||||
if err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
@@ -119,7 +122,9 @@ func SchemaVersion(ctx context.Context, options RecoveryOptions) (int64, error)
|
||||
if cfg.DatabaseURL == "" {
|
||||
return 0, errors.New("database_url is required: the configuration names no PostgreSQL database")
|
||||
}
|
||||
pool, err := postgres.Open(ctx, cfg.DatabaseURL)
|
||||
// The updater asks this while the services serve, so it reads the version
|
||||
// through the runtime role: SELECT on goose's table is all it needs.
|
||||
pool, err := postgres.Open(ctx, cfg.DatabaseURL, postgres.AppStateStore+"-schema")
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
@@ -366,10 +366,15 @@ type Config struct {
|
||||
// embedded NATS store and its endpoint file, the task-log registry, and
|
||||
// the readiness disk probe's data target. Bootstrap-only.
|
||||
StateDir string `toml:"state_dir" yaml:"state_dir"`
|
||||
// DatabaseURL is the PostgreSQL URL the State Store opens at boot. Required;
|
||||
// DatabaseURL is the PostgreSQL URL the services open at boot. Required;
|
||||
// bootstrap-only.
|
||||
DatabaseURL string `toml:"database_url" yaml:"database_url"`
|
||||
PollInterval Duration `toml:"poll_interval" yaml:"poll_interval"`
|
||||
DatabaseURL string `toml:"database_url" yaml:"database_url"`
|
||||
// MigrationDatabaseURL is the PostgreSQL URL migrations and schema-changing
|
||||
// recovery run under: a role that owns the schema, not the one serving
|
||||
// requests. Empty falls back to DatabaseURL, which is how a single-role
|
||||
// install keeps working. Bootstrap-only.
|
||||
MigrationDatabaseURL string `toml:"migration_database_url" yaml:"migration_database_url"`
|
||||
PollInterval Duration `toml:"poll_interval" yaml:"poll_interval"`
|
||||
// Label marks issues archie should pick up.
|
||||
Label string `toml:"label" yaml:"label"`
|
||||
BotUser string `toml:"bot_user" yaml:"bot_user"`
|
||||
@@ -428,6 +433,16 @@ type Config struct {
|
||||
Curators []CuratorDefinition `toml:"curators" yaml:"curators" json:"curators,omitempty"`
|
||||
}
|
||||
|
||||
// MigrationURL is the URL migrations and schema-changing recovery run under.
|
||||
// It falls back to DatabaseURL so an install that has not split the runtime
|
||||
// and migration roles behaves as it always has.
|
||||
func (c Config) MigrationURL() string {
|
||||
if c.MigrationDatabaseURL != "" {
|
||||
return c.MigrationDatabaseURL
|
||||
}
|
||||
return c.DatabaseURL
|
||||
}
|
||||
|
||||
// IdentityConfig is a per-identity configuration subset. Forge access comes
|
||||
// from the identity's organisation connections; runtime settings come from
|
||||
// the shared control plane.
|
||||
|
||||
@@ -4,6 +4,7 @@ package configuration
|
||||
// to the reason shown to the operator.
|
||||
var DeniedKeys = map[string]string{
|
||||
"database_url": "Set in the config file. Needs a restart.",
|
||||
"migration_database_url": "Set in the config file. Needs a restart.",
|
||||
"state_dir": "Set in the config file. Needs a restart.",
|
||||
"work_dir": "Set in the config file. Needs a restart.",
|
||||
"forge.type": "Needs a restart.",
|
||||
|
||||
@@ -12,6 +12,7 @@ import (
|
||||
"github.com/samcharles93/archie-core/internal/config"
|
||||
"github.com/samcharles93/archie-core/internal/infrastructure/configuration"
|
||||
"github.com/samcharles93/archie-core/internal/infrastructure/configuration/tomlwrite"
|
||||
"github.com/samcharles93/archie-core/internal/infrastructure/postgres"
|
||||
)
|
||||
|
||||
// SecretSink receives the secret values setup collects. Put buffers; the
|
||||
@@ -82,11 +83,15 @@ func RunParams(ctx context.Context, p Prompter, discovery ModelDiscovery, secret
|
||||
}
|
||||
}
|
||||
|
||||
dbURL, err := stepDatabase(ctx, p, secrets, existing.DatabaseURL, params.DatabaseURL)
|
||||
dbURL, migrationURL, err := stepDatabase(ctx, p, secrets, existing.DatabaseURL, params.DatabaseURL)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
add(tableEdits{"": {"database_url": tomlwrite.String(dbURL)}})
|
||||
dbEdits := tableEdits{"": {"database_url": tomlwrite.String(dbURL)}}
|
||||
if migrationURL != "" {
|
||||
dbEdits[""]["migration_database_url"] = tomlwrite.String(migrationURL)
|
||||
}
|
||||
add(dbEdits)
|
||||
|
||||
botUser := params.BotUser
|
||||
if strings.TrimSpace(botUser) == "" {
|
||||
@@ -135,14 +140,15 @@ func RunParams(ctx context.Context, p Prompter, discovery ModelDiscovery, secret
|
||||
return edits, nil
|
||||
}
|
||||
|
||||
// stepDatabase returns the PostgreSQL URL. A blank answer on a fresh install
|
||||
// means the bundled database. On a re-run with an existing URL the bundled
|
||||
// database is an explicit choice rather than something reachable only by
|
||||
// typing its socket URL; keeping the existing URL is the first option, so
|
||||
// the default answer is unchanged.
|
||||
func stepDatabase(ctx context.Context, p Prompter, secrets SecretSink, existing, param string) (string, error) {
|
||||
// stepDatabase returns the PostgreSQL URLs the install serves from: the
|
||||
// runtime role's URL and, for the bundled database, the migration role's. A
|
||||
// blank answer on a fresh install means the bundled database. On a re-run with
|
||||
// an existing URL the bundled database is an explicit choice rather than
|
||||
// something reachable only by typing its socket URL; keeping the existing URL
|
||||
// is the first option, so the default answer is unchanged.
|
||||
func stepDatabase(ctx context.Context, p Prompter, secrets SecretSink, existing, param string) (runtimeURL, migrationURL string, err error) {
|
||||
if strings.TrimSpace(param) != "" {
|
||||
return param, nil
|
||||
return param, "", nil
|
||||
}
|
||||
if strings.TrimSpace(existing) != "" {
|
||||
choice, err := p.Select(ctx, "Database:", []string{
|
||||
@@ -151,48 +157,53 @@ func stepDatabase(ctx context.Context, p Prompter, secrets SecretSink, existing,
|
||||
"Enter a different PostgreSQL 18 URL",
|
||||
})
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("setup: database choice: %w", err)
|
||||
return "", "", fmt.Errorf("setup: database choice: %w", err)
|
||||
}
|
||||
switch choice {
|
||||
case 0:
|
||||
return existing, nil
|
||||
return existing, "", nil
|
||||
case 1:
|
||||
return bundledDatabase(secrets)
|
||||
default:
|
||||
url, err := p.ReadLine(ctx, "PostgreSQL 18 URL: ", "")
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("setup: database url: %w", err)
|
||||
return "", "", fmt.Errorf("setup: database url: %w", err)
|
||||
}
|
||||
if strings.TrimSpace(url) == "" {
|
||||
// A blank answer keeps the existing URL, as it always has.
|
||||
return existing, nil
|
||||
return existing, "", nil
|
||||
}
|
||||
return url, nil
|
||||
return url, "", nil
|
||||
}
|
||||
}
|
||||
prompt := "PostgreSQL 18 URL (blank for the bundled database with a generated password): "
|
||||
url, err := p.ReadLine(ctx, prompt, "")
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("setup: database url: %w", err)
|
||||
return "", "", fmt.Errorf("setup: database url: %w", err)
|
||||
}
|
||||
if strings.TrimSpace(url) != "" {
|
||||
return url, nil
|
||||
return url, "", nil
|
||||
}
|
||||
return bundledDatabase(secrets)
|
||||
}
|
||||
|
||||
// bundledDatabase switches to the bundled database: no network, reached
|
||||
// through its Unix socket, with a generated password that goes only to the
|
||||
// env file as PGPASSWORD, which pgx and Compose both read, so config.toml
|
||||
// holds no secret.
|
||||
func bundledDatabase(secrets SecretSink) (string, error) {
|
||||
// through its Unix socket. The services connect as the least-privilege runtime
|
||||
// role and migrations run as the schema-owning migration role; one generated
|
||||
// password goes only to the env file as PGPASSWORD, which pgx reads for both
|
||||
// passwordless URLs, so config.toml holds no secret. The superuser credential
|
||||
// the bundled server is created with lives in the installer's Compose-only
|
||||
// env file, never here.
|
||||
func bundledDatabase(secrets SecretSink) (runtimeURL, migrationURL string, err error) {
|
||||
pw := make([]byte, 24)
|
||||
if _, err := rand.Read(pw); err != nil {
|
||||
return "", fmt.Errorf("setup: generate database password: %w", err)
|
||||
return "", "", fmt.Errorf("setup: generate database password: %w", err)
|
||||
}
|
||||
password := hex.EncodeToString(pw)
|
||||
if err := secrets.Put("env", "PGPASSWORD", password); err != nil {
|
||||
return "", fmt.Errorf("setup: store database password: %w", err)
|
||||
return "", "", fmt.Errorf("setup: store database password: %w", err)
|
||||
}
|
||||
return "postgres://archie@/archie?host=" + configuration.DefaultPostgresSocketDir(), nil
|
||||
socket := configuration.DefaultPostgresSocketDir()
|
||||
return "postgres://" + postgres.RuntimeRole + "@/archie?host=" + socket,
|
||||
"postgres://" + postgres.MigrationRole + "@/archie?host=" + socket, nil
|
||||
}
|
||||
@@ -77,7 +77,11 @@ const (
|
||||
)
|
||||
|
||||
func bundledURL() string {
|
||||
return "postgres://archie@/archie?host=" + configuration.DefaultPostgresSocketDir()
|
||||
return "postgres://archie_runtime@/archie?host=" + configuration.DefaultPostgresSocketDir()
|
||||
}
|
||||
|
||||
func bundledMigrationURL() string {
|
||||
return "postgres://archie_migrator@/archie?host=" + configuration.DefaultPostgresSocketDir()
|
||||
}
|
||||
|
||||
// TestRunParamsDatabaseChoice pins the re-run database step at the setup API
|
||||
@@ -92,12 +96,13 @@ func TestRunParamsDatabaseChoice(t *testing.T) {
|
||||
// existing is the prefilled database_url; empty means fresh install.
|
||||
existing string
|
||||
// param is Params.DatabaseURL (the -database-url flag).
|
||||
param string
|
||||
selectAnswers map[string]int
|
||||
lineAnswers map[string]string
|
||||
wantURL string
|
||||
wantPassword bool
|
||||
wantChoice bool // a database Select menu must be presented
|
||||
param string
|
||||
selectAnswers map[string]int
|
||||
lineAnswers map[string]string
|
||||
wantURL string
|
||||
wantMigrationURL string // empty means the flow must not write one
|
||||
wantPassword bool
|
||||
wantChoice bool // a database Select menu must be presented
|
||||
}{
|
||||
{
|
||||
name: "re-run keep existing is the default choice",
|
||||
@@ -107,12 +112,13 @@ func TestRunParamsDatabaseChoice(t *testing.T) {
|
||||
wantChoice: true,
|
||||
},
|
||||
{
|
||||
name: "re-run switch to the bundled database",
|
||||
existing: existing,
|
||||
selectAnswers: map[string]int{databasePrompt: bundledChoice},
|
||||
wantURL: bundledURL(),
|
||||
wantPassword: true,
|
||||
wantChoice: true,
|
||||
name: "re-run switch to the bundled database",
|
||||
existing: existing,
|
||||
selectAnswers: map[string]int{databasePrompt: bundledChoice},
|
||||
wantURL: bundledURL(),
|
||||
wantMigrationURL: bundledMigrationURL(),
|
||||
wantPassword: true,
|
||||
wantChoice: true,
|
||||
},
|
||||
{
|
||||
name: "re-run enter a different URL",
|
||||
@@ -131,12 +137,13 @@ func TestRunParamsDatabaseChoice(t *testing.T) {
|
||||
wantChoice: true,
|
||||
},
|
||||
{
|
||||
name: "fresh install blank answer means the bundled database",
|
||||
existing: "",
|
||||
lineAnswers: map[string]string{"PostgreSQL 18 URL (blank for the bundled database with a generated password): ": ""},
|
||||
wantURL: bundledURL(),
|
||||
wantPassword: true,
|
||||
wantChoice: false,
|
||||
name: "fresh install blank answer means the bundled database",
|
||||
existing: "",
|
||||
lineAnswers: map[string]string{"PostgreSQL 18 URL (blank for the bundled database with a generated password): ": ""},
|
||||
wantURL: bundledURL(),
|
||||
wantMigrationURL: bundledMigrationURL(),
|
||||
wantPassword: true,
|
||||
wantChoice: false,
|
||||
},
|
||||
{
|
||||
name: "database-url flag wins without prompting",
|
||||
@@ -167,15 +174,28 @@ func TestRunParamsDatabaseChoice(t *testing.T) {
|
||||
t.Fatalf("RunParams: %v", err)
|
||||
}
|
||||
|
||||
var gotURL string
|
||||
var gotURL, gotMigrationURL string
|
||||
for _, e := range edits {
|
||||
if e.Table == "" && e.Key == "database_url" {
|
||||
if e.Table != "" {
|
||||
continue
|
||||
}
|
||||
switch e.Key {
|
||||
case "database_url":
|
||||
gotURL = e.Value
|
||||
case "migration_database_url":
|
||||
gotMigrationURL = e.Value
|
||||
}
|
||||
}
|
||||
if gotURL != tomlwrite.String(tt.wantURL) {
|
||||
t.Errorf("database_url = %s, want %s", gotURL, tomlwrite.String(tt.wantURL))
|
||||
}
|
||||
wantMigrationURL := ""
|
||||
if tt.wantMigrationURL != "" {
|
||||
wantMigrationURL = tomlwrite.String(tt.wantMigrationURL)
|
||||
}
|
||||
if gotMigrationURL != wantMigrationURL {
|
||||
t.Errorf("migration_database_url = %q, want %q", gotMigrationURL, wantMigrationURL)
|
||||
}
|
||||
|
||||
password, hasPassword := sink.puts["env/PGPASSWORD"]
|
||||
if hasPassword != tt.wantPassword {
|
||||
|
||||
@@ -139,7 +139,7 @@ func Restore(ctx context.Context, databaseURL, from string) error {
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
pool, err := Open(ctx, databaseURL)
|
||||
pool, err := Open(ctx, databaseURL, AppStateStore+"-restore")
|
||||
if err != nil {
|
||||
return fmt.Errorf("postgres: restore cannot confirm every service is stopped: %w", err)
|
||||
}
|
||||
|
||||
@@ -18,6 +18,18 @@ import (
|
||||
// minServerVersion is PostgreSQL 18 in server_version_num form.
|
||||
const minServerVersion = 180000
|
||||
|
||||
// The application_name each service sets on its connections, so
|
||||
// pg_stat_activity says which service a connection belongs to. PostgreSQL
|
||||
// truncates the value at 63 bytes, which every name below is inside.
|
||||
const (
|
||||
AppStateStore = "archie-state-store"
|
||||
AppGateway = "archie-gateway"
|
||||
)
|
||||
|
||||
// migrationSuffix marks the transient pool that applies migrations, so the
|
||||
// activity view distinguishes it from the pool that serves traffic.
|
||||
const migrationSuffix = "-migrate"
|
||||
|
||||
//go:embed migrations/*.sql
|
||||
var migrations embed.FS
|
||||
|
||||
@@ -42,8 +54,21 @@ func checkServerVersion(num int) error {
|
||||
}
|
||||
|
||||
// Open connects a pool to url and refuses a server older than PostgreSQL 18.
|
||||
func Open(ctx context.Context, url string) (*pgxpool.Pool, error) {
|
||||
pool, err := pgxpool.New(ctx, url)
|
||||
// applicationName is the service name every connection reports to
|
||||
// pg_stat_activity; it overrides any name the URL carries, so no connection
|
||||
// arrives unnamed because a deployment template forgot one.
|
||||
func Open(ctx context.Context, url, applicationName string) (*pgxpool.Pool, error) {
|
||||
poolConfig, err := pgxpool.ParseConfig(url)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("postgres: open: %w", err)
|
||||
}
|
||||
if applicationName != "" {
|
||||
if poolConfig.ConnConfig.RuntimeParams == nil {
|
||||
poolConfig.ConnConfig.RuntimeParams = map[string]string{}
|
||||
}
|
||||
poolConfig.ConnConfig.RuntimeParams["application_name"] = applicationName
|
||||
}
|
||||
pool, err := pgxpool.NewWithConfig(ctx, poolConfig)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("postgres: open: %w", err)
|
||||
}
|
||||
@@ -60,20 +85,44 @@ func Open(ctx context.Context, url string) (*pgxpool.Pool, error) {
|
||||
}
|
||||
|
||||
// OpenMigrated opens and migrates the pool a service owns its tables in.
|
||||
// service names the owner in the error an empty database_url produces.
|
||||
func OpenMigrated(ctx context.Context, url, service string) (*pgxpool.Pool, error) {
|
||||
if url == "" {
|
||||
return nil, fmt.Errorf("database_url is required: %s is Postgres-only", service)
|
||||
// applicationName names the service in pg_stat_activity.
|
||||
//
|
||||
// runtimeURL is the pool the service serves from; migrationURL is the role
|
||||
// that owns the schema and applies migrations. An empty migrationURL falls
|
||||
// back to runtimeURL: an install that has not split the roles keeps working
|
||||
// exactly as before, applying the schema through its one role.
|
||||
func OpenMigrated(ctx context.Context, runtimeURL, migrationURL, applicationName string) (*pgxpool.Pool, error) {
|
||||
if runtimeURL == "" {
|
||||
return nil, fmt.Errorf("database_url is required: %s is PostgreSQL-only", applicationName)
|
||||
}
|
||||
pool, err := Open(ctx, url)
|
||||
if migrationURL == "" {
|
||||
migrationURL = runtimeURL
|
||||
}
|
||||
if migrationURL == runtimeURL {
|
||||
// One role for both jobs: migrate on the serving pool, as before.
|
||||
pool, err := Open(ctx, runtimeURL, applicationName)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := Migrate(ctx, pool, Migrations()); err != nil {
|
||||
pool.Close()
|
||||
return nil, err
|
||||
}
|
||||
return pool, nil
|
||||
}
|
||||
// The migration role is not the serving role: migrate on a short-lived
|
||||
// pool of its own, then open the serving pool. The two do not overlap, so a
|
||||
// runtime role with no schema privileges never carries goose's work.
|
||||
migrationPool, err := Open(ctx, migrationURL, applicationName+migrationSuffix)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := Migrate(ctx, pool, Migrations()); err != nil {
|
||||
pool.Close()
|
||||
return nil, err
|
||||
migrateErr := Migrate(ctx, migrationPool, Migrations())
|
||||
migrationPool.Close()
|
||||
if migrateErr != nil {
|
||||
return nil, migrateErr
|
||||
}
|
||||
return pool, nil
|
||||
return Open(ctx, runtimeURL, applicationName)
|
||||
}
|
||||
|
||||
// Migrate applies the goose migrations in fsys. A session-level advisory lock
|
||||
|
||||
@@ -0,0 +1,534 @@
|
||||
package postgres
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/hmac"
|
||||
"crypto/rand"
|
||||
"crypto/sha256"
|
||||
"encoding/base64"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net/url"
|
||||
"os"
|
||||
"strings"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
"golang.org/x/crypto/pbkdf2"
|
||||
)
|
||||
|
||||
// The roles the bundled installer provisions. An install pointed at its own
|
||||
// database may name different roles in its URLs; these are the names setup
|
||||
// writes into the bundled configuration.
|
||||
const (
|
||||
RuntimeRole = "archie_runtime"
|
||||
MigrationRole = "archie_migrator"
|
||||
)
|
||||
|
||||
// provisionAdminSuffix names the provisioning connection in pg_stat_activity.
|
||||
const provisionAdminSuffix = "-provision"
|
||||
|
||||
// ProvisionOptions names the three roles one provision run reconciles.
|
||||
type ProvisionOptions struct {
|
||||
// AdminURL is a role allowed to create roles and take ownership of the
|
||||
// schema: the database owner or a superuser. It is a bootstrap credential,
|
||||
// used once into the database and never stored by the services, and it
|
||||
// must not be one of the two roles being provisioned.
|
||||
AdminURL string
|
||||
// RuntimeURL is the least-privilege role the services connect as.
|
||||
RuntimeURL string
|
||||
// MigrationURL is the role that owns the schema and runs migrations.
|
||||
MigrationURL string
|
||||
// NewAdminPassword, when set, replaces the admin role's password at the end
|
||||
// of a successful run. The installer uses it to move the superuser
|
||||
// credential out of the env file the services load.
|
||||
NewAdminPassword string
|
||||
}
|
||||
|
||||
// ProvisionResult reports what one provision run reconciled.
|
||||
type ProvisionResult struct {
|
||||
RuntimeRole string
|
||||
MigrationRole string
|
||||
AdminRole string
|
||||
// RolesCreated lists the roles this run created; a re-run creates none.
|
||||
RolesCreated []string
|
||||
// Tables, Sequences and Functions count the public objects this run took
|
||||
// ownership of. A fresh database has none yet; the migration role's default
|
||||
// privileges cover the objects its first migration creates.
|
||||
Tables int
|
||||
Sequences int
|
||||
Functions int
|
||||
}
|
||||
|
||||
// provisionRoles is the role set a run reconciles, with the password each
|
||||
// login must have afterwards.
|
||||
type provisionRoles struct {
|
||||
admin provisionRole
|
||||
runtime provisionRole
|
||||
migration provisionRole
|
||||
}
|
||||
|
||||
type provisionRole struct {
|
||||
name string
|
||||
password string
|
||||
}
|
||||
|
||||
// Provision makes the database safe to serve from: it creates the migration
|
||||
// role that owns the schema and the runtime role with only row access, then
|
||||
// hands every existing object to the migration role and sets the default
|
||||
// privileges that keep objects created by future migrations usable by the
|
||||
// runtime. It is idempotent: running it on a provisioned database reconciles
|
||||
// it back to that state.
|
||||
//
|
||||
// The connection URLs also carry each role's password (or PGPASSWORD when they
|
||||
// do not). Provisioning is the only place a superuser password is needed; it
|
||||
// is not stored anywhere the services read.
|
||||
func Provision(ctx context.Context, opts ProvisionOptions) (ProvisionResult, error) {
|
||||
roles, err := parseProvisionURLs(opts, os.Getenv)
|
||||
if err != nil {
|
||||
return ProvisionResult{}, err
|
||||
}
|
||||
pool, err := Open(ctx, opts.AdminURL, AppStateStore+provisionAdminSuffix)
|
||||
if err != nil {
|
||||
return ProvisionResult{}, err
|
||||
}
|
||||
defer pool.Close()
|
||||
|
||||
tx, err := pool.Begin(ctx)
|
||||
if err != nil {
|
||||
return ProvisionResult{}, fmt.Errorf("postgres: provision: begin: %w", err)
|
||||
}
|
||||
defer func() { _ = tx.Rollback(ctx) }()
|
||||
result, err := provisionTx(ctx, tx, roles, opts.NewAdminPassword)
|
||||
if err != nil {
|
||||
return ProvisionResult{}, err
|
||||
}
|
||||
if err := tx.Commit(ctx); err != nil {
|
||||
return ProvisionResult{}, fmt.Errorf("postgres: provision: commit: %w", err)
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// provisionTx performs one provisioning run inside tx, so a failure at any
|
||||
// step leaves the database as it was.
|
||||
func provisionTx(ctx context.Context, tx pgx.Tx, roles provisionRoles, newAdminPassword string) (ProvisionResult, error) {
|
||||
result := ProvisionResult{
|
||||
RuntimeRole: roles.runtime.name,
|
||||
MigrationRole: roles.migration.name,
|
||||
AdminRole: roles.admin.name,
|
||||
}
|
||||
for _, role := range []provisionRole{roles.runtime, roles.migration} {
|
||||
created, err := ensureProvisionRole(ctx, tx, role)
|
||||
if err != nil {
|
||||
return ProvisionResult{}, err
|
||||
}
|
||||
if created {
|
||||
result.RolesCreated = append(result.RolesCreated, role.name)
|
||||
}
|
||||
}
|
||||
// The schema owner must change before the objects move: PostgreSQL only
|
||||
// lets an object's owner (or a superuser) hand it to the migration role.
|
||||
for _, statement := range schemaStatements(roles) {
|
||||
if _, err := tx.Exec(ctx, statement); err != nil {
|
||||
return ProvisionResult{}, fmt.Errorf("postgres: provision %s: %w", statement, err)
|
||||
}
|
||||
}
|
||||
objects, err := schemaObjects(ctx, tx, roles.migration.name)
|
||||
if err != nil {
|
||||
return ProvisionResult{}, err
|
||||
}
|
||||
for _, object := range objects {
|
||||
statement := object.ownerStatement(roles.migration.name)
|
||||
if _, err := tx.Exec(ctx, statement); err != nil {
|
||||
return ProvisionResult{}, fmt.Errorf("postgres: provision %s: %w", statement, err)
|
||||
}
|
||||
switch object.kind {
|
||||
case objectTable, objectForeignTable, objectPartitionedTable:
|
||||
result.Tables++
|
||||
case objectSequence:
|
||||
result.Sequences++
|
||||
default:
|
||||
result.Functions++
|
||||
}
|
||||
}
|
||||
if newAdminPassword != "" {
|
||||
if err := setRolePassword(ctx, tx, roles.admin.name, newAdminPassword); err != nil {
|
||||
return ProvisionResult{}, err
|
||||
}
|
||||
}
|
||||
if err := verifyProvision(ctx, tx, roles); err != nil {
|
||||
return ProvisionResult{}, err
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// ensureProvisionRole creates role as a non-superuser login when it is missing,
|
||||
// and reconciles an existing role back to that shape. It refuses a role that
|
||||
// is still a superuser: demoting a superuser is the operator's decision, not a
|
||||
// side effect of an install.
|
||||
func ensureProvisionRole(ctx context.Context, tx pgx.Tx, role provisionRole) (bool, error) {
|
||||
verifier, err := scramVerifier(role.password)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
var superuser bool
|
||||
err = tx.QueryRow(ctx, "SELECT rolsuper FROM pg_roles WHERE rolname = $1", role.name).Scan(&superuser)
|
||||
switch {
|
||||
case errors.Is(err, pgx.ErrNoRows):
|
||||
statement := "CREATE ROLE " + quoteIdent(role.name) + " LOGIN NOSUPERUSER NOCREATEDB NOCREATEROLE PASSWORD " + quoteLiteral(verifier)
|
||||
if _, err := tx.Exec(ctx, statement); err != nil {
|
||||
return false, fmt.Errorf("postgres: provision create role %s: %w", role.name, err)
|
||||
}
|
||||
return true, nil
|
||||
case err != nil:
|
||||
return false, fmt.Errorf("postgres: provision read role %s: %w", role.name, err)
|
||||
case superuser:
|
||||
return false, fmt.Errorf("postgres: provision refuses role %q: it is a superuser; name a least-privilege role instead", role.name)
|
||||
}
|
||||
// An existing role may have been created by hand with more than it needs.
|
||||
statement := "ALTER ROLE " + quoteIdent(role.name) + " LOGIN NOSUPERUSER NOCREATEDB NOCREATEROLE PASSWORD " + quoteLiteral(verifier)
|
||||
if _, err := tx.Exec(ctx, statement); err != nil {
|
||||
return false, fmt.Errorf("postgres: provision update role %s: %w", role.name, err)
|
||||
}
|
||||
return false, nil
|
||||
}
|
||||
|
||||
// setRolePassword stores a new password for role without sending the plaintext
|
||||
// to the server as SQL.
|
||||
func setRolePassword(ctx context.Context, tx pgx.Tx, role, password string) error {
|
||||
verifier, err := scramVerifier(password)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
statement := "ALTER ROLE " + quoteIdent(role) + " PASSWORD " + quoteLiteral(verifier)
|
||||
if _, err := tx.Exec(ctx, statement); err != nil {
|
||||
return fmt.Errorf("postgres: provision rotate %s password: %w", role, err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// schemaStatements is the fixed part of a provision run: who owns the schema
|
||||
// and what the runtime role may do in it. Every statement is idempotent, so a
|
||||
// re-run is a reconciliation rather than a second install.
|
||||
func schemaStatements(roles provisionRoles) []string {
|
||||
runtime := quoteIdent(roles.runtime.name)
|
||||
migration := quoteIdent(roles.migration.name)
|
||||
return []string{
|
||||
// The migration role owns the namespace it manufactures the schema in.
|
||||
"ALTER SCHEMA public OWNER TO " + migration,
|
||||
// PostgreSQL 15 made this the default for a new database; an install
|
||||
// created before that may still let every role create objects here.
|
||||
"REVOKE CREATE ON SCHEMA public FROM PUBLIC",
|
||||
"GRANT USAGE ON SCHEMA public TO " + runtime,
|
||||
"GRANT USAGE, CREATE ON SCHEMA public TO " + migration,
|
||||
// The runtime role reads and writes rows, and nothing else: no TRUNCATE,
|
||||
// no ownership, no CREATE. The app's queries never ask for more.
|
||||
"GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO " + runtime,
|
||||
"GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA public TO " + runtime,
|
||||
"GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA public TO " + runtime,
|
||||
// Tables and sequences a future migration creates are owned by the
|
||||
// migration role, so its default privileges are what keeps the runtime
|
||||
// role able to use them without a later grant.
|
||||
"ALTER DEFAULT PRIVILEGES FOR ROLE " + migration + " IN SCHEMA public GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES TO " + runtime,
|
||||
"ALTER DEFAULT PRIVILEGES FOR ROLE " + migration + " IN SCHEMA public GRANT USAGE, SELECT ON SEQUENCES TO " + runtime,
|
||||
"ALTER DEFAULT PRIVILEGES FOR ROLE " + migration + " IN SCHEMA public GRANT EXECUTE ON FUNCTIONS TO " + runtime,
|
||||
}
|
||||
}
|
||||
|
||||
// objectKind is a public-schema object class the migration role must own.
|
||||
type objectKind string
|
||||
|
||||
const (
|
||||
objectTable objectKind = "table"
|
||||
objectPartitionedTable objectKind = "partitioned table"
|
||||
objectSequence objectKind = "sequence"
|
||||
objectView objectKind = "view"
|
||||
objectMaterializedView objectKind = "materialized view"
|
||||
objectForeignTable objectKind = "foreign table"
|
||||
objectFunction objectKind = "function"
|
||||
objectProcedure objectKind = "procedure"
|
||||
)
|
||||
|
||||
// schemaObject is one public-schema object whose ownership moves to the
|
||||
// migration role.
|
||||
type schemaObject struct {
|
||||
kind objectKind
|
||||
// reference is the object's name for a relation, or its regprocedure text
|
||||
// for a function; both are engine-generated, never operator input.
|
||||
reference string
|
||||
}
|
||||
|
||||
// ownerStatement renders the ALTER that hands object to role. Relations are
|
||||
// quoted; a function reference is already the regprocedure form PostgreSQL
|
||||
// renders, argument types included.
|
||||
func (o schemaObject) ownerStatement(role string) string {
|
||||
if o.kind == objectFunction || o.kind == objectProcedure {
|
||||
return "ALTER " + o.kind.alterKeyword() + " " + o.reference + " OWNER TO " + quoteIdent(role)
|
||||
}
|
||||
return "ALTER " + o.kind.alterKeyword() + " " + pgx.Identifier{"public", o.reference}.Sanitize() + " OWNER TO " + quoteIdent(role)
|
||||
}
|
||||
|
||||
// alterKeyword is the object class's ALTER target. A partitioned table is
|
||||
// altered as a table: PostgreSQL has no ALTER PARTITIONED TABLE.
|
||||
func (k objectKind) alterKeyword() string {
|
||||
switch k {
|
||||
case objectTable, objectPartitionedTable:
|
||||
return "TABLE"
|
||||
case objectSequence:
|
||||
return "SEQUENCE"
|
||||
case objectView:
|
||||
return "VIEW"
|
||||
case objectMaterializedView:
|
||||
return "MATERIALIZED VIEW"
|
||||
case objectForeignTable:
|
||||
return "FOREIGN TABLE"
|
||||
case objectProcedure:
|
||||
return "PROCEDURE"
|
||||
default:
|
||||
return "FUNCTION"
|
||||
}
|
||||
}
|
||||
|
||||
// schemaObjects lists the public-schema objects someone other than the
|
||||
// migration role still owns. Objects an extension owns are left alone, and
|
||||
// indexes, row types and sequences owned by a table column follow the table's
|
||||
// owner, so the relation loop does not repeat them. A partition has its own
|
||||
// dependency on the partitioned table, so it is listed and transferred too.
|
||||
func schemaObjects(ctx context.Context, tx pgx.Tx, migrationRole string) ([]schemaObject, error) {
|
||||
rows, err := tx.Query(ctx, `
|
||||
SELECT c.relkind, c.relname
|
||||
FROM pg_class c
|
||||
JOIN pg_namespace n ON n.oid = c.relnamespace
|
||||
WHERE n.nspname = 'public'
|
||||
AND c.relkind IN ('r', 'p', 'S', 'v', 'm', 'f')
|
||||
AND pg_get_userbyid(c.relowner) <> $1
|
||||
AND NOT EXISTS (
|
||||
SELECT 1 FROM pg_depend d
|
||||
WHERE d.classid = 'pg_class'::regclass
|
||||
AND d.objid = c.oid
|
||||
AND d.deptype = 'e')
|
||||
AND (c.relkind <> 'S' OR NOT EXISTS (
|
||||
SELECT 1 FROM pg_depend d
|
||||
WHERE d.classid = 'pg_class'::regclass
|
||||
AND d.objid = c.oid
|
||||
AND d.refclassid = 'pg_class'::regclass
|
||||
AND d.deptype IN ('a', 'i')))
|
||||
ORDER BY c.relkind, c.relname`, migrationRole)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("postgres: provision list schema objects: %w", err)
|
||||
}
|
||||
var objects []schemaObject
|
||||
for rows.Next() {
|
||||
var relkind, name string
|
||||
if err := rows.Scan(&relkind, &name); err != nil {
|
||||
rows.Close()
|
||||
return nil, fmt.Errorf("postgres: provision list schema objects: %w", err)
|
||||
}
|
||||
kind, ok := relationKinds[relkind]
|
||||
if !ok {
|
||||
// An object class this provisioner does not know how to hand over;
|
||||
// leaving it behind is visible in verifyProvision's counts.
|
||||
continue
|
||||
}
|
||||
objects = append(objects, schemaObject{kind: kind, reference: name})
|
||||
}
|
||||
rows.Close()
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, fmt.Errorf("postgres: provision list schema objects: %w", err)
|
||||
}
|
||||
|
||||
rows, err = tx.Query(ctx, `
|
||||
SELECT p.prokind, p.oid::regprocedure::text
|
||||
FROM pg_proc p
|
||||
JOIN pg_namespace n ON n.oid = p.pronamespace
|
||||
WHERE n.nspname = 'public'
|
||||
AND p.prokind IN ('f', 'p')
|
||||
AND pg_get_userbyid(p.proowner) <> $1
|
||||
AND NOT EXISTS (
|
||||
SELECT 1 FROM pg_depend d
|
||||
WHERE d.classid = 'pg_proc'::regclass
|
||||
AND d.objid = p.oid
|
||||
AND d.deptype = 'e')
|
||||
ORDER BY p.oid::regprocedure::text`, migrationRole)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("postgres: provision list schema functions: %w", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
for rows.Next() {
|
||||
var prokind, reference string
|
||||
if err := rows.Scan(&prokind, &reference); err != nil {
|
||||
return nil, fmt.Errorf("postgres: provision list schema functions: %w", err)
|
||||
}
|
||||
kind := objectFunction
|
||||
if prokind == "p" {
|
||||
kind = objectProcedure
|
||||
}
|
||||
objects = append(objects, schemaObject{kind: kind, reference: reference})
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, fmt.Errorf("postgres: provision list schema functions: %w", err)
|
||||
}
|
||||
return objects, nil
|
||||
}
|
||||
|
||||
// relationKinds maps pg_class.relkind to the object class an ALTER names.
|
||||
var relationKinds = map[string]objectKind{
|
||||
"r": objectTable,
|
||||
"p": objectPartitionedTable,
|
||||
"S": objectSequence,
|
||||
"v": objectView,
|
||||
"m": objectMaterializedView,
|
||||
"f": objectForeignTable,
|
||||
}
|
||||
|
||||
// verifyProvision refuses a state that would leave the runtime role able to
|
||||
// change the schema, or either role able to reach superuser powers through a
|
||||
// role membership.
|
||||
func verifyProvision(ctx context.Context, tx pgx.Tx, roles provisionRoles) error {
|
||||
for _, role := range []provisionRole{roles.runtime, roles.migration} {
|
||||
var superuser bool
|
||||
if err := tx.QueryRow(ctx, "SELECT rolsuper FROM pg_roles WHERE rolname = $1", role.name).Scan(&superuser); err != nil {
|
||||
return fmt.Errorf("postgres: provision verify role %s: %w", role.name, err)
|
||||
}
|
||||
if superuser {
|
||||
return fmt.Errorf("postgres: provision left role %q a superuser", role.name)
|
||||
}
|
||||
if err := verifyNoSuperuserMembership(ctx, tx, role.name); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
var canCreate bool
|
||||
if err := tx.QueryRow(ctx, "SELECT has_schema_privilege($1, 'public', 'CREATE')", roles.runtime.name).Scan(&canCreate); err != nil {
|
||||
return fmt.Errorf("postgres: provision verify runtime schema privileges: %w", err)
|
||||
}
|
||||
if canCreate {
|
||||
return fmt.Errorf("postgres: provision left %q able to create schema objects; migrations would not be the migration role's alone", roles.runtime.name)
|
||||
}
|
||||
var migrationCanCreate bool
|
||||
if err := tx.QueryRow(ctx, "SELECT has_schema_privilege($1, 'public', 'CREATE')", roles.migration.name).Scan(&migrationCanCreate); err != nil {
|
||||
return fmt.Errorf("postgres: provision verify migration schema privileges: %w", err)
|
||||
}
|
||||
if !migrationCanCreate {
|
||||
return fmt.Errorf("postgres: provision left %q unable to create schema objects", roles.migration.name)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// verifyNoSuperuserMembership refuses a role that inherits a superuser's
|
||||
// powers through role membership, which rolsuper alone does not show.
|
||||
func verifyNoSuperuserMembership(ctx context.Context, tx pgx.Tx, role string) error {
|
||||
rows, err := tx.Query(ctx, `
|
||||
SELECT parent.rolname
|
||||
FROM pg_auth_members m
|
||||
JOIN pg_roles parent ON parent.oid = m.roleid
|
||||
JOIN pg_roles member ON member.oid = m.member
|
||||
WHERE member.rolname = $1 AND parent.rolsuper`, role)
|
||||
if err != nil {
|
||||
return fmt.Errorf("postgres: provision verify role memberships: %w", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
if rows.Next() {
|
||||
var parent string
|
||||
if err := rows.Scan(&parent); err != nil {
|
||||
return fmt.Errorf("postgres: provision verify role memberships: %w", err)
|
||||
}
|
||||
return fmt.Errorf("postgres: provision refuses role %q: it is a member of superuser role %q", role, parent)
|
||||
}
|
||||
return rows.Err()
|
||||
}
|
||||
|
||||
// parseProvisionURLs reads the three roles out of the URLs the installer
|
||||
// passes, taking a password from the URL's userinfo or, for a passwordless
|
||||
// URL, from PGPASSWORD. It refuses a plan that would leave the runtime role
|
||||
// with powers the services never need.
|
||||
func parseProvisionURLs(opts ProvisionOptions, getenv func(string) string) (provisionRoles, error) {
|
||||
admin, err := roleFromURL(opts.AdminURL, "admin_url", getenv, false)
|
||||
if err != nil {
|
||||
return provisionRoles{}, err
|
||||
}
|
||||
runtime, err := roleFromURL(opts.RuntimeURL, "runtime_url", getenv, true)
|
||||
if err != nil {
|
||||
return provisionRoles{}, err
|
||||
}
|
||||
migration, err := roleFromURL(opts.MigrationURL, "migration_url", getenv, true)
|
||||
if err != nil {
|
||||
return provisionRoles{}, err
|
||||
}
|
||||
if runtime.name == migration.name {
|
||||
return provisionRoles{}, fmt.Errorf("postgres: provision: runtime_url and migration_url name the same role %q; they must differ", runtime.name)
|
||||
}
|
||||
for _, role := range []provisionRole{runtime, migration} {
|
||||
if role.name == admin.name {
|
||||
return provisionRoles{}, fmt.Errorf("postgres: provision: %q is the admin role; runtime_url and migration_url must name the roles being provisioned", role.name)
|
||||
}
|
||||
}
|
||||
return provisionRoles{admin: admin, runtime: runtime, migration: migration}, nil
|
||||
}
|
||||
|
||||
// roleFromURL extracts one login role from a PostgreSQL URL. requirePassword
|
||||
// is set for the two provisioned roles, whose password must be known so the
|
||||
// run can set it; the admin role may authenticate through the environment.
|
||||
func roleFromURL(raw, label string, getenv func(string) string, requirePassword bool) (provisionRole, error) {
|
||||
if strings.TrimSpace(raw) == "" {
|
||||
return provisionRole{}, fmt.Errorf("postgres: provision: %s is required", label)
|
||||
}
|
||||
parsed, err := url.Parse(raw)
|
||||
if err != nil || (parsed.Scheme != "postgres" && parsed.Scheme != "postgresql") {
|
||||
return provisionRole{}, fmt.Errorf("postgres: provision: %s must be a postgres:// URL naming a login role", label)
|
||||
}
|
||||
if parsed.User == nil || parsed.User.Username() == "" {
|
||||
return provisionRole{}, fmt.Errorf("postgres: provision: %s must name the role in its URL userinfo", label)
|
||||
}
|
||||
role := provisionRole{name: parsed.User.Username()}
|
||||
if password, ok := parsed.User.Password(); ok && password != "" {
|
||||
role.password = password
|
||||
} else if password := getenv(databasePasswordEnv); password != "" {
|
||||
role.password = password
|
||||
}
|
||||
if requirePassword && role.password == "" {
|
||||
return provisionRole{}, fmt.Errorf("postgres: provision: %s carries no password and %s is unset", label, databasePasswordEnv)
|
||||
}
|
||||
return role, nil
|
||||
}
|
||||
|
||||
// databasePasswordEnv is the variable pgx and the PostgreSQL client tools read
|
||||
// a connection password from when a URL does not carry one.
|
||||
const databasePasswordEnv = "PGPASSWORD"
|
||||
|
||||
// scramVerifier returns the SCRAM-SHA-256 verifier PostgreSQL stores for
|
||||
// password. ALTER ROLE accepts a pre-computed verifier, so the plaintext never
|
||||
// travels in a statement another session's statement log can capture.
|
||||
func scramVerifier(password string) (string, error) {
|
||||
if password == "" {
|
||||
return "", errors.New("postgres: provision: a role password is required")
|
||||
}
|
||||
const iterations = 4096
|
||||
salt := make([]byte, 16)
|
||||
if _, err := rand.Read(salt); err != nil {
|
||||
return "", fmt.Errorf("postgres: provision: salt: %w", err)
|
||||
}
|
||||
salted := pbkdf2.Key([]byte(password), salt, iterations, sha256.Size, sha256.New)
|
||||
storedKey := sha256.Sum256(hmacSHA256(salted, []byte("Client Key")))
|
||||
serverKey := hmacSHA256(salted, []byte("Server Key"))
|
||||
return fmt.Sprintf("SCRAM-SHA-256$%d:%s$%s:%s",
|
||||
iterations,
|
||||
base64.StdEncoding.EncodeToString(salt),
|
||||
base64.StdEncoding.EncodeToString(storedKey[:]),
|
||||
base64.StdEncoding.EncodeToString(serverKey),
|
||||
), nil
|
||||
}
|
||||
|
||||
func hmacSHA256(key, message []byte) []byte {
|
||||
mac := hmac.New(sha256.New, key)
|
||||
mac.Write(message)
|
||||
return mac.Sum(nil)
|
||||
}
|
||||
|
||||
// quoteIdent quotes an SQL identifier such as a role or table name.
|
||||
func quoteIdent(name string) string { return pgx.Identifier{name}.Sanitize() }
|
||||
|
||||
// quoteLiteral quotes an SQL string literal. scramVerifier's output is
|
||||
// base64 and separators only, so it can never contain the quote being escaped;
|
||||
// the escaping is here so a future caller cannot inject through the value.
|
||||
func quoteLiteral(value string) string {
|
||||
return "'" + strings.ReplaceAll(value, "'", "''") + "'"
|
||||
}
|
||||
@@ -0,0 +1,264 @@
|
||||
package postgres
|
||||
|
||||
import (
|
||||
"encoding/base64"
|
||||
"regexp"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// testProvisionRoles is the role set the statement tests reconcile.
|
||||
func testProvisionRoles() provisionRoles {
|
||||
return provisionRoles{
|
||||
admin: provisionRole{name: "archie", password: "admin-password"},
|
||||
runtime: provisionRole{name: RuntimeRole, password: "runtime-password"},
|
||||
migration: provisionRole{name: MigrationRole, password: "migration-password"},
|
||||
}
|
||||
}
|
||||
|
||||
// TestParseProvisionURLs pins what the installer may hand the provisioner: a
|
||||
// role per URL, a password from the URL or PGPASSWORD, and a refusal for any
|
||||
// plan that would leave the runtime role owning schema changes.
|
||||
func TestParseProvisionURLs(t *testing.T) {
|
||||
const (
|
||||
adminURL = "postgres://archie:admin@db.internal/archie"
|
||||
runtimeURL = "postgres://archie_runtime:runtime@db.internal/archie"
|
||||
migrationURL = "postgres://archie_migrator:migration@db.internal/archie"
|
||||
)
|
||||
tests := []struct {
|
||||
name string
|
||||
opts ProvisionOptions
|
||||
env map[string]string
|
||||
want provisionRoles
|
||||
wantErr string
|
||||
}{
|
||||
{
|
||||
name: "passwords come from the URL userinfo",
|
||||
opts: ProvisionOptions{AdminURL: adminURL, RuntimeURL: runtimeURL, MigrationURL: migrationURL},
|
||||
want: provisionRoles{
|
||||
admin: provisionRole{name: "archie", password: "admin"},
|
||||
runtime: provisionRole{name: RuntimeRole, password: "runtime"},
|
||||
migration: provisionRole{name: MigrationRole, password: "migration"},
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "passwordless role URLs take PGPASSWORD",
|
||||
opts: ProvisionOptions{
|
||||
AdminURL: "postgres://archie@/archie?host=/run/archie/postgres",
|
||||
RuntimeURL: "postgres://archie_runtime@/archie?host=/run/archie/postgres",
|
||||
MigrationURL: "postgres://archie_migrator@/archie?host=/run/archie/postgres",
|
||||
},
|
||||
env: map[string]string{databasePasswordEnv: "from-env"},
|
||||
want: provisionRoles{
|
||||
admin: provisionRole{name: "archie", password: "from-env"},
|
||||
runtime: provisionRole{name: RuntimeRole, password: "from-env"},
|
||||
migration: provisionRole{name: MigrationRole, password: "from-env"},
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "an admin URL needs no password of its own",
|
||||
opts: ProvisionOptions{
|
||||
AdminURL: "postgres://archie@/archie?host=/run/archie/postgres",
|
||||
RuntimeURL: runtimeURL,
|
||||
MigrationURL: migrationURL,
|
||||
},
|
||||
want: provisionRoles{
|
||||
admin: provisionRole{name: "archie"},
|
||||
runtime: provisionRole{name: RuntimeRole, password: "runtime"},
|
||||
migration: provisionRole{name: MigrationRole, password: "migration"},
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "a runtime role with no password is refused",
|
||||
opts: ProvisionOptions{AdminURL: adminURL, RuntimeURL: "postgres://archie_runtime@db.internal/archie", MigrationURL: migrationURL},
|
||||
wantErr: databasePasswordEnv,
|
||||
},
|
||||
{
|
||||
name: "the same role cannot be runtime and migration",
|
||||
opts: ProvisionOptions{AdminURL: adminURL, RuntimeURL: runtimeURL, MigrationURL: "postgres://archie_runtime:other@db.internal/archie"},
|
||||
wantErr: "same role",
|
||||
},
|
||||
{
|
||||
name: "the admin role cannot be provisioned as runtime",
|
||||
opts: ProvisionOptions{AdminURL: adminURL, RuntimeURL: adminURL, MigrationURL: migrationURL},
|
||||
wantErr: "admin role",
|
||||
},
|
||||
{
|
||||
name: "a non-PostgreSQL URL is refused",
|
||||
opts: ProvisionOptions{AdminURL: "mysql://archie:admin@db.internal/archie", RuntimeURL: runtimeURL, MigrationURL: migrationURL},
|
||||
wantErr: "postgres:// URL",
|
||||
},
|
||||
{
|
||||
name: "a URL without a role is refused",
|
||||
opts: ProvisionOptions{AdminURL: adminURL, RuntimeURL: "postgres://db.internal/archie", MigrationURL: migrationURL},
|
||||
wantErr: "userinfo",
|
||||
},
|
||||
{
|
||||
name: "a key=value connection string is refused, it names no role",
|
||||
opts: ProvisionOptions{AdminURL: adminURL, RuntimeURL: "host=db.internal user=archie_runtime", MigrationURL: migrationURL},
|
||||
wantErr: "postgres:// URL",
|
||||
},
|
||||
{
|
||||
name: "a missing role URL is named in the error",
|
||||
opts: ProvisionOptions{AdminURL: adminURL, RuntimeURL: runtimeURL},
|
||||
wantErr: "migration_url is required",
|
||||
},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
getenv := func(key string) string { return tt.env[key] }
|
||||
got, err := parseProvisionURLs(tt.opts, getenv)
|
||||
if tt.wantErr != "" {
|
||||
if err == nil || !strings.Contains(err.Error(), tt.wantErr) {
|
||||
t.Fatalf("parseProvisionURLs error = %v, want one naming %q", err, tt.wantErr)
|
||||
}
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
t.Fatalf("parseProvisionURLs: %v", err)
|
||||
}
|
||||
if got != tt.want {
|
||||
t.Errorf("parseProvisionURLs = %+v, want %+v", got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestSchemaStatements pins the privilege boundary: the runtime role reads and
|
||||
// writes rows and nothing else, the migration role owns the schema, and the
|
||||
// migration role's default privileges cover the objects future migrations
|
||||
// create. A regression here is a security regression, not a formatting one.
|
||||
func TestSchemaStatements(t *testing.T) {
|
||||
roles := testProvisionRoles()
|
||||
runtime := quoteIdent(roles.runtime.name)
|
||||
migration := quoteIdent(roles.migration.name)
|
||||
statements := schemaStatements(roles)
|
||||
joined := strings.Join(statements, "\n")
|
||||
|
||||
required := []string{
|
||||
"ALTER SCHEMA public OWNER TO " + migration,
|
||||
"REVOKE CREATE ON SCHEMA public FROM PUBLIC",
|
||||
"GRANT USAGE ON SCHEMA public TO " + runtime,
|
||||
"GRANT USAGE, CREATE ON SCHEMA public TO " + migration,
|
||||
"GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO " + runtime,
|
||||
"GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA public TO " + runtime,
|
||||
"GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA public TO " + runtime,
|
||||
"ALTER DEFAULT PRIVILEGES FOR ROLE " + migration + " IN SCHEMA public GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES TO " + runtime,
|
||||
"ALTER DEFAULT PRIVILEGES FOR ROLE " + migration + " IN SCHEMA public GRANT USAGE, SELECT ON SEQUENCES TO " + runtime,
|
||||
"ALTER DEFAULT PRIVILEGES FOR ROLE " + migration + " IN SCHEMA public GRANT EXECUTE ON FUNCTIONS TO " + runtime,
|
||||
}
|
||||
for _, statement := range required {
|
||||
if !strings.Contains(joined, statement) {
|
||||
t.Errorf("provisioning lacks %q", statement)
|
||||
}
|
||||
}
|
||||
|
||||
// Every statement that mentions the runtime role must be a row-level grant
|
||||
// or a default privilege: nothing may let it create, own, truncate or
|
||||
// elevate.
|
||||
forbiddenForRuntime := []string{" CREATE ", " SUPERUSER", " CREATEDB", " CREATEROLE", " OWNER TO ", "TRUNCATE", "ALL PRIVILEGES"}
|
||||
for _, statement := range statements {
|
||||
if !strings.Contains(statement, runtime) {
|
||||
continue
|
||||
}
|
||||
for _, forbidden := range forbiddenForRuntime {
|
||||
if strings.Contains(statement, forbidden) {
|
||||
t.Errorf("statement grants the runtime role more than rows: %q", statement)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// The default privileges are what make the next migration's tables usable
|
||||
// without a hand-run grant; one per object class is the contract.
|
||||
var defaults int
|
||||
for _, statement := range statements {
|
||||
if strings.HasPrefix(statement, "ALTER DEFAULT PRIVILEGES FOR ROLE "+migration) {
|
||||
defaults++
|
||||
}
|
||||
}
|
||||
if defaults != 3 {
|
||||
t.Errorf("default privileges for %s = %d statements, want tables, sequences and functions", roles.migration.name, defaults)
|
||||
}
|
||||
}
|
||||
|
||||
// TestSchemaStatementsQuoteRoleNames pins that role names arriving in URLs are
|
||||
// quoted as identifiers, not spliced into SQL.
|
||||
func TestSchemaStatementsQuoteRoleNames(t *testing.T) {
|
||||
roles := provisionRoles{
|
||||
runtime: provisionRole{name: `runtime"; DROP TABLE tasks; --`},
|
||||
migration: provisionRole{name: `migration"role`},
|
||||
}
|
||||
joined := strings.Join(schemaStatements(roles), "\n")
|
||||
if !strings.Contains(joined, `"runtime""; DROP TABLE tasks; --"`) {
|
||||
t.Errorf("runtime role name is not quoted as one identifier:\n%s", joined)
|
||||
}
|
||||
if !strings.Contains(joined, `"migration""role"`) {
|
||||
t.Errorf("migration role name is not quoted as one identifier:\n%s", joined)
|
||||
}
|
||||
}
|
||||
|
||||
// TestOwnerStatement pins the ALTER an object gets when its ownership moves to
|
||||
// the migration role, including PostgreSQL's keyword for each object class.
|
||||
func TestOwnerStatement(t *testing.T) {
|
||||
const role = MigrationRole
|
||||
tests := []struct {
|
||||
name string
|
||||
object schemaObject
|
||||
want string
|
||||
}{
|
||||
{"table", schemaObject{kind: objectTable, reference: "tasks"}, `ALTER TABLE "public"."tasks" OWNER TO "archie_migrator"`},
|
||||
{"partitioned table alters as a table", schemaObject{kind: objectPartitionedTable, reference: "events"}, `ALTER TABLE "public"."events" OWNER TO "archie_migrator"`},
|
||||
{"sequence", schemaObject{kind: objectSequence, reference: "tasks_id_seq"}, `ALTER SEQUENCE "public"."tasks_id_seq" OWNER TO "archie_migrator"`},
|
||||
{"view", schemaObject{kind: objectView, reference: "open_tasks"}, `ALTER VIEW "public"."open_tasks" OWNER TO "archie_migrator"`},
|
||||
{"materialized view", schemaObject{kind: objectMaterializedView, reference: "summary"}, `ALTER MATERIALIZED VIEW "public"."summary" OWNER TO "archie_migrator"`},
|
||||
{"foreign table", schemaObject{kind: objectForeignTable, reference: "remote"}, `ALTER FOREIGN TABLE "public"."remote" OWNER TO "archie_migrator"`},
|
||||
{"function", schemaObject{kind: objectFunction, reference: "audit_json_diff(jsonb,jsonb)"}, `ALTER FUNCTION audit_json_diff(jsonb,jsonb) OWNER TO "archie_migrator"`},
|
||||
{"procedure", schemaObject{kind: objectProcedure, reference: "sweep(integer)"}, `ALTER PROCEDURE sweep(integer) OWNER TO "archie_migrator"`},
|
||||
{"a quoted relation name stays one identifier", schemaObject{kind: objectTable, reference: `bad"name`}, `ALTER TABLE "public"."bad""name" OWNER TO "archie_migrator"`},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
if got := tt.object.ownerStatement(role); got != tt.want {
|
||||
t.Errorf("ownerStatement = %q, want %q", got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestSCRAMVerifier pins that the provisioner stores PostgreSQL a SCRAM
|
||||
// verifier rather than a plaintext password, and that the verifier has the
|
||||
// shape the server accepts.
|
||||
func TestSCRAMVerifier(t *testing.T) {
|
||||
verifier, err := scramVerifier("correct horse battery staple")
|
||||
if err != nil {
|
||||
t.Fatalf("scramVerifier: %v", err)
|
||||
}
|
||||
if strings.Contains(verifier, "correct horse") {
|
||||
t.Fatalf("verifier contains the plaintext password: %q", verifier)
|
||||
}
|
||||
shape := regexp.MustCompile(`^SCRAM-SHA-256\$4096:([A-Za-z0-9+/=]+)\$([A-Za-z0-9+/=]+):([A-Za-z0-9+/=]+)$`)
|
||||
match := shape.FindStringSubmatch(verifier)
|
||||
if match == nil {
|
||||
t.Fatalf("verifier %q is not SCRAM-SHA-256$iterations:salt$stored:server", verifier)
|
||||
}
|
||||
for i, want := range map[int]int{1: 16, 2: 32, 3: 32} {
|
||||
decoded, err := base64.StdEncoding.DecodeString(match[i])
|
||||
if err != nil {
|
||||
t.Fatalf("part %d of the verifier does not decode: %v", i, err)
|
||||
}
|
||||
if len(decoded) != want {
|
||||
t.Errorf("part %d decodes to %d bytes, want %d", i, len(decoded), want)
|
||||
}
|
||||
}
|
||||
again, err := scramVerifier("correct horse battery staple")
|
||||
if err != nil {
|
||||
t.Fatalf("scramVerifier: %v", err)
|
||||
}
|
||||
if again == verifier {
|
||||
t.Error("two verifiers of the same password are equal; the salt is not random")
|
||||
}
|
||||
|
||||
if _, err := scramVerifier(""); err == nil {
|
||||
t.Error("scramVerifier accepted an empty password")
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user