From bef9f459a6c9c78e485cd93bbfbbb0f326119984 Mon Sep 17 00:00:00 2001 From: John Coffey Date: Wed, 14 Oct 2026 20:25:33 -0700 Subject: [PATCH] Move the server between a container and the host `install` run again with the other --server now moves the mail server, with its configuration and mail, instead of refusing ("not built yet"). - Needs an API key (--key - / INBUXA_API_KEY, never written down), as certs and join do: the server's listeners (jmap.HostListeners, and the new ContainerListeners) and its auto-ban exemptions change with the shape, and only the server changes those. - beginMove checks the key, stops what runs here and archives the data into /backups before anything of the new shape is written; finish copies it (renamed into place, or streamed into the volumes), rewrites the one path config.json names, starts the server in its new shape -- on the host first behind the loopback fence (modeFenced) until its listeners are fitted -- and checks it came back configured. - Copied, never moved: the volumes, or /server, stay where they were. Leftovers of an earlier install in the target are archived and emptied, never mixed in. A failure in finish, or anything stopping the run before it (abort), puts the old shape back. - The plan says when a run is a move. `apply -f` moves too. e2e/cases/move-server.sh: 56/56 (no key and a wrong key change nothing; a broken host binary puts the container back; container -> host -> container keeping an account and IMAP sign-in, front ends answering, status agreeing). install-host.sh expects the key refusal in place of "not built yet": 44/44; uninstall-host 14/14, rerun-host-server 12/12. --- README.md | 16 +- cmd/inbuxa/main.go | 44 +++ e2e/cases/install-host.sh | 6 +- e2e/cases/move-server.sh | 151 +++++++++ internal/apply/apply.go | 26 +- internal/apply/hostserver.go | 8 +- internal/apply/move.go | 594 +++++++++++++++++++++++++++++++++++ internal/apply/move_test.go | 110 +++++++ internal/jmap/setup.go | 62 ++++ internal/plan/plan.go | 3 + 10 files changed, 1011 insertions(+), 9 deletions(-) create mode 100755 e2e/cases/move-server.sh create mode 100644 internal/apply/move.go create mode 100644 internal/apply/move_test.go diff --git a/README.md b/README.md index a50ba4c..7a8a2d7 100644 --- a/README.md +++ b/README.md @@ -152,8 +152,19 @@ 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: 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. +- **Moving the server** -- `install` run again with the other `--server` + moves the mail server between a container and the host, with its + configuration and mail. It needs an API key made in the console (`--key -` + or `INBUXA_API_KEY`; never written down), because the server's listeners + and its auto-ban exemptions change with the shape. Everything here stops + for a minute or two. The data is archived into `/backups` first and + then copied, never moved: the old copy -- the volumes, or `/server` -- + stays where it was until you delete it, and a failure on the way puts the + server back as it was. The interface doesn't offer it yet: it has no key + to give. + +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 @@ -209,6 +220,7 @@ is tested on a throwaway virtual machine rather than on anybody's desk: e2e/vm/run.sh e2e/cases/uninstall-containers.sh uninstalled, installed again on the data, purged e2e/vm/run.sh e2e/cases/uninstall-host.sh the same with the server and the webmail on the host e2e/vm/run.sh e2e/cases/certs.sh a failed order, reported, then fixed with a key + e2e/vm/run.sh e2e/cases/move-server.sh the server into the host and back, keeping its mail 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= e2e/vm/run.sh e2e/cases/upgrade-volumes.sh diff --git a/cmd/inbuxa/main.go b/cmd/inbuxa/main.go index 3e0d7ec..822bf2e 100644 --- a/cmd/inbuxa/main.go +++ b/cmd/inbuxa/main.go @@ -77,6 +77,11 @@ install flags: are made to trust --install-deps install what the chosen shapes need and this machine lacks, rather than refusing over it + --key KEY an API key made in the console, needed only to + move the server between a container and the host + (run install again with the other --server); + "-" reads it from standard input, and + INBUXA_API_KEY works too --dry-run print the plan and stop --yes do not ask for confirmation @@ -177,6 +182,7 @@ func install(args []string) int { webmail = fs.String("webmail", "container", "") dryRun = fs.Bool("dry-run", false, "") yes = fs.Bool("yes", false, "") + key = fs.String("key", os.Getenv("INBUXA_API_KEY"), "") ) fs.StringVar(&o.Domain, "domain", "", "") fs.StringVar(&o.MailHost, "mail-host", "", "") @@ -212,6 +218,13 @@ func install(args []string) int { return 1 } fmt.Print(p.String()) + moving := false + if st, err := state.Load(); err == nil { + if from, ok := apply.MovingServer(st, p.Options); ok { + moving = true + fmt.Print("\n" + apply.MoveNote(from, p.Options.Shape(plan.Server))) + } + } if *dryRun { return 0 } @@ -219,6 +232,14 @@ func install(args []string) int { fmt.Fprintln(os.Stderr, "\nNothing has happened yet. Pass --yes to carry this out.") return 1 } + if moving { + k, err := readKey(*key) + if err != nil { + fmt.Fprintln(os.Stderr, err.Error()) + return 2 + } + p.Options.Key = k + } fmt.Println("\nApplying:") log := &printer{} @@ -522,6 +543,7 @@ func topologyCmd(args []string, doIt bool) int { machineName = fs.String("machine", "", "") yes = fs.Bool("yes", false, "") installDeps = fs.Bool("install-deps", false, "") + key = fs.String("key", os.Getenv("INBUXA_API_KEY"), "") ) if err := fs.Parse(args); err != nil { return 2 @@ -598,6 +620,15 @@ func topologyCmd(args []string, doIt bool) int { fmt.Fprintln(os.Stderr, "\ncannot apply this file here: "+err.Error()) return 1 } + if from, ok := apply.MovingServer(st, p.Options); ok { + fmt.Print("\n" + apply.MoveNote(from, p.Options.Shape(plan.Server))) + k, err := readKey(*key) + if err != nil { + fmt.Fprintln(os.Stderr, err.Error()) + return 2 + } + p.Options.Key = k + } fmt.Println("\nApplying:") log := &printer{} res, err := apply.Run(context.Background(), p, f, log) @@ -1077,3 +1108,16 @@ func shape(s string) (plan.Shape, error) { // render is the first screen, as text: what this machine is, and what that // allows. The interface's first screen is the same text. func render(f host.Facts) string { return plan.SurveyText(f) } + +// readKey is an API key given as --key: "-" reads it from standard input, +// so it stays out of the shell's history. +func readKey(key string) (string, error) { + if key != "-" { + return key, nil + } + line, err := bufio.NewReader(os.Stdin).ReadString('\n') + if err != nil && line == "" { + return "", fmt.Errorf("reading the key from standard input: %w", err) + } + return strings.TrimSpace(line), nil +} diff --git a/e2e/cases/install-host.sh b/e2e/cases/install-host.sh index 7d4007b..5a7d397 100644 --- a/e2e/cases/install-host.sh +++ b/e2e/cases/install-host.sh @@ -124,8 +124,10 @@ OUT="$(/tmp/inbuxa install --local --domain example.test --server host --yes 2>& 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" +# The move itself is move-server.sh's; without a key it changes nothing. +OUT="$(INBUXA_API_KEY= /tmp/inbuxa install --local --domain example.test --server container --yes 2>&1)"; rc=$? +[ $rc -ne 0 ] && grep -q "API key is needed" <<<"$OUT" && ok "moving the server into a container without a key is refused, with the reason" || bad "a move without a key was not refused: exit $rc" +systemctl is-active --quiet inbuxa-server && ok "and the server is still on the host" || bad "the server stopped" echo echo "==> a server without its configuration stays down" diff --git a/e2e/cases/move-server.sh b/e2e/cases/move-server.sh new file mode 100755 index 0000000..6e5244d --- /dev/null +++ b/e2e/cases/move-server.sh @@ -0,0 +1,151 @@ +#!/bin/bash +# SPDX-FileCopyrightText: 2026 Coffey Labs LLC +# SPDX-License-Identifier: AGPL-3.0-or-later +# +# Moving the mail server between a container and the host by running install +# again with the other --server: refused without a key and with a wrong one, +# changing nothing; put back when the host install fails before the move; +# then into the host and back into a container, each time keeping its +# accounts and mail, its front ends working, the old copy left in place and +# an archive taken first. +# +# Run from the host with: e2e/vm/run.sh e2e/cases/move-server.sh +set -uo pipefail + +pass=0; fail=0 +ok() { echo " ok $*"; pass=$((pass+1)); } +bad() { echo " FAIL $*"; fail=$((fail+1)); } + +DIR=/var/lib/inbuxa +SERVER=http://127.0.0.1:8081 +INSTALL=(/tmp/inbuxa install --local --domain example.test --install-deps) + +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 +} +jmap() { # jmap TOKEN-or-user:pass CAPABILITY JSON-CALLS + local auth + case "$1" in *:*) auth=(-u "$1") ;; *) auth=(-H "Authorization: Bearer $1") ;; esac + curl -s "${auth[@]}" -H 'Content-Type: application/json' \ + -d "{\"using\":[\"urn:ietf:params:jmap:core\",\"$2\"],\"methodCalls\":$3}" "$SERVER/jmap/" +} +live() { [ "$(curl -s -o /dev/null -w '%{http_code}' $SERVER/.well-known/jmap)" != 000 ]; } +wait_server() { for _ in $(seq 1 60); do live && return 0; sleep 2; done; return 1; } +in_container() { compose ps --status running --services 2>/dev/null | grep -qx server; } +on_host() { systemctl is-active --quiet inbuxa-server; } + +# The server keeps what it had: the account made before the move is still +# there, the first mailbox still signs in over IMAP, and the webmail and the +# console still answer. +kept() { + local where=$1 + wait_server && ok "$where: the server answers on $SERVER" || bad "$where: the server does not answer" + local got + got=$(jmap "$KEY" urn:inbuxa:jmap:registry '[["x:Account/get",{"ids":null,"properties":["name"]},"0"]]') + grep -q '"name":"movetest"' <<<"$got" && ok "$where: the account made before the move is there" || { bad "$where: movetest is gone"; head -c 300 <<<"$got" | sed 's/^/ /'; } + # A --local container install publishes no mail ports, so IMAP is asked + # from inside the server's own network there; on the host it is on loopback. + local imap=(curl -sk --max-time 10 "imaps://127.0.0.1:993/" -u "$FIRST:$FIRSTPASS") + if in_container; then + imap=($(rt) run --rm --network "container:$(compose ps -q server)" docker.io/curlimages/curl:8.11.1 "${imap[@]:1}") + fi + "${imap[@]}" 2>/dev/null | grep -q INBOX \ + && ok "$where: $FIRST signs in over IMAP and sees its INBOX" || bad "$where: IMAP sign-in for $FIRST failed" + curl -s --max-time 10 http://127.0.0.1:8080/api/health | grep -q '"ok":true' \ + && ok "$where: the webmail answers" || bad "$where: the webmail does not answer" + curl -s --max-time 10 http://127.0.0.1:8082/ | grep -q api-base-url \ + && ok "$where: the console answers" || bad "$where: the console does not answer" + /tmp/inbuxa status >/dev/null 2>&1 && ok "$where: status agrees with what runs" || bad "$where: status disagrees: $(/tmp/inbuxa status 2>&1 | tail -3)" +} + +echo "==> all three in containers" +OUT="$("${INSTALL[@]}" --yes 2>&1)"; rc=$? +[ $rc -eq 0 ] && ok "installed" || { bad "install exit $rc"; echo "$OUT" | tail -12 | sed 's/^/ /'; exit 1; } +FIRST=$(awk '/^first mailbox/ {print $3}' "$DIR/credentials.txt") +FIRSTPASS=$(awk '/^first mailbox/{getline; print $2}' "$DIR/credentials.txt") +[ -n "$FIRST" ] && [ -n "$FIRSTPASS" ] || bad "no first mailbox in credentials.txt" + +echo +echo "==> an API key, as an administrator makes one in the console" +# The console is a browser; here the server takes the administrator's +# password for one restart, the way the installer's own setup does. +AUSER=$(awk '/^administrator/ {print $2}' "$DIR/credentials.txt") +APASS=$(awk '/^administrator/{getline; print $2}' "$DIR/credentials.txt") +printf 'services:\n server:\n environment:\n INBUXA_HTTP_BASIC_AUTH: all\n' > /tmp/basic.yaml +compose -f /tmp/basic.yaml up -d server >/dev/null 2>&1; wait_server +EXPIRES=$(date -u -d '+1 hour' +%Y-%m-%dT%H:%M:%SZ) +ANSWER=$(jmap "$AUSER:$APASS" urn:inbuxa:jmap:registry "[[\"x:ApiKey/set\",{\"create\":{\"k\":{\"description\":\"move test\",\"expiresAt\":\"$EXPIRES\",\"permissions\":{\"@type\":\"Inherit\"}}}},\"0\"]]") +KEY=$(sed -n 's/.*"secret":"\([^"]*\)".*/\1/p' <<<"$ANSWER") +compose up -d server >/dev/null 2>&1; wait_server +[ -n "$KEY" ] && ok "an API key for the administrator" || { bad "no API key"; head -c 300 <<<"$ANSWER" | sed 's/^/ /'; exit 1; } +DOMAIN_ID=$(jmap "$KEY" urn:inbuxa:jmap:registry '[["x:Domain/query",{},"0"]]' | sed -n 's/.*"ids":\["\([^"]*\)".*/\1/p') +MADE=$(jmap "$KEY" urn:inbuxa:jmap:registry "[[\"x:Account/set\",{\"create\":{\"u\":{\"@type\":\"User\",\"name\":\"movetest\",\"domainId\":\"$DOMAIN_ID\",\"description\":null,\"credentials\":{\"0\":{\"@type\":\"Password\",\"secret\":\"move-test-pass-4410\"}},\"roles\":{\"@type\":\"User\"},\"permissions\":{\"@type\":\"Inherit\"},\"quotas\":{},\"aliases\":{},\"memberGroupIds\":{},\"encryptionAtRest\":{\"@type\":\"Disabled\"}}}},\"0\"]]") +grep -q '"created"' <<<"$MADE" && ok "an account to look for after the move" || { bad "no movetest account"; head -c 300 <<<"$MADE" | sed 's/^/ /'; } +kept "in a container" + +echo +echo "==> asked to move, without a key or with a wrong one: nothing changes" +OUT="$("${INSTALL[@]}" --server host --dry-run 2>&1)" +grep -q "Moving the mail server from a container install to a host install" <<<"$OUT" \ + && ok "the plan says it is a move" || bad "the plan says nothing of a move" +OUT="$(INBUXA_API_KEY= "${INSTALL[@]}" --server host --yes 2>&1)"; rc=$? +[ $rc -ne 0 ] && grep -q "API key is needed" <<<"$OUT" && ok "without a key it stops and says one is needed" || { bad "no key: exit $rc"; echo "$OUT" | tail -4 | sed 's/^/ /'; } +in_container && ! on_host && live && ok "the server is still in its container" || bad "the server moved or stopped without a key" +OUT="$(INBUXA_API_KEY=wrong-key "${INSTALL[@]}" --server host --yes 2>&1)"; rc=$? +[ $rc -ne 0 ] && grep -q "didn't take the API key" <<<"$OUT" && ok "a wrong key is refused, and says so" || { bad "wrong key: exit $rc"; echo "$OUT" | tail -4 | sed 's/^/ /'; } +in_container && ! on_host && live && ok "the server is still in its container" || bad "the server moved or stopped with a wrong key" + +echo +echo "==> a host install that fails before the move puts the container back" +printf '#!/bin/sh\necho "inbuxa 9.9.9 (broken)"\nexit 1\n' > /tmp/broken-server; chmod +x /tmp/broken-server +OUT="$(echo "$KEY" | INBUXA_SERVER_BINARY=/tmp/broken-server "${INSTALL[@]}" --server host --key - --yes 2>&1)"; rc=$? +[ $rc -ne 0 ] && grep -q "putting it back in its container" <<<"$OUT" && ok "it stopped and put the server back" || { bad "broken binary: exit $rc"; echo "$OUT" | tail -6 | sed 's/^/ /'; } +in_container && ! on_host && ok "the server is in its container again" || bad "not back in its container" +grep -q '"server": "container"' /etc/inbuxa/install.json && ok "the install record still says container" || bad "the record changed: $(grep -o '"server": "[a-z]*"' /etc/inbuxa/install.json)" +kept "after the failed move" + +echo +echo "==> into the host" +OUT="$(echo "$KEY" | "${INSTALL[@]}" --server host --key - --yes 2>&1)"; rc=$? +echo "$OUT" | grep -v '^ |' | sed -n '/moving the mail server/,$p' | head -24 | sed 's/^/ /' +[ $rc -eq 0 ] && ok "moved (exit 0)" || { bad "move exit $rc"; journalctl -u inbuxa-server -n 30 --no-pager -o cat | sed 's/^/ | /'; } +on_host && ok "inbuxa-server is running on the host" || bad "inbuxa-server is not running" +in_container && bad "a server container still runs" || ok "no server container runs" +grep -q '"path":"/var/lib/inbuxa/server/data/"' $DIR/server/config.json && ok "its configuration points at $DIR/server/data/" || bad "config.json: $(cat $DIR/server/config.json)" +[ "$(stat -c %U $DIR/server/data)" = inbuxa ] && ok "its data belongs to the inbuxa user" || bad "data owned by $(stat -c %U $DIR/server/data)" +ls $DIR/backups/server-*.tar.gz >/dev/null 2>&1 && ok "the volumes were archived first" || bad "no archive" +$(rt) volume inspect inbuxa_inbuxa-data >/dev/null 2>&1 && ok "the volumes are left in place" || bad "the volumes are gone" +[ ! -e /run/systemd/system/inbuxa-server.service.d/inbuxa-setup.conf ] && ok "no loopback fence is left behind" || bad "the setup drop-in is still there" +ss -ltn | grep -q '0.0.0.0:8080 \|\[::\]:8080 ' && bad "the server's HTTP is on every interface" || ok "the server's HTTP is not on every interface" +grep -qF "$KEY" <<<"$(cat $DIR/* $DIR/server/*.json /etc/inbuxa/install.json 2>/dev/null)" && bad "the API key was written down" || ok "the API key was not kept" +grep -q '"server": "host"' /etc/inbuxa/install.json && ok "the install record says host" || bad "the record: $(grep -o '"server": "[a-z]*"' /etc/inbuxa/install.json)" +kept "on the host" +OUT="$("${INSTALL[@]}" --server host --yes 2>&1)"; rc=$? +[ $rc -eq 0 ] && ! grep -q "moving the mail server" <<<"$OUT" && ok "running it again is a converge, not another move" || bad "a second run: exit $rc" + +echo +echo "==> back into a container" +OUT="$(echo "$KEY" | "${INSTALL[@]}" --server container --key - --yes 2>&1)"; rc=$? +echo "$OUT" | grep -v '^ |' | sed -n '/moving the mail server/,$p' | head -24 | sed 's/^/ /' +[ $rc -eq 0 ] && ok "moved back (exit 0)" || { bad "move back exit $rc"; compose logs --tail 30 server 2>&1 | sed 's/^/ | /'; } +in_container && ok "the server runs in its container" || bad "no server container" +on_host && bad "inbuxa-server still runs on the host" || ok "inbuxa-server is not running on the host" +[ ! -e /etc/systemd/system/inbuxa-server.service ] && [ ! -e /usr/local/bin/inbuxa-server ] \ + && ok "the unit and the binary are gone" || bad "the host install's unit or binary is left" +CFG=$($(rt) run --rm --entrypoint cat -v inbuxa_inbuxa-etc:/etc/inbuxa "$(compose config --images | grep inbuxa-server)" /etc/inbuxa/config.json 2>/dev/null) +grep -q '"path":"/var/lib/inbuxa/"' <<<"$CFG" && ok "its configuration points at /var/lib/inbuxa/ again" || bad "config.json in the volume: $CFG" +ls $DIR/backups/server-host-*.tar.gz >/dev/null 2>&1 && ok "the host copy was archived first" || bad "no archive of the host copy" +grep -q "earlier install" <<<"$OUT" && ok "the volumes' older data was archived, not mixed in" || bad "nothing said about the volumes' older data" +[ -d $DIR/server/data ] && ok "$DIR/server is left in place" || bad "$DIR/server is gone" +grep -q '"server": "container"' /etc/inbuxa/install.json && ok "the install record says container" || bad "the record: $(grep -o '"server": "[a-z]*"' /etc/inbuxa/install.json)" +kept "back in a container" + +echo +echo "==> $pass passed, $fail failed" +[ "$fail" -eq 0 ] diff --git a/internal/apply/apply.go b/internal/apply/apply.go index c12e348..31859a8 100644 --- a/internal/apply/apply.go +++ b/internal/apply/apply.go @@ -83,9 +83,9 @@ func Run(ctx context.Context, p plan.Plan, f host.Facts, log Log) (*Result, erro 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)) + var moveFrom plan.Shape + if st, err := state.Load(); err == nil { + moveFrom, _ = MovingServer(st, o) } needContainers := !onHost || o.Shape(plan.Console) == plan.Container || o.Shape(plan.Webmail) == plan.Container || (!o.Local && o.Proxy == "caddy") @@ -108,6 +108,19 @@ func Run(ctx context.Context, p plan.Plan, f host.Facts, log Log) (*Result, erro } } + // A move stops the old shape and archives it before anything of the + // new one is written; it is carried out once that is in place. + var mv *serverMove + if moveFrom != "" { + var err error + if mv, err = beginMove(ctx, o, moveFrom, f, log); err != nil { + return nil, err + } + // Whatever stops this run before the move is carried out puts the + // old shape back; finish does its own putting back. + defer mv.abort(ctx) + } + dir := o.Dir stack := compose.Stack{ Version: "dev", @@ -275,6 +288,13 @@ 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() { + if mv != nil { + if err := mv.finish(ctx, stack, !o.Local && o.Proxy == "snippets"); err != nil { + return nil, err + } + // What it reads at start has been read: nothing more to restart for. + serverChanged = false + } res, err := converge(ctx, o, stack, cmp, hs, serverChanged, existing, f, log) if err == nil && hw != nil { // Its files may be new, or what it reads at start; or it may diff --git a/internal/apply/hostserver.go b/internal/apply/hostserver.go index 595523c..93222ac 100644 --- a/internal/apply/hostserver.go +++ b/internal/apply/hostserver.go @@ -61,6 +61,7 @@ const ( modeBootstrap setupMode = iota // the bootstrap credential, loopback only modeBasic // configured, passwords on /jmap, loopback only modeNormal // as it will run from now on + modeFenced // as it is, loopback only: a server moved here, until its listeners are fitted ) // hostServer is the server as a host install, rooted in the deployment @@ -243,8 +244,11 @@ func (h hostServer) Start(ctx context.Context, mode setupMode, bootPass string) os.Remove(setupEnvPath) default: env := "INBUXA_HTTP_BASIC_AUTH=all\n" - if mode == modeBootstrap { + switch mode { + case modeBootstrap: env = "INBUXA_RECOVERY_ADMIN=admin:" + bootPass + "\n" + case modeFenced: + env = "" } if err := os.WriteFile(setupEnvPath, []byte(env), 0o600); err != nil { return err @@ -252,7 +256,7 @@ func (h hostServer) Start(ctx context.Context, mode setupMode, bootPass string) 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" + + dropIn := "# The inbuxa installer, during first boot or a move only. Gone at the next reboot.\n" + "[Service]\n" + "EnvironmentFile=" + setupEnvPath + "\n" + "IPAddressAllow=localhost\n" + diff --git a/internal/apply/move.go b/internal/apply/move.go new file mode 100644 index 0000000..a4f5c62 --- /dev/null +++ b/internal/apply/move.go @@ -0,0 +1,594 @@ +// SPDX-FileCopyrightText: 2026 Coffey Labs LLC +// SPDX-License-Identifier: AGPL-3.0-or-later + +package apply + +// Moving the mail server between a container and the host, when `install` +// is run again with the other --server. +// +// Its configuration and mail go with it. Only one thing in them names a +// place on disk: config.json, the data store's own description, whose path +// is /var/lib/inbuxa/ in a container and /server/data/ on the host. +// That is rewritten in the copy. The rest of what differs between the two +// shapes is the server's own settings, which only the server can change, so +// a move needs an API key, as `certs` and `join` do: +// +// - its listeners: everything on [::] inside a container, plain HTTP on +// loopback and no HTTPS of its own on the host (jmap.HostListeners); +// - the addresses exempted from the auto-ban, which are where the front +// ends' requests arrive from: the project network's in a container, +// loopback on the host. +// +// Nothing is moved, only copied, and the original is left where it was: the +// volumes after a move to the host, /server after a move into a +// container. A failure on the way puts the server back as it was, and the +// archive taken first is in /backups either way. + +import ( + "context" + "encoding/json" + "errors" + "fmt" + "io" + "os" + "os/exec" + "path/filepath" + "strings" + "time" + + "git.coffeylabs.org/inbuxa/inbuxa-installer/internal/compose" + "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/state" +) + +const ( + containerDataPath = "/var/lib/inbuxa/" + containerUser = "2000:2000" // the image's inbuxa user + preMoveDir = ".pre-move" +) + +// ErrMoveNeedsKey is a move asked for without an API key. +var ErrMoveNeedsKey = errors.New("an API key is needed to move the server") + +// MovingServer says whether running install with these options moves the +// server between shapes, and from which. +func MovingServer(st *state.State, o plan.Options) (from plan.Shape, moving bool) { + // Not after an uninstall either: nothing runs to move, and install + // brings the recorded shape back, or sets up the new one, as it is told. + if st == nil || !st.Installed() || st.Removed() { + return "", false + } + was, wants := st.Shapes["server"], o.Shape(plan.Server) + if was == "" || wants == plan.Skip || was == string(wants) { + return "", false + } + return plan.Shape(was), true +} + +// MoveNote is what a plan says about a move before anything happens. +func MoveNote(from, to plan.Shape) string { + return fmt.Sprintf(`Moving the mail server from a %s install to a %s install: + - everything here stops while it moves, a minute or two + - its configuration and mail are archived into backups/ first, then copied + - its listeners and the auto-ban exemptions are changed for the new shape, + with an API key made in the console (--key - or INBUXA_API_KEY) + - the %s copy is left where it is; anything failing puts it back as it was +`, from, to, from) +} + +// serverMove is a move begun: the old shape stopped and archived, waiting +// for the new shape's files to be written before finish carries it out. +type serverMove struct { + from, to plan.Shape + dir string + key string + local bool + cmp docker.Compose + log Log + archive string // the archive taken before anything changed + oldImage string // the server image a container install ran + done bool // finish ran: the move happened, or it put things back itself +} + +// beginMove checks the key, stops what runs here and archives the server's +// data. Nothing of the new shape is written yet, so a failure here leaves +// the old one exactly as it was. +func beginMove(ctx context.Context, o plan.Options, from plan.Shape, f host.Facts, log Log) (*serverMove, error) { + to := o.Shape(plan.Server) + if o.Key == "" { + return nil, fmt.Errorf("%w from a %s install to a %s install, as its listeners change with it: "+ + "make one in the console (your account, API keys) and run this again with --key - "+ + "(or INBUXA_API_KEY); it isn't kept", ErrMoveNeedsKey, from, to) + } + docker.UseRuntime(f.Runtime) + m := &serverMove{from: from, to: to, dir: o.Dir, key: o.Key, local: o.Local, log: log, + cmp: docker.Compose{Dir: o.Dir, Runtime: f.Runtime}} + srv := &jmap.Client{BaseURL: "http://" + hostFinalBind, Token: o.Key} + if _, err := srv.Listeners(ctx); err != nil { + return nil, fmt.Errorf("the server on %s didn't take the API key, so nothing was changed: %w", hostFinalBind, err) + } + + log.Step("moving the mail server from a %s install to a %s install", from, to) + stamp := time.Now().UTC().Format("20060102T150405Z") + if err := os.MkdirAll(filepath.Join(m.dir, "backups"), 0o700); err != nil { + return nil, err + } + hasCompose := exists(filepath.Join(m.dir, "compose.yaml")) + + if from == plan.Container { + b, err := os.ReadFile(filepath.Join(m.dir, "compose.yaml")) + if err != nil { + return nil, err + } + tag := installedVersion(m.dir, plan.Server, plan.Container, string(b)) + m.oldImage = strings.TrimSuffix(DefaultServerImage, ":"+tagOf(DefaultServerImage)) + ":" + tag + // The deployment as it is, to put back: the new shape's files are + // written over these before the move is carried out. + if err := m.keepDeployment(); err != nil { + return nil, err + } + log.Info("stopping everything in containers here while the server moves") + if err := m.cmp.Run(ctx, "stop"); err != nil { + return nil, err + } + name, err := archiveVolumes(ctx, m.dir, tag) + if err != nil { + m.cmp.Run(ctx, "start") + return nil, fmt.Errorf("archiving the server's data, so nothing was changed: %w", err) + } + m.archive = name + log.Info("archived its configuration and data to %s", name) + return m, nil + } + + // From the host: archived while stopped, then started once more, as it + // was, to be given the listeners a container needs. They take effect at + // its next start, which is in the container. + if hasCompose { + if err := m.keepDeployment(); err != nil { + return nil, err + } + } + if err := runQuiet(ctx, "systemctl", "stop", HostServerUnit); err != nil { + return nil, err + } + m.archive = filepath.Join(m.dir, "backups", "server-host-"+stamp+".tar.gz") + if err := runQuiet(ctx, "tar", "-czf", m.archive, "-C", m.dir, "server"); err != nil { + runQuiet(ctx, "systemctl", "start", HostServerUnit) + return nil, fmt.Errorf("archiving the server's data, so nothing was changed: %w", err) + } + log.Info("archived its configuration and data to %s", m.archive) + if err := runQuiet(ctx, "systemctl", "start", HostServerUnit); err != nil { + return nil, err + } + 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 nil, withLogs(ctx, err, hostServer{deploy: m.dir}, "server") + } + if err := srv.ContainerListeners(ctx); err != nil { + return nil, m.restoreHost(ctx, fmt.Errorf("changing the server's listeners for a container: %w", err)) + } + log.Info("its listeners set for a container, from its next start") + log.Info("stopping everything here while the server moves") + if err := runQuiet(ctx, "systemctl", "disable", "--now", "--quiet", HostServerUnit); err != nil { + return nil, m.restoreHost(ctx, err) + } + if hasCompose { + m.cmp.Run(ctx, "stop") + } + return m, nil +} + +// abort puts the old shape back when the install stops between beginMove and +// finish, writing or fetching the new shape's pieces. +func (m *serverMove) abort(ctx context.Context) { + if m.done { + return + } + m.done = true + ctx = context.WithoutCancel(ctx) + if m.from == plan.Container { + m.log.Info("the move stopped before the server moved: putting it back in its container") + removeUnit(ctx, HostServerUnit, hostUnitPath) + m.putDeploymentBack(ctx) + return + } + m.log.Info("the move stopped before the server moved: putting it back on the host") + m.restoreHost(ctx, errors.New("aborted")) + m.putDeploymentBack(ctx) +} + +// keepDeployment copies the files the new shape is about to be written +// over, so a failed move can put them back. +func (m *serverMove) keepDeployment() error { + keep := filepath.Join(m.dir, preMoveDir) + os.RemoveAll(keep) + if err := os.MkdirAll(keep, 0o700); err != nil { + return err + } + for _, name := range []string{"compose.yaml", "Caddyfile"} { + b, err := os.ReadFile(filepath.Join(m.dir, name)) + if errors.Is(err, os.ErrNotExist) { + continue + } else if err != nil { + return err + } + if err := os.WriteFile(filepath.Join(keep, name), b, 0o640); err != nil { + return err + } + } + return nil +} + +// putDeploymentBack restores what keepDeployment kept, and starts it. +func (m *serverMove) putDeploymentBack(ctx context.Context) { + keep := filepath.Join(m.dir, preMoveDir) + for _, name := range []string{"compose.yaml", "Caddyfile"} { + if b, err := os.ReadFile(filepath.Join(keep, name)); err == nil { + os.WriteFile(filepath.Join(m.dir, name), b, 0o640) + } else { + os.Remove(filepath.Join(m.dir, name)) + } + } + if exists(filepath.Join(m.dir, "compose.yaml")) { + m.cmp.Run(ctx, "up", "-d", "--remove-orphans") + } +} + +// finish carries the move out once the new shape's deployment is written +// and, for the host, its binary, user, directories and environment are in +// place. The server answers in its new shape when it returns nil. +func (m *serverMove) finish(ctx context.Context, stack compose.Stack, snippets bool) error { + m.done = true + var err error + if m.to == plan.Host { + err = m.toHost(ctx, stack, snippets) + } else { + err = m.toContainer(ctx, stack, snippets) + } + if err == nil { + os.RemoveAll(filepath.Join(m.dir, preMoveDir)) + } + return err +} + +func (m *serverMove) toHost(ctx context.Context, stack compose.Stack, snippets bool) error { + hs := hostServer{deploy: m.dir, log: m.log} + back := func(why error) error { + m.log.Info("putting the server back in its container") + removeUnit(ctx, HostServerUnit, hostUnitPath) + os.Remove(setupDropIn) + os.Remove(setupEnvPath) + m.putDeploymentBack(ctx) + return fmt.Errorf("%w; the server is back in its container with its data as it was (archived in %s)", why, m.archive) + } + + m.log.Info("copying its configuration and mail into %s", hs.home()) + if err := m.clearForCopy(ctx, hs); err != nil { + return back(err) + } + stage, err := os.MkdirTemp(m.dir, ".move-") + if err != nil { + return back(err) + } + defer os.RemoveAll(stage) + out := exec.CommandContext(ctx, docker.CLI, "run", "--rm", "--user", "0", "--entrypoint", "tar", + "-v", "inbuxa_inbuxa-etc:/from/etc:ro", "-v", "inbuxa_inbuxa-data:/from/data:ro", + m.oldImage, "-cf", "-", "-C", "/from", ".") + in := exec.CommandContext(ctx, "tar", "-xf", "-", "-C", stage) + if err := pipe(out, in); err != nil { + return back(fmt.Errorf("copying the server's volumes: %w", err)) + } + // Renamed into place, not copied: the stage is on the same filesystem, + // and a large store should not need twice its size free. + if err := moveContents(filepath.Join(stage, "data"), hs.DataPath()); err != nil { + return back(err) + } + if err := moveContents(filepath.Join(stage, "etc"), hs.home()); err != nil { + return back(err) + } + if err := rewriteDataPath(hs.configPath(), containerDataPath, hs.DataPath()); err != nil { + return back(err) + } + if err := runQuiet(ctx, "chown", "-R", HostServerUser+":"+HostServerUser, hs.home()); err != nil { + return back(err) + } + + // The first start is behind the same fence as first boot: its listeners + // are still a container's, on every interface, until they are fitted. + m.log.Info("starting it on the host, on loopback only until its listeners are fitted") + if _, err := hs.WriteUnit(ctx, true); err != nil { + return back(err) + } + if err := hs.Start(ctx, modeFenced, ""); err != nil { + return back(withLogs(ctx, err, hs, "server")) + } + if err := m.cameBack(ctx, hostSetupBind, func() string { return hs.Logs(ctx, "server", 400) }); err != nil { + return back(withLogs(ctx, err, hs, "server")) + } + srv := &jmap.Client{BaseURL: hostSetupBind, Token: m.key} + if err := srv.HostListeners(ctx, hostFinalBind, m.local); err != nil { + return back(fmt.Errorf("fitting the server's listeners to the host: %w", err)) + } + m.log.Info("plain HTTP on %s for the proxy and the webmail; 443 is left to the proxy", hostFinalBind) + if stack.ServesWebmail() || stack.Proxy || snippets { + if err := allowOnce(ctx, srv, "127.0.0.1", "the front ends on this machine: their requests arrive from loopback"); err != nil { + return back(fmt.Errorf("exempting the front ends: %w", err)) + } + } + if err := hs.Start(ctx, modeNormal, ""); err != nil { + return back(withLogs(ctx, err, hs, "server")) + } + if err := m.cameBack(ctx, "http://"+hostFinalBind, func() string { return hs.Logs(ctx, "server", 400) }); err != nil { + return back(withLogs(ctx, err, hs, "server")) + } + m.log.Info("the server answers on the host; its volumes are left as they were, for `docker volume rm` once you are sure") + return nil +} + +func (m *serverMove) toContainer(ctx context.Context, stack compose.Stack, snippets bool) error { + hs := hostServer{deploy: m.dir, log: m.log} + back := func(why error) error { + m.log.Info("putting the server back on the host") + m.cmp.Run(ctx, "rm", "--stop", "--force", "server") + m.restoreHost(ctx, why) + m.putDeploymentBack(ctx) + return fmt.Errorf("%w; the server is back on the host with its data as it was (archived in %s)", why, m.archive) + } + + // Its volumes, made by compose so they belong to the project. Volumes + // left from an earlier install in a container hold older data: archived + // and emptied, never mixed with this. + if err := m.cmp.Run(ctx, "create", "server"); err != nil { + return back(err) + } + image := DefaultServerImage + left, _ := docker.Output(ctx, "run", "--rm", "--user", "0", "--entrypoint", "sh", + "-v", "inbuxa_inbuxa-etc:/to/etc", "-v", "inbuxa_inbuxa-data:/to/data", image, + "-c", "ls -A /to/etc /to/data | grep -v '^/to\\|^$' | head -1") + if strings.TrimSpace(left) != "" { + name, err := archiveVolumes(ctx, m.dir, tagOf(image)) + if err != nil { + return back(fmt.Errorf("archiving the volumes left from an earlier install: %w", err)) + } + m.log.Info("the server's volumes held an earlier install's data: archived to %s and emptied", name) + if _, err := docker.Output(ctx, "run", "--rm", "--user", "0", "--entrypoint", "sh", + "-v", "inbuxa_inbuxa-etc:/to/etc", "-v", "inbuxa_inbuxa-data:/to/data", image, + "-c", "find /to/etc /to/data -mindepth 1 -delete"); err != nil { + return back(err) + } + } + + // Only the configuration is staged, to be rewritten; the store goes + // straight from /server into its volume. + m.log.Info("copying its configuration and mail into the volumes") + stage, err := os.MkdirTemp(m.dir, ".move-") + if err != nil { + return back(err) + } + defer os.RemoveAll(stage) + if err := os.MkdirAll(filepath.Join(stage, "etc"), 0o750); err != nil { + return back(err) + } + staged := filepath.Join(stage, "etc", "config.json") + if err := copyFile(hs.configPath(), staged, 0o640); err != nil { + return back(err) + } + if err := rewriteDataPath(staged, hs.DataPath(), containerDataPath); err != nil { + return back(err) + } + out := exec.CommandContext(ctx, "tar", "-cf", "-", "-C", stage, "etc", "-C", hs.home(), "data") + in := exec.CommandContext(ctx, docker.CLI, "run", "--rm", "-i", "--user", "0", "--entrypoint", "sh", + "-v", "inbuxa_inbuxa-etc:/to/etc", "-v", "inbuxa_inbuxa-data:/to/data", image, + "-c", "tar -xf - -C /to && chown -R "+containerUser+" /to/etc /to/data") + if err := pipe(out, in); err != nil { + return back(fmt.Errorf("filling the server's volumes: %w", err)) + } + + m.log.Info("starting it in its container") + if err := m.cmp.Run(ctx, "up", "-d", "server"); err != nil { + return back(err) + } + url := "http://" + stack.ServerBind + if err := m.cameBack(ctx, url, func() string { return m.cmp.Logs(ctx, "server", 400) }); err != nil { + return back(withLogs(ctx, err, m.cmp, "server")) + } + + // The front ends' requests now arrive from the project network. + srv := &jmap.Client{BaseURL: url, Token: m.key} + exempt := map[string]string{} + if stack.Webmail || stack.WebmailUnit { + exempt[stack.WebmailIP] = "the webmail: every request arrives from this address" + } + if stack.Proxy { + exempt[stack.CaddyIP] = "the proxy: certificate renewals and autoconfig arrive from this address" + } + if snippets { + exempt[stack.GatewayIP] = "your web server in front of the suite: its requests arrive from this address" + } + for addr, why := range exempt { + if addr == "" { + continue + } + if err := allowOnce(ctx, srv, addr, why); err != nil { + return back(fmt.Errorf("exempting %s: %w", addr, err)) + } + } + if len(exempt) > 0 { + // They take effect only on a restart. + if err := m.cmp.Run(ctx, "restart", "server"); err != nil { + return back(err) + } + if err := m.cameBack(ctx, url, func() string { return m.cmp.Logs(ctx, "server", 400) }); err != nil { + return back(withLogs(ctx, err, m.cmp, "server")) + } + } + + // Off the host: the unit and the binaries go, as uninstall takes them. + removeUnit(ctx, HostServerUnit, hostUnitPath) + old, _ := filepath.Glob(HostServerBinary + ".*") + for _, p := range append(old, HostServerBinary) { + os.Remove(p) + } + os.Remove(filepath.Join(m.dir, "server.env")) + m.log.Info("the server answers in its container; %s is left as it was, to delete once you are sure", hs.home()) + return nil +} + +// restoreHost puts the archive taken by beginMove back into /server and +// starts the server on the host again, as it was before the move began. +func (m *serverMove) restoreHost(ctx context.Context, why error) error { + home := hostServer{deploy: m.dir}.home() + os.RemoveAll(home) + if err := runQuiet(ctx, "tar", "-xzf", m.archive, "-C", m.dir); err != nil { + return fmt.Errorf("%w; and putting %s back from %s failed too: %v", why, home, m.archive, err) + } + runQuiet(ctx, "systemctl", "enable", "--quiet", HostServerUnit) + runQuiet(ctx, "systemctl", "restart", HostServerUnit) + return fmt.Errorf("%w; the server was put back on the host as it was", why) +} + +// clearForCopy makes sure /server is empty before the volumes are +// copied into it: what an earlier install on the host left there is +// archived, never mixed with this. +func (m *serverMove) clearForCopy(ctx context.Context, hs hostServer) error { + entries, _ := os.ReadDir(hs.DataPath()) + if len(entries) == 0 && !exists(hs.configPath()) { + return nil + } + name := filepath.Join(m.dir, "backups", "server-host-earlier-"+time.Now().UTC().Format("20060102T150405Z")+".tar.gz") + if err := runQuiet(ctx, "tar", "-czf", name, "-C", m.dir, "server"); err != nil { + return fmt.Errorf("archiving what an earlier install left in %s: %w", hs.home(), err) + } + m.log.Info("%s held an earlier install's data: archived to %s and emptied", hs.home(), name) + os.Remove(hs.configPath()) + for _, e := range entries { + if err := os.RemoveAll(filepath.Join(hs.DataPath(), e.Name())); err != nil { + return err + } + } + return nil +} + +// cameBack waits for the server at url and makes sure it came back with its +// configuration: a server that finds none starts in bootstrap mode and says +// so, which means the copy missed something. +func (m *serverMove) cameBack(ctx context.Context, url string, logs func() string) error { + if err := waitFor(ctx, m.log, "the server to answer", 120*time.Second, func(ctx context.Context) error { + return live(ctx, url) + }); err != nil { + return err + } + if strings.Contains(logs(), "bootstrap mode") { + return errors.New("the server came back in bootstrap mode, without its configuration") + } + return nil +} + +// allowOnce exempts an address unless it already is. +func allowOnce(ctx context.Context, srv *jmap.Client, address, reason string) error { + have, err := srv.AllowedIPs(ctx) + if err != nil { + return err + } + if have[address] { + return nil + } + return srv.AllowIP(ctx, address, reason) +} + +// rewriteDataPath points the data store's description at its new home. Only +// a path under the old home is changed: a store kept elsewhere (PostgreSQL, +// a path the operator chose) is left alone. +func rewriteDataPath(configPath, from, to string) error { + b, err := os.ReadFile(configPath) + if err != nil { + return fmt.Errorf("the server's configuration: %w", err) + } + var cfg map[string]any + if err := json.Unmarshal(b, &cfg); err != nil { + return fmt.Errorf("%s isn't JSON: %w", configPath, err) + } + p, ok := cfg["path"].(string) + if !ok || !strings.HasPrefix(p, strings.TrimSuffix(from, "/")) { + return nil + } + cfg["path"] = strings.TrimSuffix(to, "/") + strings.TrimPrefix(p, strings.TrimSuffix(from, "/")) + out, err := json.Marshal(cfg) + if err != nil { + return err + } + info, err := os.Stat(configPath) + if err != nil { + return err + } + return os.WriteFile(configPath, out, info.Mode().Perm()) +} + +// moveContents renames everything in src into dest, which is made if need +// be. Both are on one filesystem. +func moveContents(src, dest string) error { + entries, err := os.ReadDir(src) + if errors.Is(err, os.ErrNotExist) { + return nil + } else if err != nil { + return err + } + if err := os.MkdirAll(dest, 0o750); err != nil { + return err + } + for _, e := range entries { + if err := os.Rename(filepath.Join(src, e.Name()), filepath.Join(dest, e.Name())); err != nil { + return err + } + } + return nil +} + +func copyFile(src, dest string, mode os.FileMode) error { + in, err := os.Open(src) + if err != nil { + return err + } + defer in.Close() + out, err := os.OpenFile(dest, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, mode.Perm()) + if err != nil { + return err + } + if _, err := io.Copy(out, in); err != nil { + out.Close() + return err + } + return out.Close() +} + +// pipe runs out | in and reports the first of their failures, with what +// each said on its standard error. +func pipe(out, in *exec.Cmd) error { + r, w := io.Pipe() + var outErr, inErr strings.Builder + out.Stdout, out.Stderr = w, &outErr + in.Stdin, in.Stderr = r, &inErr + if err := in.Start(); err != nil { + return err + } + errOut := out.Run() + w.CloseWithError(errOut) + errIn := in.Wait() + switch { + case errOut != nil: + return fmt.Errorf("%w: %s", errOut, strings.TrimSpace(outErr.String())) + case errIn != nil: + return fmt.Errorf("%w: %s", errIn, strings.TrimSpace(inErr.String())) + } + return nil +} + +func exists(path string) bool { + _, err := os.Stat(path) + return err == nil +} diff --git a/internal/apply/move_test.go b/internal/apply/move_test.go new file mode 100644 index 0000000..325f7b4 --- /dev/null +++ b/internal/apply/move_test.go @@ -0,0 +1,110 @@ +// SPDX-FileCopyrightText: 2026 Coffey Labs LLC +// SPDX-License-Identifier: AGPL-3.0-or-later + +package apply + +import ( + "encoding/json" + "os" + "path/filepath" + "testing" + "time" + + "git.coffeylabs.org/inbuxa/inbuxa-installer/internal/plan" + "git.coffeylabs.org/inbuxa/inbuxa-installer/internal/state" +) + +func TestAMoveIsAnotherServerShapeOnAnInstalledMachine(t *testing.T) { + opts := func(s plan.Shape) plan.Options { + return plan.Options{Choices: []plan.Choice{{Component: plan.Server, Shape: s}}} + } + installed := &state.State{Shapes: map[string]string{"server": "container", "webmail": "container"}} + if from, ok := MovingServer(installed, opts(plan.Host)); !ok || from != plan.Container { + t.Errorf("container to host: from=%q ok=%v", from, ok) + } + if _, ok := MovingServer(installed, opts(plan.Container)); ok { + t.Error("the same shape is a converge, not a move") + } + if _, ok := MovingServer(installed, opts(plan.Skip)); ok { + t.Error("skipping the server is not a move") + } + if _, ok := MovingServer(&state.State{}, opts(plan.Host)); ok { + t.Error("nothing installed: a first install, not a move") + } + removed := time.Now() + gone := &state.State{Shapes: map[string]string{"server": "container"}, RemovedAt: &removed} + if _, ok := MovingServer(gone, opts(plan.Host)); ok { + t.Error("after an uninstall nothing runs to move") + } + frontEnds := &state.State{Shapes: map[string]string{"webmail": "container"}} + if _, ok := MovingServer(frontEnds, opts(plan.Host)); ok { + t.Error("a machine with only front ends has no server to move") + } +} + +func TestOnlyTheStoresPathUnderTheOldHomeIsRewritten(t *testing.T) { + dir := t.TempDir() + cfg := filepath.Join(dir, "config.json") + write := func(v map[string]any) { + b, _ := json.Marshal(v) + os.WriteFile(cfg, b, 0o640) + } + read := func() map[string]any { + b, _ := os.ReadFile(cfg) + var v map[string]any + json.Unmarshal(b, &v) + return v + } + + write(map[string]any{"@type": "RocksDb", "path": "/var/lib/inbuxa/", "poolWorkers": 4.0}) + if err := rewriteDataPath(cfg, containerDataPath, "/var/lib/inbuxa/server/data/"); err != nil { + t.Fatal(err) + } + got := read() + if got["path"] != "/var/lib/inbuxa/server/data/" || got["poolWorkers"] != 4.0 || got["@type"] != "RocksDb" { + t.Errorf("into the host: %v", got) + } + if err := rewriteDataPath(cfg, "/var/lib/inbuxa/server/data/", containerDataPath); err != nil { + t.Fatal(err) + } + if got := read(); got["path"] != "/var/lib/inbuxa/" { + t.Errorf("back into a container: %v", got) + } + if info, _ := os.Stat(cfg); info.Mode().Perm() != 0o640 { + t.Errorf("mode = %v, want the file's own", info.Mode().Perm()) + } + + // A store somewhere else is the operator's, and stays where it is. + write(map[string]any{"@type": "RocksDb", "path": "/srv/mail/store/"}) + rewriteDataPath(cfg, containerDataPath, "/var/lib/inbuxa/server/data/") + if got := read(); got["path"] != "/srv/mail/store/" { + t.Errorf("a store elsewhere moved: %v", got) + } + write(map[string]any{"@type": "PostgreSql", "host": "db"}) + rewriteDataPath(cfg, containerDataPath, "/var/lib/inbuxa/server/data/") + if got := read(); got["path"] != nil || got["host"] != "db" { + t.Errorf("a database store changed: %v", got) + } +} + +func TestMovedContentsArriveAndLeaveTheStageEmpty(t *testing.T) { + src, dest := t.TempDir(), filepath.Join(t.TempDir(), "made") + os.MkdirAll(filepath.Join(src, "rocks"), 0o750) + os.WriteFile(filepath.Join(src, "rocks", "CURRENT"), []byte("MANIFEST-1\n"), 0o640) + os.WriteFile(filepath.Join(src, "top"), []byte("x"), 0o600) + if err := moveContents(src, dest); err != nil { + t.Fatal(err) + } + if b, err := os.ReadFile(filepath.Join(dest, "rocks", "CURRENT")); err != nil || string(b) != "MANIFEST-1\n" { + t.Errorf("CURRENT: %q %v", b, err) + } + if info, err := os.Stat(filepath.Join(dest, "top")); err != nil || info.Mode().Perm() != 0o600 { + t.Errorf("top: %v %v", info, err) + } + if left, _ := os.ReadDir(src); len(left) != 0 { + t.Errorf("left behind: %v", left) + } + if err := moveContents(filepath.Join(src, "absent"), dest); err != nil { + t.Errorf("nothing to move is not an error: %v", err) + } +} diff --git a/internal/jmap/setup.go b/internal/jmap/setup.go index 7ea3649..8d335c1 100644 --- a/internal/jmap/setup.go +++ b/internal/jmap/setup.go @@ -379,6 +379,68 @@ func (c *Client) Listeners(ctx context.Context) ([]Listener, error) { return got.List, json.Unmarshal(rs[1].Args, &got) } +// ContainerListeners undoes HostListeners, for a server moving from the host +// into a container: every listener back on [::], plain HTTP on 8080, which +// is what the compose file publishes. The HTTPS listener HostListeners took +// away is not put back: the proxy terminates TLS in front of a container as +// well, and the container's 443 is not published. Like any listener change +// it takes effect when the server next starts. +func (c *Client) ContainerListeners(ctx context.Context) error { + ls, err := c.Listeners(ctx) + if err != nil { + return err + } + update := map[string]any{} + for _, l := range ls { + binds := map[string]bool{} + for addr := range l.Bind { + if i := strings.LastIndex(addr, ":"); i >= 0 { + binds["[::]"+addr[i:]] = true + } + } + if l.Protocol == "http" && !l.TLSImplicit { + binds = map[string]bool{"[::]:8080": true} + } + update[l.ID] = map[string]any{"bind": binds} + } + if len(update) == 0 { + return nil + } + rs, err := c.Do(ctx, Call{"x:NetworkListener/set", map[string]any{"update": update}, "0"}) + if err != nil { + return err + } + _, err = DecodeSet(rs[0]) + return err +} + +// AllowedIPs is the set of addresses already exempted from the auto-ban. +func (c *Client) AllowedIPs(ctx context.Context) (map[string]bool, error) { + rs, err := c.Do(ctx, + Call{"x:AllowedIp/query", map[string]any{}, "0"}, + Call{"x:AllowedIp/get", map[string]any{ + "#ids": map[string]any{"resultOf": "0", "name": "x:AllowedIp/query", "path": "/ids"}, + "properties": []string{"address"}, + }, "1"}, + ) + if err != nil { + return nil, err + } + var got struct { + List []struct { + Address string `json:"address"` + } `json:"list"` + } + if err := json.Unmarshal(rs[1].Args, &got); err != nil { + return nil, err + } + have := map[string]bool{} + for _, a := range got.List { + have[a.Address] = true + } + return have, nil +} + // HostListeners fits the listeners a server creates on its first configured // start to a server running on the host rather than in a container. // diff --git a/internal/plan/plan.go b/internal/plan/plan.go index 2a1f2e9..bcd9685 100644 --- a/internal/plan/plan.go +++ b/internal/plan/plan.go @@ -82,6 +82,9 @@ type Options struct { // ExemptAddress is the address the server sees the webmail's requests // come from, when it is not what the webmail's name resolves to. ExemptAddress string + // Key is an API key for what changes a running server's own settings: + // moving it between a container and the host. Never written down. + Key string // Where this came from, when it came from a topology file: the machine's // name in it, and the path, both recorded in the state file so a later -- 2.54.0