inbuxa uninstall, and the webmail's secret for a host server beside a host webmail #22

Merged
jcoffey-dev merged 2 commits from feat/uninstall into main 2026-10-12 20:46:29 +00:00
10 changed files with 560 additions and 31 deletions

No files matched your search

+14 -2
View File
@@ -122,14 +122,24 @@ This is early. What is built:
its own data archived into `<dir>/backups` (`--no-backup` to skip; a store
kept elsewhere, PostgreSQL or S3, is backed up where it lives).
- **`uninstall [--purge]`** -- takes away what the installer put on this
machine: containers, units, binaries (and the old ones kept for rollback),
the console's and the webmail's files, the webmail's user, its Node. The
data stays -- the server's volumes or directory, Caddy's certificates, the
credentials and secrets -- with the install record marked removed, so
`install` run again with the same options brings it all back. `--purge`
removes the data too, all but `<dir>/backups`, which it names for you to
delete. Docker, and the configuration your own web server loads, are left
alone. To take one component off, run `install` again with it skipped.
- **`status`** -- what is installed, what is running, and where those two
disagree: a container stopped by hand, or a deployment nothing recorded
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: `join` in the interface (it is a command for now) and of
front ends on the host, `uninstall`, `certs`, and moving the server between
a container and the host. The design is in the inbuxa specification (§6.1 and
front ends on the host, `certs`, 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
@@ -180,6 +190,8 @@ is tested on a throwaway virtual machine rather than on anybody's desk:
the same on the host, and a bad release put back
CONSOLE_TARBALL=… WEBMAIL_TARBALL=… e2e/vm/run.sh e2e/cases/upgrade-frontends-host.sh
the console and the webmail on the host, moved on
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/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
+79 -1
View File
@@ -50,6 +50,8 @@ const usage = `inbuxa -- install the inbuxa suite on this machine
inbuxa upgrade [component…] move what is here to the releases this
installer installs: --dry-run, --yes,
--no-backup
inbuxa uninstall take the programs away, keep the data:
--dry-run, --yes, --purge (the data too)
inbuxa export [-o FILE] write a topology file from what is here
inbuxa version this program's version
@@ -130,6 +132,8 @@ func main() {
os.Exit(statusCmd())
case "upgrade":
os.Exit(upgradeCmd(os.Args[2:]))
case "uninstall":
os.Exit(uninstallCmd(os.Args[2:]))
case "version":
fmt.Println(version)
case "-h", "--help", "help":
@@ -692,7 +696,7 @@ func upgradeCmd(args []string) int {
fmt.Fprintln(os.Stderr, err.Error())
return 1
}
if !st.Installed() {
if !st.Installed() || st.Removed() {
fmt.Fprintln(os.Stderr, "nothing is installed here to upgrade")
return 1
}
@@ -747,6 +751,74 @@ func upgradeCmd(args []string) int {
return 0
}
// uninstallCmd takes away what the installer put here. The data stays
// unless --purge, and with it the install record, marked removed, so
// install run again brings everything back.
func uninstallCmd(args []string) int {
fs := flag.NewFlagSet("uninstall", flag.ContinueOnError)
fs.Usage = func() { fmt.Print(usage) }
dryRun := fs.Bool("dry-run", false, "")
yes := fs.Bool("yes", false, "")
purge := fs.Bool("purge", false, "")
if err := fs.Parse(args); err != nil {
return 2
}
if fs.NArg() > 0 {
c := fs.Arg(0)
fmt.Fprintf(os.Stderr, "uninstall takes away the whole installation. To take only the %s off this machine,\n"+
"run install again as before, with --%s skip: it converges, and removes it.\n", c, c)
return 2
}
st, err := state.Load()
if err != nil {
fmt.Fprintln(os.Stderr, err.Error())
return 1
}
if !st.Installed() || (st.Removed() && !*purge) {
fmt.Println("Nothing is installed here to take away.")
if st.Removed() {
fmt.Printf("The data of an earlier install is kept in %s; --purge removes that too.\n", st.Dir)
}
return 0
}
r := apply.UninstallPlan(st, *purge)
fmt.Println("Taken away:")
for _, x := range r.Remove {
fmt.Println(" - " + x)
}
if len(r.Keep) > 0 {
fmt.Println("\nKept:")
for _, x := range r.Keep {
fmt.Println(" - " + x)
}
}
if len(r.Notes) > 0 {
fmt.Println("\nWorth knowing:")
for _, x := range r.Notes {
fmt.Println(" - " + x)
}
}
if *dryRun {
return 0
}
if !*yes {
fmt.Fprintln(os.Stderr, "\nNothing has happened yet. Pass --yes to carry this out.")
return 1
}
f := host.Survey(context.Background())
if !f.Root {
fmt.Fprintln(os.Stderr, "uninstalling needs root")
return 1
}
fmt.Println("\nUninstalling:")
if err := apply.Uninstall(context.Background(), st, *purge, f, &printer{}); err != nil {
fmt.Fprintln(os.Stderr, "\nstopped: "+err.Error())
return 1
}
fmt.Println("\nDone.")
return 0
}
func shapeComponent(s string) (string, error) {
switch strings.ToLower(s) {
case "server", "console", "webmail":
@@ -771,6 +843,12 @@ func statusCmd() int {
fmt.Println("Nothing is installed on this machine.")
return 0
}
if st.Removed() {
fmt.Printf("Nothing is installed on this machine: uninstalled %s, with its data kept in %s.\n",
st.RemovedAt.Format("2006-01-02 15:04 UTC"), st.Dir)
fmt.Println("`inbuxa install` with the same options brings it back; `inbuxa uninstall --purge` removes the data.")
return 0
}
name := st.Machine
if name == "" {
+7
View File
@@ -53,6 +53,13 @@ via admin.$D -D - -o /dev/null "https://admin.$D$ASSET" | grep -qi "cache-contro
via webmail.$D https://webmail.$D/api/health | grep -q '"ok":true' && ok "the webmail is healthy through nginx" || bad "the webmail through nginx"
CODE=$(via mail.$D -o /dev/null -w '%{http_code}' https://mail.$D/.well-known/jmap)
case "$CODE" in 30*|200|401) ok "the mail server through nginx ($CODE)" ;; *) bad "the server through nginx: $CODE" ;; esac
# The server gives a code for the webmail's own address only if it knows the
# webmail's client: registered from the secret in its environment.
USER=$(awk '/^first mailbox/ {print $3}' "$DIR/credentials.txt")
PASS=$(awk '/^first mailbox/{getline; print $2}' "$DIR/credentials.txt")
ANSWER=$(via mail.$D -X POST https://mail.$D/api/auth -H 'Content-Type: application/json' -H 'Accept: application/json' \
-d "{\"type\":\"authCode\",\"accountName\":\"$USER\",\"accountSecret\":\"$PASS\",\"clientId\":\"ihasmail-inbuxa\",\"redirectUri\":\"https://webmail.$D/api/auth/callback\",\"codeChallenge\":\"E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM\",\"codeChallengeMethod\":\"S256\"}")
grep -q '"client_\{0,1\}[cC]ode"' <<<"$ANSWER" && ok "the server signs people in for the webmail at https://webmail.$D" || { bad "no sign-in for the webmail"; head -c 200 <<<"$ANSWER" | sed 's/^/ /'; }
echo
echo "==> status"
+74
View File
@@ -0,0 +1,74 @@
#!/bin/bash
# SPDX-FileCopyrightText: 2026 Coffey Labs LLC
# SPDX-License-Identifier: AGPL-3.0-or-later
#
# inbuxa uninstall, everything in containers: the programs go and the data
# stays; install run again brings it back with the same mailbox; --purge
# then removes the data too, all but the backups.
#
# Run from the host with: e2e/vm/run.sh e2e/cases/uninstall-containers.sh
set -uo pipefail
pass=0; fail=0
ok() { echo " ok $*"; pass=$((pass+1)); }
bad() { echo " FAIL $*"; fail=$((fail+1)); }
DIR=/var/lib/inbuxa
rt() { command -v docker >/dev/null 2>&1 && echo docker || echo podman; }
containers() { $(rt) ps -a --filter label=com.docker.compose.project=inbuxa --format '{{.Names}}' | wc -l; }
volumes() { $(rt) volume ls --format '{{.Name}}' | grep -c '^inbuxa_'; }
signs_in() {
local user pass
user=$(awk '/^first mailbox/ {print $3}' "$DIR/credentials.txt")
pass=$(awk '/^first mailbox/{getline; print $2}' "$DIR/credentials.txt")
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\":\"http://127.0.0.1:8080/api/auth/callback\",\"codeChallenge\":\"E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM\",\"codeChallengeMethod\":\"S256\"}" \
| grep -q '"client_\{0,1\}[cC]ode"'
}
echo "==> installed, with an archive from an upgrade"
/tmp/inbuxa install --local --domain example.test --install-deps --yes >/dev/null 2>&1 && ok "installed" || bad "install"
mkdir -p $DIR/backups && echo archive > $DIR/backups/server-test.tar.gz
signs_in && ok "the first mailbox signs in" || bad "no sign-in to start with"
echo
echo "==> what it would do"
DRY="$(/tmp/inbuxa uninstall --dry-run 2>&1)"; rc=$?
grep -q "inbuxa_inbuxa-data" <<<"$(sed -n '/^Kept:/,$p' <<<"$DRY")" && ok "the server's volumes are kept" || { bad "dry run"; echo "$DRY" | sed 's/^/ /'; }
[ "$(containers)" = 3 ] && ok "a dry run changed nothing" || bad "containers: $(containers)"
OUT="$(/tmp/inbuxa uninstall 2>&1)"; rc=$?
[ $rc -ne 0 ] && [ "$(containers)" = 3 ] && ok "without --yes, nothing happens" || bad "it ran without --yes"
OUT="$(/tmp/inbuxa uninstall console --yes 2>&1)"; rc=$?
[ $rc -eq 2 ] && grep -q -- "--console skip" <<<"$OUT" && ok "one component points to install --console skip" || bad "uninstall console: exit $rc"
echo
echo "==> uninstalling"
OUT="$(/tmp/inbuxa uninstall --yes 2>&1)"; rc=$?
[ $rc -eq 0 ] && ok "uninstalled (exit 0)" || { bad "exit $rc"; echo "$OUT" | tail -6 | sed 's/^/ /'; }
[ "$(containers)" = 0 ] && ok "no containers left" || bad "$(containers) containers left"
[ "$(volumes)" -ge 2 ] && ok "the volumes are kept ($(volumes))" || bad "the volumes are gone"
[ -f $DIR/credentials.txt ] && [ -f $DIR/.env ] && ok "credentials.txt and .env are kept" || bad "the credentials are gone"
[ ! -f $DIR/compose.yaml ] && ok "the compose file is gone" || bad "compose.yaml is still there"
/tmp/inbuxa status 2>&1 | grep -q "uninstalled" && ok "status says it was uninstalled, data kept" || bad "status: $(/tmp/inbuxa status 2>&1 | head -2)"
/tmp/inbuxa upgrade --yes >/dev/null 2>&1 && bad "upgrade ran on nothing" || ok "upgrade has nothing to do"
echo
echo "==> installed again, on what was kept"
OUT="$(/tmp/inbuxa install --local --domain example.test --yes 2>&1)"; rc=$?
[ $rc -eq 0 ] && ok "install again (exit 0)" || { bad "reinstall exit $rc"; echo "$OUT" | tail -8 | sed 's/^/ /'; }
[ "$(containers)" = 3 ] && ok "three containers again" || bad "$(containers) containers"
for _ in $(seq 1 30); do signs_in && break; sleep 2; done
signs_in && ok "the same mailbox signs in: the data came back" || bad "the first mailbox no longer signs in"
/tmp/inbuxa status >/dev/null 2>&1 && ok "status: installed and in agreement" || bad "status after reinstall"
echo
echo "==> purged"
OUT="$(/tmp/inbuxa uninstall --purge --yes 2>&1)"; rc=$?
[ $rc -eq 0 ] && ok "purged (exit 0)" || { bad "purge exit $rc"; echo "$OUT" | tail -6 | sed 's/^/ /'; }
[ "$(containers)" = 0 ] && [ "$(volumes)" = 0 ] && ok "no containers, no volumes" || bad "containers $(containers), volumes $(volumes)"
[ "$(ls -A $DIR)" = backups ] && ok "only $DIR/backups is left" || bad "left in $DIR: $(ls -A $DIR | tr '\n' ' ')"
[ ! -f /etc/inbuxa/install.json ] && ok "the install record is gone" || bad "install.json is still there"
/tmp/inbuxa status 2>&1 | grep -q "Nothing is installed" && ok "status: nothing installed" || bad "status after purge"
echo
echo "==> $pass passed, $fail failed"
[ "$fail" -eq 0 ]
+60
View File
@@ -0,0 +1,60 @@
#!/bin/bash
# SPDX-FileCopyrightText: 2026 Coffey Labs LLC
# SPDX-License-Identifier: AGPL-3.0-or-later
#
# inbuxa uninstall, the server and the webmail on the host: units, binaries,
# the webmail's files and user and the installer's Node go; the server's
# directory and user stay, and install run again brings the server back on
# them; --purge takes those too.
#
# Run from the host with: e2e/vm/run.sh e2e/cases/uninstall-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
signs_in() {
local user pass
user=$(awk '/^first mailbox/ {print $3}' "$DIR/credentials.txt")
pass=$(awk '/^first mailbox/{getline; print $2}' "$DIR/credentials.txt")
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\":\"http://127.0.0.1:8080/api/auth/callback\",\"codeChallenge\":\"E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM\",\"codeChallengeMethod\":\"S256\"}" \
| grep -q '"client_\{0,1\}[cC]ode"'
}
user() { getent passwd "$1" >/dev/null; }
INSTALL=(/tmp/inbuxa install --local --domain example.test --server host --webmail host --install-deps --yes)
echo "==> installed on the host"
"${INSTALL[@]}" >/dev/null 2>&1 && ok "installed" || bad "install"
signs_in && ok "the first mailbox signs in" || bad "no sign-in to start with"
echo
echo "==> uninstalling"
OUT="$(/tmp/inbuxa uninstall --yes 2>&1)"; rc=$?
[ $rc -eq 0 ] && ok "uninstalled (exit 0)" || { bad "exit $rc"; echo "$OUT" | tail -6 | sed 's/^/ /'; }
for u in inbuxa-server inbuxa-webmail; do
[ ! -f /etc/systemd/system/$u.service ] && ! systemctl is-active --quiet $u && ok "$u is gone" || bad "$u is still there"
done
[ ! -e /usr/local/bin/inbuxa-server ] && ok "the server's binary is gone" || bad "the binary is still there"
[ ! -e $DIR/webmail ] && ! user inbuxa-webmail && ok "the webmail's files and user are gone" || bad "webmail files or user left"
[ ! -e /opt/inbuxa/node ] && ok "the installer's Node is gone" || bad "/opt/inbuxa/node is still there"
[ -f $DIR/server/config.json ] && user inbuxa && ok "the server's directory and user are kept" || bad "the server's data or user went"
echo
echo "==> installed again, on what was kept"
OUT="$("${INSTALL[@]}" 2>&1)"; rc=$?
[ $rc -eq 0 ] && ok "install again (exit 0)" || { bad "reinstall exit $rc"; echo "$OUT" | tail -8 | sed 's/^/ /'; }
for _ in $(seq 1 30); do signs_in && break; sleep 2; done
signs_in && ok "the same mailbox signs in" || bad "the first mailbox no longer signs in"
curl -fsS http://127.0.0.1:8080/api/health | grep -q '"ok":true' && ok "the webmail is back" || bad "no webmail"
echo
echo "==> purged"
OUT="$(/tmp/inbuxa uninstall --purge --yes 2>&1)"; rc=$?
[ $rc -eq 0 ] && ok "purged (exit 0)" || bad "purge exit $rc"
[ ! -e $DIR ] && ! user inbuxa && ok "$DIR and the inbuxa user are gone" || bad "left: $(ls -A $DIR 2>/dev/null | tr '\n' ' ') user=$(user inbuxa && echo yes)"
echo
echo "==> $pass passed, $fail failed"
[ "$fail" -eq 0 ]
+53 -28
View File
@@ -228,20 +228,7 @@ func Run(ctx context.Context, p plan.Plan, f host.Facts, log Log) (*Result, erro
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 {
if _, err := hs.WriteEnv(serverEnv(o, stack, sec)); err != nil {
return nil, err
}
log.Info("%s, %s", hostUnitPath, hs.envPath())
@@ -757,6 +744,7 @@ 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.RemovedAt = nil // installed again, on what was kept
st.Shapes = map[string]string{}
for _, c := range []plan.Component{plan.Server, plan.Console, plan.Webmail} {
if sh := o.Shape(c); sh != plan.Skip {
@@ -768,25 +756,41 @@ func saveState(st *state.State, o plan.Options, f host.Facts, log Log) {
}
}
// verifyFor is how long Verify gives each check.
var verifyFor = time.Minute
// Verify is the last step: does what was installed actually answer?
func Verify(ctx context.Context, res *Result, o plan.Options, server bool, log Log) []string {
var problems []string
// Each for up to a minute: a container started a moment ago -- the
// last thing a converge does -- can refuse a connection before it
// answers, and that is not a problem to report.
check := func(what, url string, want string) {
ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
defer cancel()
req, _ := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
resp, err := (&http.Client{}).Do(req)
if err != nil {
problems = append(problems, fmt.Sprintf("%s did not answer at %s: %v", what, url, err))
return
var last string
deadline := time.Now().Add(verifyFor)
for {
ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
req, _ := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
resp, err := (&http.Client{}).Do(req)
if err == nil {
body, _ := io.ReadAll(io.LimitReader(resp.Body, 64<<10))
resp.Body.Close()
if want == "" || strings.Contains(string(body), want) {
cancel()
log.Info("%s answers", what)
return
}
last = fmt.Sprintf("%s answered at %s but did not look like itself", what, url)
} else {
last = fmt.Sprintf("%s did not answer at %s: %v", what, url, err)
}
cancel()
if time.Now().After(deadline) {
problems = append(problems, last)
return
}
time.Sleep(2 * time.Second)
}
defer resp.Body.Close()
body, _ := io.ReadAll(io.LimitReader(resp.Body, 64<<10))
if want != "" && !strings.Contains(string(body), want) {
problems = append(problems, fmt.Sprintf("%s answered at %s but did not look like itself", what, url))
return
}
log.Info("%s answers", what)
}
if server {
check("the mail server", "http://127.0.0.1:8081/.well-known/jmap", "")
@@ -871,6 +875,27 @@ func waitFor(ctx context.Context, log Log, what string, limit time.Duration, pro
return fmt.Errorf("waited %s for %s: %w", limit, what, last)
}
// serverEnv is what a server on the host reads from its environment: the
// front ends' addresses, and the webmail's client secret whenever there is
// a webmail here in either shape -- without it the server registers no
// client for the webmail, which then answers and signs nobody in.
func serverEnv(o plan.Options, stack compose.Stack, sec compose.Secrets) map[string]string {
env := map[string]string{
"INBUXA_ADMIN_URL": stack.ConsoleURL,
"INBUXA_WEBMAIL_URL": stack.WebmailURL,
}
if stack.WebmailURL != "" {
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(o.Dir, "ca-bundle.crt")
}
return env
}
// logSource is wherever a server's last lines come from: its container, or
// the journal.
type logSource interface {
+21
View File
@@ -88,3 +88,24 @@ func TestUnpackReplacesOnlyWhenComplete(t *testing.T) {
t.Error("a failed unpack disturbed what was there")
}
}
// The webmail's client is registered from the server's environment: a
// webmail in either shape needs its secret there, or it answers and signs
// nobody in. (2026.10.12.3 left it out for a webmail on the host beside a
// server on the host.)
func TestAServerOnTheHostIsGivenTheWebmailsSecretInEitherShape(t *testing.T) {
sec := compose.Secrets{WebmailOAuth: "w"}
o := plan.Options{Dir: "/var/lib/inbuxa"}
for _, s := range []compose.Stack{
{HostServer: true, Webmail: true, WebmailURL: "https://webmail.example.org"},
{HostServer: true, WebmailUnit: true, WebmailURL: "https://webmail.example.org"},
} {
env := serverEnv(o, s, sec)
if env["INBUXA_WEBMAIL_CLIENT_SECRET"] != "w" || env["INBUXA_WEBMAIL_URL"] != "https://webmail.example.org" {
t.Errorf("webmail container=%v unit=%v: %v", s.Webmail, s.WebmailUnit, env)
}
}
if env := serverEnv(o, compose.Stack{HostServer: true}, sec); env["INBUXA_WEBMAIL_CLIENT_SECRET"] != "" {
t.Errorf("no webmail, and a secret anyway: %v", env)
}
}
+184
View File
@@ -0,0 +1,184 @@
// SPDX-FileCopyrightText: 2026 Coffey Labs LLC
// SPDX-License-Identifier: AGPL-3.0-or-later
package apply
// Uninstall takes away what the installer put on this machine.
//
// The programs go: containers and the compose project, units, binaries and
// the old ones kept for rollback, the console's and the webmail's files, the
// webmail's user, the installer's own Node. The data stays unless --purge:
// the server's volumes or its directory, Caddy's certificates, the
// credentials, the secrets and the zone file -- and the install record,
// marked removed, so `install` run again picks all of it up.
//
// Never touched, purge or not: the backups the installer made (named, for
// the operator to delete once sure), Docker and anything else the
// distribution installed, and the operator's own web server -- if it loads
// the proxy configuration that was written for it, taking that file away
// would break its next reload, so it is said instead.
//
// Taking one component off is `install` with that component skipped, which
// converges; this is the whole machine.
import (
"context"
"fmt"
"os"
"path/filepath"
"strings"
"time"
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/docker"
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/host"
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/plan"
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/state"
)
// Removal is what uninstall would do, in the words it is shown in.
type Removal struct {
Remove []string
Keep []string
Notes []string
}
// UninstallPlan says what goes and what stays, for what is recorded here.
func UninstallPlan(st *state.State, purge bool) Removal {
var r Removal
dir := st.Dir
keepOrRemove := func(what string) {
if purge {
r.Remove = append(r.Remove, what)
} else {
r.Keep = append(r.Keep, what)
}
}
exists := func(p string) bool { _, err := os.Stat(p); return err == nil }
if exists(filepath.Join(dir, "compose.yaml")) {
r.Remove = append(r.Remove, "the containers of the compose project in "+dir)
if st.Shapes["server"] == string(plan.Container) {
keepOrRemove("the server's volumes, inbuxa_inbuxa-etc and inbuxa_inbuxa-data (its configuration and mail)")
}
if b, _ := os.ReadFile(filepath.Join(dir, "compose.yaml")); strings.Contains(string(b), "\n caddy:\n") {
keepOrRemove("Caddy's volumes (its certificates and ACME account)")
}
}
if st.Shapes["server"] == string(plan.Host) {
r.Remove = append(r.Remove, HostServerUnit+", "+HostServerBinary+" and any older binaries kept beside it")
keepOrRemove(filepath.Join(dir, "server") + " (the server's configuration and mail) and its user, inbuxa")
}
if st.Shapes["console"] == string(plan.Host) {
r.Remove = append(r.Remove, filepath.Join(dir, "console")+" (the console's files)")
}
if st.Shapes["webmail"] == string(plan.Host) {
r.Remove = append(r.Remove, HostWebmailUnit+", "+filepath.Join(dir, "webmail")+" and its user, "+HostWebmailUser)
if exists(filepath.Dir(filepath.Dir(host.OwnPath))) {
r.Remove = append(r.Remove, "the installer's own Node, "+filepath.Dir(filepath.Dir(host.OwnPath)))
}
}
keepOrRemove("credentials.txt, .env, dns.zone and the rest of " + dir)
if exists(filepath.Join(dir, "proxy")) {
keepOrRemove(filepath.Join(dir, "proxy") + " (the configuration written for your web server)")
r.Notes = append(r.Notes, "if your web server loads anything from "+filepath.Join(dir, "proxy")+", take that out of its configuration")
}
if exists(filepath.Join(dir, "backups")) {
r.Keep = append(r.Keep, filepath.Join(dir, "backups")+" (the server's archives: delete it yourself once you are sure)")
}
if purge {
r.Remove = append(r.Remove, "the install record, "+state.Path)
} else {
r.Keep = append(r.Keep, "the install record, "+state.Path+", marked removed: `inbuxa install` with the same options brings it all back")
}
if st.ServerURL != "" {
r.Notes = append(r.Notes, "the server at "+st.ServerURL+" still lists these front ends; clear them in its console")
}
r.Notes = append(r.Notes, "Docker, and anything else the distribution installed, is left as it is")
return r
}
// Uninstall carries the plan out.
func Uninstall(ctx context.Context, st *state.State, purge bool, f host.Facts, log Log) error {
dir := st.Dir
if _, err := os.Stat(filepath.Join(dir, "compose.yaml")); err == nil {
log.Step("removing the containers")
docker.UseRuntime(f.Runtime)
cmp := docker.Compose{Dir: dir, Runtime: f.Runtime}
args := []string{"down", "--remove-orphans"}
if purge {
args = append(args, "--volumes")
}
if err := cmp.Run(ctx, args...); err != nil {
return err
}
os.Remove(filepath.Join(dir, "compose.yaml"))
os.Remove(filepath.Join(dir, "Caddyfile"))
}
if st.Shapes["webmail"] == string(plan.Host) {
log.Step("removing the webmail from this machine")
removeUnit(ctx, HostWebmailUnit, webmailUnitPath)
os.RemoveAll(filepath.Join(dir, "webmail"))
os.RemoveAll(filepath.Join(dir, "webmail.prev"))
os.Remove(filepath.Join(dir, "webmail.env"))
runQuiet(ctx, "userdel", HostWebmailUser)
os.RemoveAll(filepath.Dir(filepath.Dir(host.OwnPath)))
os.Remove(filepath.Dir(filepath.Dir(filepath.Dir(host.OwnPath)))) // /opt/inbuxa, if now empty
}
if st.Shapes["console"] == string(plan.Host) {
log.Step("removing the console's files")
os.RemoveAll(filepath.Join(dir, "console"))
os.RemoveAll(filepath.Join(dir, "console.prev"))
}
if st.Shapes["server"] == string(plan.Host) {
log.Step("removing the server from this machine")
removeUnit(ctx, HostServerUnit, hostUnitPath)
old, _ := filepath.Glob(HostServerBinary + ".*")
for _, p := range append(old, HostServerBinary) {
os.Remove(p)
}
os.Remove(filepath.Join(dir, "server.env"))
if purge {
os.RemoveAll(filepath.Join(dir, "server"))
runQuiet(ctx, "userdel", HostServerUser)
}
}
if purge {
log.Step("removing the data (--purge)")
// By name, as well as by `down --volumes`: after an uninstall that
// kept them there is no compose file left to name them.
if f.Runtime.Usable {
docker.UseRuntime(f.Runtime)
for _, v := range []string{"inbuxa_inbuxa-etc", "inbuxa_inbuxa-data", "inbuxa_caddy-data", "inbuxa_caddy-config"} {
docker.Output(ctx, "volume", "rm", "--force", v)
}
}
entries, _ := os.ReadDir(dir)
for _, e := range entries {
if e.Name() == "backups" {
log.Info("left %s: delete it yourself once you are sure", filepath.Join(dir, "backups"))
continue
}
os.RemoveAll(filepath.Join(dir, e.Name()))
}
os.Remove(dir) // only if nothing is left in it
os.Remove(state.Path)
os.Remove(filepath.Dir(state.Path))
return nil
}
now := time.Now().UTC().Truncate(time.Second)
st.RemovedAt = &now
if err := st.Save(); err != nil {
return fmt.Errorf("the programs are gone, but the record of what was kept could not be written: %w", err)
}
log.Info("the data is kept; `inbuxa install` with the same options brings it back")
return nil
}
func removeUnit(ctx context.Context, unit, path string) {
runQuiet(ctx, "systemctl", "disable", "--now", "--quiet", unit)
os.Remove(path)
os.RemoveAll(path + ".d")
runQuiet(ctx, "systemctl", "daemon-reload")
}
+60
View File
@@ -0,0 +1,60 @@
// SPDX-FileCopyrightText: 2026 Coffey Labs LLC
// SPDX-License-Identifier: AGPL-3.0-or-later
package apply
import (
"os"
"path/filepath"
"strings"
"testing"
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/state"
)
func TestUninstallKeepsTheDataUnlessPurged(t *testing.T) {
dir := t.TempDir()
os.WriteFile(filepath.Join(dir, "compose.yaml"), []byte("services:\n server:\n caddy:\n"), 0o640)
os.MkdirAll(filepath.Join(dir, "backups"), 0o700)
st := &state.State{Dir: dir, Shapes: map[string]string{"server": "container", "console": "container", "webmail": "container"}}
r := UninstallPlan(st, false)
all := func(l []string) string { return strings.Join(l, "\n") }
if !strings.Contains(all(r.Remove), "containers") {
t.Errorf("remove = %v", r.Remove)
}
for _, want := range []string{"inbuxa_inbuxa-data", "Caddy's volumes", "credentials.txt", "backups", "marked removed"} {
if !strings.Contains(all(r.Keep), want) {
t.Errorf("kept lacks %q: %v", want, r.Keep)
}
}
r = UninstallPlan(st, true)
for _, want := range []string{"inbuxa_inbuxa-data", "Caddy's volumes", "credentials.txt", "the install record"} {
if !strings.Contains(all(r.Remove), want) {
t.Errorf("purge does not remove %q: %v", want, r.Remove)
}
}
if !strings.Contains(all(r.Keep), "backups") {
t.Error("purge would take the backups")
}
}
func TestUninstallOnTheHost(t *testing.T) {
st := &state.State{Dir: t.TempDir(), Shapes: map[string]string{"server": "host", "console": "host", "webmail": "host"},
ServerURL: ""}
r := UninstallPlan(st, false)
all := strings.Join(r.Remove, "\n")
for _, want := range []string{HostServerUnit, HostWebmailUnit, "console's files"} {
if !strings.Contains(all, want) {
t.Errorf("remove lacks %q: %v", want, r.Remove)
}
}
if !strings.Contains(strings.Join(r.Keep, "\n"), "/server (the server's configuration and mail)") {
t.Errorf("the host server's data is not kept: %v", r.Keep)
}
st.ServerURL = "https://mail.example.org"
if r := UninstallPlan(st, false); !strings.Contains(strings.Join(r.Notes, "\n"), "still lists these front ends") {
t.Errorf("a joined machine's note is missing: %v", r.Notes)
}
}
+8
View File
@@ -35,8 +35,16 @@ type State struct {
ServerURL string `json:"serverUrl,omitempty"` // the server on another machine these front ends were joined to
Updated time.Time `json:"updated"` //
Installer string `json:"installer,omitempty"` // the version that wrote this
// RemovedAt is when `inbuxa uninstall` took the programs away and kept
// the data. The shapes stay, so `install` run again picks the data up
// rather than trying a first boot on a server configured long ago.
RemovedAt *time.Time `json:"removedAt,omitempty"`
}
// Removed is whether the programs were uninstalled with the data kept.
func (s *State) Removed() bool { return s.RemovedAt != nil }
const Version = 1
// Load reads the state, returning an empty one when there is none. A machine