`inbuxa uninstall [--dry-run] [--yes] [--purge]` takes away what the installer put on this machine: the compose project's containers, the units, the server's binary and the older ones kept for rollback, the console's and the webmail's files, the webmail's user, the installer's own Node. The data stays -- the server's volumes or its directory and user, Caddy's certificates, credentials.txt, .env, dns.zone -- and the install record, marked removed, so `install` run again with the same options converges onto it: the same mailboxes, no first boot. --purge takes the data too, volumes by name as well (after an uninstall that kept them there is no compose file left to name them), all but <dir>/backups, which it names for the operator to delete. Docker, other distribution packages and the configuration an operator's own web server loads are never touched; the last is said, as is a joined server that still lists these front ends. One component off is `install` with it skipped, and uninstall says so rather than doing it a second way. status says what was uninstalled and what was kept; upgrade has nothing to do on it. Tests: what is removed and kept, with and without --purge, in each shape. e2e: uninstall-containers 22/22 (a dry run and a run without --yes change nothing; uninstalled with volumes, credentials and backups kept; installed again with the same mailbox signing in; purged to the backups alone), uninstall-host 14/14 (units, binaries, the webmail's user and Node gone, the server's data and user kept, back again, then purged). upgrade-containers, install-local, install-host, status-export, topology, interface, all-host and webmail-host pass.
86 lines
3.1 KiB
Go
86 lines
3.1 KiB
Go
// SPDX-FileCopyrightText: 2026 Coffey Labs LLC
|
|
// SPDX-License-Identifier: AGPL-3.0-or-later
|
|
|
|
// Package state is what this machine remembers about what was installed on
|
|
// it, so a second run converges instead of building a second one.
|
|
//
|
|
// It is deliberately small, and deliberately not the truth: the truth is the
|
|
// machine, and a plan is built by reading both. What this adds is intent --
|
|
// which components this installer put here, in which shape, from which
|
|
// topology -- which the machine itself cannot tell you. A container that was
|
|
// stopped by hand is still ours; a container we never installed is not.
|
|
package state
|
|
|
|
import (
|
|
"encoding/json"
|
|
"os"
|
|
"path/filepath"
|
|
"time"
|
|
)
|
|
|
|
// Path is where it lives. /etc, not the deployment directory: it survives
|
|
// the deployment directory being moved or rebuilt, and an operator looking
|
|
// for "what did this thing do to my machine" looks in /etc.
|
|
const Path = "/etc/inbuxa/install.json"
|
|
|
|
// State is the file.
|
|
type State struct {
|
|
Version int `json:"version"`
|
|
Machine string `json:"machine"` // its name in the topology
|
|
Dir string `json:"dir"` // the deployment directory
|
|
Runtime string `json:"runtime,omitempty"` // docker or podman
|
|
Domain string `json:"domain,omitempty"` //
|
|
Shapes map[string]string `json:"shapes"` // component -> container|host
|
|
Topology string `json:"topology,omitempty"` // the file this came from, if any
|
|
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
|
|
// with nothing installed is not an error; it is the ordinary first case.
|
|
func Load() (*State, error) {
|
|
b, err := os.ReadFile(Path)
|
|
if os.IsNotExist(err) {
|
|
return &State{Version: Version, Shapes: map[string]string{}}, nil
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var s State
|
|
if err := json.Unmarshal(b, &s); err != nil {
|
|
return nil, err
|
|
}
|
|
if s.Shapes == nil {
|
|
s.Shapes = map[string]string{}
|
|
}
|
|
return &s, nil
|
|
}
|
|
|
|
// Save writes it, creating /etc/inbuxa if it is not there.
|
|
func (s *State) Save() error {
|
|
s.Version = Version
|
|
s.Updated = time.Now().UTC().Truncate(time.Second)
|
|
if err := os.MkdirAll(filepath.Dir(Path), 0o755); err != nil {
|
|
return err
|
|
}
|
|
b, err := json.MarshalIndent(s, "", " ")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return os.WriteFile(Path, append(b, '\n'), 0o644)
|
|
}
|
|
|
|
// Installed is whether anything is recorded here at all.
|
|
func (s *State) Installed() bool { return len(s.Shapes) > 0 }
|