Files
inbuxa-installer/internal/topology/diff.go
T
jcoffey-dev 5a79e657ff Name Coffey Labs LLC as the copyright holder
Coffey Labs is now Coffey Labs LLC, an Arizona limited liability company. Copyright lines and SPDX-FileCopyrightText headers naming Coffey Labs or John Coffey now name Coffey Labs LLC. Upstream copyright notices are unchanged.
2026-10-05 23:32:49 -07:00

143 lines
4.0 KiB
Go

// SPDX-FileCopyrightText: 2026 Coffey Labs LLC
// SPDX-License-Identifier: AGPL-3.0-or-later
package topology
import (
"fmt"
"sort"
"strings"
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/state"
)
// Change is one difference between what a machine runs and what the topology
// says it should.
type Change struct {
Component string
Was string // shape it is in now, "" for absent
Wants string // shape the file asks for, "" for removed
}
// What it is, in a word, for the line that prints it.
func (c Change) Verb() string {
switch {
case c.Was == "" && c.Wants != "":
return "add"
case c.Was != "" && c.Wants == "":
return "remove"
case c.Was != c.Wants:
return "change"
default:
return "keep"
}
}
// Diff compares what this machine has against what the file asks of it.
//
// The comparison is against recorded intent and not only against what is
// running: a container that is stopped is still installed, and a plan that
// offered to install it again would be lying about what it is doing.
type Diff struct {
Machine string
Changes []Change
}
// Compare works out the difference for one machine.
func Compare(s *state.State, m Machine) Diff {
d := Diff{Machine: m.Name}
seen := map[string]bool{}
for _, kind := range []string{"server", "console", "webmail"} {
was, wants := s.Shapes[kind], m.Shape(kind)
seen[kind] = true
if was == "" && wants == "" {
continue
}
d.Changes = append(d.Changes, Change{Component: kind, Was: was, Wants: wants})
}
// Anything recorded that is not a component this version knows about:
// report it rather than silently leaving it, because an older or newer
// installer put it here and this one is about to rewrite the deployment.
var extra []string
for kind := range s.Shapes {
if !seen[kind] {
extra = append(extra, kind)
}
}
sort.Strings(extra)
for _, kind := range extra {
d.Changes = append(d.Changes, Change{Component: kind, Was: s.Shapes[kind]})
}
return d
}
// Empty is whether anything would happen.
func (d Diff) Empty() bool {
for _, c := range d.Changes {
if c.Verb() != "keep" {
return false
}
}
return true
}
// Removals is what would be taken off this machine.
func (d Diff) Removals() []Change {
var out []Change
for _, c := range d.Changes {
if c.Verb() == "remove" {
out = append(out, c)
}
}
return out
}
// String is the diff as the plan shows it: what is here, what is asked for,
// and nothing has happened yet.
func (d Diff) String() string {
var b strings.Builder
fmt.Fprintf(&b, "On %s\n", d.Machine)
if d.Empty() {
for _, c := range d.Changes {
fmt.Fprintf(&b, " keep %-8s %s\n", c.Component, c.Wants)
}
b.WriteString(" nothing to do: this machine already matches the file\n")
return b.String()
}
for _, c := range d.Changes {
switch c.Verb() {
case "add":
fmt.Fprintf(&b, " add %-8s as a %s install\n", c.Component, c.Wants)
case "remove":
fmt.Fprintf(&b, " remove %-8s (installed as a %s)\n", c.Component, c.Was)
case "change":
fmt.Fprintf(&b, " change %-8s %s -> %s\n", c.Component, c.Was, c.Wants)
default:
fmt.Fprintf(&b, " keep %-8s %s\n", c.Component, c.Wants)
}
}
return b.String()
}
// Elsewhere is the part of the plan this machine will not carry out: what
// every other machine in the file has to run, as the command to run there.
// Printed, never executed -- no machine in this design reaches another.
func Elsewhere(t *Topology, path, self string) string {
others := t.Others(self)
if len(others) == 0 {
return ""
}
var b strings.Builder
b.WriteString("\nOn the other machines in this file, run there:\n")
for _, m := range others {
var parts []string
for _, c := range m.Components {
parts = append(parts, c.Kind+" as a "+c.Shape)
}
fmt.Fprintf(&b, " %-10s %s\n", m.Name, strings.Join(parts, ", "))
fmt.Fprintf(&b, " inbuxa apply -f %s --machine %s\n", path, m.Name)
}
b.WriteString("\nNothing here touches them. Copy the file across and run it there.\n")
return b.String()
}