The nginx file terminated TLS for the server's names with a certificate the operator supplied, for the names known at install time only. A domain added later got the wrong certificate on 443, its HTTP-01 challenges weren't forwarded on port 80, and the server's _443._tcp TLSA records described a certificate nobody was served. nginx now routes 443 by name, in nginx-inbuxa-stream.conf (stream, ssl_preread). The console and the webmail go to nginx's own TLS on 127.0.0.1:8444; every other name goes, untouched and with the PROXY protocol header, to the server's own HTTPS listener on 127.0.0.1:8443. That listener is fitted by the installer (jmap.PassThroughListener): bound on loopback on the host, or kept on the container's 443 and published on 127.0.0.1:8443, and taking PROXY only from where nginx connects. Port 80 also passes the challenges of the four service names of any domain. An install from before keeps its layout, since a new file in front of an unfitted server would break its names at the next reload. Running install again with --key fits the listener and moves it over; the install record notes it (passThrough). A move between shapes fits it again. Caddy can't route by name without a plugin, so its fragment says what that means for domains added later and TLSA.
93 lines
3.6 KiB
Go
93 lines
3.6 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"` //
|
|
MailHost string `json:"mailHost,omitempty"` // the server's name; installs before 2026.10.13 did not record it
|
|
Local bool `json:"local,omitempty"` // --local: loopback only, no certificates
|
|
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
|
|
|
|
// PassThrough is whether the server's HTTPS listener was fitted to the
|
|
// name router --proxy snippets writes for nginx (#48). Installs from
|
|
// before it are moved over by a run with --key.
|
|
PassThrough bool `json:"passThrough,omitempty"`
|
|
|
|
// 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 }
|