scripts/db-trial.sh builds the persistent manual trial stack on literal faunosteo_trial_* names, loopback 58xxx ports, named volumes and a 700 state folder outside any git work tree; it refuses SANDBOX_* variables, a remote Docker daemon, a missing or failing ss, and checks each container's exact loopback publication and the gateway identity. The stub harness (scripts/db-trial-check.sh, 87 cases, no daemon reachable) proves it; db-sandbox.sh refuses a trial state folder (additions only). Nothing is created here.
1081 lines
50 KiB
Bash
Executable File
1081 lines
50 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
# Dedicated persistent manual trial stack (docs/development/TRIAL_STACK.md, SUPABASE.md §5.2):
|
|
# Postgres, GoTrue, PostgREST, Storage, Mailpit and a gateway under the literal names
|
|
# faunosteo_trial_*, published on 127.0.0.1 only, the data in two named volumes, secrets of its
|
|
# own. Nothing starts at boot. No automated suite reaches it: this script refuses a shell that
|
|
# carries SANDBOX_* variables, and the suites accept the sandbox's exact values only.
|
|
#
|
|
# pnpm db:trial plan read-only: what create would make, ports, places, limits, refusals
|
|
# pnpm db:trial create secrets, network, volumes, services, migrations, equine_draft.sql only
|
|
# pnpm db:trial start | stop the same containers, data kept
|
|
# pnpm db:trial status read-only: containers, keys, migrations, equine sheet, accounts, backups
|
|
# pnpm db:trial migrate a backup first (A15), then the branch's new migrations
|
|
# pnpm db:trial backup cold copy of both volumes and the secrets (the stack stops a few seconds)
|
|
# pnpm db:trial restore <backup> typed confirmation, a backup first, then <backup>'s volumes and secrets
|
|
# pnpm db:trial rotate-keys new anon and service keys signed with the same JWT secret, one year
|
|
# pnpm db:trial rotate-secrets a backup first, then a new JWT secret, keys and role passwords
|
|
# pnpm db:trial app the app on http://<trial host>:5194; Ctrl+C stops it, the stack stays
|
|
# pnpm db:trial account <email> a confirmed account, password at a hidden prompt (12 characters min.)
|
|
# pnpm db:trial grant <email> <owner|admin|catalog_reader|sheet_editor|sheet_reviewer|sheet_publisher>
|
|
# pnpm db:trial assets the equine drawings through the trial gateway, then checked
|
|
# pnpm db:trial destroy inventory, typed confirmation, a backup, then containers, network, volumes
|
|
#
|
|
# State: $FAUNOSTEO_TRIAL_DIR (default ~/.cache/faunosteo-trial), 700, outside every git work tree:
|
|
# secrets.env and the services' env files (600, written whole then renamed), stack.conf (images),
|
|
# migrations.sha256, backups/ (never pruned here). No secret is printed, logged, written to the
|
|
# repository or put on a command line: containers read env files, tools their environment, psql its
|
|
# standard input. Never `docker inspect` a trial container without -f: it would print the env files.
|
|
# Typed confirmations need a terminal. Every command but plan needs a reachable Docker daemon.
|
|
set -euo pipefail
|
|
cd "$(dirname "$0")/.."
|
|
# shellcheck source=scripts/dev-env.sh
|
|
. scripts/dev-env.sh
|
|
|
|
# Pinned here, apart from the sandbox: an image change on this persistent stack is a deliberate
|
|
# step. create records the images in stack.conf; every later recreation reuses the recorded ones.
|
|
IMAGE_DB=public.ecr.aws/supabase/postgres:17.11.0.004
|
|
IMAGE_AUTH=public.ecr.aws/supabase/gotrue:v2.197.0
|
|
IMAGE_REST=public.ecr.aws/supabase/postgrest:v16.4
|
|
IMAGE_STORAGE=public.ecr.aws/supabase/storage-api:v1.79.36
|
|
IMAGE_MAIL=public.ecr.aws/supabase/mailpit:v1.31.3
|
|
IMAGE_GATEWAY=nginx:1.31-alpine
|
|
NET=faunosteo_trial_net
|
|
DB=faunosteo_trial_db
|
|
MAIL=faunosteo_trial_mail
|
|
AUTH=faunosteo_trial_auth
|
|
STORAGE=faunosteo_trial_storage
|
|
REST=faunosteo_trial_rest
|
|
GATEWAY=faunosteo_trial_gateway
|
|
HELPER=faunosteo_trial_helper
|
|
VOL_DB=faunosteo_trial_db
|
|
VOL_STORAGE=faunosteo_trial_storage
|
|
CONTAINERS=("$DB" "$MAIL" "$AUTH" "$STORAGE" "$REST" "$GATEWAY")
|
|
STOP_ORDER=("$GATEWAY" "$REST" "$STORAGE" "$AUTH" "$MAIL" "$DB")
|
|
PORT_DB=58432 PORT_AUTH=58999 PORT_REST=58300 PORT_STORAGE=58500 PORT_MAIL=58025 PORT_GATEWAY=58801
|
|
PORT_APP=5194
|
|
# The six caps add up to 1 920 MiB (TRIAL_STACK.md §3.7); about 650 MiB are used in practice.
|
|
MEMORY_FLOOR_MIB=2048
|
|
SEED=supabase/seed/anatomical-sheets/equine/draft
|
|
HISTORICAL_SHEET=503dc301-a8b1-50d4-9e44-0919b2fc2916
|
|
CLI=node_modules/.bin/supabase
|
|
# Canonical from the start (symlinks resolved): the guard, every mode check and every state path
|
|
# below read the real folder, never a link (whose own mode stat would report as 777).
|
|
STATE="$(realpath -m "${FAUNOSTEO_TRIAL_DIR:-$HOME/.cache/faunosteo-trial}")"
|
|
MARKER="$STATE/.faunosteo-trial-state"
|
|
SECRETS="$STATE/secrets.env"
|
|
CONF="$STATE/stack.conf"
|
|
MANIFEST="$STATE/migrations.sha256"
|
|
BACKUPS="$STATE/backups"
|
|
# Everything in the state folder but the marker, the lock and backups/: what destroy (and a create
|
|
# that died before its first resource) removes.
|
|
LIVE_FILES=(secrets.env secrets.next.env db.env auth.env storage.env rest.env stack.conf migrations.sha256)
|
|
JWT_RE='^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$'
|
|
|
|
die() { echo "db-trial: $*" >&2; exit 1; }
|
|
say() { echo "== $*"; }
|
|
usage() { grep '^# pnpm db:trial' "$0" | cut -c2-; }
|
|
|
|
# Any git work tree, not only this one (the other checkout, a dotfiles repository): the secrets
|
|
# and backups would sit one `git add` away from a commit. Fails closed: a `.git` entry (folder or
|
|
# file) in any ancestor refuses; then git itself answers with its own repository variables unset,
|
|
# and only "not a git repository" counts as outside.
|
|
refuse_inside_git() { # canonical state path
|
|
local dir="$1" status=0 answer
|
|
local why="FAUNOSTEO_TRIAL_DIR must be outside every git work tree: refused"
|
|
while :; do
|
|
[ ! -e "$dir/.git" ] || die "$why"
|
|
[ "$dir" != / ] || break
|
|
dir="$(dirname "$dir")"
|
|
done
|
|
dir="$1"
|
|
while [ ! -e "$dir" ]; do dir="$(dirname "$dir")"; done
|
|
answer="$( (unset GIT_DIR GIT_WORK_TREE GIT_CEILING_DIRECTORIES; git -C "$dir" rev-parse --is-inside-work-tree) 2>&1)" || status=$?
|
|
case "$status" in
|
|
0) [ "$answer" != true ] || die "$why"
|
|
die "git answered '$answer' for $dir: cannot tell whether it is a work tree, refused" ;;
|
|
128) case "$answer" in
|
|
*"not a git repository"*) ;;
|
|
*) die "git failed for $dir ($answer): cannot tell whether it is a work tree, refused" ;;
|
|
esac ;;
|
|
*) die "git failed for $dir (exit $status): cannot tell whether it is a work tree, refused" ;;
|
|
esac
|
|
}
|
|
|
|
# Refusals that come before anything else, whatever the command (TRIAL_STACK.md §3.6).
|
|
guard_environment() {
|
|
local name repo state sandbox
|
|
for name in $(compgen -e); do
|
|
case "$name" in
|
|
SANDBOX_*) die "$name is set: this shell is wired to the sandbox suites; open a clean shell (nothing was run)" ;;
|
|
esac
|
|
done
|
|
repo="$(realpath "$PWD")"
|
|
state="$STATE"
|
|
sandbox="$(realpath -m "${FAUNOSTEO_SANDBOX_DIR:-$HOME/.cache/faunosteo-db-sandbox}")"
|
|
case "$state" in
|
|
"$repo" | "$repo"/*) die "FAUNOSTEO_TRIAL_DIR must be outside the repository" ;;
|
|
esac
|
|
refuse_inside_git "$state"
|
|
[ "$state" != "$sandbox" ] || die "FAUNOSTEO_TRIAL_DIR is the sandbox's state folder: refused"
|
|
if [ -e "$STATE" ] && [ ! -e "$MARKER" ] && [ -n "$(ls -A "$STATE" 2>/dev/null || echo unreadable)" ]; then
|
|
die "$STATE is not empty and holds no db:trial state: refused"
|
|
fi
|
|
}
|
|
|
|
check_private() { # path mode
|
|
[ "$(stat -c %u "$1")" = "$(id -u)" ] && [ "$(stat -c %a "$1")" = "$2" ] \
|
|
|| die "$1 must belong to $(id -un) with mode $2: refused"
|
|
}
|
|
|
|
# KEY=value lines, read without `source`: only these keys, each value checked against its shape.
|
|
parse_secrets() { # file → TR_PW TR_JWT_SECRET TR_ANON_KEY TR_SERVICE_KEY
|
|
local key value
|
|
TR_PW='' TR_JWT_SECRET='' TR_ANON_KEY='' TR_SERVICE_KEY=''
|
|
while IFS='=' read -r key value; do
|
|
case "$key" in
|
|
TR_PW) if [[ "$value" =~ ^[0-9a-f]{48}$ ]]; then TR_PW="$value"; fi ;;
|
|
TR_JWT_SECRET) if [[ "$value" =~ ^[0-9a-f]{64}$ ]]; then TR_JWT_SECRET="$value"; fi ;;
|
|
TR_ANON_KEY) if [[ "$value" =~ $JWT_RE ]]; then TR_ANON_KEY="$value"; fi ;;
|
|
TR_SERVICE_KEY) if [[ "$value" =~ $JWT_RE ]]; then TR_SERVICE_KEY="$value"; fi ;;
|
|
esac
|
|
done < "$1"
|
|
[ -n "$TR_PW" ] && [ -n "$TR_JWT_SECRET" ] && [ -n "$TR_ANON_KEY" ] && [ -n "$TR_SERVICE_KEY" ]
|
|
}
|
|
load_secrets() {
|
|
[ -f "$SECRETS" ] || die "not created: no $SECRETS (pnpm db:trial plan, then create)"
|
|
check_private "$SECRETS" 600
|
|
parse_secrets "$SECRETS" || die "secrets.env is incomplete or malformed: nothing was run (pnpm db:trial restore <backup>)"
|
|
}
|
|
|
|
# A state file is written whole under <file>.new (600) then renamed: an interrupted write never
|
|
# leaves half a file behind the real name. Content on stdin (printf is a builtin: no argv).
|
|
write_private() { # file
|
|
( umask 077; cat > "$1.new" ) && mv -f "$1.new" "$1"
|
|
}
|
|
remove_live_files() { # never backups/, the marker or the lock
|
|
local f
|
|
for f in "${LIVE_FILES[@]}"; do rm -f -- "$STATE/$f" "$STATE/$f.new"; done
|
|
}
|
|
|
|
# The six IMAGE_* recorded at create. The app host is not recorded: `app` decides it at each run.
|
|
parse_conf() { # file
|
|
local key value seen=0
|
|
while IFS='=' read -r key value; do
|
|
case "$key" in
|
|
IMAGE_DB | IMAGE_AUTH | IMAGE_REST | IMAGE_STORAGE | IMAGE_MAIL | IMAGE_GATEWAY)
|
|
if [[ "$value" =~ ^[a-z0-9./_-]+:[A-Za-z0-9._-]+$ ]]; then printf -v "$key" '%s' "$value"; seen=$((seen + 1)); fi ;;
|
|
esac
|
|
done < "$1"
|
|
[ "$seen" -eq 6 ]
|
|
}
|
|
load_conf() {
|
|
[ -f "$CONF" ] || die "not created: no $CONF (pnpm db:trial plan, then create)"
|
|
check_private "$CONF" 600
|
|
parse_conf "$CONF" || die "stack.conf is incomplete or malformed: nothing was run (pnpm db:trial restore <backup>)"
|
|
}
|
|
write_conf() {
|
|
printf 'IMAGE_DB=%s\nIMAGE_AUTH=%s\nIMAGE_REST=%s\nIMAGE_STORAGE=%s\nIMAGE_MAIL=%s\nIMAGE_GATEWAY=%s\n' \
|
|
"$IMAGE_DB" "$IMAGE_AUTH" "$IMAGE_REST" "$IMAGE_STORAGE" "$IMAGE_MAIL" "$IMAGE_GATEWAY" | write_private "$CONF"
|
|
}
|
|
|
|
# Fresh values (`new`) or new keys for the current secret (`keys`, the secret in TR_JWT_SECRET),
|
|
# as KEY=value lines for a 600 file, never for the terminal. Keys: issuer faunosteo-trial (the
|
|
# sandbox suites refuse it), one year, a random jti so every rotation yields new keys.
|
|
KEYGEN='
|
|
const c = require("crypto");
|
|
const fresh = process.argv[1] === "new";
|
|
const secret = fresh ? c.randomBytes(32).toString("hex") : process.env.TR_JWT_SECRET;
|
|
if (!/^[0-9a-f]{64}$/.test(secret || "")) process.exit(2);
|
|
const b64 = (o) => Buffer.from(JSON.stringify(o)).toString("base64url");
|
|
const jwt = (p) => { const h = b64({ alg: "HS256", typ: "JWT" }), b = b64(p);
|
|
return h + "." + b + "." + c.createHmac("sha256", secret).update(h + "." + b).digest("base64url"); };
|
|
const iat = Math.floor(Date.now() / 1000), exp = iat + 365 * 86400;
|
|
if (fresh) console.log("TR_PW=" + c.randomBytes(24).toString("hex") + "\nTR_JWT_SECRET=" + secret);
|
|
for (const [name, role] of [["TR_ANON_KEY", "anon"], ["TR_SERVICE_KEY", "service_role"]])
|
|
console.log(name + "=" + jwt({ role, iss: "faunosteo-trial", iat, exp, jti: c.randomUUID() }));
|
|
'
|
|
new_secrets_file() { # file: written whole under <file>.new (600), then renamed
|
|
if ( umask 077; node -e "$KEYGEN" new > "$1.new" ) && mv -f "$1.new" "$1"; then return 0; fi
|
|
rm -f -- "$1.new"
|
|
return 1
|
|
}
|
|
# A key is handed over (Vite, the upload tool, GoTrue's admin API, Storage's env) only when it is
|
|
# this stack's: issuer faunosteo-trial, the role asked, not expired, signed with TR_JWT_SECRET.
|
|
# Exit 0: this stack's key; 1: not this stack's (issuer, role, signature); 3 (mode fresh only):
|
|
# this stack's but expired. Identity and expiry are apart on purpose: an expired key must never
|
|
# block start or rotate-keys (the way to renew it), only its use by a client.
|
|
KEYCHECK='
|
|
const c = require("crypto");
|
|
const [role, mode] = process.argv.slice(1);
|
|
const [h, b, s] = (process.env.KEY || "").split(".");
|
|
let p = null;
|
|
try { p = JSON.parse(Buffer.from(b, "base64url").toString("utf8")); } catch { process.exit(1); }
|
|
const mac = c.createHmac("sha256", process.env.SECRET || "").update(h + "." + b).digest("base64url");
|
|
const own = p !== null && typeof p === "object" && s === mac && p.iss === "faunosteo-trial"
|
|
&& p.role === role && typeof p.exp === "number";
|
|
if (!own) process.exit(1);
|
|
process.exit(mode === "fresh" && p.exp <= Date.now() / 1000 ? 3 : 0);
|
|
'
|
|
key_check() { # key role any|fresh [secret]: the status of KEYCHECK
|
|
KEY="$1" SECRET="${4:-$TR_JWT_SECRET}" node -e "$KEYCHECK" "$2" "$3"
|
|
}
|
|
key_identity() { # key role: this stack's key, expired or not (env files, Storage)
|
|
key_check "$1" "$2" any \
|
|
|| die "the $2 key in secrets.env is not this stack's (issuer faunosteo-trial, signed with its secret): refused, nothing was done (pnpm db:trial restore <backup>)"
|
|
}
|
|
client_key() { # key role: what a client receives (Vite, the upload tool, GoTrue's admin API) is also valid now
|
|
local status=0
|
|
key_check "$1" "$2" fresh || status=$?
|
|
case "$status" in
|
|
0) ;;
|
|
3) die "the $2 key expired: pnpm db:trial rotate-keys renews it; nothing was done" ;;
|
|
*) die "the $2 key in secrets.env is not this stack's (issuer faunosteo-trial, signed with its secret): refused, nothing was done (pnpm db:trial restore <backup>)" ;;
|
|
esac
|
|
}
|
|
require_trial_keys() {
|
|
key_identity "$TR_ANON_KEY" anon
|
|
key_identity "$TR_SERVICE_KEY" service_role
|
|
}
|
|
key_expiry() {
|
|
TR_ANON_KEY="$TR_ANON_KEY" node -e '
|
|
const p = JSON.parse(Buffer.from(process.env.TR_ANON_KEY.split(".")[1], "base64url"));
|
|
console.log(new Date(p.exp * 1000).toISOString().slice(0, 10));'
|
|
}
|
|
|
|
# The values reach the containers through 600 env files, never through argv. Always derived from
|
|
# secrets.env, so they can be rewritten at any time (start rewrites them before recreating a
|
|
# missing container). Both keys are this stack's first.
|
|
write_env_files() {
|
|
require_trial_keys
|
|
printf 'POSTGRES_PASSWORD=%s\nPGPASSWORD=%s\nJWT_SECRET=%s\n' "$TR_PW" "$TR_PW" "$TR_JWT_SECRET" \
|
|
| write_private "$STATE/db.env"
|
|
printf 'GOTRUE_DB_DATABASE_URL=postgresql://supabase_auth_admin:%s@%s:5432/postgres\nGOTRUE_JWT_SECRET=%s\n' \
|
|
"$TR_PW" "$DB" "$TR_JWT_SECRET" | write_private "$STATE/auth.env"
|
|
printf 'ANON_KEY=%s\nSERVICE_KEY=%s\nAUTH_JWT_SECRET=%s\nDATABASE_URL=postgresql://supabase_storage_admin:%s@%s:5432/postgres\n' \
|
|
"$TR_ANON_KEY" "$TR_SERVICE_KEY" "$TR_JWT_SECRET" "$TR_PW" "$DB" | write_private "$STATE/storage.env"
|
|
printf 'PGRST_DB_URI=postgresql://authenticator:%s@%s:5432/postgres\nPGRST_JWT_SECRET=%s\n' \
|
|
"$TR_PW" "$DB" "$TR_JWT_SECRET" | write_private "$STATE/rest.env"
|
|
}
|
|
|
|
# The daemon this script talks to is the local one: DOCKER_HOST unset or a unix socket, else the
|
|
# current context's endpoint a unix socket (a named, non-secret field of the context).
|
|
daemon_endpoint() {
|
|
if [ -n "${DOCKER_HOST:-}" ]; then printf '%s' "$DOCKER_HOST"
|
|
else docker context inspect -f '{{.Endpoints.docker.Host}}' 2>/dev/null; fi
|
|
}
|
|
require_local_daemon() {
|
|
local endpoint
|
|
endpoint="$(daemon_endpoint)" || die "the current Docker context cannot be read: refused, nothing was run"
|
|
case "$endpoint" in
|
|
unix://?*) ;;
|
|
*) die "the Docker endpoint '${endpoint##*@}' is not a local unix socket (DOCKER_HOST or the current context): refused, nothing was run" ;;
|
|
esac
|
|
}
|
|
# Checked at dispatch for every command but plan: past it, "absent" means absent, not "daemon down".
|
|
daemon_ok() { docker info --format '{{.ServerVersion}}' >/dev/null 2>&1; }
|
|
# Always -f with a named field: a bare inspect prints the containers' env-file values.
|
|
# "No such <kind>" is the only answer read as absent; any other inspect error refuses.
|
|
resource_exists() { # kind name: 0 exists, 1 absent, else die
|
|
local out status=0
|
|
out="$(docker "$1" inspect -f '{{.Name}}' "$2" 2>&1)" || status=$?
|
|
[ "$status" -ne 0 ] || return 0
|
|
# Docker's wordings differ by kind: "No such container: x", "get x: no such volume", "network x not found".
|
|
case "${out,,}" in *"no such"* | *"not found"*) return 1 ;; esac
|
|
die "docker $1 inspect $2 failed (exit $status) with an answer other than 'no such' / 'not found': refused, nothing was changed"
|
|
}
|
|
container_exists() { resource_exists container "$1"; }
|
|
container_running() { [ "$(docker container inspect -f '{{.State.Running}}' "$1" 2>/dev/null)" = true ]; }
|
|
volume_exists() { resource_exists volume "$1"; }
|
|
network_exists() { resource_exists network "$1"; }
|
|
existing_resources() { # the literal names of this stack that exist now, one per line
|
|
local name
|
|
for name in "${CONTAINERS[@]}"; do if container_exists "$name"; then echo "container $name"; fi; done
|
|
if network_exists "$NET"; then echo "network $NET"; fi
|
|
for name in "$VOL_DB" "$VOL_STORAGE"; do if volume_exists "$name"; then echo "volume $name"; fi; done
|
|
}
|
|
|
|
port_of() { # name → host port, container port
|
|
case "$1" in
|
|
"$DB") echo "$PORT_DB 5432" ;; "$MAIL") echo "$PORT_MAIL 8025" ;; "$AUTH") echo "$PORT_AUTH 9999" ;;
|
|
"$STORAGE") echo "$PORT_STORAGE 5000" ;; "$REST") echo "$PORT_REST 3000" ;; "$GATEWAY") echo "$PORT_GATEWAY 8000" ;;
|
|
esac
|
|
}
|
|
limits_of() { # name → memory, pids (TRIAL_STACK.md §3.7; --cpus 1 for all)
|
|
case "$1" in
|
|
"$DB") echo "1g 512" ;; "$REST") echo "384m 256" ;; "$STORAGE") echo "256m 256" ;;
|
|
"$AUTH") echo "128m 256" ;; "$MAIL" | "$GATEWAY") echo "64m 64" ;;
|
|
esac
|
|
}
|
|
image_of() {
|
|
case "$1" in
|
|
"$DB") echo "$IMAGE_DB" ;; "$MAIL") echo "$IMAGE_MAIL" ;; "$AUTH") echo "$IMAGE_AUTH" ;;
|
|
"$STORAGE") echo "$IMAGE_STORAGE" ;; "$REST") echo "$IMAGE_REST" ;; "$GATEWAY") echo "$IMAGE_GATEWAY" ;;
|
|
esac
|
|
}
|
|
mount_of() {
|
|
case "$1" in
|
|
"$DB") echo "$VOL_DB:/var/lib/postgresql/data" ;; "$STORAGE") echo "$VOL_STORAGE:/mnt" ;; *) echo - ;;
|
|
esac
|
|
}
|
|
# What every service container shares: its name, the stack network, no restart at boot, its caps
|
|
# and its one loopback port.
|
|
base_opts() { # name → one option per line
|
|
local host inner memory pids
|
|
read -r host inner <<<"$(port_of "$1")"
|
|
read -r memory pids <<<"$(limits_of "$1")"
|
|
printf '%s\n' --name "$1" --network "$NET" --restart no --memory "$memory" --cpus 1 \
|
|
--pids-limit "$pids" -p "127.0.0.1:$host:$inner"
|
|
}
|
|
|
|
# True when any local address listens on the port (rootless Docker's forwarders show in ss too,
|
|
# checked 2026-11-10). Fails closed: no ss answer, no command goes on.
|
|
port_listening() { # port
|
|
local out status=0
|
|
out="$(ss -Hltn "sport = :$1" 2>&1)" || status=$?
|
|
# Fail closed: an ss error is never read as "nothing listens".
|
|
[ "$status" -eq 0 ] || die "ss cannot list the listening ports (exit $status): nothing was done"
|
|
[ -n "$out" ]
|
|
}
|
|
ports_free() { # container...: each one's host port, all checked before any docker call
|
|
local name host inner
|
|
for name in "$@"; do
|
|
read -r host inner <<<"$(port_of "$name")"
|
|
if port_listening "$host"; then die "port 127.0.0.1:$host is taken: nothing was started or changed (pnpm db:trial plan)"; fi
|
|
done
|
|
}
|
|
available_mib() { awk '/^MemAvailable:/ { print int($2 / 1024) }' /proc/meminfo; }
|
|
memory_ok() {
|
|
local mib
|
|
mib="$(available_mib)"
|
|
[ "$mib" -ge "$MEMORY_FLOOR_MIB" ] || die "only $mib MiB of memory available, the stack's caps need $MEMORY_FLOOR_MIB: nothing was started"
|
|
}
|
|
|
|
# The trial app host: loopback or a private IPv4 of an interface of this machine, nothing else
|
|
# (same rule as db-sandbox.sh trial_host). Prints the normalised address.
|
|
valid_host() { # address
|
|
local host="$1" a b c d
|
|
[[ "$host" =~ ^([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})$ ]] \
|
|
|| die "FAUNOSTEO_TRIAL_HOST must be an IPv4 address (not a name, not 0.0.0.0): $host"
|
|
a=$((10#${BASH_REMATCH[1]})) b=$((10#${BASH_REMATCH[2]}))
|
|
c=$((10#${BASH_REMATCH[3]})) d=$((10#${BASH_REMATCH[4]}))
|
|
[ "$a" -le 255 ] && [ "$b" -le 255 ] && [ "$c" -le 255 ] && [ "$d" -le 255 ] \
|
|
|| die "FAUNOSTEO_TRIAL_HOST is not an IPv4 address: $host"
|
|
[ "$host" = "$a.$b.$c.$d" ] || die "FAUNOSTEO_TRIAL_HOST: write the address without leading zeros"
|
|
if [ "$a" -eq 127 ]; then host=127.0.0.1
|
|
elif [ "$a" -eq 10 ] || { [ "$a" -eq 172 ] && [ "$b" -ge 16 ] && [ "$b" -le 31 ]; } \
|
|
|| { [ "$a" -eq 192 ] && [ "$b" -eq 168 ]; }; then :
|
|
else die "FAUNOSTEO_TRIAL_HOST must be loopback or a private address (10/8, 172.16/12, 192.168/16): $host"
|
|
fi
|
|
ip -4 -o addr | grep -qF "inet $host/" || die "FAUNOSTEO_TRIAL_HOST $host is not an address of this machine"
|
|
printf '%s' "$host"
|
|
}
|
|
# Decided at each use, never recorded: a DHCP change of the LAN address needs no state edit. Call
|
|
# it as `host="$(trial_host)"` (a plain assignment, so a refusal stops the script).
|
|
trial_host() { valid_host "${FAUNOSTEO_TRIAL_HOST:-$FAUNOSTEO_DEV_HOST}"; }
|
|
|
|
wait_for() { # what command...
|
|
local what="$1"
|
|
shift
|
|
for _ in $(seq 1 120); do
|
|
if "$@" >/dev/null 2>&1; then return 0; fi
|
|
sleep 1
|
|
done
|
|
die "timeout waiting for $what"
|
|
}
|
|
# psql inside the database container; the password reaches it through the environment.
|
|
db_ready() { # role
|
|
PGPASSWORD="$TR_PW" docker exec -e PGPASSWORD "$DB" psql -X -h 127.0.0.1 -U "$1" -d postgres -c 'select 1'
|
|
}
|
|
sb_psql() {
|
|
PGPASSWORD="$TR_PW" docker exec -i -e PGPASSWORD "$DB" \
|
|
psql -X -q -h 127.0.0.1 -U postgres -d postgres -v ON_ERROR_STOP=1 "$@"
|
|
}
|
|
|
|
# The role passwords the CLI sets at its first database start (/etc/postgresql.schema.sql, run
|
|
# once on an empty data folder), for the roles this stack uses, supabase_admin included so that
|
|
# rotate-secrets can renew every password through it. A failing ALTER would log its statement,
|
|
# password included, at the default log_min_error_statement: the session turns that off first.
|
|
# shellcheck disable=SC2016
|
|
DB_INIT='cat <<'"'"'EOF'"'"' > /etc/postgresql.schema.sql && exec docker-entrypoint.sh postgres -D /etc/postgresql -c shared_buffers=128MB
|
|
set log_min_error_statement = panic;
|
|
\set pgpass `echo "$PGPASSWORD"`
|
|
\set jwt_secret `echo "$JWT_SECRET"`
|
|
ALTER DATABASE postgres SET "app.settings.jwt_secret" TO :'"'"'jwt_secret'"'"';
|
|
ALTER DATABASE postgres SET "app.settings.jwt_exp" TO '"'"'3600'"'"';
|
|
ALTER USER supabase_admin WITH PASSWORD :'"'"'pgpass'"'"';
|
|
ALTER USER postgres WITH PASSWORD :'"'"'pgpass'"'"';
|
|
ALTER USER authenticator WITH PASSWORD :'"'"'pgpass'"'"';
|
|
ALTER USER supabase_auth_admin WITH PASSWORD :'"'"'pgpass'"'"';
|
|
ALTER USER supabase_storage_admin WITH PASSWORD :'"'"'pgpass'"'"';
|
|
EOF'
|
|
|
|
# The CLI stack's Kong routes on the trial network. GoTrue's admin API is not routed: the account
|
|
# command calls GoTrue on its loopback port, so the app's LAN proxy never reaches it. The static
|
|
# /__faunosteo_stack answer names this gateway (R13: app, assets and the trial Vite config check
|
|
# it); it carries no data, and Vite proxies only the three Supabase routes, so the LAN never sees it.
|
|
GATEWAY_CONF='server {
|
|
listen 8000;
|
|
client_max_body_size 8m;
|
|
proxy_http_version 1.1;
|
|
location = /__faunosteo_stack { default_type text/plain; return 200 "faunosteo_trial\n"; }
|
|
location /auth/v1/admin/ { return 403; }
|
|
location /auth/v1/ { proxy_pass http://'"$AUTH"':9999/; }
|
|
location /rest/v1/ { proxy_pass http://'"$REST"':3000/; }
|
|
location /storage/v1/ { proxy_pass http://'"$STORAGE"':5000/; }
|
|
location / { return 404; }
|
|
}'
|
|
|
|
# Every curl of this script: -q first (no ~/.curlrc: no proxy, connect-to or resolve from it) and
|
|
# --noproxy '*' (no http_proxy / ALL_PROXY): the destination is the literal 127.0.0.1 port, always.
|
|
wait_service() { # name
|
|
case "$1" in
|
|
"$DB")
|
|
wait_for "database roles" db_ready supabase_auth_admin
|
|
wait_for "database" db_ready postgres ;;
|
|
"$MAIL") wait_for "mailpit" curl -q --noproxy '*' -fsS -o /dev/null "http://127.0.0.1:$PORT_MAIL/" ;;
|
|
"$AUTH") wait_for "auth" curl -q --noproxy '*' -fsS -o /dev/null "http://127.0.0.1:$PORT_AUTH/health" ;;
|
|
"$STORAGE") wait_for "storage" curl -q --noproxy '*' -fsS -o /dev/null "http://127.0.0.1:$PORT_STORAGE/status" ;;
|
|
"$REST") wait_for "postgrest" curl -q --noproxy '*' -fsS -o /dev/null "http://127.0.0.1:$PORT_REST/" ;;
|
|
"$GATEWAY") wait_for "gateway" curl -q --noproxy '*' -fsS -o /dev/null "http://127.0.0.1:$PORT_GATEWAY/rest/v1/" ;;
|
|
esac
|
|
}
|
|
|
|
run_db() {
|
|
local opts
|
|
mapfile -t opts < <(base_opts "$DB")
|
|
docker run -d "${opts[@]}" -v "$(mount_of "$DB")" --env-file "$STATE/db.env" \
|
|
-e POSTGRES_HOST=/var/run/postgresql -e JWT_EXP=3600 \
|
|
-e POSTGRES_INITDB_ARGS="--allow-group-access --locale-provider=icu --encoding=UTF-8 --icu-locale=en_US.UTF-8" \
|
|
--entrypoint sh "$IMAGE_DB" -c "$DB_INIT" >/dev/null
|
|
}
|
|
run_mail() {
|
|
local opts
|
|
mapfile -t opts < <(base_opts "$MAIL")
|
|
docker run -d "${opts[@]}" "$IMAGE_MAIL" >/dev/null
|
|
}
|
|
# Sign-up closed (accounts come from `account` only); mail links lead to the app origin of the
|
|
# trial host at the time GoTrue starts (create, restore, rotate-secrets, a recreation by start),
|
|
# whose proxy forwards /auth/v1 to GoTrue.
|
|
run_auth() {
|
|
local opts host origin
|
|
host="$(trial_host)"
|
|
origin="http://$host:$PORT_APP"
|
|
mapfile -t opts < <(base_opts "$AUTH")
|
|
docker run -d "${opts[@]}" --env-file "$STATE/auth.env" \
|
|
-e GOTRUE_API_HOST=0.0.0.0 -e GOTRUE_API_PORT=9999 -e API_EXTERNAL_URL="$origin/auth/v1" \
|
|
-e GOTRUE_DB_DRIVER=postgres -e GOTRUE_DB_MIGRATIONS_PATH=/usr/local/etc/auth/migrations \
|
|
-e GOTRUE_SITE_URL="$origin" -e GOTRUE_URI_ALLOW_LIST="$origin/**" -e GOTRUE_DISABLE_SIGNUP=true \
|
|
-e GOTRUE_JWT_EXP=3600 -e GOTRUE_JWT_AUD=authenticated -e GOTRUE_JWT_DEFAULT_GROUP_NAME=authenticated \
|
|
-e GOTRUE_JWT_ADMIN_ROLES=service_role \
|
|
-e GOTRUE_EXTERNAL_EMAIL_ENABLED=true -e GOTRUE_EXTERNAL_PHONE_ENABLED=false \
|
|
-e GOTRUE_EXTERNAL_ANONYMOUS_USERS_ENABLED=false -e GOTRUE_MAILER_AUTOCONFIRM=false \
|
|
-e GOTRUE_MAILER_URLPATHS_CONFIRMATION="$origin/auth/v1/verify" \
|
|
-e GOTRUE_SMTP_HOST="$MAIL" -e GOTRUE_SMTP_PORT=1025 \
|
|
-e GOTRUE_SMTP_ADMIN_EMAIL=admin@trial.local -e GOTRUE_SMTP_SENDER_NAME=faunosteo-trial \
|
|
-e GOTRUE_PASSWORD_MIN_LENGTH=12 "$IMAGE_AUTH" >/dev/null
|
|
}
|
|
run_storage() {
|
|
local opts
|
|
mapfile -t opts < <(base_opts "$STORAGE")
|
|
docker run -d "${opts[@]}" -v "$(mount_of "$STORAGE")" --env-file "$STATE/storage.env" \
|
|
-e FILE_SIZE_LIMIT=52428800 -e STORAGE_BACKEND=file -e FILE_STORAGE_BACKEND_PATH=/mnt \
|
|
-e TENANT_ID=stub -e STORAGE_S3_REGION=local -e GLOBAL_S3_BUCKET=stub \
|
|
-e ENABLE_IMAGE_TRANSFORMATION=false -e IMAGE_TRANSFORMATION_ENABLED=false \
|
|
-e S3_PROTOCOL_ENABLED=false -e DB_MIGRATIONS_FREEZE_AT= "$IMAGE_STORAGE" >/dev/null
|
|
}
|
|
run_rest() {
|
|
local opts
|
|
mapfile -t opts < <(base_opts "$REST")
|
|
docker run -d "${opts[@]}" --env-file "$STATE/rest.env" \
|
|
-e PGRST_DB_SCHEMAS=public -e PGRST_DB_EXTRA_SEARCH_PATH=public,extensions \
|
|
-e PGRST_DB_ANON_ROLE=anon -e PGRST_DB_MAX_ROWS=1000 "$IMAGE_REST" >/dev/null
|
|
}
|
|
run_gateway() {
|
|
local opts
|
|
mapfile -t opts < <(base_opts "$GATEWAY")
|
|
# "$0" is the inner shell's, expanded in the container:
|
|
# shellcheck disable=SC2016
|
|
docker run -d "${opts[@]}" --security-opt no-new-privileges:true \
|
|
--entrypoint sh "$IMAGE_GATEWAY" -c 'printf "%s\n" "$0" > /etc/nginx/conf.d/default.conf && exec nginx -g "daemon off;"' \
|
|
"$GATEWAY_CONF" >/dev/null
|
|
}
|
|
run_service() { # name: run, then wait until it answers
|
|
case "$1" in
|
|
"$DB") run_db ;; "$MAIL") run_mail ;; "$AUTH") run_auth ;;
|
|
"$STORAGE") run_storage ;; "$REST") run_rest ;; "$GATEWAY") run_gateway ;;
|
|
esac
|
|
wait_service "$1"
|
|
}
|
|
|
|
published_exactly() { # name: its one port, on 127.0.0.1, and nothing else
|
|
local host inner
|
|
read -r host inner <<<"$(port_of "$1")"
|
|
[ "$(docker port "$1" 2>/dev/null)" = "$inner/tcp -> 127.0.0.1:$host" ] \
|
|
|| die "$1 is not published on 127.0.0.1:$host only: refused (pnpm db:trial stop, then check Docker)"
|
|
}
|
|
check_loopback() {
|
|
local name
|
|
for name in "${CONTAINERS[@]}"; do published_exactly "$name"; done
|
|
}
|
|
# The gateway a tool or the app is pointed at is this stack's container, on its port, answering
|
|
# its name; never another local service on 58801.
|
|
STACK_IDENTITY=faunosteo_trial
|
|
gateway_identity() {
|
|
local body
|
|
published_exactly "$GATEWAY"
|
|
body="$(curl -q --noproxy '*' -fsS --max-time 3 "http://127.0.0.1:$PORT_GATEWAY/__faunosteo_stack" 2>/dev/null)" || body=''
|
|
[ "$body" = "$STACK_IDENTITY" ] \
|
|
|| die "127.0.0.1:$PORT_GATEWAY does not answer as the faunosteo_trial gateway: refused, nothing was done"
|
|
}
|
|
ensure_network() {
|
|
if ! network_exists "$NET"; then docker network create --label faunosteo.stack=trial "$NET" >/dev/null; fi
|
|
}
|
|
# nginx resolves the services' names once, at its start: a service started or recreated under a
|
|
# running gateway means a gateway restart.
|
|
restart_gateway() {
|
|
docker restart -t 10 "$GATEWAY" >/dev/null
|
|
wait_service "$GATEWAY"
|
|
}
|
|
# Every port of a stopped or missing container is checked before the first start. A missing
|
|
# container is recreated from stack.conf and secrets.env (env files rewritten first), so a failed
|
|
# recreation (rotate-keys, restore, a daemon hiccup) is repaired by `start`, never by a restore.
|
|
start_containers() {
|
|
local name todo=() missing=no
|
|
for name in "${CONTAINERS[@]}"; do
|
|
if container_running "$name"; then continue; fi
|
|
todo+=("$name")
|
|
if ! container_exists "$name"; then missing=yes; fi
|
|
done
|
|
ports_free "${todo[@]}"
|
|
if [ "$missing" = yes ]; then write_env_files; ensure_network; fi
|
|
for name in "${todo[@]}"; do
|
|
if container_exists "$name"; then
|
|
docker start "$name" >/dev/null
|
|
wait_service "$name"
|
|
else
|
|
run_service "$name"
|
|
fi
|
|
done
|
|
# CONTAINERS ends with the gateway: when it was not started last, it ran over the others.
|
|
if [ "${#todo[@]}" -gt 0 ] && [ "${todo[-1]}" != "$GATEWAY" ]; then restart_gateway; fi
|
|
check_loopback
|
|
}
|
|
stop_containers() {
|
|
local name
|
|
for name in "${STOP_ORDER[@]}"; do
|
|
if container_running "$name"; then docker stop -t 60 "$name" >/dev/null; fi
|
|
done
|
|
}
|
|
remove_containers() { # stopped first by the caller; volumes untouched
|
|
local name
|
|
for name in "${CONTAINERS[@]}"; do
|
|
if container_exists "$name"; then docker rm "$name" >/dev/null; fi
|
|
done
|
|
}
|
|
|
|
require_state() {
|
|
[ -e "$MARKER" ] || die "no db:trial state in $STATE (pnpm db:trial plan, then create)"
|
|
check_private "$STATE" 700
|
|
}
|
|
# The data volume is the stack: containers can be recreated (start), the volume cannot.
|
|
require_created() {
|
|
require_state
|
|
load_conf
|
|
load_secrets
|
|
volume_exists "$VOL_DB" || die "$VOL_DB does not exist (pnpm db:trial status)"
|
|
}
|
|
require_running() {
|
|
local name
|
|
require_created
|
|
for name in "${CONTAINERS[@]}"; do
|
|
container_running "$name" || die "$name is not running (pnpm db:trial start)"
|
|
done
|
|
}
|
|
# Before the commands that change keys or data under a running app (rotate-keys, rotate-secrets,
|
|
# restore, destroy) and before stop (the app would proxy to whatever then answers 58801). A local
|
|
# listener check: no probe of a LAN address.
|
|
refuse_while_app_runs() {
|
|
if port_listening "$PORT_APP"; then
|
|
die "port $PORT_APP is in use (the trial app, or another process): stop it first; nothing was changed"
|
|
fi
|
|
}
|
|
take_lock() {
|
|
local previous
|
|
previous="$(umask)"
|
|
umask 077
|
|
exec 9>"$STATE/.lock"
|
|
umask "$previous"
|
|
flock -n 9 || die "another pnpm db:trial command is running"
|
|
}
|
|
|
|
db_url() { printf 'postgresql://postgres@127.0.0.1:%s/postgres?sslmode=disable' "$PORT_DB"; }
|
|
# The CLI's own runner, always against the trial URL; the password through PGPASSWORD only.
|
|
migrate_up() { PGPASSWORD="$TR_PW" "$CLI" --workdir . migration up --db-url "$(db_url)"; }
|
|
applied_versions() {
|
|
sb_psql -t -A -c "-- db-trial:applied
|
|
select version from supabase_migrations.schema_migrations order by version"
|
|
}
|
|
file_version() { basename "$1" | cut -d_ -f1; }
|
|
file_sum() { sha256sum < "$1" | cut -d' ' -f1; }
|
|
# One line per applied migration: version, sha256 of its file, file name. A persistent stack
|
|
# replays nothing, so an applied file edited later must be noticed (TRIAL_STACK.md §3.4).
|
|
write_manifest() {
|
|
local applied f
|
|
applied="$(applied_versions)"
|
|
( umask 077
|
|
for f in supabase/migrations/*.sql; do
|
|
if grep -qx "$(file_version "$f")" <<<"$applied"; then
|
|
printf '%s %s %s\n' "$(file_version "$f")" "$(file_sum "$f")" "$(basename "$f")"
|
|
fi
|
|
done > "$MANIFEST.new" )
|
|
[ "$(cut -d' ' -f1 "$MANIFEST.new")" = "$applied" ] \
|
|
|| die "an applied migration has no file in this branch: migrations.sha256 not written"
|
|
mv -f "$MANIFEST.new" "$MANIFEST"
|
|
}
|
|
check_manifest() {
|
|
local version sum file
|
|
[ -f "$MANIFEST" ] || die "migrations.sha256 missing: the applied migrations cannot be checked (pnpm db:trial restore <backup>)"
|
|
while read -r version sum file; do
|
|
[[ "$version" =~ ^[0-9]{14}$ && "$sum" =~ ^[0-9a-f]{64}$ && "$file" =~ ^[0-9]{14}_[A-Za-z0-9_]+\.sql$ ]] \
|
|
|| die "migrations.sha256 is malformed"
|
|
[ -f "supabase/migrations/$file" ] || die "applied migration $file is missing from this branch: refused"
|
|
[ "$(file_sum "supabase/migrations/$file")" = "$sum" ] \
|
|
|| die "applied migration $file was edited after it was applied: refused (migrations are forward-only)"
|
|
done < "$MANIFEST"
|
|
[ "$(cut -d' ' -f1 "$MANIFEST")" = "$(applied_versions)" ] \
|
|
|| die "the database's migration history differs from migrations.sha256 (a migrate stopped part-way?): refused; pnpm db:trial restore <its pre-migrate backup> (pnpm db:trial status lists them)"
|
|
}
|
|
# Kept although `migration up` would refuse too: this refusal comes before migrate's cold backup
|
|
# and its stop/start of the stack.
|
|
pending_migrations() { # the branch's files not applied yet; refuses one older than the last applied
|
|
local last f
|
|
last="$(tail -n 1 "$MANIFEST" | cut -d' ' -f1)"
|
|
for f in supabase/migrations/*.sql; do
|
|
if grep -q "^$(file_version "$f") " "$MANIFEST"; then continue; fi
|
|
[ "$(file_version "$f")" \> "$last" ] || die "$(basename "$f") is older than the last applied migration $last: refused"
|
|
basename "$f"
|
|
done
|
|
}
|
|
|
|
# The seed folder's own consistency: sheet id, every drawing's size and sha256 against
|
|
# assets.json, both declared by equine_draft.sql. Prints "sha256 size" per drawing.
|
|
SEED_CHECK='
|
|
const fs = require("fs"), path = require("path"), c = require("crypto");
|
|
const [dir, sheet] = process.argv.slice(1);
|
|
const fail = (why) => { console.error(why); process.exit(1); };
|
|
const ref = JSON.parse(fs.readFileSync(path.join(dir, "sheet-ref.json"), "utf8"));
|
|
const assets = JSON.parse(fs.readFileSync(path.join(dir, "assets.json"), "utf8"));
|
|
const seed = fs.readFileSync(path.join(dir, "equine_draft.sql"), "utf8");
|
|
if (ref.sheet_id !== sheet || !seed.includes(sheet)) fail("the seed does not name the historical sheet");
|
|
if (!Array.isArray(assets) || assets.length === 0) fail("assets.json lists no drawing");
|
|
for (const a of assets) {
|
|
if (!/^[0-9a-f]{64}$/.test(a.sha256) || !Number.isInteger(a.byte_size)) fail("assets.json entry malformed");
|
|
const bytes = fs.readFileSync(path.join(dir, "assets", path.basename(String(a.file))));
|
|
if (bytes.length !== a.byte_size || c.createHash("sha256").update(bytes).digest("hex") !== a.sha256)
|
|
fail(a.file + " differs from assets.json");
|
|
if (!seed.includes(a.sha256)) fail("equine_draft.sql does not declare " + a.file);
|
|
console.log(a.sha256 + " " + a.byte_size);
|
|
}
|
|
'
|
|
check_seed_sources() {
|
|
node -e "$SEED_CHECK" "$SEED" "$HISTORICAL_SHEET" >/dev/null || die "the equine seed folder fails its own hashes: nothing was created"
|
|
}
|
|
expected_assets() { node -e "$SEED_CHECK" "$SEED" "$HISTORICAL_SHEET" | LC_ALL=C sort; }
|
|
# The Rust pipeline regenerates the seed from the legacy sources and compares it byte for byte
|
|
# (R5.6 fingerprint convention): what is loaded is what the pipeline produces. Both checks stay:
|
|
# check_seed_sources (folder vs its own hashes, cheap, also in plan) then this one (folder vs
|
|
# pipeline); verify_equine_db then checks the database against the folder.
|
|
check_seed_pipeline() {
|
|
say "equine seed: the Rust pipeline regenerates it and compares (the first run compiles)"
|
|
( unset INIT_CWD; bash scripts/import-equine.sh --check ) \
|
|
|| die "the equine seed differs from what the pipeline produces: nothing was created"
|
|
}
|
|
seed_equine() { sb_psql --single-transaction < "$SEED/equine_draft.sql" >/dev/null; }
|
|
asset_rows() {
|
|
sb_psql -t -A -c "-- db-trial:asset-rows
|
|
select sha256 || ' ' || byte_size from public.anatomical_sheet_assets
|
|
where sheet_id = private.historical_sheet_id() order by sha256 collate \"C\""
|
|
}
|
|
uploaded_count() {
|
|
sb_psql -t -A -c "-- db-trial:assets-uploaded
|
|
select count(*) from public.anatomical_sheet_assets a
|
|
where a.sheet_id = private.historical_sheet_id() and a.uploaded_at is not null
|
|
and exists (select 1 from storage.objects o
|
|
where o.bucket_id = 'anatomical-sheet-assets' and o.name = a.sha256 || '.svg')"
|
|
}
|
|
# Right after the seed: the historical sheet is the only official one, its single version is a
|
|
# draft equal to document.json (jsonb equality, so the canonical fingerprint recorded in
|
|
# sheet-ref.json holds), its drawing rows match assets.json, and no account exists.
|
|
# A dollar-quote tag, never expanded:
|
|
# shellcheck disable=SC2016
|
|
DOC_TAG='$faunosteo_trial_doc$'
|
|
verify_equine_db() {
|
|
local got want="official=1 historical=1 versions=1 draft_equal=true accounts=0"
|
|
! grep -qF "$DOC_TAG" "$SEED/document.json" || die "document.json contains $DOC_TAG: cannot compare"
|
|
got="$( { cat <<'SQL'
|
|
-- db-trial:equine
|
|
select concat_ws(' ',
|
|
'official=' || (select count(*) from public.anatomical_sheets where is_official),
|
|
'historical=' || (select count(*) from public.anatomical_sheets s
|
|
where s.id = private.historical_sheet_id() and s.id = :'sheet'::uuid and s.is_official),
|
|
'versions=' || (select count(*) from public.anatomical_sheet_versions v
|
|
where v.sheet_id = private.historical_sheet_id()),
|
|
'draft_equal=' || coalesce((select (v.content =
|
|
SQL
|
|
printf '%s' "$DOC_TAG"
|
|
cat "$SEED/document.json"
|
|
printf '%s' "$DOC_TAG"
|
|
cat <<'SQL'
|
|
::jsonb)::text from public.anatomical_sheet_versions v
|
|
where v.sheet_id = private.historical_sheet_id() and v.status = 'draft'), 'none'),
|
|
'accounts=' || (select count(*) from auth.users));
|
|
SQL
|
|
} | sb_psql -t -A -v sheet="$HISTORICAL_SHEET")"
|
|
[ "$got" = "$want" ] || die "the equine sheet in the database is not the seed's ($got; expected $want)"
|
|
[ "$(asset_rows)" = "$(expected_assets)" ] || die "the equine drawing rows differ from assets.json"
|
|
say "equine sheet loaded: $got; drawing rows match assets.json"
|
|
}
|
|
inventory_counts() {
|
|
sb_psql -t -A -F ': ' <<'SQL'
|
|
-- db-trial:inventory
|
|
select 'accounts', count(*) from auth.users
|
|
union all select 'official sheets', count(*) from public.anatomical_sheets where is_official
|
|
union all select 'sheet versions', count(*) from public.anatomical_sheet_versions
|
|
union all select 'workspaces', count(*) from public.workspaces;
|
|
SQL
|
|
}
|
|
list_backups() { # a folder without SHA256SUMS never finished: listed, marked, never restored
|
|
local dir kind
|
|
say "backups in $BACKUPS"
|
|
[ -d "$BACKUPS" ] || return 0
|
|
for dir in "$BACKUPS"/*/; do
|
|
[ -d "$dir" ] || continue
|
|
if [ -f "$dir/SHA256SUMS" ]; then kind=complete; else kind=incomplete; fi
|
|
printf ' %s %s %s\n' "$(basename "$dir")" "$(du -sh "$dir" | cut -f1)" "$kind"
|
|
done
|
|
}
|
|
|
|
# plan: each section prints its lines and appends its refusals to the array named by $1.
|
|
plan_container_line() { # name
|
|
local host inner memory pids
|
|
read -r host inner <<<"$(port_of "$1")"
|
|
read -r memory pids <<<"$(limits_of "$1")"
|
|
printf ' %-24s %-46s 127.0.0.1:%s -> %-5s --memory %-5s --pids-limit %-4s volume %s\n' \
|
|
"$1" "$(image_of "$1")" "$host" "$inner" "$memory" "$pids" "$(mount_of "$1")"
|
|
}
|
|
plan_containers() { # refusals-array
|
|
# shellcheck disable=SC2178 # a nameref to the caller's array
|
|
local -n refs=$1
|
|
local name
|
|
echo "Containers (network $NET, restart policy no, --cpus 1):"
|
|
for name in "${CONTAINERS[@]}"; do
|
|
plan_container_line "$name"
|
|
if container_exists "$name"; then refs+=("container $name already exists"); fi
|
|
done
|
|
echo " $HELPER (create's image check, backup, restore, destroy only): --rm, --network none, image $IMAGE_DB"
|
|
}
|
|
plan_network_volumes() { # refusals-array
|
|
# shellcheck disable=SC2178 # a nameref to the caller's array
|
|
local -n refs=$1
|
|
local root vol
|
|
echo "Network: $NET"
|
|
if network_exists "$NET"; then refs+=("network $NET already exists"); fi
|
|
root="$(docker info --format '{{.DockerRootDir}}' 2>/dev/null || echo '<Docker data root>')"
|
|
echo "Volumes:"
|
|
for vol in "$VOL_DB" "$VOL_STORAGE"; do
|
|
printf ' %-24s %s/volumes/%s/_data\n' "$vol" "$root" "$vol"
|
|
if volume_exists "$vol"; then refs+=("volume $vol already exists"); fi
|
|
done
|
|
}
|
|
plan_images() {
|
|
local image where
|
|
echo "Images:"
|
|
for image in "$IMAGE_DB" "$IMAGE_AUTH" "$IMAGE_REST" "$IMAGE_STORAGE" "$IMAGE_MAIL" "$IMAGE_GATEWAY"; do
|
|
if docker image inspect -f '{{.Id}}' "$image" >/dev/null 2>&1; then where=present; else where='not pulled yet (create pulls it)'; fi
|
|
printf ' %-46s %s\n' "$image" "$where"
|
|
done
|
|
}
|
|
plan_ports() { # refusals-array
|
|
# shellcheck disable=SC2178 # a nameref to the caller's array
|
|
local -n refs=$1
|
|
local name host inner owner
|
|
echo "Ports (127.0.0.1 only):"
|
|
for name in "${CONTAINERS[@]}"; do
|
|
read -r host inner <<<"$(port_of "$name")"
|
|
if port_listening "$host"; then
|
|
owner="$(docker ps --format '{{.Names}} {{.Ports}}' 2>/dev/null | grep -F ":$host->" | cut -d' ' -f1 | head -n 1 || true)"
|
|
printf ' %-6s taken by %s\n' "$host" "${owner:-a process outside Docker}"
|
|
refs+=("port 127.0.0.1:$host is taken")
|
|
else
|
|
printf ' %-6s free\n' "$host"
|
|
fi
|
|
done
|
|
}
|
|
plan_app_host() { # refusals-array
|
|
# shellcheck disable=SC2178 # a nameref to the caller's array
|
|
local -n refs=$1
|
|
local host where
|
|
if host="$( (trial_host) 2>&1)"; then
|
|
if port_listening "$PORT_APP"; then where=taken; else where=free; fi
|
|
echo "App (pnpm db:trial app): http://$host:$PORT_APP, $where; the host is decided again at each app run"
|
|
else
|
|
refs+=("$host")
|
|
fi
|
|
}
|
|
plan_state_and_disk() { # refusals-array
|
|
# shellcheck disable=SC2178 # a nameref to the caller's array
|
|
local -n refs=$1
|
|
local where="$STATE"
|
|
echo "State folder: $STATE (700, secrets 600)"
|
|
if [ -f "$SECRETS" ]; then refs+=("$STATE already holds a stack"); fi
|
|
echo "Backups: $BACKUPS (cold copies, never pruned by the script; each needs free space of 110 % of the volumes)"
|
|
while [ ! -e "$where" ]; do where="$(dirname "$where")"; done
|
|
echo "Free disk there: $(df -h --output=avail "$where" | tail -n 1 | tr -d ' ')"
|
|
}
|
|
plan_memory_and_seed() { # refusals-array
|
|
# shellcheck disable=SC2178 # a nameref to the caller's array
|
|
local -n refs=$1
|
|
local mib
|
|
mib="$(available_mib)"
|
|
echo "Memory: caps 1920 MiB in all (about 650 MiB used in practice), $mib MiB available, floor $MEMORY_FLOOR_MIB MiB; the app's Node heap is capped at 768 MiB"
|
|
if [ "$mib" -lt "$MEMORY_FLOOR_MIB" ]; then refs+=("only $mib MiB of memory available"); fi
|
|
if (check_seed_sources) 2>/dev/null; then echo "Equine seed folder: sheet id and drawing hashes match"
|
|
else refs+=("the equine seed folder fails its hashes"); fi
|
|
echo "At create, before anything is made: the Rust pipeline regenerates the seed and compares it (pnpm r5:import-equine --check), then a --rm helper with no network checks that $IMAGE_DB holds tar and du"
|
|
}
|
|
cmd_plan() {
|
|
[ $# -eq 0 ] || die "plan takes no argument"
|
|
local refusals=()
|
|
say "db:trial plan: read-only, nothing is created, started or changed"
|
|
echo "Docker endpoint: $(daemon_endpoint) (a local unix socket, checked at dispatch)"
|
|
if daemon_ok; then echo "Docker daemon: reachable"
|
|
else refusals+=("the Docker daemon is unreachable (every Docker answer below is unknown)"); fi
|
|
plan_containers refusals
|
|
plan_network_volumes refusals
|
|
plan_images
|
|
plan_ports refusals
|
|
plan_app_host refusals
|
|
plan_state_and_disk refusals
|
|
plan_memory_and_seed refusals
|
|
if [ "${#refusals[@]}" -eq 0 ]; then
|
|
say "create would proceed"
|
|
else
|
|
say "create would refuse:"
|
|
printf ' - %s\n' "${refusals[@]}"
|
|
fi
|
|
}
|
|
|
|
# The backups run tar and du in the database image: proven before anything is made.
|
|
check_helper_image() {
|
|
docker run --rm --name "$HELPER" --network none --entrypoint sh "$IMAGE_DB" -c 'command -v tar && command -v du' >/dev/null \
|
|
|| die "helper check failed: the image lacks tar or du, or a $HELPER container is left over (docker rm $HELPER)"
|
|
}
|
|
# Before the first Docker resource, the files this create wrote are removed (none existed: create
|
|
# refuses a folder holding secrets.env). FIRST_RESOURCE is set just before the first Docker create,
|
|
# so a create that died after making something is never mistaken for one that made nothing: past
|
|
# it, the files go only when no faunosteo_trial_ resource exists; else nothing is removed and the
|
|
# way out is named.
|
|
create_stopped() {
|
|
local status=$? present
|
|
[ "$status" -ne 0 ] || return 0
|
|
present=''
|
|
if [ "$FIRST_RESOURCE" = yes ]; then present="$(existing_resources 2>/dev/null)" || present=unknown; fi
|
|
if [ -z "$present" ]; then
|
|
remove_live_files
|
|
echo "db-trial: create stopped before any Docker resource existed; the state files it wrote are removed" >&2
|
|
return 0
|
|
fi
|
|
echo "db-trial: create stopped before the end; nothing was removed. Present now:" >&2
|
|
existing_resources | sed 's/^/ /' >&2
|
|
echo "pnpm db:trial status shows the state; pnpm db:trial destroy (after the owner's go) clears it." >&2
|
|
}
|
|
FIRST_RESOURCE=no
|
|
# Everything that can refuse comes first: no file, no Docker write yet.
|
|
create_preflight() {
|
|
local found
|
|
[ ! -f "$SECRETS" ] || die "$STATE already holds a trial stack (pnpm db:trial status)"
|
|
found="$(existing_resources | tr '\n' ' ')"
|
|
[ -z "$found" ] || die "these faunosteo_trial_ resources already exist, nothing was created: $found"
|
|
ports_free "${CONTAINERS[@]}"
|
|
memory_ok
|
|
trial_host >/dev/null
|
|
check_seed_sources
|
|
check_seed_pipeline
|
|
check_helper_image
|
|
}
|
|
# The lock comes right after the folder exists; the secrets check is repeated under it.
|
|
create_state_folder() {
|
|
( umask 077; mkdir -p "$STATE" "$BACKUPS" )
|
|
chmod 700 "$STATE" "$BACKUPS"
|
|
take_lock
|
|
[ ! -f "$SECRETS" ] || die "$STATE already holds a trial stack (pnpm db:trial status)"
|
|
( umask 077; : > "$MARKER" )
|
|
}
|
|
create_state_files() {
|
|
new_secrets_file "$SECRETS"
|
|
load_secrets
|
|
write_conf
|
|
write_env_files
|
|
}
|
|
create_docker_resources() {
|
|
FIRST_RESOURCE=yes
|
|
docker network create --label faunosteo.stack=trial "$NET" >/dev/null
|
|
docker volume create --label faunosteo.stack=trial "$VOL_DB" >/dev/null
|
|
docker volume create --label faunosteo.stack=trial "$VOL_STORAGE" >/dev/null
|
|
}
|
|
create_database() {
|
|
local name
|
|
for name in "$DB" "$MAIL" "$AUTH" "$STORAGE"; do run_service "$name"; done
|
|
published_exactly "$DB"
|
|
migrate_up
|
|
write_manifest
|
|
seed_equine
|
|
verify_equine_db
|
|
}
|
|
create_front() {
|
|
local name
|
|
for name in "$REST" "$GATEWAY"; do run_service "$name"; done
|
|
check_loopback
|
|
}
|
|
cmd_create() {
|
|
[ $# -eq 0 ] || die "create takes no argument"
|
|
create_preflight
|
|
create_state_folder
|
|
trap create_stopped EXIT
|
|
create_state_files
|
|
create_docker_resources
|
|
create_database
|
|
create_front
|
|
trap - EXIT
|
|
say "trial stack created and running (gateway http://127.0.0.1:$PORT_GATEWAY)"
|
|
echo "Next: pnpm db:trial assets, then the accounts (SUPABASE.md §5.2), then pnpm db:trial app"
|
|
}
|
|
|
|
cmd_start() {
|
|
[ $# -eq 0 ] || die "start takes no argument"
|
|
require_created
|
|
take_lock
|
|
memory_ok
|
|
start_containers
|
|
say "trial stack running; the app: pnpm db:trial app"
|
|
}
|
|
cmd_stop() {
|
|
[ $# -eq 0 ] || die "stop takes no argument"
|
|
require_created
|
|
take_lock
|
|
# A running app would keep proxying session tokens to whatever answers 58801 next.
|
|
refuse_while_app_runs
|
|
stop_containers
|
|
say "trial stack stopped; data kept in $VOL_DB and $VOL_STORAGE"
|
|
}
|
|
|
|
status_migrations() {
|
|
local check pending
|
|
say "migrations: $(applied_versions | grep -c .) applied, $(find supabase/migrations -maxdepth 1 -name '*.sql' | wc -l) files in this branch"
|
|
if check="$( (check_manifest) 2>&1)"; then
|
|
# A refusal of pending_migrations is printed as it is, never fatal here.
|
|
pending="$( (pending_migrations) 2>&1 | tr '\n' ' ' || true)"
|
|
echo " applied files unchanged; new: ${pending:-none}"
|
|
else
|
|
echo " $check"
|
|
fi
|
|
}
|
|
status_sheet() {
|
|
say "equine sheet (versions by status)"
|
|
sb_psql -t -A -c "-- db-trial:equine-status
|
|
select status::text || ' ' || count(*) from public.anatomical_sheet_versions
|
|
where sheet_id = private.historical_sheet_id() group by status order by 1" | sed 's/^/ /'
|
|
echo " drawings uploaded and confirmed: $(uploaded_count)/$(expected_assets | grep -c .)"
|
|
}
|
|
status_accounts() {
|
|
say "accounts (email | platform roles | catalogue rights | verified TOTP factors)"
|
|
sb_psql -t -A -F ' | ' <<'SQL' | sed 's/^/ /'
|
|
-- db-trial:accounts
|
|
select u.email,
|
|
coalesce((select string_agg(r.role::text, ',' order by r.role::text) from public.profile_roles r
|
|
where r.user_id = u.id and r.revoked_at is null), '-'),
|
|
coalesce((select string_agg(g.grant_kind::text, ',' order by g.grant_kind::text)
|
|
from public.anatomical_catalog_grants g
|
|
where g.user_id = u.id and g.revoked_at is null
|
|
and (g.expires_at is null or g.expires_at > now())), '-'),
|
|
(select count(*) from auth.mfa_factors f
|
|
where f.user_id = u.id and f.factor_type = 'totp' and f.status = 'verified')
|
|
from auth.users u order by u.email;
|
|
SQL
|
|
}
|
|
status_database() {
|
|
status_migrations
|
|
status_sheet
|
|
status_accounts
|
|
say "content"
|
|
inventory_counts | sed 's/^/ /'
|
|
}
|
|
status_containers() {
|
|
local name
|
|
say "containers"
|
|
for name in "${CONTAINERS[@]}"; do
|
|
printf ' %-24s %s\n' "$name" "$(docker container inspect -f '{{.State.Status}} {{.Config.Image}}' "$name" 2>/dev/null || echo absent)"
|
|
done
|
|
}
|
|
status_keys_and_host() {
|
|
local host
|
|
say "keys valid until $(key_expiry) (pnpm db:trial rotate-keys renews them)"
|
|
if [ "$(key_check "$TR_ANON_KEY" anon fresh >/dev/null 2>&1; echo $?)" = 3 ]; then
|
|
say "the keys have EXPIRED: app, assets and account refuse until pnpm db:trial rotate-keys"
|
|
fi
|
|
host="$( (trial_host) 2>&1 || true)"
|
|
say "app host now: $host (pnpm db:trial app serves http://<host>:$PORT_APP)"
|
|
}
|
|
status_without_stack() {
|
|
say "no trial stack in $STATE (pnpm db:trial plan shows what create would make)"
|
|
existing_resources | sed 's/^/ present anyway: /'
|
|
list_backups
|
|
}
|
|
cmd_status() {
|
|
[ $# -eq 0 ] || die "status takes no argument"
|
|
if [ ! -e "$MARKER" ] || [ ! -f "$SECRETS" ]; then status_without_stack; return 0; fi
|
|
check_private "$STATE" 700
|
|
load_conf
|
|
load_secrets
|
|
status_containers
|
|
say "Docker endpoint: $(daemon_endpoint)"
|
|
status_keys_and_host
|
|
if container_running "$DB"; then status_database; else say "database stopped: pnpm db:trial start"; fi
|
|
list_backups
|
|
}
|
|
|
|
# Every command's arguments are checked before any Docker call (a refusal here logs nothing).
|
|
# The commands keep their own checks too, so each stays safe if called on its own.
|
|
check_arguments() { # action args...
|
|
local action="$1"
|
|
shift
|
|
case "$action" in
|
|
plan | create | start | stop | status)
|
|
[ $# -eq 0 ] || die "$action takes no argument" ;;
|
|
*) usage; exit 1 ;;
|
|
esac
|
|
}
|
|
|
|
guard_environment
|
|
action="${1:-}"
|
|
[ $# -eq 0 ] || shift
|
|
case "$action" in
|
|
'' | help | -h | --help) usage; exit 1 ;;
|
|
esac
|
|
check_arguments "$action" "$@"
|
|
command -v docker >/dev/null || die "docker is not installed"
|
|
command -v ss >/dev/null || die "ss (iproute2) is not installed: the ports cannot be checked, nothing was run"
|
|
require_local_daemon
|
|
# Past this line a Docker "absent" is an answer, not a dead daemon (plan reports the daemon itself).
|
|
if [ "$action" != plan ]; then
|
|
daemon_ok || die "Docker daemon unreachable: nothing was run (systemctl --user status docker)"
|
|
fi
|
|
case "$action" in
|
|
plan) cmd_plan "$@" ;;
|
|
create) cmd_create "$@" ;;
|
|
start) cmd_start "$@" ;;
|
|
stop) cmd_stop "$@" ;;
|
|
status) cmd_status "$@" ;;
|
|
*) usage; exit 1 ;;
|
|
esac
|