523 lines
23 KiB
Bash
Executable File
523 lines
23 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
# install.sh - installs Archie Core for the current user.
|
|
#
|
|
# curl -fsSL https://offloaded.dev/install.sh | bash
|
|
#
|
|
# Downloads a release from its OCI registry, verifies the release key signed
|
|
# it and that the zip is the one signed, 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
|
|
|
|
MODULE="github.com/samcharles93/archie-core"
|
|
SOURCE_GIT="https://git.catlow.cloud/sam/archie.git"
|
|
# Where releases come from: an OCI repository and the base64 ed25519 key that
|
|
# must have signed them. A self-hosted source sets both.
|
|
DEFAULT_RELEASES="git.catlow.cloud/sam/archie"
|
|
DEFAULT_RELEASE_KEY="gIBqoQMwy+8WXmGfiuHtnUa50W0IqfzkTR6iF5q3dSM="
|
|
ARCHIE_RELEASES="${ARCHIE_RELEASES:-${DEFAULT_RELEASES}}"
|
|
ARCHIE_RELEASE_KEY="${ARCHIE_RELEASE_KEY:-${DEFAULT_RELEASE_KEY}}"
|
|
ARCHIE_CHANNEL="${ARCHIE_CHANNEL:-stable}"
|
|
|
|
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_BIN_DIR="${XDG_BIN_HOME}"
|
|
INSTANCE=archie
|
|
PORT_BASE=""
|
|
|
|
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://offloaded.dev/install.sh | bash -s -- [options]
|
|
|
|
Environment:
|
|
ARCHIE_RELEASES OCI repository to install from (default ${DEFAULT_RELEASES})
|
|
ARCHIE_RELEASE_KEY base64 ed25519 key that source signs with
|
|
ARCHIE_CHANNEL stable (default) or next
|
|
|
|
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
|
|
--instance NAME Install a named instance beside others: archie (default)
|
|
or archie-X; its dirs are <xdg>/NAME and its units end in -X
|
|
--port-base N Use ports N..N+6 for web, health, gateway, state store,
|
|
state store readiness, messaging and daemon
|
|
--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 ;;
|
|
--instance) INSTANCE="${2:?--instance needs a value}"; shift ;;
|
|
--port-base) PORT_BASE="${2:?--port-base 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
|
|
|
|
if ! [[ "${INSTANCE}" =~ ^archie(-[a-z0-9][a-z0-9-]{0,23})?$ ]]; then
|
|
echo "Error: --instance '${INSTANCE}' must be archie or archie-<name>, e.g. archie-dev" >&2; exit 1
|
|
fi
|
|
if [ -n "${PORT_BASE}" ] && ! { [[ "${PORT_BASE}" =~ ^[0-9]+$ ]] && [ "${PORT_BASE}" -ge 1024 ] && [ "${PORT_BASE}" -le 65529 ]; }; then
|
|
echo "Error: --port-base must be a number from 1024 to 65529" >&2; exit 1
|
|
fi
|
|
export ARCHIE_INSTANCE="${INSTANCE}"
|
|
ARCHIE_CONFIG_DIR="${XDG_CONFIG_HOME}/${INSTANCE}"
|
|
ARCHIE_DATA_DIR="${XDG_DATA_HOME}/${INSTANCE}"
|
|
ENV_FILE="${ARCHIE_CONFIG_DIR}/env"
|
|
|
|
# unit maps a base unit name to this instance's: unchanged for the default
|
|
# instance, suffixed with the name after archie- otherwise.
|
|
unit() {
|
|
if [ "${INSTANCE}" = archie ]; then echo "$1"; else echo "$1-${INSTANCE#archie-}"; fi
|
|
}
|
|
U_DAEMON="$(unit archied)"
|
|
U_STATE="$(unit archie-state-store)"
|
|
U_GATEWAY="$(unit archie-gateway)"
|
|
U_UI="$(unit archie-ui)"
|
|
U_MESSAGING="$(unit archie-messaging)"
|
|
|
|
# Ports in --port-base order; without it, today's defaults.
|
|
if [ -n "${PORT_BASE}" ]; then
|
|
P_WEB=${PORT_BASE}; P_HEALTH=$((PORT_BASE + 1)); P_GATEWAY=$((PORT_BASE + 2))
|
|
P_STATE=$((PORT_BASE + 3)); P_READY=$((PORT_BASE + 4)); P_MESSAGING=$((PORT_BASE + 5)); P_DAEMON=$((PORT_BASE + 6))
|
|
else
|
|
P_WEB=8484; P_HEALTH=8485; P_GATEWAY=8585; P_STATE=9090; P_READY=9091; P_MESSAGING=8586; P_DAEMON=8587
|
|
fi
|
|
|
|
need() {
|
|
for cmd in "$@"; do
|
|
command -v "$cmd" &>/dev/null || { echo "Error: '$cmd' is required but not installed." >&2; exit 1; }
|
|
done
|
|
}
|
|
|
|
# install_release fetches the release on ARCHIE_CHANNEL (or VERSION) from
|
|
# ARCHIE_RELEASES and unpacks it into TMP: the statement must verify against
|
|
# ARCHIE_RELEASE_KEY and the zip must hash to the digest the statement names.
|
|
install_release() {
|
|
local registry="${ARCHIE_RELEASES%%/*}" repo="${ARCHIE_RELEASES#*/}" scheme=https tag="${ARCHIE_CHANNEL}"
|
|
case "${registry}" in localhost | localhost:* | 127.* | "[::1]"*) scheme=http ;; esac
|
|
[ -n "${VERSION}" ] && tag="v${VERSION#v}"
|
|
local base="${scheme}://${registry}/v2/${repo}" auth=()
|
|
# Registries hand anonymous readers a pull token named by the challenge.
|
|
local challenge
|
|
challenge="$(curl -fsS -o /dev/null -D - "${base}/manifests/${tag}" 2>/dev/null | tr -d '\r' | sed -n 's/^[Ww][Ww][Ww]-[Aa]uthenticate: *Bearer *//p')" || true
|
|
if [ -n "${challenge}" ]; then
|
|
local realm service token
|
|
realm="$(sed -n 's/.*realm="\([^"]*\)".*/\1/p' <<<"${challenge}")"
|
|
service="$(sed -n 's/.*service="\([^"]*\)".*/\1/p' <<<"${challenge}")"
|
|
token="$(curl -fsSL -G "${realm}" --data-urlencode "service=${service}" --data-urlencode "scope=repository:${repo}:pull" | jq -r '.token // .access_token')"
|
|
auth=(-H "Authorization: Bearer ${token}")
|
|
fi
|
|
echo "==> Fetching ${ARCHIE_RELEASES}:${tag}..."
|
|
curl -fsSL "${auth[@]}" -H "Accept: application/vnd.oci.image.manifest.v1+json" "${base}/manifests/${tag}" -o "${TMP}/manifest.json"
|
|
blob() { curl -fsSL "${auth[@]}" "${base}/blobs/$1" -o "$2" && [ "sha256:$(sha256sum "$2" | cut -d' ' -f1)" = "$1" ]; }
|
|
local statement_digest
|
|
statement_digest="$(jq -er '.layers[0].digest' "${TMP}/manifest.json")"
|
|
blob "${statement_digest}" "${TMP}/statement.json" || { echo "Error: the release statement does not match its digest." >&2; exit 1; }
|
|
jq -er '.annotations["dev.archie.release.signature.v1"]' "${TMP}/manifest.json" | base64 -d >"${TMP}/statement.sig"
|
|
# An ed25519 public key is its 32 bytes behind a fixed SubjectPublicKeyInfo header.
|
|
{ printf '\x30\x2a\x30\x05\x06\x03\x2b\x65\x70\x03\x21\x00'; base64 -d <<<"${ARCHIE_RELEASE_KEY}"; } >"${TMP}/key.der"
|
|
openssl pkeyutl -verify -pubin -inkey "${TMP}/key.der" -keyform DER -rawin \
|
|
-in "${TMP}/statement.json" -sigfile "${TMP}/statement.sig" >/dev/null 2>&1 ||
|
|
{ echo "Error: ${ARCHIE_RELEASES}:${tag} is not signed by the release key." >&2; exit 1; }
|
|
local zip_name zip_digest
|
|
VERSION="$(jq -er .version "${TMP}/statement.json")"
|
|
[ "$(jq -r .platform "${TMP}/statement.json")" = linux-amd64 ] || { echo "Error: the release is not built for linux-amd64." >&2; exit 1; }
|
|
[ -z "${VERSION}" ] || [ "${tag}" = "${ARCHIE_CHANNEL}" ] || [ "v${VERSION}" = "${tag}" ] ||
|
|
{ echo "Error: ${tag} carries the statement for ${VERSION}." >&2; exit 1; }
|
|
zip_name="$(jq -er .zip.name "${TMP}/statement.json")"
|
|
zip_digest="$(jq -er .zip.digest "${TMP}/statement.json")"
|
|
RELEASE_NAME="${zip_name%.zip}"
|
|
case "${RELEASE_NAME}" in archie-core-archied-v*-linux-amd64) ;; *) echo "Error: unexpected release zip ${zip_name}." >&2; exit 1 ;; esac
|
|
echo "==> Downloading Archie ${VERSION}..."
|
|
blob "${zip_digest}" "${TMP}/${zip_name}" || { echo "Error: ${zip_name} does not match the signed digest." >&2; exit 1; }
|
|
unzip -q "${TMP}/${zip_name}" -d "${TMP}"
|
|
}
|
|
|
|
# 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 openssl jq base64
|
|
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 "${MODULE}" "${SCRIPT_DIR}/go.mod"; then
|
|
SRC_DIR="${SCRIPT_DIR}"
|
|
else
|
|
SRC_DIR="${TMP}/src"
|
|
git clone --quiet --depth=1 "${SOURCE_GIT}" "${SRC_DIR}"
|
|
fi
|
|
echo "==> Building from ${SRC_DIR}..."
|
|
# Selects (and under the default GOTOOLCHAIN=auto, downloads) the toolchain
|
|
# go.mod requires, so a missing one fails here rather than mid-build.
|
|
required="$(sed -n 's/^go //p' "${SRC_DIR}/go.mod")"
|
|
if ! out="$(cd "${SRC_DIR}" && go list -m 2>&1)"; then
|
|
echo "Error: Archie needs Go ${required}, which is not available: ${out}" >&2
|
|
echo "Install Go ${required} from https://go.dev/dl, or allow the download with GOTOOLCHAIN=auto and network access to proxy.golang.org." >&2
|
|
exit 1
|
|
fi
|
|
STAGE="${TMP}/stage"
|
|
mkdir -p "${STAGE}"
|
|
# A source build is not a release: it says `dev`, and buildType=binary lets
|
|
# it self-update. The agentworker stamp only lands in archie-agent.
|
|
LDFLAGS="-X ${MODULE}/internal/buildinfo.Version=dev -X ${MODULE}/internal/buildinfo.Runtime=dev -X ${MODULE}/internal/installtype.buildType=binary -X ${MODULE}/internal/app/agentworker.version=dev"
|
|
for cmd in $(jq -er '[.required_topology.units[], .required_topology.binaries[]?] | 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
|
|
install_release
|
|
STAGE="${TMP}/${RELEASE_NAME}"
|
|
fi
|
|
|
|
TOPOLOGY_UNITS="$(tr -d '\n' <"${STAGE}/release.json" | sed -n 's/.*"units": *\[\([^]]*\)\].*/\1/p' | tr -d '" ' | tr , ' ')"
|
|
# Binaries that run beside the units without a service of their own: a Kit run
|
|
# mounts archie-agent from archied's directory, so it must be installed with
|
|
# them and replaced with them.
|
|
TOPOLOGY_BINARIES="$(tr -d '\n' <"${STAGE}/release.json" | sed -n 's/.*"binaries": *\[\([^]]*\)\].*/\1/p' | tr -d '" ' | tr , ' ')"
|
|
for cmd in ${TOPOLOGY_UNITS} ${TOPOLOGY_BINARIES}; do
|
|
install -m755 "${STAGE}/${cmd}" "${ARCHIE_BIN_DIR}/${cmd}"
|
|
done
|
|
echo " Installed ${TOPOLOGY_UNITS} ${TOPOLOGY_BINARIES} 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
|
|
if [ "${ARCHIE_RELEASES}" != "${DEFAULT_RELEASES}" ] || [ "${ARCHIE_RELEASE_KEY}" != "${DEFAULT_RELEASE_KEY}" ]; then
|
|
# The instance keeps updating from the source it was installed from.
|
|
printf '\n[distribution]\nreleases = "%s"\nreleases_key = "%s"\n' "${ARCHIE_RELEASES}" "${ARCHIE_RELEASE_KEY}" >>"${ARCHIE_CONFIG_DIR}/config.toml"
|
|
fi
|
|
if [ -n "${PORT_BASE}" ]; then
|
|
# The generated config names the default addresses; move them to this
|
|
# instance's ports and pin the services the template leaves commented.
|
|
sed -i -e "s/127\.0\.0\.1:8484/127.0.0.1:${P_WEB}/g" -e "s/127\.0\.0\.1:8485/127.0.0.1:${P_HEALTH}/g" \
|
|
-e "s/127\.0\.0\.1:8585/127.0.0.1:${P_GATEWAY}/g" -e "s/127\.0\.0\.1:9090/127.0.0.1:${P_STATE}/g" \
|
|
-e "s/127\.0\.0\.1:8586/127.0.0.1:${P_MESSAGING}/g" -e "s/127\.0\.0\.1:8587/127.0.0.1:${P_DAEMON}/g" \
|
|
"${ARCHIE_CONFIG_DIR}/config.toml"
|
|
for section in messaging:${P_MESSAGING} daemon:${P_DAEMON}; do
|
|
name="${section%%:*}" port="${section#*:}"
|
|
grep -q "^\[services\.${name}\]" "${ARCHIE_CONFIG_DIR}/config.toml" ||
|
|
printf '\n[services.%s]\ntarget = "127.0.0.1:%s"\nlisten = "127.0.0.1:%s"\n' "${name}" "${port}" "${port}" >>"${ARCHIE_CONFIG_DIR}/config.toml"
|
|
done
|
|
fi
|
|
else
|
|
[ -n "${PORT_BASE}" ] && echo " [WARN] --port-base only applies to a new config; ${ARCHIE_CONFIG_DIR}/config.toml keeps its addresses." >&2
|
|
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 "${INSTANCE}" --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 "${INSTANCE}" -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}/${U_DAEMON}.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=notify
|
|
NotifyAccess=main
|
|
# Beats only while the run loop is polling, so a wedged loop is restarted.
|
|
WatchdogSec=30s
|
|
ExecStart=${ARCHIE_BIN_DIR}/archied -config ${ARCHIE_CONFIG_DIR}/config.toml
|
|
EnvironmentFile=-${ENV_FILE}
|
|
Environment=ARCHIE_INSTANCE=${INSTANCE}
|
|
# 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}/${U_STATE}.service"
|
|
[Unit]
|
|
Description=Archie State Store Service
|
|
After=network.target
|
|
|
|
[Service]
|
|
Type=notify
|
|
NotifyAccess=main
|
|
ExecStart=${ARCHIE_BIN_DIR}/archie-state-store -config ${ARCHIE_CONFIG_DIR}/config.toml -listen 127.0.0.1:${P_STATE} -ready-addr 127.0.0.1:${P_READY}
|
|
EnvironmentFile=-${ENV_FILE}
|
|
Environment=ARCHIE_INSTANCE=${INSTANCE}
|
|
Restart=on-failure
|
|
RestartSec=5s
|
|
|
|
[Install]
|
|
WantedBy=default.target
|
|
EOF
|
|
|
|
cat <<EOF > "${SYSTEMD_USER_DIR}/${U_GATEWAY}.service"
|
|
[Unit]
|
|
Description=Archie Gateway Service
|
|
After=network.target
|
|
|
|
[Service]
|
|
Type=notify
|
|
NotifyAccess=main
|
|
ExecStart=${ARCHIE_BIN_DIR}/archie-gateway -config ${ARCHIE_CONFIG_DIR}/config.toml -listen 127.0.0.1:${P_GATEWAY}
|
|
EnvironmentFile=-${ENV_FILE}
|
|
Environment=ARCHIE_INSTANCE=${INSTANCE}
|
|
Restart=on-failure
|
|
RestartSec=5s
|
|
|
|
[Install]
|
|
WantedBy=default.target
|
|
EOF
|
|
|
|
cat <<EOF > "${SYSTEMD_USER_DIR}/${U_UI}.service"
|
|
[Unit]
|
|
Description=Archie UI Service
|
|
After=network.target ${U_STATE}.service
|
|
Wants=${U_STATE}.service
|
|
|
|
[Service]
|
|
Type=simple
|
|
ExecStart=${ARCHIE_BIN_DIR}/archie-ui -config ${ARCHIE_CONFIG_DIR}/config.toml
|
|
EnvironmentFile=-${ENV_FILE}
|
|
Environment=ARCHIE_INSTANCE=${INSTANCE}
|
|
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}/${U_MESSAGING}.service"
|
|
[Unit]
|
|
Description=Archie Messaging Service
|
|
After=network.target ${U_GATEWAY}.service ${U_STATE}.service
|
|
Wants=${U_GATEWAY}.service ${U_STATE}.service
|
|
|
|
[Service]
|
|
Type=notify
|
|
NotifyAccess=main
|
|
ExecStart=${ARCHIE_BIN_DIR}/archie-messaging -config ${ARCHIE_CONFIG_DIR}/config.toml
|
|
EnvironmentFile=-${ENV_FILE}
|
|
Environment=ARCHIE_INSTANCE=${INSTANCE}
|
|
Restart=on-failure
|
|
RestartSec=5s
|
|
|
|
[Install]
|
|
WantedBy=default.target
|
|
EOF
|
|
|
|
INSTANCE_UNITS=""
|
|
for base in $TOPOLOGY_UNITS; do INSTANCE_UNITS="${INSTANCE_UNITS:+${INSTANCE_UNITS} }$(unit "${base}")"; done
|
|
|
|
systemctl --user daemon-reload || true
|
|
SERVICE_INSTALLED=true
|
|
for unit in $INSTANCE_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. Restart rather than start, because a
|
|
# reinstall over running services would otherwise leave the old binaries
|
|
# running.
|
|
if [ "${AUTO_START}" = true ]; then
|
|
echo "==> Enabling and starting Archie services..."
|
|
{ systemctl --user enable $INSTANCE_UNITS && systemctl --user restart $INSTANCE_UNITS; } ||
|
|
echo " Notice: Could not start every service automatically. Check: systemctl --user status ${INSTANCE_UNITS}"
|
|
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 : ${INSTANCE_UNITS}"
|
|
echo " - View live logs : journalctl --user -u ${U_DAEMON} -f"
|
|
echo " - Service status : systemctl --user status ${INSTANCE_UNITS}"
|
|
echo " - Restart daemon : systemctl --user restart ${U_DAEMON}"
|
|
else
|
|
echo "Manual Startup: start the five services as in https://offloaded.dev"
|
|
fi
|
|
echo ""
|
|
SETUP_HINT="archied setup"
|
|
[ "${INSTANCE}" = archie ] || SETUP_HINT="ARCHIE_INSTANCE=${INSTANCE} archied setup"
|
|
echo "Dashboard: http://127.0.0.1:${P_WEB} Change the config: ${SETUP_HINT}"
|
|
echo ""
|