crosscode script: deploy, status, install, adopt (Events 2.2.0, plan §4-5)
One script for installing, updating and moving church installs, replacing hope-events' scripts/deploy.sh and install.sh: - deploy <church> [events] / --every-church, with --version, --main, --check and --allow-local-changes: checks every product first (files changed by hand, Node, release requirements from WHATS-NEW.md headings), then each product in order with backup, checkout, install, migrate, build, PM2 reload and a /health version check; a failure rolls that product back and stops. - status [<church>]: checked-out and latest release, /health, and the old folder kept after adopt. - install <church> --products events --domain <address>: a new church under /var/www/sites/<church>, writing church.env. - adopt <church> --events-dir <old> builds the monorepo checkout next to the running install and switches PM2 over; adopt --undo goes back to it. Product hooks live in scripts/products/events.sh. shellcheck (lint:scripts) and 47 bats tests (test:scripts) are part of npm run check. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,328 @@
|
||||
# shellcheck shell=bash
|
||||
# Shared helpers for the crosscode script: logging, users, church.env, tags, versions, health.
|
||||
# Only functions and defaults: sourcing this file changes nothing (the bats tests rely on that).
|
||||
|
||||
CROSSCODE_SITES="${CROSSCODE_SITES:-/var/www/sites}"
|
||||
CROSSCODE_REPO="${CROSSCODE_REPO:-https://c-git.crosscode.co.za/joshua/crosscode-platform.git}"
|
||||
# Every deploy runs the products in this order (ROADMAP §8): Accounts first, since others sign in
|
||||
# through it.
|
||||
PRODUCT_ORDER=(accounts events website app)
|
||||
# Products this version of the script can deploy (a products/<name>.sh exists for each).
|
||||
SUPPORTED_PRODUCTS=(events)
|
||||
# Releases older than this get a warning; older than CROSSCODE_NODE_MIN the deploy is refused.
|
||||
CROSSCODE_NODE_MIN=20
|
||||
CROSSCODE_NODE_WARN=22
|
||||
|
||||
# ── Logging ──────────────────────────────────────────────────────────────────────────────────
|
||||
step() { printf '==> %s\n' "$*"; }
|
||||
info() { printf ' %s\n' "$*"; }
|
||||
warn() { printf '!!> %s\n' "$*" >&2; }
|
||||
die() { printf '!!> %s\n' "$*" >&2; exit 1; }
|
||||
|
||||
# ── Small checks ─────────────────────────────────────────────────────────────────────────────
|
||||
require_root() {
|
||||
# The bats tests run deploys against stub products as an ordinary user.
|
||||
[ "${CROSSCODE_TEST:-}" = 1 ] && return 0
|
||||
[ "$(id -u)" = 0 ] || die "Run this as root (sudo crosscode …): it reads church.env (root only) and runs each app as its own user."
|
||||
}
|
||||
|
||||
# A church's short name: lower case letters, digits and -, starting with a letter.
|
||||
valid_slug() { [[ "$1" =~ ^[a-z][a-z0-9-]{0,39}$ ]]; }
|
||||
|
||||
is_known_product() {
|
||||
local p
|
||||
for p in "${PRODUCT_ORDER[@]}"; do [ "$p" = "$1" ] && return 0; done
|
||||
return 1
|
||||
}
|
||||
|
||||
is_supported_product() {
|
||||
local p
|
||||
for p in "${SUPPORTED_PRODUCTS[@]}"; do [ "$p" = "$1" ] && return 0; done
|
||||
return 1
|
||||
}
|
||||
|
||||
# A product's place in the deploy order (0 for accounts).
|
||||
product_index() {
|
||||
local i
|
||||
for i in "${!PRODUCT_ORDER[@]}"; do [ "${PRODUCT_ORDER[$i]}" = "$1" ] && { echo "$i"; return 0; }; done
|
||||
echo 99
|
||||
}
|
||||
|
||||
# The products given (any order, repeats allowed), printed in deploy order, one per line.
|
||||
in_product_order() {
|
||||
local p q
|
||||
for p in "${PRODUCT_ORDER[@]}"; do
|
||||
for q in "$@"; do
|
||||
if [ "$p" = "$q" ]; then echo "$p"; break; fi
|
||||
done
|
||||
done
|
||||
}
|
||||
|
||||
# Upper case for church.env keys: events → EVENTS.
|
||||
upper() { printf '%s' "$1" | tr '[:lower:]-' '[:upper:]_'; }
|
||||
|
||||
# ── Running things as the app user ───────────────────────────────────────────────────────────
|
||||
# run_as <user> <dir> <command…>: runs the command in <dir> as <user> (directly when we already
|
||||
# are that user), with that user's HOME so PM2 and npm use their own folders.
|
||||
run_as() {
|
||||
local user="$1" dir="$2"
|
||||
shift 2
|
||||
if [ "$(id -un)" = "$user" ]; then
|
||||
(cd -- "$dir" && "$@")
|
||||
else
|
||||
sudo -u "$user" -H -- bash -c 'cd -- "$1" && shift && exec "$@"' crosscode-run "$dir" "$@"
|
||||
fi
|
||||
}
|
||||
|
||||
# ── church.env ───────────────────────────────────────────────────────────────────────────────
|
||||
# /var/www/sites/<church>/church.env holds names, folders, domains and ports (never secrets). It is
|
||||
# read as data, never sourced: only KEY=VALUE lines with known keys are taken, into CENV.
|
||||
declare -gA CENV=()
|
||||
|
||||
church_dir() { printf '%s/%s' "$CROSSCODE_SITES" "$1"; }
|
||||
church_env_path() { printf '%s/%s/church.env' "$CROSSCODE_SITES" "$1"; }
|
||||
|
||||
church_env_key_ok() {
|
||||
[[ "$1" =~ ^(CHURCH|PRODUCTS|ADDRESS)$ ]] || [[ "$1" =~ ^(ACCOUNTS|EVENTS|WEBSITE|APP)_[A-Z0-9_]+$ ]]
|
||||
}
|
||||
|
||||
# church_env_read <file>: fills CENV. Values may be bare or in double or single quotes; a
|
||||
# "# comment" after the value is ignored. Unknown keys and other lines are skipped.
|
||||
church_env_read() {
|
||||
local file="$1" line key value
|
||||
CENV=()
|
||||
[ -f "$file" ] || return 1
|
||||
while IFS= read -r line || [ -n "$line" ]; do
|
||||
line="${line%$'\r'}"
|
||||
[[ "$line" =~ ^[[:space:]]*([A-Z][A-Z0-9_]*)=(.*)$ ]] || continue
|
||||
key="${BASH_REMATCH[1]}"
|
||||
value="${BASH_REMATCH[2]}"
|
||||
church_env_key_ok "$key" || continue
|
||||
if [[ "$value" =~ ^\"([^\"]*)\" ]] || [[ "$value" =~ ^\'([^\']*)\' ]]; then
|
||||
value="${BASH_REMATCH[1]}"
|
||||
else
|
||||
value="${value%%#*}"
|
||||
value="${value%"${value##*[![:space:]]}"}"
|
||||
fi
|
||||
CENV[$key]="$value"
|
||||
done < "$file"
|
||||
}
|
||||
|
||||
# cenv <KEY> [default]: a value from CENV.
|
||||
cenv() { printf '%s' "${CENV[$1]:-${2:-}}"; }
|
||||
# pvar <product> <NAME> [default]: a product's value, e.g. pvar events DIR → CENV[EVENTS_DIR].
|
||||
pvar() { cenv "$(upper "$1")_$2" "${3:-}"; }
|
||||
|
||||
church_env_set() {
|
||||
church_env_key_ok "$1" || die "church.env: unknown key $1"
|
||||
[[ "$2" != *[\"\'\$\`\\]* && "$2" != *$'\n'* ]] || die "church.env: $1 can't contain quotes, \$, \` , \\ or newlines"
|
||||
CENV[$1]="$2"
|
||||
}
|
||||
|
||||
church_env_unset() { unset 'CENV[$1]'; }
|
||||
|
||||
# church_env_write <file>: writes CENV in a fixed order (CHURCH, PRODUCTS, ADDRESS, then each
|
||||
# product's keys in deploy order), atomically, mode 600.
|
||||
church_env_write() {
|
||||
local file="$1" tmp key p prefix
|
||||
local -a keys=()
|
||||
for key in CHURCH PRODUCTS ADDRESS; do [ -n "${CENV[$key]+x}" ] && keys+=("$key"); done
|
||||
for p in "${PRODUCT_ORDER[@]}"; do
|
||||
prefix="$(upper "$p")_"
|
||||
while IFS= read -r key; do [ -n "$key" ] && keys+=("$key"); done < <(
|
||||
for key in "${!CENV[@]}"; do [[ "$key" == "$prefix"* ]] && echo "$key"; done | LC_ALL=C sort
|
||||
)
|
||||
done
|
||||
tmp="$(mktemp "$(dirname "$file")/.church.env.XXXXXX")"
|
||||
{
|
||||
echo "# Written by crosscode. Names, folders, domains and ports only: secrets stay in each product's .env."
|
||||
for key in "${keys[@]}"; do
|
||||
if [[ "${CENV[$key]}" =~ [[:space:]#] || -z "${CENV[$key]}" ]]; then
|
||||
printf '%s="%s"\n' "$key" "${CENV[$key]}"
|
||||
else
|
||||
printf '%s=%s\n' "$key" "${CENV[$key]}"
|
||||
fi
|
||||
done
|
||||
} > "$tmp"
|
||||
chmod 600 "$tmp"
|
||||
mv -f "$tmp" "$file"
|
||||
}
|
||||
|
||||
# Church names on this server: every folder in $CROSSCODE_SITES with a church.env.
|
||||
list_churches() {
|
||||
local f
|
||||
for f in "$CROSSCODE_SITES"/*/church.env; do
|
||||
[ -f "$f" ] && basename "$(dirname "$f")"
|
||||
done
|
||||
return 0
|
||||
}
|
||||
|
||||
# Loads a church's church.env into CENV, or stops.
|
||||
load_church() {
|
||||
valid_slug "$1" || die "\"$1\" isn't a church name (a-z, 0-9 and -)."
|
||||
church_env_read "$(church_env_path "$1")" || die "No church \"$1\" on this server ($(church_env_path "$1") is missing)."
|
||||
}
|
||||
|
||||
church_has_product() {
|
||||
local p
|
||||
for p in $(cenv PRODUCTS); do [ "$p" = "$1" ] && return 0; done
|
||||
return 1
|
||||
}
|
||||
|
||||
# ── Versions and tags ────────────────────────────────────────────────────────────────────────
|
||||
# version_ge <a> <b>: a >= b, for x.y.z with an optional -prerelease (1.2.0-rc1 < 1.2.0).
|
||||
version_ge() {
|
||||
local a="$1" b="$2" an bn ap bp i x y
|
||||
an="${a%%-*}"; bn="${b%%-*}"
|
||||
ap=""; bp=""
|
||||
[[ "$a" == *-* ]] && ap="${a#*-}"
|
||||
[[ "$b" == *-* ]] && bp="${b#*-}"
|
||||
local -a A B
|
||||
IFS=. read -r -a A <<< "$an"
|
||||
IFS=. read -r -a B <<< "$bn"
|
||||
for i in 0 1 2; do
|
||||
x="${A[$i]:-0}"; y="${B[$i]:-0}"
|
||||
[[ "$x" =~ ^[0-9]+$ && "$y" =~ ^[0-9]+$ ]] || return 2
|
||||
if ((10#$x > 10#$y)); then return 0; fi
|
||||
if ((10#$x < 10#$y)); then return 1; fi
|
||||
done
|
||||
# Same x.y.z: a release beats its prereleases; prereleases compare as text.
|
||||
if [ -z "$ap" ]; then return 0; fi
|
||||
if [ -z "$bp" ]; then return 1; fi
|
||||
[[ "$ap" > "$bp" || "$ap" == "$bp" ]]
|
||||
}
|
||||
|
||||
# tag_version <product@x.y.z> → x.y.z
|
||||
tag_version() { printf '%s' "${1#*@}"; }
|
||||
|
||||
# latest_tag <product>, reading tag names on stdin: the newest released product@x.y.z
|
||||
# (prerelease and test tags such as events@2.2.0-test are never "latest").
|
||||
latest_tag_from() {
|
||||
local p="$1" t best=""
|
||||
while IFS= read -r t; do
|
||||
[[ "$t" =~ ^${p}@[0-9]+\.[0-9]+\.[0-9]+$ ]] || continue
|
||||
if [ -z "$best" ] || version_ge "$(tag_version "$t")" "$(tag_version "$best")"; then best="$t"; fi
|
||||
done
|
||||
printf '%s' "$best"
|
||||
}
|
||||
|
||||
# git_in <checkout> <args…>: git for reading a checkout owned by the app user (as root, git would
|
||||
# otherwise refuse it as "dubious ownership"). Anything that writes runs as the app user instead.
|
||||
git_in() {
|
||||
local dir="$1"
|
||||
shift
|
||||
git -c safe.directory="$dir" -C "$dir" "$@"
|
||||
}
|
||||
|
||||
# latest_tag <checkout> <product>: from the checkout's tags (fetch first).
|
||||
latest_tag() { git_in "$1" tag -l "$2@*" | latest_tag_from "$2"; }
|
||||
|
||||
# checkout_ref <checkout> <product>: the product tag the checkout is on, or the short commit.
|
||||
checkout_ref() {
|
||||
git_in "$1" describe --tags --exact-match --match "$2@*" 2>/dev/null || git_in "$1" rev-parse --short HEAD
|
||||
}
|
||||
|
||||
# whatsnew_requires <version>, reading a WHATS-NEW.md on stdin: the requirements in that
|
||||
# version's heading, one "product x.y.z" per line. Same grammar as the Hub's release sync
|
||||
# (events-hub releaseSync.js): "## 3.0.0 — requires accounts 1.2.0, website 1.1.0 — urgent".
|
||||
# HTML comments are skipped (the file's own instructions contain example headings).
|
||||
whatsnew_requires() {
|
||||
local version="$1"
|
||||
awk -v want="$version" '
|
||||
BEGIN { products = "accounts|events|website|app" }
|
||||
{
|
||||
line = $0
|
||||
sub(/\r$/, "", line)
|
||||
# Drop <!-- … --> comments, which can span lines.
|
||||
out = ""
|
||||
while (line != "") {
|
||||
if (incomment) {
|
||||
e = index(line, "-->")
|
||||
if (e == 0) { line = ""; break }
|
||||
line = substr(line, e + 3); incomment = 0
|
||||
} else {
|
||||
s = index(line, "<!--")
|
||||
if (s == 0) { out = out line; line = ""; break }
|
||||
out = out substr(line, 1, s - 1); line = substr(line, s + 4); incomment = 1
|
||||
}
|
||||
}
|
||||
if (out !~ /^##[ \t]+/) next
|
||||
h = out; sub(/^##[ \t]+/, "", h)
|
||||
if (!match(h, /v?[0-9]+\.[0-9]+\.[0-9]+/)) next
|
||||
v = substr(h, RSTART, RLENGTH); sub(/^v/, "", v)
|
||||
if (v != want) next
|
||||
rest = tolower(substr(h, RSTART + RLENGTH))
|
||||
if (!match(rest, /(^|[^a-z])requires?([^a-z]|$)/)) exit
|
||||
rest = substr(rest, RSTART)
|
||||
while (match(rest, "(" products ")[ \t]+v?[0-9]+\\.[0-9]+\\.[0-9]+")) {
|
||||
m = substr(rest, RSTART, RLENGTH)
|
||||
before = RSTART > 1 ? substr(rest, RSTART - 1, 1) : " "
|
||||
rest = substr(rest, RSTART + RLENGTH)
|
||||
if (before ~ /[a-z0-9]/) continue
|
||||
split(m, parts, /[ \t]+/)
|
||||
p = parts[1]; ver = parts[2]; sub(/^v/, "", ver)
|
||||
if (!(p in seen)) { seen[p] = 1; print p " " ver }
|
||||
}
|
||||
exit
|
||||
}
|
||||
'
|
||||
}
|
||||
|
||||
# ── .env files and URLs ──────────────────────────────────────────────────────────────────────
|
||||
# env_value <file> <KEY>: a value from a .env file (quotes removed), "" when absent.
|
||||
env_value() {
|
||||
local line
|
||||
line="$(grep -E "^[[:space:]]*(export[[:space:]]+)?$2=" "$1" 2>/dev/null | tail -n 1)" || true
|
||||
line="${line#*=}"
|
||||
line="${line%$'\r'}"
|
||||
if [[ "$line" =~ ^\"(.*)\"$ ]] || [[ "$line" =~ ^\'(.*)\'$ ]]; then line="${BASH_REMATCH[1]}"; fi
|
||||
printf '%s' "$line"
|
||||
}
|
||||
|
||||
# db_name_from_url <postgresql://user:pass@host:5432/name?x=y> → name
|
||||
db_name_from_url() {
|
||||
local u="${1%%\?*}"
|
||||
printf '%s' "${u##*/}"
|
||||
}
|
||||
|
||||
# host_from_url <https://events.church.org/x> → events.church.org (the first, if a list)
|
||||
host_from_url() {
|
||||
local u="${1%%,*}"
|
||||
u="${u#*://}"
|
||||
u="${u%%/*}"
|
||||
printf '%s' "${u%%:*}"
|
||||
}
|
||||
|
||||
# ── Health ───────────────────────────────────────────────────────────────────────────────────
|
||||
# json_get <path>, reading JSON on stdin: a value ("a.b"), objects as compact JSON, "" if absent.
|
||||
json_get() {
|
||||
node -e '
|
||||
let s = "";
|
||||
process.stdin.on("data", d => (s += d)).on("end", () => {
|
||||
try {
|
||||
const v = process.argv[1].split(".").reduce((o, k) => (o == null ? o : o[k]), JSON.parse(s));
|
||||
process.stdout.write(v == null ? "" : typeof v === "object" ? JSON.stringify(v) : String(v));
|
||||
} catch { process.exit(1); }
|
||||
});' "$1"
|
||||
}
|
||||
|
||||
health_json() { curl -fsS --max-time 5 "$1" 2>/dev/null; }
|
||||
|
||||
# wait_for_version <health url> <version> [seconds]: until /health answers with that version.
|
||||
wait_for_version() {
|
||||
local url="$1" want="$2" limit="${3:-60}" waited=0 got=""
|
||||
while [ "$waited" -lt "$limit" ]; do
|
||||
got="$(health_json "$url" | json_get version 2>/dev/null || true)"
|
||||
[ "$got" = "$want" ] && return 0
|
||||
sleep 2
|
||||
waited=$((waited + 2))
|
||||
done
|
||||
warn "/health ($url) didn't report $want within ${limit}s (last answer: ${got:-none})."
|
||||
return 1
|
||||
}
|
||||
|
||||
node_major() { node -p 'process.versions.node.split(".")[0]' 2>/dev/null || echo 0; }
|
||||
|
||||
# Files changed or added by hand in a checkout (ignored files such as .env, uploads, backups and
|
||||
# the install's ecosystem.config.js never count).
|
||||
local_changes() { git_in "$1" status --porcelain --untracked-files=all; }
|
||||
Reference in New Issue
Block a user