ci / test (pull_request) Successful in 1m28s
Topology version 2 adds an optional cluster block to a server machine: where this node reaches the shared SQL store, the coordinator and the blob store, what role it takes, and what it must start after. Every address in it is the operator's; the installer bakes in none of its own, and a file with no cluster block is read exactly as before. inbuxa cluster join -f FILE acts on this machine's block: it installs the secrets every node reads from disk, points the server at the shared store (keeping the old config.json aside for rollback), writes the hostname, role and boot-order drop-ins, and restarts. --dry-run prints every file it would write and stops. It is the node's half only; the shared registry that names the blob store and coordinator is set up once per cluster, not by each node that joins.
99 lines
3.9 KiB
Go
99 lines
3.9 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"`
|
|
|
|
// 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 }
|