Files
inbuxa-installer/internal/state/state.go
T
jcoffey-dev bca479d29a Give the server log files, so the console's Logs page has something (#70)
Bootstrap takes one tracer and was given stdout, and the server adds its
own file tracer only when it has none, so no installed server ever wrote
a log file and Observability › Logs, which reads them, was always empty.

A Log tracer is now added beside the stdout one with the setup's API key:
the server's own default (inbuxa.log, rotated daily, plain text), deleted
after inbuxa:LogSettings.keepForDays, which a new install sets to 30. On
the host the files go to /var/log/inbuxa, which the unit makes with
LogsDirectory= and the installer makes too; in a container, where that
path is not a volume and the image's user could not write to one mounted
there, to /var/lib/inbuxa/logs on the data volume.

An install from before this is given its tracer by `inbuxa upgrade --key`
or a run of install with --key, and is told so until then. A tracer an
administrator set up is left alone, and a server moved between a
container and the host takes the installer's tracer with it. A move to
the host leaves the container's log files in its volume, and purge
removes /var/log/inbuxa.
2026-11-16 11:24:16 -07:00

104 lines
4.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"` //
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"`
// LogFiles is whether the server was given the Log tracer the console's
// Logs page reads (#70). Installs from before it are given it by a run
// with --key.
LogFiles bool `json:"logFiles,omitempty"`
// Clustered is whether `inbuxa cluster join` pointed this node's server at
// a shared store; ClusterRole is the role it was given, empty for the node
// that carries every task.
Clustered bool `json:"clustered,omitempty"`
ClusterRole string `json:"clusterRole,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 }