Install the mail server on the host: release binary, its own user, a systemd unit #15
No files matched your search
@@ -48,12 +48,20 @@ This is early. What is built:
|
||||
anything is put in place. `install --install-deps` does the same as part of
|
||||
a run. A missing dependency is an offer, not a refusal.
|
||||
|
||||
- **`install --yes`** -- carries the plan out, for container shapes: writes
|
||||
the deployment, fetches the images, brings the mail server up in bootstrap
|
||||
mode with a credential that exists only for that step, completes bootstrap,
|
||||
brings the rest up without it, exempts the front ends from the auto-ban,
|
||||
creates the first mailbox, writes `credentials.txt` and `dns.zone`, and
|
||||
then checks that all three answer.
|
||||
- **`install --yes`** -- carries the plan out: writes the deployment,
|
||||
fetches the images, brings the mail server up in bootstrap mode with a
|
||||
credential that exists only for that step, completes bootstrap, brings the
|
||||
rest up without it, exempts the front ends from the auto-ban, creates the
|
||||
first mailbox, writes `credentials.txt` and `dns.zone`, and then checks
|
||||
that all three answer.
|
||||
- **`install --server host`** -- the same, with the mail server as the
|
||||
release binary under systemd instead of a container, checked against a
|
||||
checksum in the source. It gets a user of its own, its configuration and
|
||||
data in `<dir>/server`, and a unit, `inbuxa-server.service`. During setup
|
||||
it is reachable from the machine itself and nowhere else; afterwards its
|
||||
plain HTTP is on loopback for the proxy and the webmail, 443 is left to
|
||||
the proxy, and the unit will not start without a configuration file. The
|
||||
console and the webmail run in containers beside it, or not at all.
|
||||
|
||||
- **`plan -f` / `apply -f` / `export`** -- a whole installation described in
|
||||
one file, however many machines. Each machine acts on its own part and
|
||||
@@ -66,8 +74,9 @@ This is early. What is built:
|
||||
installing. It exits non-zero when they disagree, so a machine can be
|
||||
asked in a script whether it still matches itself.
|
||||
|
||||
Not built yet: host installs, the terminal interface, `join`, `status`,
|
||||
`upgrade`, `uninstall`. The design is in the inbuxa specification (§6.1 and
|
||||
Not built yet: host installs of the console and the webmail, the terminal
|
||||
interface, `join`, `upgrade`, `uninstall`, and moving the server between a
|
||||
container and the host. The design is in the inbuxa specification (§6.1 and
|
||||
the installer draft); the phases are there too.
|
||||
|
||||
inbuxa install --local --domain example.test --install-deps --yes
|
||||
@@ -106,6 +115,7 @@ is tested on a throwaway virtual machine rather than on anybody's desk:
|
||||
e2e/vm/run.sh e2e/cases/deps.sh the offer, and taking it
|
||||
e2e/vm/run.sh e2e/cases/install-local.sh a whole suite, and signing in to it
|
||||
e2e/vm/run.sh e2e/cases/install-public.sh the same with real ports and certificates
|
||||
e2e/vm/run.sh e2e/cases/install-host.sh the server on the host, the rest beside it
|
||||
e2e/vm/run.sh e2e/cases/topology.sh growing and shrinking from a file
|
||||
e2e/vm/run.sh e2e/cases/status-export.sh intent against reality, and the file
|
||||
OLD_REF=<commit> e2e/vm/run.sh e2e/cases/upgrade-volumes.sh
|
||||
|
||||
@@ -433,6 +433,8 @@ func exportCmd(args []string) int {
|
||||
switch {
|
||||
case st.Shapes[kind] != "":
|
||||
m.Components = append(m.Components, topology.Component{Kind: kind, Shape: st.Shapes[kind]})
|
||||
case kind == "server" && found.HostServer:
|
||||
m.Components = append(m.Components, topology.Component{Kind: kind, Shape: "host"})
|
||||
case found.Services[kind] != "":
|
||||
m.Components = append(m.Components, topology.Component{Kind: kind, Shape: "container"})
|
||||
}
|
||||
@@ -514,6 +516,8 @@ func statusCmd() int {
|
||||
fmt.Printf(" %-8s installed as a %-9s %s\n", kind, shape, state)
|
||||
case intended:
|
||||
fmt.Printf(" %-8s installed as a %-9s missing from the deployment\n", kind, shape)
|
||||
case kind == "server" && found.HostServer:
|
||||
fmt.Printf(" %-8s %-24s %s\n", kind, "on the host", state)
|
||||
default:
|
||||
fmt.Printf(" %-8s %-24s %s\n", kind, "in the deployment", state)
|
||||
}
|
||||
|
||||
@@ -0,0 +1,145 @@
|
||||
#!/bin/bash
|
||||
# SPDX-FileCopyrightText: 2026 Coffey Labs LLC
|
||||
# SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
#
|
||||
# The mail server on the host, the console and the webmail in containers
|
||||
# beside it, on loopback: the same whole system install-local.sh proves, with
|
||||
# the server as a release binary under systemd instead of a container.
|
||||
#
|
||||
# What is particular to the host is checked as well as what is common: the
|
||||
# setup's drop-in and credential are gone, the server runs as its own user
|
||||
# with nothing on 443 or on 8080 of its own, the unit refuses to start
|
||||
# without a configuration, and status says where the server is.
|
||||
#
|
||||
# Run from the host with: e2e/vm/run.sh e2e/cases/install-host.sh
|
||||
set -uo pipefail
|
||||
|
||||
pass=0; fail=0
|
||||
ok() { echo " ok $*"; pass=$((pass+1)); }
|
||||
bad() { echo " FAIL $*"; fail=$((fail+1)); }
|
||||
|
||||
DIR=/var/lib/inbuxa
|
||||
UNIT=inbuxa-server.service
|
||||
|
||||
rt() { command -v docker >/dev/null 2>&1 && echo docker || echo podman; }
|
||||
compose() {
|
||||
if [ "$(rt)" = docker ]; then
|
||||
docker compose -f "$DIR/compose.yaml" "$@"
|
||||
else
|
||||
DOCKER_HOST=unix:///run/podman/podman.sock \
|
||||
/usr/local/lib/docker/cli-plugins/docker-compose -f "$DIR/compose.yaml" "$@"
|
||||
fi
|
||||
}
|
||||
listening() { ss -ltnH "sport = :$1" | awk '{print $4}'; }
|
||||
|
||||
echo "==> what it would do"
|
||||
PLAN="$(/tmp/inbuxa install --local --domain example.test --server host --install-deps --dry-run 2>&1)"
|
||||
grep -q "Install the mail server on this machine" <<<"$PLAN" && ok "the plan names the host install" || { bad "no host install in the plan"; echo "$PLAN" | sed 's/^/ /'; }
|
||||
grep -q "/usr/local/bin/inbuxa-server, release" <<<"$PLAN" && ok "and the release it fetches" || bad "the plan does not name the release"
|
||||
|
||||
echo
|
||||
echo "==> installing"
|
||||
OUT="$(/tmp/inbuxa install --local --domain example.test --server host --install-deps --yes 2>&1)"; rc=$?
|
||||
echo "$OUT" | grep -v '^ |' | tail -30 | sed 's/^/ /'
|
||||
[ $rc -eq 0 ] && ok "installed (exit 0)" || bad "exit $rc"
|
||||
|
||||
echo
|
||||
echo "==> the server is a host install"
|
||||
/usr/local/bin/inbuxa-server --version 2>&1 | grep -q '[0-9]\{4\}\.[0-9]' && ok "the release binary runs: $(/usr/local/bin/inbuxa-server --version 2>&1 | head -1)" || bad "no runnable /usr/local/bin/inbuxa-server"
|
||||
systemctl is-active --quiet $UNIT && ok "$UNIT is running" || { bad "$UNIT is not running"; journalctl -u $UNIT -n 20 --no-pager | sed 's/^/ /'; }
|
||||
systemctl is-enabled --quiet $UNIT && ok "and enabled, so it comes back after a reboot" || bad "$UNIT is not enabled"
|
||||
PID=$(systemctl show -p MainPID --value $UNIT)
|
||||
[ "$(ps -o user= -p "$PID" 2>/dev/null)" = inbuxa ] && ok "it runs as the inbuxa user" || bad "it runs as '$(ps -o user= -p "$PID" 2>/dev/null)'"
|
||||
[ -f "$DIR/server/config.json" ] && ok "its configuration is in $DIR/server" || bad "no $DIR/server/config.json"
|
||||
[ "$(stat -c %U "$DIR/server/data")" = inbuxa ] && ok "and its data directory is its own" || bad "$DIR/server/data is owned by $(stat -c %U "$DIR/server/data")"
|
||||
grep -q "^ConditionPathExists=$DIR/server/config.json" /etc/systemd/system/$UNIT && ok "the finished unit needs the configuration to start" || bad "no ConditionPathExists in the unit"
|
||||
grep -q "^AmbientCapabilities=CAP_NET_BIND_SERVICE" /etc/systemd/system/$UNIT && ok "and may bind the ports below 1024" || bad "no AmbientCapabilities in the unit"
|
||||
compose ps --format '{{.Service}}' | grep -qx server && bad "a server container is running too" || ok "no server container"
|
||||
|
||||
echo
|
||||
echo "==> the setup left nothing behind"
|
||||
[ ! -e /run/systemd/system/$UNIT.d/inbuxa-setup.conf ] && ok "the setup's drop-in is gone" || bad "the setup's drop-in is still there"
|
||||
[ ! -e /run/inbuxa-server-setup.env ] && ok "and so is its credential file" || bad "the setup's credential file is still there"
|
||||
ENVOUT="$(tr '\0' '\n' < /proc/"$PID"/environ)"
|
||||
grep -q "RECOVERY_ADMIN" <<<"$ENVOUT" && bad "the server still carries a recovery admin" || ok "no recovery admin in the running server"
|
||||
grep -q "HTTP_BASIC_AUTH" <<<"$ENVOUT" && bad "the server still takes passwords everywhere" || ok "no Basic-everywhere override in the running server"
|
||||
grep -q "INBUXA_WEBMAIL_CLIENT_SECRET" <<<"$ENVOUT" && ok "the webmail's client secret is in its environment" || bad "the server has no webmail client secret"
|
||||
[ "$(stat -c %a "$DIR/server.env")" = 600 ] && ok "server.env is 600" || bad "server.env is $(stat -c %a "$DIR/server.env")"
|
||||
[ "$(stat -c %a "$DIR/credentials.txt")" = 600 ] && ok "credentials.txt is 600" || bad "credentials.txt is $(stat -c %a "$DIR/credentials.txt")"
|
||||
|
||||
echo
|
||||
echo "==> its listeners fit the host"
|
||||
[ "$(listening 8081)" = "127.0.0.1:8081" ] && ok "plain HTTP on 127.0.0.1:8081 only" || bad "8081 is on '$(listening 8081)'"
|
||||
[ -z "$(listening 443)" ] && ok "nothing on 443: that is the proxy's" || bad "443 is held: $(listening 443)"
|
||||
[ "$(listening 8080)" = "127.0.0.1:8080" ] && ok "8080 is the webmail's, on loopback" || bad "8080 is on '$(listening 8080)'"
|
||||
for p in 25 465 993 995 4190; do
|
||||
[ "$(listening $p)" = "127.0.0.1:$p" ] || { bad "port $p is on '$(listening $p)', not loopback"; continue; }
|
||||
done
|
||||
ok "the mail ports are on loopback, as a local install publishes nothing"
|
||||
|
||||
echo
|
||||
echo "==> and it answers"
|
||||
curl -fsS -o /dev/null http://127.0.0.1:8081/.well-known/jmap 2>/dev/null
|
||||
[ $? -le 22 ] && ok "the mail server answers on its loopback bind" || bad "the mail server does not answer"
|
||||
curl -fsS http://127.0.0.1:8082/ 2>/dev/null | grep -q 'api-base-url' && ok "the console is served, pointed at the server" || bad "the console is not served"
|
||||
curl -fsS http://127.0.0.1:8080/api/health 2>/dev/null | grep -q '"ok":true' && ok "the webmail is healthy" || bad "the webmail is not healthy"
|
||||
AUSER=$(awk '/^administrator/ {print $2}' "$DIR/credentials.txt")
|
||||
APASS=$(awk '/^administrator/{getline; print $2}' "$DIR/credentials.txt")
|
||||
CODE=$(curl -s -o /dev/null -w '%{http_code}' -u "$AUSER:$APASS" -H 'Content-Type: application/json' \
|
||||
-d '{"using":["urn:ietf:params:jmap:core"],"methodCalls":[]}' http://127.0.0.1:8081/jmap/)
|
||||
[ "$CODE" = 401 ] && ok "the administrator's password is refused on /jmap" || bad "the administrator's password on /jmap answered $CODE, not 401"
|
||||
|
||||
echo
|
||||
echo "==> the account it created can sign in to the webmail it installed"
|
||||
USER=$(awk '/^first mailbox/ {print $3}' "$DIR/credentials.txt")
|
||||
PASS=$(awk '/^first mailbox/{getline; print $2}' "$DIR/credentials.txt")
|
||||
[ -n "$USER" ] && ok "credentials.txt names the first mailbox ($USER)" || bad "no first mailbox in credentials.txt"
|
||||
rm -f /tmp/jar
|
||||
LOC=$(curl -s -o /dev/null -c /tmp/jar -w '%{redirect_url}' "http://127.0.0.1:8080/api/auth/oauth/start?username=$USER&remember=1")
|
||||
grep -q "^http://127.0.0.1:8081/" <<<"$LOC" && ok "the webmail sends sign-in to the server's loopback address" || bad "sign-in went to '${LOC:-nowhere}'"
|
||||
q() { sed -n "s/.*[?&]$1=\([^&]*\).*/\1/p" <<<"$LOC"; }
|
||||
urldecode() { printf '%b' "${1//%/\\x}"; }
|
||||
STATE=$(q state); CHALLENGE=$(q code_challenge); REDIRECT=$(urldecode "$(q redirect_uri)")
|
||||
ANSWER=$(curl -s -X POST http://127.0.0.1:8081/api/auth -H 'Content-Type: application/json' -H 'Accept: application/json' \
|
||||
-d "{\"type\":\"authCode\",\"accountName\":\"$USER\",\"accountSecret\":\"$PASS\",\"clientId\":\"ihasmail-inbuxa\",\"redirectUri\":\"$REDIRECT\",\"codeChallenge\":\"$CHALLENGE\",\"codeChallengeMethod\":\"S256\"}")
|
||||
AUTHCODE=$(sed -n 's/.*"client_\{0,1\}[cC]ode":"\([^"]*\)".*/\1/p' <<<"$ANSWER")
|
||||
[ -n "$AUTHCODE" ] && ok "the server's sign-in takes the first mailbox's password" || { bad "the server's sign-in answered"; head -c 200 <<<"$ANSWER" | sed 's/^/ /'; }
|
||||
BACK=$(curl -s -o /dev/null -b /tmp/jar -c /tmp/jar -w '%{redirect_url}' "$REDIRECT?code=$AUTHCODE&state=$STATE")
|
||||
grep -q "signin_error" <<<"$BACK" && bad "the webmail refused the code: $BACK" || ok "the webmail takes the code back"
|
||||
CODE=$(curl -s -o /tmp/login.json -b /tmp/jar -w '%{http_code}' -H 'X-Requested-With: ihasmail' http://127.0.0.1:8080/api/auth/session)
|
||||
[ "$CODE" = 200 ] && ok "sign-in succeeds" || { bad "the session answered $CODE"; head -c 200 /tmp/login.json | sed 's/^/ /'; }
|
||||
grep -q "urn:ietf:params:jmap:mail" /tmp/login.json && ok "and the session carries the mail capability" || bad "no mail capability in the session"
|
||||
|
||||
echo
|
||||
echo "==> status knows where the server is"
|
||||
STATUS="$(/tmp/inbuxa status 2>&1)"; rc=$?
|
||||
grep -q "server.*installed as a host" <<<"$STATUS" && ok "status: the server is a host install" || { bad "status does not say so"; echo "$STATUS" | sed 's/^/ /'; }
|
||||
[ $rc -eq 0 ] && ok "and intent and reality agree (exit 0)" || { bad "status exit $rc"; echo "$STATUS" | sed 's/^/ /'; }
|
||||
/tmp/inbuxa export 2>/dev/null | grep -A1 '"kind": "server"' | grep -q '"shape": "host"' && ok "export writes the server as host" || bad "export does not say host"
|
||||
|
||||
echo
|
||||
echo "==> running it again converges rather than duplicating"
|
||||
OUT="$(/tmp/inbuxa install --local --domain example.test --server host --yes 2>&1)"; rc=$?
|
||||
[ $rc -eq 0 ] && ok "a second run succeeds" || { bad "second run exit $rc"; echo "$OUT" | tail -10 | sed 's/^/ /'; }
|
||||
grep -q "is already" <<<"$OUT" && ok "and keeps the binary it has" || bad "the second run fetched the binary again"
|
||||
COUNT=$(compose ps --format '{{.Service}}' | sort -u | wc -l)
|
||||
[ "$COUNT" = 2 ] && ok "still two containers beside the server" || bad "$COUNT containers after a second run"
|
||||
OUT="$(/tmp/inbuxa install --local --domain example.test --server container --yes 2>&1)"; rc=$?
|
||||
[ $rc -ne 0 ] && grep -q "not built yet" <<<"$OUT" && ok "moving the server into a container is refused, with the reason" || bad "a shape change was not refused: exit $rc"
|
||||
|
||||
echo
|
||||
echo "==> a server without its configuration stays down"
|
||||
mv "$DIR/server/config.json" /tmp/config.json.kept
|
||||
systemctl restart $UNIT; sleep 2
|
||||
systemctl is-active --quiet $UNIT && bad "the server started without a configuration" || ok "it does not start in bootstrap mode"
|
||||
[ -z "$(listening 8080 | grep -v 127.0.0.1:8080)" ] && ok "and nothing opened 8080 on another interface" || bad "8080 is open: $(listening 8080)"
|
||||
mv /tmp/config.json.kept "$DIR/server/config.json"; chown inbuxa:inbuxa "$DIR/server/config.json"
|
||||
systemctl restart $UNIT
|
||||
# Any HTTP answer at all; 000 is curl failing to connect.
|
||||
code() { curl -s -o /dev/null -w '%{http_code}' http://127.0.0.1:8081/.well-known/jmap; }
|
||||
for _ in $(seq 1 60); do [ "$(code)" != 000 ] && break; sleep 2; done
|
||||
code | grep -qE '^(200|401|30[0-9])$' && ok "with it back, the server answers again" || { bad "the server did not come back ($(code))"; journalctl -u $UNIT -n 15 --no-pager | sed 's/^/ /'; }
|
||||
|
||||
echo
|
||||
echo "==> $pass passed, $fail failed"
|
||||
[ "$fail" -eq 0 ]
|
||||
+207
-40
@@ -1,7 +1,8 @@
|
||||
// SPDX-FileCopyrightText: 2026 Coffey Labs LLC
|
||||
// SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
|
||||
// Package apply carries out a plan, for the shapes that are containers.
|
||||
// Package apply carries out a plan: every component in a container, or the
|
||||
// mail server on the host with whatever runs beside it in containers.
|
||||
//
|
||||
// The sequence is SPEC.md 6.2's, which ihasmail-oneshot worked out against a
|
||||
// running server: bring the mail server up in bootstrap mode with a
|
||||
@@ -29,10 +30,12 @@ import (
|
||||
|
||||
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/compose"
|
||||
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/deps"
|
||||
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/discover"
|
||||
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/docker"
|
||||
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/host"
|
||||
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/jmap"
|
||||
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/plan"
|
||||
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/release"
|
||||
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/state"
|
||||
)
|
||||
|
||||
@@ -41,7 +44,7 @@ import (
|
||||
// here would mean this program needing a release of its own for every one of
|
||||
// theirs.
|
||||
const (
|
||||
DefaultServerImage = "registry.coffeylabs.org/inbuxa/inbuxa-server:2026.10.10.1"
|
||||
DefaultServerImage = release.ServerImage
|
||||
DefaultConsoleImage = "registry.coffeylabs.org/inbuxa/inbuxa-admin:2026.10.5"
|
||||
DefaultWebmailImage = "registry.coffeylabs.org/inbuxa/inbuxa-webmail:2026.10.9-g62936ab"
|
||||
DefaultCaddyImage = "docker.io/library/caddy:2-alpine"
|
||||
@@ -70,18 +73,25 @@ type Log interface {
|
||||
Out() io.Writer
|
||||
}
|
||||
|
||||
// Run carries out p. It refuses anything but container shapes for now, and
|
||||
// says so rather than pretending a host install happened.
|
||||
// Run carries out p. The console and the webmail are containers for now, and
|
||||
// it says so rather than pretending a host install of either happened.
|
||||
func Run(ctx context.Context, p plan.Plan, f host.Facts, log Log) (*Result, error) {
|
||||
o := p.Options
|
||||
for _, c := range []plan.Component{plan.Server, plan.Console, plan.Webmail} {
|
||||
for _, c := range []plan.Component{plan.Console, plan.Webmail} {
|
||||
if o.Shape(c) == plan.Host {
|
||||
return nil, fmt.Errorf("host installs are not built yet: %s was asked for as a host install", c)
|
||||
return nil, fmt.Errorf("host installs of the console and the webmail are not built yet: %s was asked for as a host install", c)
|
||||
}
|
||||
}
|
||||
if o.Shape(plan.Server) != plan.Container {
|
||||
if o.Shape(plan.Server) == plan.Skip {
|
||||
return nil, fmt.Errorf("this build installs the front ends only alongside a server it installs too; use join once that is built")
|
||||
}
|
||||
onHost := o.Shape(plan.Server) == plan.Host
|
||||
if st, err := state.Load(); err == nil && st.Installed() && st.Shapes["server"] != "" && st.Shapes["server"] != string(o.Shape(plan.Server)) {
|
||||
return nil, fmt.Errorf("the server is installed here as a %s install; moving it to a %s install is not built yet",
|
||||
st.Shapes["server"], o.Shape(plan.Server))
|
||||
}
|
||||
needContainers := !onHost || o.Shape(plan.Console) == plan.Container ||
|
||||
o.Shape(plan.Webmail) == plan.Container || (!o.Local && o.Proxy == "caddy")
|
||||
|
||||
if len(p.Needs) > 0 && o.InstallDeps {
|
||||
log.Step("installing what this machine is missing")
|
||||
@@ -93,7 +103,7 @@ func Run(ctx context.Context, p plan.Plan, f host.Facts, log Log) (*Result, erro
|
||||
// with the old facts meant reaching for a docker that was never
|
||||
// going to be there.
|
||||
f = host.Survey(ctx)
|
||||
if !f.Runtime.Usable {
|
||||
if needContainers && !f.Runtime.Usable {
|
||||
return nil, fmt.Errorf("after installing what was missing, containers still are not usable: %s", f.Runtime.Why)
|
||||
}
|
||||
log.Info("using %s %s", f.Runtime.Kind, f.Runtime.Version)
|
||||
@@ -103,6 +113,8 @@ func Run(ctx context.Context, p plan.Plan, f host.Facts, log Log) (*Result, erro
|
||||
stack := compose.Stack{
|
||||
Version: "dev",
|
||||
Project: "inbuxa",
|
||||
Server: !onHost,
|
||||
HostServer: onHost,
|
||||
Domain: o.Domain,
|
||||
Email: o.ACMEEmail,
|
||||
Local: o.Local,
|
||||
@@ -155,9 +167,14 @@ func Run(ctx context.Context, p plan.Plan, f host.Facts, log Log) (*Result, erro
|
||||
if err := os.MkdirAll(dir, 0o750); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
bundle, err := docker.SystemCABundle(ctx, stack.ServerImage)
|
||||
var bundle []byte
|
||||
if onHost {
|
||||
bundle, err = systemCABundle()
|
||||
} else {
|
||||
bundle, err = docker.SystemCABundle(ctx, stack.ServerImage)
|
||||
}
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("reading the server image's CA bundle: %w", err)
|
||||
return nil, fmt.Errorf("reading the server's CA bundle: %w", err)
|
||||
}
|
||||
if err := os.WriteFile(filepath.Join(dir, "ca-bundle.crt"), append(bundle, root...), 0o644); err != nil {
|
||||
return nil, err
|
||||
@@ -171,19 +188,59 @@ func Run(ctx context.Context, p plan.Plan, f host.Facts, log Log) (*Result, erro
|
||||
stack.ACMEDirectory = o.ACMEDirectory
|
||||
|
||||
log.Step("writing the deployment into %s", dir)
|
||||
if _, err := compose.Write(dir, &stack); err != nil {
|
||||
return nil, err
|
||||
var sec compose.Secrets
|
||||
var err error
|
||||
if stack.Empty() {
|
||||
if sec, err = compose.EnsureSecrets(dir); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
log.Info(".env (nothing runs in containers here)")
|
||||
} else {
|
||||
if sec, err = compose.Write(dir, &stack); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
log.Info("compose.yaml, .env%s", map[bool]string{true: " and Caddyfile", false: ""}[stack.Proxy])
|
||||
}
|
||||
log.Info("compose.yaml, .env%s", map[bool]string{true: " and Caddyfile", false: ""}[stack.Proxy])
|
||||
|
||||
// Whichever runtime the survey found: docker where there is one, podman
|
||||
// on the Red Hat family, driven through the same compose plugin.
|
||||
docker.UseRuntime(f.Runtime)
|
||||
cmp := docker.Compose{Dir: dir, Runtime: f.Runtime}
|
||||
|
||||
log.Step("fetching the images")
|
||||
if err := cmp.Run(ctx, "pull", "--quiet"); err != nil {
|
||||
return nil, err
|
||||
if !stack.Empty() {
|
||||
log.Step("fetching the images")
|
||||
if err := cmp.Run(ctx, "pull", "--quiet"); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
// The server on the host: what a container would have brought with it.
|
||||
var hs *hostServer
|
||||
var srvLogs logSource = cmp
|
||||
if onHost {
|
||||
hs = &hostServer{deploy: dir, log: log}
|
||||
srvLogs = hs
|
||||
log.Step("installing the mail server on this machine")
|
||||
if err := hs.Install(ctx); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
env := map[string]string{
|
||||
"INBUXA_ADMIN_URL": stack.ConsoleURL,
|
||||
"INBUXA_WEBMAIL_URL": stack.WebmailURL,
|
||||
}
|
||||
if stack.Webmail {
|
||||
env["INBUXA_WEBMAIL_CLIENT_SECRET"] = sec.WebmailOAuth
|
||||
}
|
||||
if o.Local {
|
||||
env["INBUXA_PUBLIC_URL"] = stack.ServerPublicURL
|
||||
}
|
||||
if stack.CABundle {
|
||||
env["SSL_CERT_FILE"] = filepath.Join(dir, "ca-bundle.crt")
|
||||
}
|
||||
if _, err := hs.WriteEnv(env); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
log.Info("%s, %s", hostUnitPath, hs.envPath())
|
||||
}
|
||||
|
||||
// A machine that already runs this installation is converged, not set up
|
||||
@@ -193,7 +250,7 @@ func Run(ctx context.Context, p plan.Plan, f host.Facts, log Log) (*Result, erro
|
||||
// moment it was configured -- which is exactly what adding or removing a
|
||||
// front end used to do, and why it could not.
|
||||
if existing, err := state.Load(); err == nil && existing.Installed() {
|
||||
return converge(ctx, o, stack, cmp, existing, f, log)
|
||||
return converge(ctx, o, stack, cmp, hs, existing, f, log)
|
||||
}
|
||||
|
||||
// The bootstrap credential lives in an override file for this step only,
|
||||
@@ -212,18 +269,30 @@ func Run(ctx context.Context, p plan.Plan, f host.Facts, log Log) (*Result, erro
|
||||
defer os.Remove(override)
|
||||
|
||||
log.Step("starting the mail server in bootstrap mode")
|
||||
boot := cmp
|
||||
boot.Files = []string{override}
|
||||
boot.Env = []string{"INBUXA_BOOTSTRAP_ADMIN=admin:" + bootPass}
|
||||
if err := boot.Run(ctx, "up", "-d", "server"); err != nil {
|
||||
return nil, err
|
||||
serverURL := "http://" + stack.ServerBind
|
||||
if onHost {
|
||||
// Its default listeners until they are fitted to the host, behind a
|
||||
// drop-in that keeps everything but loopback out meanwhile.
|
||||
serverURL = hostSetupBind
|
||||
if err := hs.WriteUnit(ctx, false); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := hs.Start(ctx, modeBootstrap, bootPass); err != nil {
|
||||
return nil, withLogs(ctx, err, srvLogs, "server")
|
||||
}
|
||||
} else {
|
||||
boot := cmp
|
||||
boot.Files = []string{override}
|
||||
boot.Env = []string{"INBUXA_BOOTSTRAP_ADMIN=admin:" + bootPass}
|
||||
if err := boot.Run(ctx, "up", "-d", "server"); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
serverURL := "http://" + stack.ServerBind
|
||||
if err := waitFor(ctx, log, "the mail server", 120*time.Second, func(ctx context.Context) error {
|
||||
return live(ctx, serverURL)
|
||||
}); err != nil {
|
||||
return nil, withLogs(ctx, err, cmp, "server")
|
||||
return nil, withLogs(ctx, err, srvLogs, "server")
|
||||
}
|
||||
|
||||
bootClient := &jmap.Client{BaseURL: serverURL, Username: "admin", Password: bootPass}
|
||||
@@ -232,7 +301,11 @@ func Run(ctx context.Context, p plan.Plan, f host.Facts, log Log) (*Result, erro
|
||||
}
|
||||
|
||||
log.Step("setting up %s (hostname %s)", o.Domain, o.MailHost)
|
||||
admin, err := bootClient.Bootstrap(ctx, o.MailHost, o.Domain)
|
||||
dataPath := ""
|
||||
if onHost {
|
||||
dataPath = hs.DataPath()
|
||||
}
|
||||
admin, err := bootClient.Bootstrap(ctx, o.MailHost, o.Domain, dataPath)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("bootstrap: %w", err)
|
||||
}
|
||||
@@ -262,10 +335,16 @@ func Run(ctx context.Context, p plan.Plan, f host.Facts, log Log) (*Result, erro
|
||||
}
|
||||
defer os.Remove(basicOverride)
|
||||
log.Step("restarting the mail server configured, to give the setup an API key")
|
||||
basic := cmp
|
||||
basic.Files = []string{basicOverride}
|
||||
if err := basic.Run(ctx, "up", "-d", "server"); err != nil {
|
||||
return res, err
|
||||
if onHost {
|
||||
if err := hs.Start(ctx, modeBasic, ""); err != nil {
|
||||
return res, withLogs(ctx, err, srvLogs, "server")
|
||||
}
|
||||
} else {
|
||||
basic := cmp
|
||||
basic.Files = []string{basicOverride}
|
||||
if err := basic.Run(ctx, "up", "-d", "server"); err != nil {
|
||||
return res, err
|
||||
}
|
||||
}
|
||||
adminBasic := &jmap.Client{BaseURL: serverURL, Username: admin.Username, Password: admin.Secret}
|
||||
var keyID, key string
|
||||
@@ -274,7 +353,7 @@ func Run(ctx context.Context, p plan.Plan, f host.Facts, log Log) (*Result, erro
|
||||
keyID, key, err = adminBasic.CreateAPIKey(ctx, "inbuxa installer, for this setup only", time.Hour)
|
||||
return err
|
||||
}); err != nil {
|
||||
return res, withLogs(ctx, fmt.Errorf("an API key for the setup: %w", err), cmp, "server")
|
||||
return res, withLogs(ctx, fmt.Errorf("an API key for the setup: %w", err), srvLogs, "server")
|
||||
}
|
||||
srv := &jmap.Client{BaseURL: serverURL, Token: key}
|
||||
defer func() {
|
||||
@@ -285,21 +364,42 @@ func Run(ctx context.Context, p plan.Plan, f host.Facts, log Log) (*Result, erro
|
||||
}
|
||||
}()
|
||||
|
||||
if onHost {
|
||||
log.Step("fitting the server's listeners to the host")
|
||||
if err := srv.HostListeners(ctx, hostFinalBind, o.Local); err != nil {
|
||||
return res, fmt.Errorf("moving the server's listeners: %w", err)
|
||||
}
|
||||
log.Info("plain HTTP on %s for the proxy and the webmail; 443 is left to the proxy", hostFinalBind)
|
||||
if o.Local {
|
||||
log.Info("the mail ports on loopback only")
|
||||
}
|
||||
if err := hs.WriteUnit(ctx, true); err != nil {
|
||||
return res, err
|
||||
}
|
||||
if err := hs.Start(ctx, modeNormal, ""); err != nil {
|
||||
return res, withLogs(ctx, err, srvLogs, "server")
|
||||
}
|
||||
serverURL = "http://" + hostFinalBind
|
||||
srv.BaseURL = serverURL
|
||||
}
|
||||
|
||||
log.Step("starting the rest of the stack")
|
||||
// Without the override, so the server is recreated taking tokens only.
|
||||
// --remove-orphans: the compose file is rendered from the shapes asked
|
||||
// for, so a component the topology no longer lists is simply not in it
|
||||
// any more. Without this its container would keep running, belonging to
|
||||
// a project that no longer describes it.
|
||||
if err := cmp.Run(ctx, "up", "-d", "--remove-orphans"); err != nil {
|
||||
return res, err
|
||||
if !stack.Empty() {
|
||||
if err := cmp.Run(ctx, "up", "-d", "--remove-orphans"); err != nil {
|
||||
return res, err
|
||||
}
|
||||
}
|
||||
|
||||
if err := waitFor(ctx, log, "the server to come back configured", 120*time.Second, func(ctx context.Context) error {
|
||||
_, err := srv.DomainID(ctx, o.Domain)
|
||||
return err
|
||||
}); err != nil {
|
||||
return res, withLogs(ctx, err, cmp, "server")
|
||||
return res, withLogs(ctx, err, srvLogs, "server")
|
||||
}
|
||||
domainID, err := srv.DomainID(ctx, o.Domain)
|
||||
if err != nil {
|
||||
@@ -310,32 +410,41 @@ func Run(ctx context.Context, p plan.Plan, f host.Facts, log Log) (*Result, erro
|
||||
// sign-in, every push stream opened and dropped as tabs come and go. The
|
||||
// server bans per address, so a ban on that one is a ban on everybody's
|
||||
// webmail. The webmail rate-limits sign-ins per real client itself.
|
||||
// On the host both arrive from loopback, which is exempted once.
|
||||
allowed := map[string]bool{}
|
||||
if stack.Webmail {
|
||||
log.Step("exempting the webmail from the auto-ban")
|
||||
if err := srv.AllowIP(ctx, stack.WebmailIP, "the webmail: every request arrives from this address"); err != nil {
|
||||
return res, fmt.Errorf("exempting the webmail: %w", err)
|
||||
}
|
||||
allowed[stack.WebmailIP] = true
|
||||
}
|
||||
if stack.Proxy {
|
||||
log.Step("trusting the proxy's X-Forwarded-For")
|
||||
if err := srv.TrustForwardedFor(ctx); err != nil {
|
||||
return res, fmt.Errorf("trusting the proxy: %w", err)
|
||||
}
|
||||
if err := srv.AllowIP(ctx, stack.CaddyIP, "the proxy: certificate renewals and autoconfig arrive from this address"); err != nil {
|
||||
return res, fmt.Errorf("exempting the proxy: %w", err)
|
||||
if !allowed[stack.CaddyIP] {
|
||||
if err := srv.AllowIP(ctx, stack.CaddyIP, "the proxy: certificate renewals and autoconfig arrive from this address"); err != nil {
|
||||
return res, fmt.Errorf("exempting the proxy: %w", err)
|
||||
}
|
||||
}
|
||||
}
|
||||
if stack.Webmail || stack.Proxy {
|
||||
// Neither setting takes effect on a running server.
|
||||
log.Info("restarting the server so those take effect")
|
||||
if err := cmp.Run(ctx, "restart", "server"); err != nil {
|
||||
restart := func() error { return cmp.Run(ctx, "restart", "server") }
|
||||
if onHost {
|
||||
restart = func() error { return hs.Restart(ctx) }
|
||||
}
|
||||
if err := restart(); err != nil {
|
||||
return res, err
|
||||
}
|
||||
if err := waitFor(ctx, log, "the server to restart", 120*time.Second, func(ctx context.Context) error {
|
||||
_, err := srv.DomainID(ctx, o.Domain)
|
||||
return err
|
||||
}); err != nil {
|
||||
return res, withLogs(ctx, err, cmp, "server")
|
||||
return res, withLogs(ctx, err, srvLogs, "server")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -443,7 +552,7 @@ func waitForCertificate(ctx context.Context, srv *jmap.Client, log Log, domainID
|
||||
// brought up, and anything no longer in the file goes with --remove-orphans.
|
||||
// Nothing touches the mail: data volumes are left alone, and a component
|
||||
// that is removed can be added back with what it had.
|
||||
func converge(ctx context.Context, o plan.Options, stack compose.Stack, cmp docker.Compose,
|
||||
func converge(ctx context.Context, o plan.Options, stack compose.Stack, cmp docker.Compose, hs *hostServer,
|
||||
st *state.State, f host.Facts, log Log) (*Result, error) {
|
||||
|
||||
res := &Result{
|
||||
@@ -458,6 +567,10 @@ func converge(ctx context.Context, o plan.Options, stack compose.Stack, cmp dock
|
||||
}
|
||||
}
|
||||
|
||||
if hs != nil {
|
||||
return convergeHost(ctx, o, stack, cmp, hs, st, f, log, res)
|
||||
}
|
||||
|
||||
// Before anything is recreated: an install from before #5 keeps the
|
||||
// server's data where the corrected compose file no longer mounts it.
|
||||
moved, err := adoptServerVolumes(ctx, cmp, stack.Project, log)
|
||||
@@ -504,8 +617,57 @@ func converge(ctx context.Context, o plan.Options, stack compose.Stack, cmp dock
|
||||
}
|
||||
}
|
||||
|
||||
saveState(st, o, f, log)
|
||||
return res, nil
|
||||
}
|
||||
|
||||
// convergeHost is converge for a server on the host: the binary, the unit
|
||||
// and its environment are rewritten if they changed, whatever runs in
|
||||
// containers beside it is brought in line, and the server is restarted only
|
||||
// if what it reads at start is different.
|
||||
func convergeHost(ctx context.Context, o plan.Options, stack compose.Stack, cmp docker.Compose, hs *hostServer,
|
||||
st *state.State, f host.Facts, log Log, res *Result) (*Result, error) {
|
||||
|
||||
// Run already wrote the environment; reading it back as it was before is
|
||||
// not possible, so whether it changed is decided by the shapes, as for a
|
||||
// container.
|
||||
if err := hs.WriteUnit(ctx, true); err != nil {
|
||||
return res, err
|
||||
}
|
||||
log.Step("bringing the stack in line with the file")
|
||||
if stack.Empty() {
|
||||
if _, err := os.Stat(filepath.Join(o.Dir, "compose.yaml")); err == nil {
|
||||
// Everything that ran beside the server was removed.
|
||||
if err := cmp.Run(ctx, "down", "--remove-orphans"); err != nil {
|
||||
return res, err
|
||||
}
|
||||
os.Remove(filepath.Join(o.Dir, "compose.yaml"))
|
||||
os.Remove(filepath.Join(o.Dir, "Caddyfile"))
|
||||
}
|
||||
} else if err := cmp.Run(ctx, "up", "-d", "--remove-orphans"); err != nil {
|
||||
return res, err
|
||||
}
|
||||
_, active := discover.HostServer(ctx)
|
||||
frontEnds := st.Shapes["console"] != string(o.Shape(plan.Console)) || st.Shapes["webmail"] != string(o.Shape(plan.Webmail))
|
||||
if frontEnds || !active {
|
||||
log.Info("restarting the server")
|
||||
if err := hs.Restart(ctx); err != nil {
|
||||
return res, withLogs(ctx, err, hs, "server")
|
||||
}
|
||||
if err := waitFor(ctx, log, "the server to answer again", 120*time.Second, func(ctx context.Context) error {
|
||||
return live(ctx, "http://"+hostFinalBind)
|
||||
}); err != nil {
|
||||
return res, withLogs(ctx, err, hs, "server")
|
||||
}
|
||||
}
|
||||
saveState(st, o, f, log)
|
||||
return res, nil
|
||||
}
|
||||
|
||||
func saveState(st *state.State, o plan.Options, f host.Facts, log Log) {
|
||||
st.Machine, st.Dir, st.Domain = o.Machine, o.Dir, o.Domain
|
||||
st.Runtime, st.Topology = f.Runtime.Kind, o.TopologyPath
|
||||
st.Installer = "server " + release.ServerVersion
|
||||
st.Shapes = map[string]string{}
|
||||
for _, c := range []plan.Component{plan.Server, plan.Console, plan.Webmail} {
|
||||
if sh := o.Shape(c); sh != plan.Skip {
|
||||
@@ -515,7 +677,6 @@ func converge(ctx context.Context, o plan.Options, stack compose.Stack, cmp dock
|
||||
if err := st.Save(); err != nil {
|
||||
log.Info("could not write %s: %v", state.Path, err)
|
||||
}
|
||||
return res, nil
|
||||
}
|
||||
|
||||
// Verify is the last step: does what was installed actually answer?
|
||||
@@ -604,7 +765,13 @@ func waitFor(ctx context.Context, log Log, what string, limit time.Duration, pro
|
||||
return fmt.Errorf("waited %s for %s: %w", limit, what, last)
|
||||
}
|
||||
|
||||
func withLogs(ctx context.Context, err error, c docker.Compose, service string) error {
|
||||
// logSource is wherever a server's last lines come from: its container, or
|
||||
// the journal.
|
||||
type logSource interface {
|
||||
Logs(ctx context.Context, service string, lines int) string
|
||||
}
|
||||
|
||||
func withLogs(ctx context.Context, err error, c logSource, service string) error {
|
||||
logs := c.Logs(ctx, service, 25)
|
||||
if strings.TrimSpace(logs) == "" {
|
||||
return err
|
||||
|
||||
@@ -0,0 +1,322 @@
|
||||
// SPDX-FileCopyrightText: 2026 Coffey Labs LLC
|
||||
// SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
|
||||
package apply
|
||||
|
||||
// The mail server on the host: the release binary, a user of its own, a
|
||||
// directory for its configuration and data, and a systemd unit.
|
||||
//
|
||||
// First boot is the same sequence as in a container, and the differences are
|
||||
// all about what a container would otherwise have contained:
|
||||
//
|
||||
// - Setup runs behind a drop-in that lets the server talk to loopback and
|
||||
// nothing else. In a container nothing is published until the compose
|
||||
// file says so; on the host the server binds every interface the moment
|
||||
// it starts, and during setup it takes the bootstrap credential, then
|
||||
// passwords on /jmap. The drop-in lives under /run, so even a setup that
|
||||
// stops halfway leaves nothing behind after a reboot.
|
||||
// - The credential for each setup step is in a file only root can read,
|
||||
// not in the unit, which anyone can.
|
||||
// - After setup the listeners are fitted to the host (jmap.HostListeners):
|
||||
// plain HTTP on loopback, where the proxy and the webmail reach it, and
|
||||
// no HTTPS listener of its own on 443, which is the proxy's.
|
||||
// - The finished unit refuses to start without a configuration file, so a
|
||||
// server that loses its configuration stays down instead of coming back
|
||||
// in bootstrap mode on every interface.
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"fmt"
|
||||
"os"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"sort"
|
||||
"strings"
|
||||
|
||||
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/deps"
|
||||
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/discover"
|
||||
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/release"
|
||||
)
|
||||
|
||||
const (
|
||||
// HostServerBinary is where the server's binary goes. Not
|
||||
// /usr/local/bin/inbuxa, which is this installer.
|
||||
HostServerBinary = "/usr/local/bin/inbuxa-server"
|
||||
HostServerUnit = discover.HostServerUnit
|
||||
HostServerUser = "inbuxa"
|
||||
|
||||
hostUnitPath = discover.HostServerUnitPath
|
||||
setupDropIn = "/run/systemd/system/" + HostServerUnit + ".d/inbuxa-setup.conf"
|
||||
setupEnvPath = "/run/inbuxa-server-setup.env"
|
||||
hostSetupBind = "http://127.0.0.1:8080" // the default listeners, before they are fitted
|
||||
hostFinalBind = "127.0.0.1:8081" // where a container install publishes it, too
|
||||
)
|
||||
|
||||
// setupMode is how the server is started for each step of first boot.
|
||||
type setupMode int
|
||||
|
||||
const (
|
||||
modeBootstrap setupMode = iota // the bootstrap credential, loopback only
|
||||
modeBasic // configured, passwords on /jmap, loopback only
|
||||
modeNormal // as it will run from now on
|
||||
)
|
||||
|
||||
// hostServer is the server as a host install, rooted in the deployment
|
||||
// directory: <dir>/server holds config.json and data/, <dir>/server.env what
|
||||
// the unit reads into the server's environment.
|
||||
type hostServer struct {
|
||||
deploy string
|
||||
log Log
|
||||
}
|
||||
|
||||
func (h hostServer) home() string { return filepath.Join(h.deploy, "server") }
|
||||
func (h hostServer) configPath() string { return filepath.Join(h.home(), "config.json") }
|
||||
func (h hostServer) envPath() string { return filepath.Join(h.deploy, "server.env") }
|
||||
|
||||
// DataPath is the built-in store's directory, given to bootstrap.
|
||||
func (h hostServer) DataPath() string { return filepath.Join(h.home(), "data") + "/" }
|
||||
|
||||
// Install puts the release binary, the user and the directories in place. It
|
||||
// changes nothing that is already right, so a converge can call it too.
|
||||
func (h hostServer) Install(ctx context.Context) error {
|
||||
if v := binaryVersion(ctx, HostServerBinary); strings.Contains(v, release.ServerVersion) {
|
||||
h.log.Info("%s is already %s", HostServerBinary, release.ServerVersion)
|
||||
} else {
|
||||
if err := h.fetchBinary(ctx); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
if err := exec.CommandContext(ctx, "getent", "passwd", HostServerUser).Run(); err != nil {
|
||||
if err := runQuiet(ctx, "useradd", "--system", "--user-group", "--no-create-home",
|
||||
"--home-dir", h.home(), "--shell", nologin(), HostServerUser); err != nil {
|
||||
return fmt.Errorf("creating the %s user: %w", HostServerUser, err)
|
||||
}
|
||||
h.log.Info("user %s (system, no login)", HostServerUser)
|
||||
}
|
||||
|
||||
// The deployment directory is root's and holds the credentials, which
|
||||
// are 0600 on their own; the server only needs to pass through it to
|
||||
// reach its own directory.
|
||||
if err := os.MkdirAll(h.deploy, 0o750); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := os.Chmod(h.deploy, 0o711); err != nil {
|
||||
return err
|
||||
}
|
||||
for _, d := range []string{h.home(), h.DataPath()} {
|
||||
if err := os.MkdirAll(d, 0o750); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := runQuiet(ctx, "chown", HostServerUser+":"+HostServerUser, d); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (h hostServer) fetchBinary(ctx context.Context) error {
|
||||
arch := runtime.GOARCH
|
||||
sum, ok := release.ServerSHA256[arch]
|
||||
if !ok {
|
||||
return fmt.Errorf("inbuxa-server %s has no release binary for %s", release.ServerVersion, arch)
|
||||
}
|
||||
h.log.Step("fetching inbuxa-server %s for %s", release.ServerVersion, arch)
|
||||
work, err := os.MkdirTemp("", "inbuxa-server-")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer os.RemoveAll(work)
|
||||
tarball := filepath.Join(work, "inbuxa.tar.gz")
|
||||
if err := deps.FetchVerified(ctx, h.log.Out(), release.ServerTarball(arch), sum, tarball, 0o644); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := runQuiet(ctx, "tar", "-xzf", tarball, "-C", work, "inbuxa"); err != nil {
|
||||
return fmt.Errorf("unpacking the release: %w", err)
|
||||
}
|
||||
// Run before it is put in place: a binary this machine's C library
|
||||
// cannot load is caught here, not by a unit that restarts forever.
|
||||
got := binaryVersion(ctx, filepath.Join(work, "inbuxa"))
|
||||
if !strings.Contains(got, release.ServerVersion) {
|
||||
return fmt.Errorf("the release binary does not run here (it said %q); run the server as a container on this machine", got)
|
||||
}
|
||||
if err := runQuiet(ctx, "install", "-m", "0755", filepath.Join(work, "inbuxa"), HostServerBinary); err != nil {
|
||||
return err
|
||||
}
|
||||
h.log.Info("%s, %s", HostServerBinary, strings.TrimSpace(got))
|
||||
return nil
|
||||
}
|
||||
|
||||
// WriteEnv writes what the server reads from its environment, and says
|
||||
// whether that changed: the server only sees it at a start.
|
||||
func (h hostServer) WriteEnv(vars map[string]string) (bool, error) {
|
||||
keys := make([]string, 0, len(vars))
|
||||
for k, v := range vars {
|
||||
if v != "" {
|
||||
keys = append(keys, k)
|
||||
}
|
||||
}
|
||||
sort.Strings(keys)
|
||||
var b strings.Builder
|
||||
b.WriteString("# Written by the inbuxa installer: the mail server's environment.\n")
|
||||
b.WriteString("# Read by " + HostServerUnit + " at each start.\n")
|
||||
for _, k := range keys {
|
||||
fmt.Fprintf(&b, "%s=%s\n", k, vars[k])
|
||||
}
|
||||
return writeIfChanged(h.envPath(), b.String(), 0o600)
|
||||
}
|
||||
|
||||
// WriteUnit writes the unit. configured adds the condition that a finished
|
||||
// install keeps: no configuration file, no start.
|
||||
func (h hostServer) WriteUnit(ctx context.Context, configured bool) error {
|
||||
cond := ""
|
||||
if configured {
|
||||
cond = "# A server that has lost its configuration stays down rather than coming\n" +
|
||||
"# back in bootstrap mode.\n" +
|
||||
"ConditionPathExists=" + h.configPath() + "\n"
|
||||
}
|
||||
unit := fmt.Sprintf(`# Written by the inbuxa installer. Changes here are replaced on its next run.
|
||||
[Unit]
|
||||
Description=inbuxa mail server
|
||||
Documentation=https://docs.inbuxa.org/
|
||||
After=network-online.target
|
||||
Wants=network-online.target
|
||||
%s
|
||||
[Service]
|
||||
Type=simple
|
||||
User=%s
|
||||
Group=%s
|
||||
EnvironmentFile=%s
|
||||
ExecStart=%s --config %s
|
||||
WorkingDirectory=%s
|
||||
# The mail ports and 443 are below 1024; this lets an unprivileged user
|
||||
# bind them, and survives the binary being replaced, which setcap does not.
|
||||
AmbientCapabilities=CAP_NET_BIND_SERVICE
|
||||
CapabilityBoundingSet=CAP_NET_BIND_SERVICE
|
||||
NoNewPrivileges=true
|
||||
ProtectSystem=full
|
||||
ProtectHome=true
|
||||
PrivateTmp=true
|
||||
LimitNOFILE=65536
|
||||
KillSignal=SIGINT
|
||||
Restart=on-failure
|
||||
RestartSec=5
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
`, cond, HostServerUser, HostServerUser, h.envPath(), HostServerBinary, h.configPath(), h.home())
|
||||
changed, err := writeIfChanged(hostUnitPath, unit, 0o644)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if changed {
|
||||
if err := runQuiet(ctx, "systemctl", "daemon-reload"); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return runQuiet(ctx, "systemctl", "enable", "--quiet", HostServerUnit)
|
||||
}
|
||||
|
||||
// Start (re)starts the server for a step of first boot, or as it runs from
|
||||
// then on.
|
||||
func (h hostServer) Start(ctx context.Context, mode setupMode, bootPass string) error {
|
||||
switch mode {
|
||||
case modeNormal:
|
||||
os.Remove(setupDropIn)
|
||||
os.Remove(setupEnvPath)
|
||||
default:
|
||||
env := "INBUXA_HTTP_BASIC_AUTH=all\n"
|
||||
if mode == modeBootstrap {
|
||||
env = "INBUXA_RECOVERY_ADMIN=admin:" + bootPass + "\n"
|
||||
}
|
||||
if err := os.WriteFile(setupEnvPath, []byte(env), 0o600); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := os.MkdirAll(filepath.Dir(setupDropIn), 0o755); err != nil {
|
||||
return err
|
||||
}
|
||||
dropIn := "# The inbuxa installer, during first boot only. Gone at the next reboot.\n" +
|
||||
"[Service]\n" +
|
||||
"EnvironmentFile=" + setupEnvPath + "\n" +
|
||||
"IPAddressAllow=localhost\n" +
|
||||
"IPAddressDeny=any\n"
|
||||
if err := os.WriteFile(setupDropIn, []byte(dropIn), 0o644); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if err := runQuiet(ctx, "systemctl", "daemon-reload"); err != nil {
|
||||
return err
|
||||
}
|
||||
return runQuiet(ctx, "systemctl", "restart", HostServerUnit)
|
||||
}
|
||||
|
||||
// Restart restarts the server as it is.
|
||||
func (h hostServer) Restart(ctx context.Context) error {
|
||||
return runQuiet(ctx, "systemctl", "restart", HostServerUnit)
|
||||
}
|
||||
|
||||
// Logs is the server's last lines from the journal, for an error message.
|
||||
// The service argument is there so it reads like a compose project's.
|
||||
func (h hostServer) Logs(ctx context.Context, _ string, lines int) string {
|
||||
out, _ := exec.CommandContext(ctx, "journalctl", "-u", HostServerUnit,
|
||||
"-n", fmt.Sprint(lines), "--no-pager", "-o", "cat").CombinedOutput()
|
||||
return string(out)
|
||||
}
|
||||
|
||||
// systemCABundle is this machine's trust store, which a private ACME CA's
|
||||
// root is added to for a server on the host, as it is to the image's for a
|
||||
// server in a container.
|
||||
func systemCABundle() ([]byte, error) {
|
||||
for _, p := range []string{
|
||||
"/etc/ssl/certs/ca-certificates.crt", // Debian, Ubuntu, Arch
|
||||
"/etc/pki/tls/certs/ca-bundle.crt", // Fedora, Rocky
|
||||
"/etc/ssl/ca-bundle.pem", // openSUSE
|
||||
} {
|
||||
if b, err := os.ReadFile(p); err == nil {
|
||||
return b, nil
|
||||
}
|
||||
}
|
||||
return nil, fmt.Errorf("no system CA bundle found")
|
||||
}
|
||||
|
||||
// binaryVersion is what a binary says --version is, or what it said instead
|
||||
// when it could not run: a missing library is reported in that output.
|
||||
func binaryVersion(ctx context.Context, path string) string {
|
||||
out, _ := exec.CommandContext(ctx, path, "--version").CombinedOutput()
|
||||
return strings.TrimSpace(string(out))
|
||||
}
|
||||
|
||||
func nologin() string {
|
||||
for _, p := range []string{"/usr/sbin/nologin", "/sbin/nologin", "/usr/bin/nologin"} {
|
||||
if _, err := os.Stat(p); err == nil {
|
||||
return p
|
||||
}
|
||||
}
|
||||
return "/bin/false"
|
||||
}
|
||||
|
||||
func writeIfChanged(path, content string, mode os.FileMode) (bool, error) {
|
||||
if old, err := os.ReadFile(path); err == nil && bytes.Equal(old, []byte(content)) {
|
||||
return false, os.Chmod(path, mode)
|
||||
}
|
||||
if err := os.WriteFile(path, []byte(content), mode); err != nil {
|
||||
return false, err
|
||||
}
|
||||
return true, os.Chmod(path, mode)
|
||||
}
|
||||
|
||||
func runQuiet(ctx context.Context, name string, args ...string) error {
|
||||
var out bytes.Buffer
|
||||
cmd := exec.CommandContext(ctx, name, args...)
|
||||
cmd.Stdout, cmd.Stderr = &out, &out
|
||||
if err := cmd.Run(); err != nil {
|
||||
msg := strings.TrimSpace(out.String())
|
||||
if msg == "" {
|
||||
return fmt.Errorf("%s %s: %w", name, strings.Join(args, " "), err)
|
||||
}
|
||||
return fmt.Errorf("%s %s: %w: %s", name, strings.Join(args, " "), err, msg)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
+62
-20
@@ -39,10 +39,18 @@ type Stack struct {
|
||||
ConsoleHost string
|
||||
WebmailHost string
|
||||
|
||||
Server bool // the server runs in this compose project
|
||||
Console bool
|
||||
Webmail bool
|
||||
Proxy bool
|
||||
|
||||
// HostServer is a mail server running on this machine but outside the
|
||||
// project, under systemd. The front ends and the proxy then reach it on
|
||||
// loopback, so the ones that talk to it -- the webmail and Caddy -- share
|
||||
// the host's network instead of the project's. The console does not:
|
||||
// only the browser talks to the server from it.
|
||||
HostServer bool
|
||||
|
||||
ServerImage string
|
||||
ConsoleImage string
|
||||
WebmailImage string
|
||||
@@ -125,29 +133,18 @@ type Secrets struct {
|
||||
// goes, and the caller needs them: the mail server is told which addresses
|
||||
// the front ends speak from, and passing a copy meant telling it "".
|
||||
func Write(dir string, s *Stack) (Secrets, error) {
|
||||
var sec Secrets
|
||||
if err := os.MkdirAll(dir, 0o750); err != nil {
|
||||
sec, err := EnsureSecrets(dir)
|
||||
if err != nil {
|
||||
return sec, err
|
||||
}
|
||||
if err := s.Addresses(); err != nil {
|
||||
return sec, err
|
||||
}
|
||||
|
||||
// Secrets are generated once and kept. Rewriting the deployment to add
|
||||
// or remove a component must not roll the webmail's session key or the
|
||||
// OAuth client secret the server was told: the point of converging is
|
||||
// that everything not being changed stays as it was.
|
||||
sec = readSecrets(filepath.Join(dir, ".env"))
|
||||
var err error
|
||||
if sec.AppSecret == "" {
|
||||
if sec.AppSecret, err = secret(); err != nil {
|
||||
return sec, err
|
||||
}
|
||||
}
|
||||
if sec.WebmailOAuth == "" {
|
||||
if sec.WebmailOAuth, err = secret(); err != nil {
|
||||
return sec, err
|
||||
}
|
||||
if s.HostServer {
|
||||
// Everything that talks to the server is on the host's network and
|
||||
// arrives from loopback, which is the address the server is told to
|
||||
// exempt from the auto-ban.
|
||||
s.WebmailIP, s.CaddyIP = "127.0.0.1", "127.0.0.1"
|
||||
}
|
||||
|
||||
funcs := template.FuncMap{"join": strings.Join}
|
||||
@@ -171,8 +168,34 @@ func Write(dir string, s *Stack) (Secrets, error) {
|
||||
}
|
||||
}
|
||||
|
||||
// The secrets live beside the compose file, not in it, so the compose
|
||||
// file can be read to somebody, pasted into an issue, or committed.
|
||||
return sec, nil
|
||||
}
|
||||
|
||||
// EnsureSecrets returns the deployment's secrets, generating and writing any
|
||||
// that do not exist yet. They are generated once and kept: rewriting the
|
||||
// deployment to add or remove a component must not roll the webmail's
|
||||
// session key or the OAuth client secret the server was told, because the
|
||||
// point of converging is that everything not being changed stays as it was.
|
||||
//
|
||||
// The secrets live in .env beside the compose file, not in it, so the compose
|
||||
// file can be read to somebody, pasted into an issue, or committed. A server
|
||||
// on the host reads the one it needs from there too.
|
||||
func EnsureSecrets(dir string) (Secrets, error) {
|
||||
if err := os.MkdirAll(dir, 0o750); err != nil {
|
||||
return Secrets{}, err
|
||||
}
|
||||
sec := readSecrets(filepath.Join(dir, ".env"))
|
||||
var err error
|
||||
if sec.AppSecret == "" {
|
||||
if sec.AppSecret, err = secret(); err != nil {
|
||||
return sec, err
|
||||
}
|
||||
}
|
||||
if sec.WebmailOAuth == "" {
|
||||
if sec.WebmailOAuth, err = secret(); err != nil {
|
||||
return sec, err
|
||||
}
|
||||
}
|
||||
env := fmt.Sprintf("APP_SECRET=%s\nWEBMAIL_CLIENT_SECRET=%s\n", sec.AppSecret, sec.WebmailOAuth)
|
||||
if err := os.WriteFile(filepath.Join(dir, ".env"), []byte(env), 0o600); err != nil {
|
||||
return sec, err
|
||||
@@ -180,6 +203,25 @@ func Write(dir string, s *Stack) (Secrets, error) {
|
||||
return sec, nil
|
||||
}
|
||||
|
||||
// Empty is whether the stack has nothing to run: a server on the host with no
|
||||
// front ends and no proxy here. Then there is no compose project at all.
|
||||
func (s Stack) Empty() bool {
|
||||
return !s.Server && !s.Console && !s.Webmail && !s.Proxy
|
||||
}
|
||||
|
||||
// Upstreams are where Caddy finds each program: by service name on the
|
||||
// project's network, or on loopback when it shares the host's.
|
||||
func (s Stack) ServerUpstream() string { return s.pick("server:8080", "127.0.0.1:8081") }
|
||||
func (s Stack) WebmailUpstream() string { return s.pick("webmail:8080", "127.0.0.1:8080") }
|
||||
func (s Stack) ConsoleUpstream() string { return s.pick("console:8080", "127.0.0.1:8082") }
|
||||
|
||||
func (s Stack) pick(project, host string) string {
|
||||
if s.HostServer {
|
||||
return host
|
||||
}
|
||||
return project
|
||||
}
|
||||
|
||||
// readSecrets recovers what a previous run generated, so a converge keeps
|
||||
// them. A missing or unreadable file means a first install, and new ones.
|
||||
func readSecrets(path string) Secrets {
|
||||
|
||||
@@ -0,0 +1,87 @@
|
||||
// SPDX-FileCopyrightText: 2026 Coffey Labs LLC
|
||||
// SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
|
||||
package compose
|
||||
|
||||
import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func stack(hostServer bool) *Stack {
|
||||
return &Stack{
|
||||
Version: "test", Project: "inbuxa", Domain: "example.com", Email: "[email protected]",
|
||||
MailHost: "mail.example.com", ConsoleHost: "admin.example.com", WebmailHost: "webmail.example.com",
|
||||
Server: !hostServer, HostServer: hostServer, Console: true, Webmail: true, Proxy: true,
|
||||
ServerImage: "s", ConsoleImage: "c", WebmailImage: "w", CaddyImage: "k",
|
||||
ServerBind: "127.0.0.1:8081", ConsoleBind: "127.0.0.1:8082", WebmailBind: "127.0.0.1:8080",
|
||||
Subnet: "172.31.253.0/24", MailPorts: []int{25},
|
||||
ServerPublicURL: "https://mail.example.com", ConsoleURL: "https://admin.example.com", WebmailURL: "https://webmail.example.com",
|
||||
}
|
||||
}
|
||||
|
||||
func render(t *testing.T, s *Stack) (compose, caddy string) {
|
||||
t.Helper()
|
||||
dir := t.TempDir()
|
||||
if _, err := Write(dir, s); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
a, _ := os.ReadFile(filepath.Join(dir, "compose.yaml"))
|
||||
b, _ := os.ReadFile(filepath.Join(dir, "Caddyfile"))
|
||||
return string(a), string(b)
|
||||
}
|
||||
|
||||
func TestContainerServerIsInTheProject(t *testing.T) {
|
||||
c, k := render(t, stack(false))
|
||||
for _, want := range []string{"\n server:\n", "depends_on: [server]", "MAIL_SERVER_URL: http://server:8080", "inbuxa-data:/var/lib/inbuxa"} {
|
||||
if !strings.Contains(c, want) {
|
||||
t.Errorf("compose.yaml lacks %q", want)
|
||||
}
|
||||
}
|
||||
if strings.Contains(c, "network_mode: host") {
|
||||
t.Error("a container install put something on the host's network")
|
||||
}
|
||||
if !strings.Contains(k, "reverse_proxy server:8080") || !strings.Contains(k, "reverse_proxy webmail:8080") {
|
||||
t.Errorf("Caddyfile does not use the project's names:\n%s", k)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHostServerIsReachedOnLoopback(t *testing.T) {
|
||||
s := stack(true)
|
||||
c, k := render(t, s)
|
||||
for _, bad := range []string{"\n server:\n", "depends_on", "inbuxa-data:", "http://server:8080"} {
|
||||
if strings.Contains(c, bad) {
|
||||
t.Errorf("compose.yaml still has %q", bad)
|
||||
}
|
||||
}
|
||||
for _, want := range []string{"network_mode: host", "HOST: 127.0.0.1", "MAIL_SERVER_URL: http://127.0.0.1:8081", "\"127.0.0.1:8082:8080\""} {
|
||||
if !strings.Contains(c, want) {
|
||||
t.Errorf("compose.yaml lacks %q", want)
|
||||
}
|
||||
}
|
||||
for _, want := range []string{"reverse_proxy 127.0.0.1:8081", "reverse_proxy 127.0.0.1:8080", "reverse_proxy 127.0.0.1:8082"} {
|
||||
if !strings.Contains(k, want) {
|
||||
t.Errorf("Caddyfile lacks %q", want)
|
||||
}
|
||||
}
|
||||
if s.WebmailIP != "127.0.0.1" || s.CaddyIP != "127.0.0.1" {
|
||||
t.Errorf("the server would exempt %s and %s, not loopback", s.WebmailIP, s.CaddyIP)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSecretsSurviveARewrite(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
a, err := EnsureSecrets(dir)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
b, err := Write(dir, stack(true))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if a != b {
|
||||
t.Error("writing the deployment rolled the secrets")
|
||||
}
|
||||
}
|
||||
@@ -25,7 +25,7 @@
|
||||
# they are written rather than buffered.
|
||||
{{.WebmailHost}} {
|
||||
encode zstd gzip
|
||||
reverse_proxy webmail:8080 {
|
||||
reverse_proxy {{.WebmailUpstream}} {
|
||||
flush_interval -1
|
||||
}
|
||||
}
|
||||
@@ -36,7 +36,7 @@
|
||||
# nothing here proxies the API.
|
||||
{{.ConsoleHost}} {
|
||||
encode zstd gzip
|
||||
reverse_proxy console:8080
|
||||
reverse_proxy {{.ConsoleUpstream}}
|
||||
}
|
||||
{{- end}}
|
||||
|
||||
@@ -57,13 +57,13 @@
|
||||
disable_http_challenge
|
||||
}
|
||||
}
|
||||
reverse_proxy server:8080
|
||||
reverse_proxy {{.ServerUpstream}}
|
||||
}
|
||||
|
||||
# Port 80 for the server's names is its challenge path and a redirect.
|
||||
{{range $i, $n := .ServerNames}}{{if $i}}, {{end}}http://{{$n}}{{end}} {
|
||||
handle /.well-known/acme-challenge/* {
|
||||
reverse_proxy server:8080
|
||||
reverse_proxy {{.ServerUpstream}}
|
||||
}
|
||||
handle {
|
||||
redir https://{host}{uri} 308
|
||||
|
||||
@@ -4,12 +4,20 @@
|
||||
# from this directory. Secrets are in .env beside it and the administrator's
|
||||
# password is in credentials.txt -- both readable only by root.
|
||||
#
|
||||
{{- if .HostServer}}
|
||||
# The mail server runs on this machine under systemd (inbuxa-server.service),
|
||||
# not in this project. Its plain HTTP is on loopback only, which is why the
|
||||
# webmail and Caddy share the host's network: that is where they reach it, as
|
||||
# http://, a leg that never leaves this machine.
|
||||
{{- else}}
|
||||
# The mail server's plain HTTP port is published on loopback only and reached
|
||||
# over the private network below, which is why the front ends talk to it as
|
||||
# http://: that leg never leaves this machine.
|
||||
{{- end}}
|
||||
name: {{.Project}}
|
||||
|
||||
services:
|
||||
{{- if .Server}}
|
||||
server:
|
||||
image: {{.ServerImage}}
|
||||
hostname: {{.MailHost}}
|
||||
@@ -48,12 +56,15 @@ services:
|
||||
networks:
|
||||
stack:
|
||||
ipv4_address: {{.ServerIP}}
|
||||
{{- end}}
|
||||
{{- if .Console}}
|
||||
|
||||
console:
|
||||
image: {{.ConsoleImage}}
|
||||
restart: unless-stopped
|
||||
{{- if .Server}}
|
||||
depends_on: [server]
|
||||
{{- end}}
|
||||
# Not read-only, unlike the webmail: this image writes the api-base-url
|
||||
# into index.html when it starts, which is what lets one image serve any
|
||||
# installation. A read-only root makes it restart forever instead.
|
||||
@@ -73,15 +84,28 @@ services:
|
||||
webmail:
|
||||
image: {{.WebmailImage}}
|
||||
restart: unless-stopped
|
||||
{{- if .Server}}
|
||||
depends_on: [server]
|
||||
{{- end}}
|
||||
# Immutable: read-only root, no volume, sessions in memory. A restart
|
||||
# signs everyone out; nothing else is lost, because nothing else is kept.
|
||||
read_only: true
|
||||
tmpfs: [/tmp]
|
||||
{{- if .HostServer}}
|
||||
# On the host's network, listening on loopback only, beside the server.
|
||||
network_mode: host
|
||||
{{- else}}
|
||||
ports:
|
||||
- "{{.WebmailBind}}:8080"
|
||||
{{- end}}
|
||||
environment:
|
||||
{{- if .HostServer}}
|
||||
HOST: 127.0.0.1
|
||||
PORT: "8080"
|
||||
MAIL_SERVER_URL: http://127.0.0.1:8081
|
||||
{{- else}}
|
||||
MAIL_SERVER_URL: http://server:8080
|
||||
{{- end}}
|
||||
APP_SECRET: ${APP_SECRET:?APP_SECRET is missing from .env}
|
||||
APP_NAME: inbuxa
|
||||
IMMUTABLE: "1"
|
||||
@@ -106,20 +130,30 @@ services:
|
||||
# is not the webmail.
|
||||
PUSH_URL: {{.WebmailURL}}
|
||||
{{- end}}
|
||||
{{- if not .HostServer}}
|
||||
networks:
|
||||
stack:
|
||||
ipv4_address: {{.WebmailIP}}
|
||||
{{- end}}
|
||||
{{- end}}
|
||||
{{- if .Proxy}}
|
||||
|
||||
caddy:
|
||||
image: {{.CaddyImage}}
|
||||
restart: unless-stopped
|
||||
{{- if .Server}}
|
||||
depends_on: [server]
|
||||
{{- end}}
|
||||
{{- if .HostServer}}
|
||||
# On the host's network: it holds 80 and 443 itself, and reaches the
|
||||
# server, the webmail and the console on loopback.
|
||||
network_mode: host
|
||||
{{- else}}
|
||||
ports:
|
||||
- "80:80"
|
||||
- "443:443"
|
||||
- "443:443/udp"
|
||||
{{- end}}
|
||||
volumes:
|
||||
- ./Caddyfile:/etc/caddy/Caddyfile:ro
|
||||
- caddy-data:/data
|
||||
@@ -127,20 +161,28 @@ services:
|
||||
{{- if .ACMECARoot}}
|
||||
- ./acme-ca-root.pem:/etc/caddy/acme-ca-root.pem:ro
|
||||
{{- end}}
|
||||
{{- if not .HostServer}}
|
||||
networks:
|
||||
stack:
|
||||
ipv4_address: {{.CaddyIP}}
|
||||
{{- end}}
|
||||
{{- end}}
|
||||
{{- if or .Server .Console}}
|
||||
|
||||
networks:
|
||||
stack:
|
||||
ipam:
|
||||
config:
|
||||
- subnet: {{.Subnet}}
|
||||
{{- end}}
|
||||
{{- if or .Server .Proxy}}
|
||||
|
||||
volumes:
|
||||
{{- end}}
|
||||
{{- if .Server}}
|
||||
inbuxa-etc:
|
||||
inbuxa-data:
|
||||
{{- end}}
|
||||
{{- if .Proxy}}
|
||||
# Certificates and the ACME account. Losing this means asking for every
|
||||
# certificate again, which is how rate limits are reached.
|
||||
|
||||
@@ -333,6 +333,14 @@ func Fixable(needs []Need) bool {
|
||||
return len(needs) > 0
|
||||
}
|
||||
|
||||
// FetchVerified downloads url to dest, and puts it there only when its
|
||||
// SHA-256 is want. It is how everything this program installs from the
|
||||
// network arrives: against a checksum written into the source, never one
|
||||
// fetched from beside the download.
|
||||
func FetchVerified(ctx context.Context, log io.Writer, url, want, dest string, mode os.FileMode) error {
|
||||
return fetchVerified(ctx, log, url, want, dest, mode)
|
||||
}
|
||||
|
||||
func fetchVerified(ctx context.Context, log io.Writer, url, want, dest string, mode os.FileMode) error {
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
|
||||
if err != nil {
|
||||
|
||||
@@ -17,6 +17,7 @@ package discover
|
||||
import (
|
||||
"context"
|
||||
"os"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"regexp"
|
||||
"strings"
|
||||
@@ -35,6 +36,22 @@ type Found struct {
|
||||
Runtime string // what is running them
|
||||
Proxy bool // the deployment includes a proxy
|
||||
Credential bool // credentials.txt is there
|
||||
HostServer bool // the server runs on the host, under systemd
|
||||
}
|
||||
|
||||
// HostServerUnit is the unit a host install of the server runs as.
|
||||
const (
|
||||
HostServerUnit = "inbuxa-server.service"
|
||||
HostServerUnitPath = "/etc/systemd/system/" + HostServerUnit
|
||||
)
|
||||
|
||||
// HostServer is whether the server is installed here as a host install, and
|
||||
// whether systemd has it running.
|
||||
func HostServer(ctx context.Context) (installed, active bool) {
|
||||
if _, err := os.Stat(HostServerUnitPath); err != nil {
|
||||
return false, false
|
||||
}
|
||||
return true, exec.CommandContext(ctx, "systemctl", "is-active", "--quiet", HostServerUnit).Run() == nil
|
||||
}
|
||||
|
||||
// Dirs are where a deployment may be. The first is what this installer
|
||||
@@ -52,10 +69,16 @@ func Run(ctx context.Context, f host.Facts, dirs ...string) Found {
|
||||
if len(dirs) == 0 {
|
||||
dirs = Dirs
|
||||
}
|
||||
// A server on the host is in no compose file: systemd is what knows.
|
||||
if installed, active := HostServer(ctx); installed {
|
||||
found.HostServer = true
|
||||
found.Services["server"] = map[bool]string{true: "running", false: "stopped"}[active]
|
||||
}
|
||||
for _, dir := range dirs {
|
||||
if _, err := os.Stat(filepath.Join(dir, "compose.yaml")); err == nil {
|
||||
found.Dir = dir
|
||||
break
|
||||
for _, marker := range []string{"compose.yaml", "server.env"} {
|
||||
if _, err := os.Stat(filepath.Join(dir, marker)); err == nil && found.Dir == "" {
|
||||
found.Dir = dir
|
||||
}
|
||||
}
|
||||
}
|
||||
if found.Dir == "" {
|
||||
@@ -68,6 +91,7 @@ func Run(ctx context.Context, f host.Facts, dirs ...string) Found {
|
||||
|
||||
b, err := os.ReadFile(filepath.Join(found.Dir, "compose.yaml"))
|
||||
if err != nil {
|
||||
// A server on the host with nothing beside it has no compose file.
|
||||
return found
|
||||
}
|
||||
text := string(b)
|
||||
|
||||
@@ -51,7 +51,7 @@ func TestBootstrapReturnsTheAdministrator(t *testing.T) {
|
||||
c, seen := fake(t, map[string]string{
|
||||
"x:Bootstrap/set": `{"methodResponses":[["x:Bootstrap/set",{"updated":{"singleton":{"username":"[email protected]","secret":"s3cret"}}},"0"]]}`,
|
||||
})
|
||||
a, err := c.Bootstrap(context.Background(), "mail.example.com", "example.com")
|
||||
a, err := c.Bootstrap(context.Background(), "mail.example.com", "example.com", "")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
@@ -154,3 +154,72 @@ func TestBearerReplacesBasic(t *testing.T) {
|
||||
t.Fatal("a wrong token was accepted: the password must not be sent alongside it")
|
||||
}
|
||||
}
|
||||
|
||||
func TestBootstrapOnTheHostNamesItsDataDirectory(t *testing.T) {
|
||||
c, seen := fake(t, map[string]string{
|
||||
"x:Bootstrap/set": `{"methodResponses":[["x:Bootstrap/set",{"updated":{"singleton":{"username":"[email protected]","secret":"s3cret"}}},"0"]]}`,
|
||||
})
|
||||
if _, err := c.Bootstrap(context.Background(), "mail.example.com", "example.com", "/var/lib/inbuxa/server/data/"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
update := (*seen)[0]["args"].(map[string]any)["update"].(map[string]any)["singleton"].(map[string]any)
|
||||
store, _ := update["dataStore"].(map[string]any)
|
||||
if store["@type"] != "RocksDb" || store["path"] != "/var/lib/inbuxa/server/data/" {
|
||||
t.Errorf("dataStore = %v", update["dataStore"])
|
||||
}
|
||||
}
|
||||
|
||||
const defaultListeners = `{"methodResponses":[
|
||||
["x:NetworkListener/query",{"ids":["a","b","c"]},"0"],
|
||||
["x:NetworkListener/get",{"list":[
|
||||
{"id":"a","name":"smtp","protocol":"smtp","tlsImplicit":false,"bind":{"[::]:25":true}},
|
||||
{"id":"b","name":"https","protocol":"http","tlsImplicit":true,"bind":{"[::]:443":true}},
|
||||
{"id":"c","name":"http","protocol":"http","tlsImplicit":false,"bind":{"[::]:8080":true}}
|
||||
]},"1"]]}`
|
||||
|
||||
func TestHostListenersMoveHTTPAndLeave443ToTheProxy(t *testing.T) {
|
||||
c, seen := fake(t, map[string]string{
|
||||
"x:NetworkListener/query": defaultListeners,
|
||||
"x:NetworkListener/set": `{"methodResponses":[["x:NetworkListener/set",{"updated":{"c":null},"destroyed":["b"]},"0"]]}`,
|
||||
})
|
||||
if err := c.HostListeners(context.Background(), "127.0.0.1:8081", false); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
args := (*seen)[1]["args"].(map[string]any)
|
||||
update := args["update"].(map[string]any)
|
||||
if len(update) != 1 {
|
||||
t.Fatalf("updated %v, want only the plain HTTP listener", update)
|
||||
}
|
||||
bind := update["c"].(map[string]any)["bind"].(map[string]any)
|
||||
if len(bind) != 1 || bind["127.0.0.1:8081"] != true {
|
||||
t.Errorf("http bind = %v", bind)
|
||||
}
|
||||
if d := args["destroy"].([]any); len(d) != 1 || d[0] != "b" {
|
||||
t.Errorf("destroy = %v, want the HTTPS listener", d)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHostListenersOnLoopbackForALocalInstall(t *testing.T) {
|
||||
c, seen := fake(t, map[string]string{
|
||||
"x:NetworkListener/query": defaultListeners,
|
||||
"x:NetworkListener/set": `{"methodResponses":[["x:NetworkListener/set",{"updated":{"a":null,"c":null},"destroyed":["b"]},"0"]]}`,
|
||||
})
|
||||
if err := c.HostListeners(context.Background(), "127.0.0.1:8081", true); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
update := (*seen)[1]["args"].(map[string]any)["update"].(map[string]any)
|
||||
bind := update["a"].(map[string]any)["bind"].(map[string]any)
|
||||
if len(bind) != 1 || bind["127.0.0.1:25"] != true {
|
||||
t.Errorf("smtp bind = %v, want loopback", bind)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHostListenersRefusalIsAnError(t *testing.T) {
|
||||
c, _ := fake(t, map[string]string{
|
||||
"x:NetworkListener/query": defaultListeners,
|
||||
"x:NetworkListener/set": `{"methodResponses":[["x:NetworkListener/set",{"notDestroyed":{"b":{"type":"forbidden","description":"no"}}},"0"]]}`,
|
||||
})
|
||||
if err := c.HostListeners(context.Background(), "127.0.0.1:8081", false); err == nil {
|
||||
t.Fatal("a refused destroy was not reported")
|
||||
}
|
||||
}
|
||||
+94
-1
@@ -12,6 +12,7 @@ import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
@@ -40,7 +41,12 @@ func (c *Client) CheckBootstrapMode(ctx context.Context) error {
|
||||
// Bootstrap completes the setup wizard the web UI would otherwise walk someone
|
||||
// through, and returns the administrator it creates. The temporary bootstrap
|
||||
// account stops working once the server restarts out of bootstrap mode.
|
||||
func (c *Client) Bootstrap(ctx context.Context, hostname, domain string) (Admin, error) {
|
||||
//
|
||||
// dataPath is where the built-in store keeps its files. Empty leaves the
|
||||
// server's default, /var/lib/inbuxa/, which is the image's data volume; a
|
||||
// server on the host is given a directory of its own, so its store does not
|
||||
// share a directory with the deployment's files.
|
||||
func (c *Client) Bootstrap(ctx context.Context, hostname, domain, dataPath string) (Admin, error) {
|
||||
update := map[string]any{
|
||||
"serverHostname": hostname,
|
||||
"defaultDomain": domain,
|
||||
@@ -57,6 +63,9 @@ func (c *Client) Bootstrap(ctx context.Context, hostname, domain string) (Admin,
|
||||
"events": map[string]any{}, "eventsPolicy": "exclude",
|
||||
},
|
||||
}
|
||||
if dataPath != "" {
|
||||
update["dataStore"] = map[string]any{"@type": "RocksDb", "path": dataPath}
|
||||
}
|
||||
rs, err := c.Do(ctx, Call{"x:Bootstrap/set", map[string]any{"update": map[string]any{"singleton": update}}, "0"})
|
||||
if err != nil {
|
||||
return Admin{}, err
|
||||
@@ -331,3 +340,87 @@ func (c *Client) DNSZone(ctx context.Context, domainID string) (string, error) {
|
||||
}
|
||||
return got.List[0].DNSZoneFile, nil
|
||||
}
|
||||
|
||||
// Listener is one of the server's network listeners, as much of it as
|
||||
// HostListeners needs to tell them apart.
|
||||
type Listener struct {
|
||||
ID string `json:"id"`
|
||||
Name string `json:"name"`
|
||||
Protocol string `json:"protocol"`
|
||||
TLSImplicit bool `json:"tlsImplicit"`
|
||||
Bind map[string]bool `json:"bind"`
|
||||
}
|
||||
|
||||
// Listeners lists the server's network listeners.
|
||||
func (c *Client) Listeners(ctx context.Context) ([]Listener, error) {
|
||||
rs, err := c.Do(ctx,
|
||||
Call{"x:NetworkListener/query", map[string]any{}, "0"},
|
||||
Call{"x:NetworkListener/get", map[string]any{
|
||||
"#ids": map[string]any{"resultOf": "0", "name": "x:NetworkListener/query", "path": "/ids"},
|
||||
"properties": []string{"name", "protocol", "tlsImplicit", "bind"},
|
||||
}, "1"},
|
||||
)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var got struct {
|
||||
List []Listener `json:"list"`
|
||||
}
|
||||
return got.List, json.Unmarshal(rs[1].Args, &got)
|
||||
}
|
||||
|
||||
// HostListeners fits the listeners a server creates on its first configured
|
||||
// start to a server running on the host rather than in a container.
|
||||
//
|
||||
// In a container they are all on [::] inside the container, and only what
|
||||
// the compose file publishes is reachable. On the host there is nothing in
|
||||
// between, so the defaults would put plain HTTP on every interface at 8080,
|
||||
// where the webmail listens, and take 443, which belongs to the proxy. So:
|
||||
//
|
||||
// - plain HTTP moves to httpBind, on loopback, where the proxy and the
|
||||
// webmail reach it -- the same place a container install publishes it;
|
||||
// - the server's own HTTPS listener goes: the proxy terminates TLS for the
|
||||
// server's names, as it does in front of a container;
|
||||
// - with local, every other listener moves to loopback too, since a
|
||||
// loopback evaluation publishes nothing.
|
||||
//
|
||||
// It takes effect at the next restart.
|
||||
func (c *Client) HostListeners(ctx context.Context, httpBind string, local bool) error {
|
||||
ls, err := c.Listeners(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
update, destroy := map[string]any{}, []string{}
|
||||
for _, l := range ls {
|
||||
switch {
|
||||
case l.Protocol == "http" && l.TLSImplicit:
|
||||
destroy = append(destroy, l.ID)
|
||||
case l.Protocol == "http":
|
||||
update[l.ID] = map[string]any{"bind": map[string]bool{httpBind: true}}
|
||||
case local:
|
||||
binds := map[string]bool{}
|
||||
for addr := range l.Bind {
|
||||
if i := strings.LastIndex(addr, ":"); i >= 0 {
|
||||
binds["127.0.0.1"+addr[i:]] = true
|
||||
}
|
||||
}
|
||||
update[l.ID] = map[string]any{"bind": binds}
|
||||
}
|
||||
}
|
||||
if len(update) == 0 && len(destroy) == 0 {
|
||||
return nil
|
||||
}
|
||||
args := map[string]any{}
|
||||
if len(update) > 0 {
|
||||
args["update"] = update
|
||||
}
|
||||
if len(destroy) > 0 {
|
||||
args["destroy"] = destroy
|
||||
}
|
||||
rs, err := c.Do(ctx, Call{"x:NetworkListener/set", args, "0"})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
_, err = DecodeSet(rs[0])
|
||||
return err
|
||||
}
|
||||
+17
-4
@@ -11,10 +11,12 @@ package plan
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"runtime"
|
||||
"strings"
|
||||
|
||||
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/deps"
|
||||
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/host"
|
||||
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/release"
|
||||
)
|
||||
|
||||
// Component is one of the three programs.
|
||||
@@ -157,6 +159,10 @@ func Available(f host.Facts, c Component, s Shape) Availability {
|
||||
case Server:
|
||||
// The binary is downloaded, not built here, so the machine has
|
||||
// to be able to run it.
|
||||
if _, ok := release.ServerSHA256[runtime.GOARCH]; !ok {
|
||||
return Availability{Why: fmt.Sprintf("inbuxa-server %s has no release binary for %s; run the server as a container here",
|
||||
release.ServerVersion, runtime.GOARCH)}
|
||||
}
|
||||
if f.Glibc.Version == "" {
|
||||
return Availability{Why: "this machine's C library could not be read, and the server binary is linked against glibc " +
|
||||
fmt.Sprintf("%d.%d", ServerGlibcMajor, ServerGlibcMinor)}
|
||||
@@ -225,6 +231,11 @@ func Build(f host.Facts, o Options) (Plan, error) {
|
||||
if chosen == 0 {
|
||||
return p, fmt.Errorf("nothing chosen: pick at least one component")
|
||||
}
|
||||
// The proxy the installer manages is Caddy in a container, whatever the
|
||||
// server is: a server on the host still needs a runtime for it.
|
||||
if !o.Local && o.Proxy == "caddy" {
|
||||
wantContainers = true
|
||||
}
|
||||
|
||||
// What is missing is not the same as what is impossible. Docker absent on
|
||||
// a Debian machine is one package and a service; Node too old is a pinned
|
||||
@@ -286,7 +297,7 @@ func Build(f host.Facts, o Options) (Plan, error) {
|
||||
p.Steps = append(p.Steps, Step{
|
||||
Title: "Start the mail server as a container",
|
||||
Detail: []string{
|
||||
"image: registry.coffeylabs.org/inbuxa/inbuxa-server (pinned to a release tag)",
|
||||
"image: " + release.ServerImage,
|
||||
"volumes: inbuxa-data, inbuxa-etc",
|
||||
"ports: 25, 465, 993, 995, 4190, and 8081 on loopback for the proxy",
|
||||
},
|
||||
@@ -295,9 +306,11 @@ func Build(f host.Facts, o Options) (Plan, error) {
|
||||
p.Steps = append(p.Steps, Step{
|
||||
Title: "Install the mail server on this machine",
|
||||
Detail: []string{
|
||||
"binary: /usr/local/bin/inbuxa-server, from the release on git.coffeylabs.org",
|
||||
"user: inbuxa (system, no login), data in " + o.Dir + "/server",
|
||||
"unit: /etc/systemd/system/inbuxa-server.service",
|
||||
fmt.Sprintf("binary: /usr/local/bin/inbuxa-server, release %s for %s, checked against its pinned checksum",
|
||||
release.ServerVersion, runtime.GOARCH),
|
||||
"user: inbuxa (system, no login); configuration and data in " + o.Dir + "/server",
|
||||
"unit: /etc/systemd/system/inbuxa-server.service, its environment in " + o.Dir + "/server.env",
|
||||
"during setup it is reachable from this machine only; then its plain HTTP moves to 127.0.0.1:8081 and 443 is left to the proxy",
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
@@ -0,0 +1,33 @@
|
||||
// SPDX-FileCopyrightText: 2026 Coffey Labs LLC
|
||||
// SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
|
||||
// Package release is which version of the mail server this installer puts on
|
||||
// a machine, as an image or as a binary, and what that binary must hash to.
|
||||
//
|
||||
// One version for both shapes, so a server moved from a container to the host
|
||||
// is the same program, and the plan, the image tag and the download cannot
|
||||
// name three different releases.
|
||||
package release
|
||||
|
||||
import "fmt"
|
||||
|
||||
// ServerVersion is the inbuxa-server release this installer installs.
|
||||
const ServerVersion = "2026.10.10.1"
|
||||
|
||||
// ServerImage is that release as a container image.
|
||||
const ServerImage = "registry.coffeylabs.org/inbuxa/inbuxa-server:" + ServerVersion
|
||||
|
||||
// ServerSHA256 is the SHA-256 of each architecture's release tarball, copied
|
||||
// from the release's SHA256SUMS when the version was moved and checked here
|
||||
// rather than fetched beside the download: a checksum that arrives with the
|
||||
// file only proves the file arrived.
|
||||
var ServerSHA256 = map[string]string{
|
||||
"amd64": "118087b0f7c98d326e3622a1732d733d1869c8b9210cc8a4eeb5c7101009daa5",
|
||||
"arm64": "128c1234032bf4806e44285271469db6eba246f8944d474c92f9d3fdbbcd03f4",
|
||||
}
|
||||
|
||||
// ServerTarball is where the release's tarball for an architecture is.
|
||||
func ServerTarball(arch string) string {
|
||||
return fmt.Sprintf("https://git.coffeylabs.org/inbuxa/inbuxa-server/releases/download/v%s/inbuxa-linux-%s.tar.gz",
|
||||
ServerVersion, arch)
|
||||
}
|
||||
Reference in new issue
Block a user