Files
archie/install.sh
T
sam 8540c9f7c8 feat(releaseupdate): transactional self-update through archied (#1633)
archied update install verifies the release zip, checks every binary
reports the release, pulls the agent image by digest, backs up the
database in-process and stages the binaries before handing off to
archied update watchdog in its own process. The watchdog restarts units
in release order, requires archied healthy for 120s and otherwise rolls
back binaries and image policy, restoring the database only when a
migration ran. Boot recovery resumes the frozen watchdog.

Deletes scripts/archie-update-install, scripts/archie-update-watchdog,
the updater's --from-source and --auto, CommandInstaller,
ScriptInstaller and the update-image and update-topology subcommands.
2026-10-12 03:21:02 +11:00

398 lines
15 KiB
Bash
Executable File

#!/usr/bin/env bash
# install.sh - installs Archie Core for the current user.
#
# curl -fsSL https://raw.githubusercontent.com/samcharles93/archie-core/main/install.sh | bash
#
# Downloads the latest release, verifies it against SHA256SUMS, installs the
# five services to ${XDG_BIN_HOME:-~/.local/bin}, runs `archied setup`, starts
# the bundled PostgreSQL and installs systemd user units.
# Config: ${XDG_CONFIG_HOME:-~/.config}/archie Data: ${XDG_DATA_HOME:-~/.local/share}/archie
set -euo pipefail
REPO="samcharles93/archie-core"
XDG_CONFIG_HOME="${XDG_CONFIG_HOME:-${HOME}/.config}"
XDG_DATA_HOME="${XDG_DATA_HOME:-${HOME}/.local/share}"
XDG_BIN_HOME="${XDG_BIN_HOME:-${HOME}/.local/bin}"
ARCHIE_CONFIG_DIR="${XDG_CONFIG_HOME}/archie"
ARCHIE_DATA_DIR="${XDG_DATA_HOME}/archie"
ARCHIE_BIN_DIR="${XDG_BIN_HOME}"
ENV_FILE="${ARCHIE_CONFIG_DIR}/env"
INSTALL_SYSTEMD=true
ENABLE_LINGER=true
AUTO_START=true
FROM_SOURCE=false
# Piped into bash, stdin is the script; setup reads its answers from the
# terminal instead, so a pipe can still be interactive.
INTERACTIVE=false
if (: </dev/tty) 2>/dev/null; then INTERACTIVE=true; fi
usage() {
cat <<EOF
Usage: install.sh [options]
or: curl -fsSL https://raw.githubusercontent.com/${REPO}/main/install.sh | bash -s -- [options]
Options:
--version X.Y.Z Install this release instead of the latest
--from-source Build from a checkout (this one, or a fresh clone) instead
of a release; needs Go, git and jq
--no-systemd Skip systemd user units
--no-linger Skip loginctl enable-linger
--no-start Install the units but do not start them
--non-interactive Write an unattended config (no forge, Ollama)
--help, -h Show this help
EOF
}
VERSION=""
while [ $# -gt 0 ]; do
case "$1" in
--version) VERSION="${2:?--version needs a value}"; shift ;;
--from-source) FROM_SOURCE=true ;;
--no-systemd) INSTALL_SYSTEMD=false; AUTO_START=false ;;
--no-linger) ENABLE_LINGER=false ;;
--no-start) AUTO_START=false ;;
--non-interactive|--batch) INTERACTIVE=false ;;
--help|-h) usage; exit 0 ;;
*) echo "Error: unknown option '$1'" >&2; usage >&2; exit 1 ;;
esac
shift
done
need() {
for cmd in "$@"; do
command -v "$cmd" &>/dev/null || { echo "Error: '$cmd' is required but not installed." >&2; exit 1; }
done
}
# 1. Prerequisites
echo "==> Checking prerequisites..."
# The installer depends on systemd user units and GNU tools.
if [ "$(uname -s)" != "Linux" ]; then
echo "Error: the installer supports Linux only. Detected: $(uname -s)" >&2
exit 1
fi
if [ "${FROM_SOURCE}" = true ]; then
need git go jq
else
[ "$(uname -m)" = x86_64 ] || { echo "Error: releases are built for x86_64 only; use --from-source." >&2; exit 1; }
need curl unzip sha256sum
fi
if command -v docker &>/dev/null; then
echo " [OK] $(docker --version)"
else
echo " [WARN] Docker not found. Agents run in containers and the bundled PostgreSQL needs it."
fi
mkdir -p "${ARCHIE_CONFIG_DIR}" "${ARCHIE_DATA_DIR}" "${ARCHIE_BIN_DIR}"
# 2. Binaries. STAGE ends up holding the binaries and release.json, whichever
# way they were obtained.
TMP="$(mktemp -d)"
trap 'rm -rf "${TMP}"' EXIT
if [ "${FROM_SOURCE}" = true ]; then
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)"
if [ -f "${SCRIPT_DIR}/go.mod" ] && grep -q "github.com/${REPO}" "${SCRIPT_DIR}/go.mod"; then
SRC_DIR="${SCRIPT_DIR}"
else
SRC_DIR="${TMP}/src"
git clone --quiet --depth=1 "https://github.com/${REPO}.git" "${SRC_DIR}"
fi
echo "==> Building from ${SRC_DIR}..."
STAGE="${TMP}/stage"
mkdir -p "${STAGE}"
# A source build is not a release: it says `dev`, and buildType=binary lets
# it self-update.
LDFLAGS="-X github.com/${REPO}/internal/buildinfo.Version=dev -X github.com/${REPO}/internal/buildinfo.Runtime=dev -X github.com/${REPO}/internal/installtype.buildType=binary"
for cmd in $(jq -er '.required_topology.units | join(" ")' "${SRC_DIR}/release.json"); do
(cd "${SRC_DIR}" && go build -ldflags "${LDFLAGS}" -o "${STAGE}/${cmd}" "./cmd/${cmd}")
done
cp "${SRC_DIR}/release.json" "${STAGE}/"
else
if [ -z "${VERSION}" ]; then
tag="$(curl -fsSL "https://api.github.com/repos/${REPO}/releases/latest" | sed -n 's/.*"tag_name": *"\([^"]*\)".*/\1/p')"
[ -n "${tag}" ] || { echo "Error: could not find the latest release." >&2; exit 1; }
else
tag="v${VERSION}"
fi
VERSION="${tag##*v}"
name="archie-core-archied-v${VERSION}-linux-amd64"
echo "==> Downloading Archie ${VERSION}..."
base="https://github.com/${REPO}/releases/download/${tag}"
curl -fsSL "${base}/${name}.zip" -o "${TMP}/${name}.zip"
curl -fsSL "${base}/SHA256SUMS" -o "${TMP}/SHA256SUMS"
expected="$(awk -v n="${name}.zip" '$2 == n {print $1}' "${TMP}/SHA256SUMS")"
[[ "${expected}" =~ ^[a-f0-9]{64}$ ]] || { echo "Error: ${name}.zip is not in SHA256SUMS." >&2; exit 1; }
printf '%s %s\n' "${expected}" "${TMP}/${name}.zip" | sha256sum --check --status ||
{ echo "Error: checksum mismatch for ${name}.zip." >&2; exit 1; }
unzip -q "${TMP}/${name}.zip" -d "${TMP}"
STAGE="${TMP}/${name}"
fi
TOPOLOGY_UNITS="$(tr -d '\n' <"${STAGE}/release.json" | sed -n 's/.*"units": *\[\([^]]*\)\].*/\1/p' | tr -d '" ' | tr , ' ')"
for cmd in ${TOPOLOGY_UNITS}; do
install -m755 "${STAGE}/${cmd}" "${ARCHIE_BIN_DIR}/${cmd}"
done
echo " Installed ${TOPOLOGY_UNITS} to ${ARCHIE_BIN_DIR}/"
# 3. Configuration. archied setup asks every question and writes config.toml
# plus any secrets to the env file beside it; this script asks nothing itself.
if [ ! -f "${ARCHIE_CONFIG_DIR}/config.toml" ]; then
echo "==> Generating config.toml (archied setup)..."
if [ "${INTERACTIVE}" = true ]; then
setup_args=(-config "${ARCHIE_CONFIG_DIR}/config.toml")
else
# Unattended: no forge and keyless Ollama, so the services boot without a secret.
setup_args=(--defaults -config "${ARCHIE_CONFIG_DIR}/config.toml" -forge-type none)
fi
setup_in=/dev/null
[ "${INTERACTIVE}" = true ] && setup_in=/dev/tty
if ! "${ARCHIE_BIN_DIR}/archied" setup "${setup_args[@]}" <"${setup_in}"; then
echo "ERROR: archied setup could not generate ${ARCHIE_CONFIG_DIR}/config.toml" >&2
exit 1
fi
else
echo " [SKIP] ${ARCHIE_CONFIG_DIR}/config.toml already exists. Re-run 'archied setup' to change it."
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.
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
echo " [OK] Using the PostgreSQL server named by database_url."
elif ! command -v docker &>/dev/null; then
echo " [WARN] Docker not found: the bundled PostgreSQL needs it. Install Docker, or run 'archied setup' with your own PostgreSQL 18 URL." >&2
AUTO_START=false
else
echo "==> Starting the bundled PostgreSQL 18..."
mkdir -p "${PG_SOCKET_DIR}"
cat >"${PG_COMPOSE}" <<'EOF'
services:
postgres:
image: postgres:18
network_mode: none
environment:
POSTGRES_USER: archie
POSTGRES_PASSWORD: ${PGPASSWORD:-}
POSTGRES_DB: archie
POSTGRES_INITDB_ARGS: --auth-local=scram-sha-256
PGDATA: /var/lib/postgresql/data/pgdata
volumes:
- pg_data:/var/lib/postgresql/data
# :z relabels the directory for SELinux hosts.
- ./postgres:/var/run/postgresql:z
restart: unless-stopped
healthcheck:
test: ["CMD-SHELL", "pg_isready -U archie -d archie"]
interval: 5s
timeout: 5s
retries: 10
volumes:
pg_data:
EOF
if ! docker compose -p archie --env-file "${ENV_FILE}" -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 archie -f ${PG_COMPOSE} logs" >&2
AUTO_START=false
fi
fi
# Extensions run in an unprivileged user namespace. Ubuntu 23.10+ forbids
# those unless an AppArmor profile allows them, and only root can add one, so
# print the profile that allows it for these binaries alone.
if [ "$(cat /proc/sys/kernel/apparmor_restrict_unprivileged_userns 2>/dev/null)" = 1 ]; then
echo " [WARN] This host restricts user namespaces, so extensions will not start until you run:" >&2
cat >&2 <<EOF
sudo tee /etc/apparmor.d/archie >/dev/null <<'PROFILE'
abi <abi/4.0>,
include <tunables/global>
profile archie ${ARCHIE_BIN_DIR}/archie{d,-*} flags=(unconfined) {
userns,
}
PROFILE
sudo apparmor_parser -r /etc/apparmor.d/archie
EOF
fi
# 5. Systemd user service setup & linger configuration
SERVICE_INSTALLED=false
if [ "${INSTALL_SYSTEMD}" = true ] && command -v systemctl &>/dev/null && [ -d "${XDG_CONFIG_HOME}" ]; then
SYSTEMD_USER_DIR="${XDG_CONFIG_HOME}/systemd/user"
echo "==> Configuring systemd user services..."
mkdir -p "${SYSTEMD_USER_DIR}"
# Every service this installer builds gets a unit, with the contents the
# runbook used to tell an operator to paste by hand. The runbook is a
# description now, not the mechanism: a fresh install must not need four
# hand-written units before its own updater will run, and
# the contents must not live in two places to drift apart.
cat <<EOF > "${SYSTEMD_USER_DIR}/archied.service"
[Unit]
Description=Archie Core Orchestrator Daemon
After=network.target
# Give up after 5 failures in 5 minutes rather than restarting forever. A
# genuinely broken install otherwise loops every RestartSec indefinitely,
# burying the real error in the journal instead of surfacing a failed unit.
StartLimitIntervalSec=300
StartLimitBurst=5
[Service]
Type=simple
ExecStart=${ARCHIE_BIN_DIR}/archied -config ${ARCHIE_CONFIG_DIR}/config.toml
EnvironmentFile=-${ENV_FILE}
# archied reloads its configuration on SIGHUP. Without ExecReload,
# 'systemctl --user reload archied' fails and the operator has to know
# to run 'systemctl --user kill -s HUP' instead.
ExecReload=/bin/kill -HUP \$MAINPID
Restart=on-failure
RestartSec=5s
[Install]
WantedBy=default.target
EOF
# The State Store owns the task data and is the process everything else dials, so
# its unit is the first dependency the others name.
cat <<EOF > "${SYSTEMD_USER_DIR}/archie-state-store.service"
[Unit]
Description=Archie State Store Service
After=network.target
[Service]
Type=simple
ExecStart=${ARCHIE_BIN_DIR}/archie-state-store -config ${ARCHIE_CONFIG_DIR}/config.toml -listen 127.0.0.1:9090 -ready-addr 127.0.0.1:9091
EnvironmentFile=-${ENV_FILE}
Restart=on-failure
RestartSec=5s
[Install]
WantedBy=default.target
EOF
cat <<EOF > "${SYSTEMD_USER_DIR}/archie-gateway.service"
[Unit]
Description=Archie Gateway Service
After=network.target
[Service]
Type=simple
ExecStart=${ARCHIE_BIN_DIR}/archie-gateway -config ${ARCHIE_CONFIG_DIR}/config.toml -listen 127.0.0.1:8585
EnvironmentFile=-${ENV_FILE}
Restart=on-failure
RestartSec=5s
[Install]
WantedBy=default.target
EOF
cat <<EOF > "${SYSTEMD_USER_DIR}/archie-ui.service"
[Unit]
Description=Archie UI Service
After=network.target archie-state-store.service
Wants=archie-state-store.service
[Service]
Type=simple
ExecStart=${ARCHIE_BIN_DIR}/archie-ui -config ${ARCHIE_CONFIG_DIR}/config.toml
EnvironmentFile=-${ENV_FILE}
Restart=on-failure
RestartSec=5s
[Install]
WantedBy=default.target
EOF
# The Telegram, email and webhook channels run here, not in archied: without
# this unit a host looks healthy while its channels are dead.
cat <<EOF > "${SYSTEMD_USER_DIR}/archie-messaging.service"
[Unit]
Description=Archie Messaging Service
After=network.target archie-gateway.service archie-state-store.service
Wants=archie-gateway.service archie-state-store.service
[Service]
Type=simple
ExecStart=${ARCHIE_BIN_DIR}/archie-messaging -config ${ARCHIE_CONFIG_DIR}/config.toml
EnvironmentFile=-${ENV_FILE}
Restart=on-failure
RestartSec=5s
[Install]
WantedBy=default.target
EOF
systemctl --user daemon-reload || true
SERVICE_INSTALLED=true
for unit in $TOPOLOGY_UNITS; do
test -f "${SYSTEMD_USER_DIR}/${unit}.service" || { echo "missing required unit: $unit" >&2; exit 1; }
echo " Installed ${SYSTEMD_USER_DIR}/${unit}.service"
done
# Enable linger so systemd --user runs continuously without an active login
# session. $(id -un) is used rather than $USER, which is unset in some
# container and cron contexts and would abort under `set -u`. Only a
# positive "Linger=yes" counts as already enabled -- a failed or empty
# `loginctl show-user` (no logind session, a container) falls through to
# enable-linger rather than being reported as already OK, since nothing
# was actually observed. enable-linger is idempotent, so a redundant call
# here is harmless.
if [ "${ENABLE_LINGER}" = true ] && command -v loginctl &>/dev/null; then
LINGER_USER="$(id -un)"
if loginctl show-user "${LINGER_USER}" 2>/dev/null | grep -q "Linger=yes"; then
echo " [OK] User linger is already enabled."
else
echo "==> Enabling systemd user linger (loginctl enable-linger ${LINGER_USER})..."
loginctl enable-linger "${LINGER_USER}" || echo " Notice: Could not enable linger automatically. Run 'loginctl enable-linger ${LINGER_USER}' manually if needed."
fi
fi
# Auto-enable and start the services, the store first so a fresh boot does
# not race a dial it depends on.
if [ "${AUTO_START}" = true ]; then
echo "==> Enabling and starting Archie services..."
systemctl --user enable --now $TOPOLOGY_UNITS ||
echo " Notice: Could not start every service automatically. Check: systemctl --user status archied archie-state-store archie-gateway archie-ui archie-messaging"
fi
fi
# 6. Post-installation summary & instructions
echo ""
echo "============================================================"
echo " ✓ Archie Core Installation Complete!"
echo "============================================================"
echo ""
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}"
echo " - Data : ${ARCHIE_DATA_DIR}/"
echo ""
# Check PATH
if [[ ":$PATH:" != *":${ARCHIE_BIN_DIR}:"* ]]; then
echo "NOTE: ${ARCHIE_BIN_DIR} is not in your current PATH."
echo "Add it to your shell configuration file (~/.bashrc or ~/.zshrc):"
echo " export PATH=\"${ARCHIE_BIN_DIR}:\$PATH\""
echo ""
fi
if [ "${SERVICE_INSTALLED}" = true ] && [ "${AUTO_START}" = true ]; then
echo "Service Management:"
echo " - Units installed : archied archie-state-store archie-gateway archie-ui archie-messaging"
echo " - View live logs : journalctl --user -u archied -f"
echo " - Service status : systemctl --user status archied archie-state-store archie-gateway archie-ui archie-messaging"
echo " - Restart daemon : systemctl --user restart archied"
else
echo "Manual Startup: start the five services as in https://github.com/${REPO}/blob/main/deployments/README.md"
fi
echo ""
echo "Dashboard: http://127.0.0.1:8484 Change the config: archied setup"
echo ""