The host says what filters the machine, with owners, and keeps the found firewall retired on every converged apply (hq ADR 0168)

Every table and chain that refuses traffic is reported with whose it is:
the mesh's, the found firewall's, the container runtime's own, a ban, or
other — the runtime's user chain is other, which is where both predecessors
kept their rules, in the legacy filter on one machine and invisible to the
mesh. Adoption's threshold does not move; a converged machine's report
grows by its filters and its found firewall's state.

Convergence is a state the host keeps: a found firewall enabled again is
retired again and said; a reconcile that finds it inactive records that it
was found so, never that the mesh did it; a step skipped after a failed
apply is said. A retirement the mesh began and did not finish is finished.

Fixtures are rulesets captured from three machines of the first mesh.

cmd/mesh-host/main.go

@@ -1432,7 +1432,7 @@ func applyAndKeep(ctx context.Context, opts options, raw []byte, signed *store.D
 	// (novox/hq ADR 0140). Reported whatever the node's mode: a converged node's filter needs it,
 	// and an adopted one becomes converged without a further round trip. A machine that cannot read
 	// its own routing table says nothing rather than guessing, and is sent no filter.
-	if links, err := outward.Links("", ""); err != nil {
+	if links, err := outward.Links(""); err != nil {
 		fmt.Fprintf(os.Stderr, "mesh-host: applied, and could not read which links face outside: %v\n", err)
 	} else {
 		report.Outward = links

internal/apply/apply.go

@@ -1041,38 +1041,6 @@ type unitReloader interface {
 	ReloadUnits(ctx context.Context, run system.Runner) error
 }
 
-// serviceSettle is how long the host waits before looking at a unit a second time. A test sets it
-// to nothing; on a machine it is the window in which a daemon that refuses its configuration dies.
-var serviceSettle = 2 * time.Second
-
-// stayedRunning is the state of a unit the host has just asked to run, read twice.
-//
-// **Because the first read races the failure.** A service manager returns when it has started the
-// process, and the unit is "activating" or "active" at that instant whatever the process is about
-// to do. A daemon that reads its configuration, refuses it and exits does so a fraction of a second
-// later — fail2ban took 221 milliseconds the day this was written — so a single read back says
-// running about a machine whose daemon is already gone, and the apply reports "restarted" for a
-// service that is dead. Every ban on both public machines was lost that way while every check
-// passed (novox/hq ADR 0184), which is the one shape of failure this host exists to refuse.
-//
-// So it looks again, after the moment in which that happens. It does not wait for a slow unit to
-// finish starting: a unit still coming up reads as running both times and is accepted, as before.
-// What this catches is a unit that was running and is not any more.
-func stayedRunning(ctx context.Context, sys system.System, run Runner, unit string) (string, error) {
-	state, err := sys.ServiceState(ctx, run, unit)
-	if err != nil || state != "running" {
-		return state, err
-	}
-	timer := time.NewTimer(serviceSettle)
-	defer timer.Stop()
-	select {
-	case <-ctx.Done():
-		return state, ctx.Err()
-	case <-timer.C:
-	}
-	return sys.ServiceState(ctx, run, unit)
-}
-
 func applyService(ctx context.Context, sys system.System, r *declaration.Service, run Runner,
 	changed map[string]bool, previous store.Applied) (Outcome, error) {
 	if r.Stateless() {
@@ -1152,9 +1120,6 @@ func applyService(ctx context.Context, sys system.System, r *declaration.Service
 		// Read back. A service manager accepting a command says the transaction was accepted,
 		// not that the unit is running — one that starts and immediately dies satisfies it.
 		after, err := sys.ServiceState(ctx, run, r.Unit)
-		if err == nil && r.State == "running" {
-			after, err = stayedRunning(ctx, sys, run, r.Unit)
-		}
 		if err != nil {
 			return out, err
 		}
@@ -1175,7 +1140,7 @@ func applyService(ctx context.Context, sys system.System, r *declaration.Service
 		}
 		// Read back, for the same reason as above: a unit that starts and immediately dies
 		// satisfies a service manager and nothing else.
-		after, err := stayedRunning(ctx, sys, run, r.Unit)
+		after, err := sys.ServiceState(ctx, run, r.Unit)
 		if err != nil {
 			return out, err
 		}
@@ -1265,7 +1230,7 @@ func reflectOnly(ctx context.Context, sys system.System, r *declaration.Service,
 	}
 	// Read back: it was running, and a restart or reload that left it otherwise is a failure —
 	// the machine's network manager down is not a change to report and move past.
-	after, err := stayedRunning(ctx, sys, run, r.Unit)
+	after, err := sys.ServiceState(ctx, run, r.Unit)
 	if err != nil {
 		return out, err
 	}
@@ -1442,25 +1407,6 @@ func applyPackage(ctx context.Context, sys system.System, r *declaration.Package
 	if err != nil {
 		return out, err
 	}
-	if r.Absent {
-		// Declared absent (novox/hq ADR 0180): removed when it is here, left alone when it is not.
-		if !installed {
-			out.Action = "unchanged"
-			out.Detail = "not installed, as declared"
-			return out, nil
-		}
-		if err := sys.RemovePackage(ctx, run, r.Package); err != nil {
-			return out, fmt.Errorf("removing %s: %w", r.Package, err)
-		}
-		if still, err := sys.PackageInstalled(ctx, run, r.Package); err != nil {
-			return out, err
-		} else if still {
-			return out, fmt.Errorf("%s was removed without error and the package database still has it", r.Package)
-		}
-		out.Action = "removed"
-		out.Detail = "declared absent; its configuration is left where the package manager leaves it"
-		return out, nil
-	}
 	if installed {
 		out.Action = "unchanged"
 		out.Detail = "already installed"
@@ -1637,15 +1583,6 @@ func containerSpecReading(r *declaration.Container, declares, reads map[string]s
 	for _, n := range r.Networks {
 		b.WriteString("also-on " + n + "\n")
 	}
-	// And the capabilities it was granted (ADR 0170): one gained or dropped is a different
-	// container, and the runtime cannot change a running one's.
-	for _, c := range r.Capabilities {
-		b.WriteString("cap " + c + "\n")
-	}
-	// And where it logs (ADR 0179): the runtime cannot move a running container's output.
-	if r.Logging != "" {
-		b.WriteString("log " + r.Logging + "\n")
-	}
 	// The cadence is part of what was declared, so a changed schedule is a changed spec — the marker
 	// moves and the install is reported "updated" and re-established. Added only when present, so no
 	// ordinary container's or run-once step's digest moves for a field it does not set.
@@ -1840,14 +1777,6 @@ func applyContainer(ctx context.Context, r *declaration.Container, run Runner,
 	if r.Network != "" {
 		args = append(args, "--network", r.Network)
 	}
-	for _, c := range r.Capabilities {
-		args = append(args, "--cap-add", c)
-	}
-	if r.Logging != "" {
-		// The journal keeps the container's name on every line (CONTAINER_NAME), which is what a
-		// jail matches on (novox/hq ADR 0179); `docker logs` keeps working against the journal.
-		args = append(args, "--log-driver", r.Logging)
-	}
 	for _, d := range r.Dns {
 		args = append(args, "--dns", d)
 	}

internal/apply/left_out_test.go

@@ -134,81 +134,3 @@ func TestALeftOutModuleIsNeitherRemovedNorForgotten(t *testing.T) {
 		t.Fatalf("keeping the left-out module's container was not said: %+v", report.Outcomes)
 	}
 }
-
-// A container's capabilities reach the runtime and are part of its spec (novox/hq ADR 0170).
-func TestACapabilityReachesTheRuntimeAndTheSpec(t *testing.T) {
-	var ran []string
-	run := func(_ context.Context, name string, args ...string) (string, error) {
-		if name != "docker" {
-			return "", errors.New("not installed")
-		}
-		switch args[0] {
-		case "info":
-			return "29.0.0\n", nil
-		case "container":
-			return "false\t\n", errors.New("no such container")
-		case "run":
-			ran = args
-			return "deadbeef\n", nil
-		}
-		return "", nil
-	}
-	d := parseTrusted(t, `{"declaration":1,"resources":[
-	  {"id":"fw","type":"container","name":"fw","image":"`+pinned+`","network":"host","capabilities":["NET_ADMIN"]}
-	]}`)
-	_, _, _ = Apply(context.Background(), archHost(t), d, store.State{}, store.OriginCarried, run, nil, nil)
-	granted := false
-	for i, a := range ran {
-		if a == "--cap-add" && i+1 < len(ran) && ran[i+1] == "NET_ADMIN" {
-			granted = true
-		}
-	}
-	if !granted {
-		t.Fatalf("the capability was not granted: %v", ran)
-	}
-	with := d.Resources[0].(*declaration.Container)
-	without := *with
-	without.Capabilities = nil
-	if containerSpec(with, inputs{}) == containerSpec(&without, inputs{}) {
-		t.Fatal("a capability is not part of the container's spec")
-	}
-}
-
-// A package may be declared absent (novox/hq ADR 0180): removed when it is installed, read back,
-// left alone when it is not.
-func TestAPackageDeclaredAbsentIsRemovedWhenPresentAndLeftWhenNot(t *testing.T) {
-	installed := true
-	var ran []string
-	run := func(_ context.Context, name string, args ...string) (string, error) {
-		ran = append(ran, name+" "+strings.Join(args, " "))
-		if name != "pacman" {
-			return "", nil
-		}
-		switch args[0] {
-		case "-Q":
-			if args[1] == "pacman" || installed {
-				return args[1] + " 1.0\n", nil
-			}
-			return "", errors.New("package not found")
-		case "-R":
-			installed = false
-		}
-		return "", nil
-	}
-	d := parseTrusted(t, `{"declaration":1,"resources":[{"id":"front-end","type":"package","package":"ufw","absent":true}]}`)
-	report, _, err := Apply(context.Background(), archHost(t), d, store.State{}, store.OriginCarried, run, nil, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if report.Outcomes[0].Action != "removed" || !strings.Contains(strings.Join(ran, "\n"), "pacman -R --noconfirm ufw") {
-		t.Fatalf("an installed package declared absent was not removed: %+v\n%v", report.Outcomes[0], ran)
-	}
-	ran = nil
-	report, _, err = Apply(context.Background(), archHost(t), d, store.State{}, store.OriginCarried, run, nil, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if report.Outcomes[0].Action != "unchanged" || strings.Contains(strings.Join(ran, "\n"), "-R") {
-		t.Fatalf("a package already absent was touched: %+v\n%v", report.Outcomes[0], ran)
-	}
-}

internal/apply/logging_test.go

@@ -1,43 +0,0 @@
-package apply
-
-import (
-	"context"
-	"strings"
-	"testing"
-
-	"github.com/novox/mesh-host/internal/declaration"
-	"github.com/novox/mesh-host/internal/store"
-)
-
-// A container declared to log to the journal is run with the journal as its log driver, and the
-// place it logs is part of its spec, so moving it recreates the container (novox/hq ADR 0179).
-func TestAContainerLoggingToTheJournalIsRunThatWayAndRecreatedWhenMoved(t *testing.T) {
-	pinned := "postgres@sha256:" + strings.Repeat("a", 64)
-	var ran []string
-	run := func(_ context.Context, cmd string, args ...string) (string, error) {
-		if cmd == "docker" && len(args) > 0 && args[0] == "run" {
-			ran = args
-			return "deadbeef\n", nil
-		}
-		return "", nil
-	}
-	d := parseTrusted(t, `{"declaration":1,"resources":[
-	  {"id":"front","type":"container","name":"front","image":"`+pinned+`","logging":"journald"}
-	]}`)
-	_, _, _ = Apply(context.Background(), archHost(t), d, store.State{}, store.OriginCarried, run, nil, nil)
-	sent := false
-	for i, a := range ran {
-		if a == "--log-driver" && i+1 < len(ran) && ran[i+1] == "journald" {
-			sent = true
-		}
-	}
-	if !sent {
-		t.Fatalf("the container's output was not sent to the journal: %v", ran)
-	}
-	with := d.Resources[0].(*declaration.Container)
-	without := *with
-	without.Logging = ""
-	if containerSpec(with, inputs{}) == containerSpec(&without, inputs{}) {
-		t.Fatal("where a container logs is not part of its spec, so moving it would not recreate it")
-	}
-}

internal/apply/opening.go

@@ -76,16 +76,6 @@ func retireFirewall(ctx context.Context, d *declaration.Declaration, origin stri
 	if origin != store.OriginDeclared || d.Adoption != nil || rec == nil || rec.Kind != string(firewall.UFW) || !rec.WasActive {
 		return "", nil
 	}
-	if !firewall.Installed(ctx, run) {
-		// Uninstalled (novox/hq ADR 0180): retired for good, by the module that replaced it. Said
-		// once, and nothing is asked of a command that is not there.
-		if rec.RetiredBy != firewall.RetiredRemoved {
-			rec.RetiredBy = firewall.RetiredRemoved
-			log("  the found firewall (ufw) is no longer installed; the mesh's filter is what filters this machine")
-			return "removed: ufw is no longer installed; the mesh's filter is what filters this machine", nil
-		}
-		return "", nil
-	}
 	active := firewall.Active(ctx, run)
 	if !active && !(rec.Forward != nil && !rec.DisabledByMesh) {
 		// Inactive, and either the mesh's doing already or nobody's recorded here: said as found,

internal/apply/opening_test.go

@@ -8,7 +8,6 @@ import (
 	"path/filepath"
 	"strings"
 	"testing"
-	"time"
 
 	"github.com/novox/mesh-host/internal/declaration"
 	"github.com/novox/mesh-host/internal/store"
@@ -523,33 +522,3 @@ func TestUfwIsNotRetiredUntilTheMeshsOwnFilterIsLoaded(t *testing.T) {
 		t.Errorf("ufw was not retired once the mesh's filter was loaded: active %v, %+v", u.active, state.Firewall)
 	}
 }
-
-// A front end that is no longer installed is recorded as removed, said once, and asked nothing of
-// (novox/hq ADR 0180).
-func TestAnUninstalledFrontEndIsRetiredForGood(t *testing.T) {
-	dir := t.TempDir()
-	u := &ufwMachine{installed: false, ruleset: "table inet mesh\n"}
-	known := store.State{Firewall: &store.FoundFirewall{Kind: "ufw", WasActive: true, DisabledByMesh: true,
-		RetiredBy: "mesh", FoundAt: time.Now()}}
-	converged := parse(t, `{"declaration":1,"resources":[`+withConf(dir)+`]}`)
-	report, state, err := applyWith(t, converged, known, u.run)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if state.Firewall.RetiredBy != "removed" || !strings.Contains(report.Firewall, "no longer installed") {
-		t.Fatalf("record %+v, said %q", state.Firewall, report.Firewall)
-	}
-	u.asked = nil
-	report, _, err = applyWith(t, converged, state, u.run)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if report.Firewall != "" {
-		t.Errorf("said again: %q", report.Firewall)
-	}
-	for _, a := range u.asked {
-		if strings.HasPrefix(a, "ufw") && a != "ufw status" {
-			t.Errorf("asked something of a front end that is not there: %v", u.asked)
-		}
-	}
-}

internal/apply/stayed_running_test.go

@@ -1,100 +0,0 @@
-package apply
-
-import (
-	"context"
-	"os"
-	"strings"
-	"testing"
-
-	"github.com/novox/mesh-host/internal/store"
-)
-
-// A daemon that reads a configuration it refuses dies a fraction of a second after the service
-// manager has reported it started — fail2ban took 221 milliseconds on the control node the day this
-// was written. One read back catches nothing: the unit is active at that instant. The mesh reported
-// the service "restarted" while every ban on two public machines was gone, and every check passed
-// (novox/hq ADR 0184). The host looks again, after the moment in which that happens.
-func TestAServiceThatDiesJustAfterItsRestartIsNotReportedRestarted(t *testing.T) {
-	serviceSettle = 0
-	// Alive at the first look after starting, dead at the second — the shape of a daemon that
-	// refuses what it was just given.
-	started, looks := false, 0
-	run := func(ctx context.Context, name string, args ...string) (string, error) {
-		if args[0] == "show" {
-			state := "active"
-			if started {
-				if looks++; looks >= 2 {
-					state = "failed"
-				}
-			}
-			return "LoadState=loaded\nActiveState=" + state + "\n", nil
-		}
-		if args[0] == "start" {
-			started = true
-		}
-		return "", nil
-	}
-	dir := t.TempDir()
-	d := parse(t, `{"declaration":1,"resources":[
-	  {"id":"conf","type":"file","path":"`+dir+`/jail.conf","content":"[sshd]\n","mode":"0644"},
-	  {"id":"run","type":"service","unit":"fail2ban.service","state":"running","restart-on":["conf"]}
-	]}`)
-	_, _, err := Apply(context.Background(), archHost(t), d, store.State{}, store.OriginCarried, run, nil, nil)
-	if err == nil {
-		t.Fatal("a service that died just after being restarted was reported as restarted")
-	}
-	if !strings.Contains(err.Error(), "fail2ban.service") || !strings.Contains(err.Error(), "is stopped") {
-		t.Errorf("the failure does not name the unit and what it is now: %v", err)
-	}
-	if looks < 2 {
-		t.Errorf("the host looked at the unit %d time(s) after starting it; it must look again", looks)
-	}
-}
-
-// A unit still coming up reads as running at both looks and is accepted: the second look is for a
-// unit that WAS running and is not any more, never a wait for a slow one to finish starting.
-func TestAUnitStillStartingIsNotAFailure(t *testing.T) {
-	serviceSettle = 0
-	run := func(ctx context.Context, name string, args ...string) (string, error) {
-		if args[0] == "show" {
-			return "LoadState=loaded\nActiveState=activating\n", nil
-		}
-		return "", nil
-	}
-	d := parse(t, `{"declaration":1,"resources":[
-	  {"id":"s","type":"service","unit":"slow.service","state":"running"}
-	]}`)
-	if _, _, err := Apply(context.Background(), archHost(t), d, store.State{}, store.OriginCarried, run, nil, nil); err != nil {
-		t.Fatalf("a unit still starting was reported as a failure: %v", err)
-	}
-}
-
-// And a service the declaration asks to be stopped is not waited on at all.
-func TestAServiceAskedToStopIsNotWaitedOn(t *testing.T) {
-	serviceSettle = 0
-	shows := 0
-	run := func(ctx context.Context, name string, args ...string) (string, error) {
-		if args[0] == "show" {
-			shows++
-			if shows == 1 {
-				return "LoadState=loaded\nActiveState=active\n", nil
-			}
-			return "LoadState=loaded\nActiveState=inactive\n", nil
-		}
-		return "", nil
-	}
-	d := parse(t, `{"declaration":1,"resources":[
-	  {"id":"s","type":"service","unit":"off.service","state":"stopped"}
-	]}`)
-	if _, _, err := Apply(context.Background(), archHost(t), d, store.State{}, store.OriginCarried, run, nil, nil); err != nil {
-		t.Fatalf("stopping a service was reported as a failure: %v", err)
-	}
-}
-
-// The settle between a unit's two read-backs is a real pause on a machine and nothing in a test:
-// no test here drives a service manager that takes time, so paying it would only slow the suite
-// (novox/hq ADR 0184).
-func TestMain(m *testing.M) {
-	serviceSettle = 0
-	os.Exit(m.Run())
-}

internal/declaration/declaration.go

@@ -870,12 +870,6 @@ type Package struct {
 	ID      string `json:"id"`
 	Type    Type   `json:"type"`
 	Package string `json:"package"`
-	// Absent declares that the package is NOT installed (novox/hq ADR 0180): the host removes it
-	// when it is, and leaves a machine that never had it alone. For the one case a module replaces
-	// software the machine was found with and the operator has decided it does not come back — the
-	// firewall front end a converged machine's filter module retired. Nothing to undo when the
-	// declaration drops it: the host does not install what a declaration stopped saying is absent.
-	Absent bool `json:"absent,omitempty"`
 }
 
 func (p *Package) Identity() string { return p.ID }
@@ -946,20 +940,6 @@ type Container struct {
 	// its siblings can name before any of them can resolve anything.
 	Dns []string `json:"dns,omitempty"`
 
-	// Capabilities are the Linux capabilities this container is granted beyond the runtime's
-	// default set, by name (novox/hq ADR 0170): a holder's runtime that changes the machine's packet
-	// filter asks for NET_ADMIN. Exactly these, named in the spec so a change recreates the
-	// container; a privileged container stays undeclarable.
-	Capabilities []string `json:"capabilities,omitempty"`
-
-	// Logging names where the runtime sends this container's output: "journald" sends it to the
-	// machine's journal, under the container's name, where what reads the machine's logs — its
-	// intrusion prevention first of all (novox/hq ADR 0179) — can read it the way it reads the
-	// machine's own services. Empty keeps the runtime's default, which is a file of the runtime's
-	// own that nothing but the runtime reads. Part of the spec: a container that logs elsewhere
-	// is a different container, and the runtime cannot change a running one's driver.
-	Logging string `json:"logging,omitempty"`
-
 	// Networks are networks this container also joins once created, by name — a found network a
 	// per-machine setting keeps for a taken container (novox/hq ADR 0163, rule 4), so a
 	// neighbour that resolves it there keeps resolving it until the neighbour is taken too.
@@ -1059,16 +1039,6 @@ func (c *Container) validate(where string, _ bool) []string {
 				"static address anywhere but a user-defined one")
 		}
 	}
-	for _, cap := range c.Capabilities {
-		if !capabilityName.MatchString(cap) {
-			problems = append(problems, where+": capabilities names "+strconv.Quote(cap)+", which is not a "+
-				"capability's name (CAP_NET_ADMIN or NET_ADMIN)")
-		}
-	}
-	if c.Logging != "" && c.Logging != "journald" {
-		problems = append(problems, where+": logging is "+strconv.Quote(c.Logging)+", and the only place a "+
-			"container's output can be sent besides the runtime's own file is \"journald\"")
-	}
 	for _, n := range c.Networks {
 		problems = append(problems, (&Network{Name: n}).validate(where+": networks", false)...)
 		if n == c.Network {
@@ -1239,10 +1209,6 @@ type Adoption struct {
 	Untaken map[string][]string `json:"untaken,omitempty"`
 }
 
-// capabilityName is what a Linux capability is called: upper case, underscores, an optional CAP_
-// prefix. The runtime accepts either spelling.
-var capabilityName = regexp.MustCompile(`^(CAP_)?[A-Z][A-Z0-9_]*$`)
-
 // AdoptionPrefix is the id prefix of what the mesh itself declares because a node is adopted —
 // its openings and its guard. Nothing under it belongs to a module, so none of it is ever held.
 const AdoptionPrefix = "adoption."

internal/declaration/declaration_test.go

@@ -504,44 +504,3 @@ func TestKeptNetworksAndLeftOutModulesAreReadStrictly(t *testing.T) {
 		t.Fatalf("a carried bundle leaving modules out was accepted: %v", err)
 	}
 }
-
-// A container may ask for a capability by name, and nothing else (novox/hq ADR 0170).
-func TestACapabilityIsNamedOrRefused(t *testing.T) {
-	image := "postgres@sha256:" + strings.Repeat("a", 64)
-	d, err := Parse([]byte(`{"declaration":1,"resources":[
-	  {"id":"fw","type":"container","name":"fw","image":"` + image + `","network":"host","capabilities":["NET_ADMIN","CAP_NET_RAW"]}
-	]}`))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if got := d.Resources[0].(*Container).Capabilities; len(got) != 2 || got[0] != "NET_ADMIN" {
-		t.Fatalf("capabilities read as %v", got)
-	}
-	for _, bad := range []string{`"net_admin"`, `"ALL;rm -rf /"`, `"privileged"`} {
-		if _, err := Parse([]byte(`{"declaration":1,"resources":[
-		  {"id":"fw","type":"container","name":"fw","image":"` + image + `","capabilities":[` + bad + `]}]}`)); err == nil {
-			t.Errorf("%s was accepted as a capability", bad)
-		}
-	}
-}
-
-// A container may send its output to the machine's journal, and nowhere else but the runtime's own
-// file (novox/hq ADR 0179): what reads the machine's logs then reads the container's too.
-func TestAContainerMayLogToTheJournalAndNowhereElse(t *testing.T) {
-	image := "postgres@sha256:" + strings.Repeat("a", 64)
-	d, err := Parse([]byte(`{"declaration":1,"resources":[
-	  {"id":"front","type":"container","name":"front","image":"` + image + `","logging":"journald"}
-	]}`))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if got := d.Resources[0].(*Container).Logging; got != "journald" {
-		t.Fatalf("logging read as %q", got)
-	}
-	for _, bad := range []string{`"syslog"`, `"none"`, `"json-file"`} {
-		if _, err := Parse([]byte(`{"declaration":1,"resources":[
-		  {"id":"front","type":"container","name":"front","image":"` + image + `","logging":` + bad + `}]}`)); err == nil {
-			t.Errorf("%s was accepted as a place to log", bad)
-		}
-	}
-}

internal/firewall/filters.go

@@ -179,18 +179,27 @@ func legacyFilters(rules, tool string, ufwActive bool) []Filter {
 			}
 		}
 	}
-	// A chain of refusals is a ban list when every refusal names the sources it refuses and the
-	// chain accepts nothing — the same rule the nftables side applies, and no more.
-	//
-	// **The policy of the chains that jump to it says nothing about what it is.** An earlier cut
-	// required every path into the chain to come from a built-in whose policy accepts, and the
-	// mesh's own intrusion prevention then read as a foreign rule set on the home server: its ban
-	// chain hangs off the container runtime's user chain as well as INPUT, and that machine's
-	// forward policy is DROP because the runtime set it. The machine reported "NOT the mesh alone"
-	// about a chain the mesh had just written (novox/hq ADR 0186). The policy is already classified
-	// where it belongs — as the runtime's — so requiring it here counted it twice.
+	var entered func(chain string, seen map[string]bool) bool
+	entered = func(chain string, seen map[string]bool) bool {
+		if seen[chain] || accepting[chain] || len(jumpedFrom[chain]) == 0 {
+			return false
+		}
+		seen[chain] = true
+		for _, from := range jumpedFrom[chain] {
+			if p, builtIn := policy[from]; builtIn {
+				if p != "ACCEPT" {
+					return false
+				}
+				continue
+			}
+			if !entered(from, seen) {
+				return false
+			}
+		}
+		return true
+	}
 	ban := func(chain, line string) bool {
-		return bansSources(line) && !accepting[chain] && len(jumpedFrom[chain]) > 0
+		return bansSources(line) && entered(chain, map[string]bool{})
 	}
 	type seen struct {
 		owner string
@@ -310,17 +319,8 @@ func Active(ctx context.Context, run Runner) bool {
 	return err == nil && statusActive(out)
 }
 
-// Installed says whether ufw is on this machine at all: a command that is not there is a front end
-// that was uninstalled (novox/hq ADR 0180), not one that is silent.
-func Installed(ctx context.Context, run Runner) bool {
-	_, err := run(ctx, "ufw", "status")
-	return !missing(err)
-}
-
 // Retirements of a found firewall, as the host records them.
 const (
 	RetiredByMesh  = "mesh"
 	RetiredFoundSo = "found-inactive"
-	// RetiredRemoved is a front end uninstalled by the module that replaced it (ADR 0180).
-	RetiredRemoved = "removed"
 )

internal/firewall/neighbour_ban_test.go

@@ -1,60 +0,0 @@
-package firewall
-
-import (
-	"os"
-	"testing"
-)
-
-// The mesh's own ban list is a ban wherever it hangs (novox/hq ADR 0186).
-//
-// Captured from the home server after the intrusion prevention had banned four addresses: its ban
-// chain is jumped to from INPUT, whose policy accepts, and from the container runtime's user chain,
-// which hangs off a FORWARD the runtime set to DROP. Requiring every path to come from an accepting
-// built-in made the machine report "NOT the mesh alone" about a chain the mesh had just written.
-func TestTheMeshsOwnBanChainIsABanBehindADroppingForward(t *testing.T) {
-	legacy, err := os.ReadFile("testdata/home-server-bans-S.txt")
-	if err != nil {
-		t.Fatal(err)
-	}
-	filters := Filters("", map[string]string{"iptables-legacy": string(legacy)}, false)
-
-	var ban, other []string
-	for _, f := range filters {
-		switch f.Owner {
-		case OwnerBan:
-			ban = append(ban, f.Where)
-		case OwnerOther:
-			other = append(other, f.Where)
-		}
-	}
-	if len(other) > 0 {
-		t.Errorf("the machine reports %v as rule sets the mesh did not write", other)
-	}
-	found := false
-	for _, w := range ban {
-		if w == "chain f2b-route-proxy (iptables-legacy)" {
-			found = true
-		}
-	}
-	if !found {
-		t.Errorf("the intrusion prevention's own chain was not read as a ban; bans were %v", ban)
-	}
-	if !Alone(filters) {
-		t.Error("a machine filtered by the mesh and its own bans does not read as the mesh alone")
-	}
-}
-
-// A chain that accepts anything is doing more than banning, and is still not a ban — which is what
-// keeps a predecessor's allow-and-drop chain classified as something the operator must look at.
-func TestAChainThatAcceptsIsNotABan(t *testing.T) {
-	rules := "-P INPUT ACCEPT\n" +
-		"-A INPUT -j HAL-MESH-ONLY\n" +
-		"-N HAL-MESH-ONLY\n" +
-		"-A HAL-MESH-ONLY -s 10.0.0.0/8 -j ACCEPT\n" +
-		"-A HAL-MESH-ONLY -s 203.0.113.7/32 -j DROP\n"
-	for _, f := range Filters("", map[string]string{"iptables-legacy": rules}, false) {
-		if f.Where == "chain HAL-MESH-ONLY (iptables-legacy)" && f.Owner != OwnerOther {
-			t.Errorf("a chain that accepts was classified as %s", f.Owner)
-		}
-	}
-}

internal/firewall/testdata/home-server-bans-S.txt

@@ -1,147 +0,0 @@
--P INPUT ACCEPT
--P FORWARD DROP
--P OUTPUT ACCEPT
--N DOCKER
--N DOCKER-BRIDGE
--N DOCKER-CT
--N DOCKER-FORWARD
--N DOCKER-INTERNAL
--N DOCKER-USER
--N f2b-route-proxy
--N ufw-after-forward
--N ufw-after-input
--N ufw-after-logging-forward
--N ufw-after-logging-input
--N ufw-after-logging-output
--N ufw-after-output
--N ufw-before-forward
--N ufw-before-input
--N ufw-before-logging-forward
--N ufw-before-logging-input
--N ufw-before-logging-output
--N ufw-before-output
--N ufw-reject-forward
--N ufw-reject-input
--N ufw-reject-output
--N ufw-track-forward
--N ufw-track-input
--N ufw-track-output
--A INPUT -p tcp -j f2b-route-proxy
--A INPUT -j ufw-before-logging-input
--A INPUT -j ufw-before-input
--A INPUT -j ufw-after-input
--A INPUT -j ufw-after-logging-input
--A INPUT -j ufw-reject-input
--A INPUT -j ufw-track-input
--A FORWARD -j DOCKER-USER
--A FORWARD -j DOCKER-FORWARD
--A FORWARD -j ufw-before-logging-forward
--A FORWARD -j ufw-before-forward
--A FORWARD -j ufw-after-forward
--A FORWARD -j ufw-after-logging-forward
--A FORWARD -j ufw-reject-forward
--A FORWARD -j ufw-track-forward
--A OUTPUT -j ufw-before-logging-output
--A OUTPUT -j ufw-before-output
--A OUTPUT -j ufw-after-output
--A OUTPUT -j ufw-after-logging-output
--A OUTPUT -j ufw-reject-output
--A OUTPUT -j ufw-track-output
--A DOCKER -d 172.17.0.18/32 ! -i docker0 -o docker0 -p tcp -m tcp --dport 8686 -j ACCEPT
--A DOCKER -d 172.17.0.14/32 ! -i docker0 -o docker0 -p tcp -m tcp --dport 8989 -j ACCEPT
--A DOCKER -d 172.17.0.15/32 ! -i docker0 -o docker0 -p tcp -m tcp --dport 7878 -j ACCEPT
--A DOCKER -d 172.17.0.5/32 ! -i docker0 -o docker0 -p tcp -m tcp --dport 9117 -j ACCEPT
--A DOCKER -d 172.17.0.13/32 ! -i docker0 -o docker0 -p tcp -m tcp --dport 6789 -j ACCEPT
--A DOCKER -d 172.19.0.2/32 ! -i br-32062158f584 -o br-32062158f584 -p tcp -m tcp --dport 8080 -j ACCEPT
--A DOCKER -d 172.17.0.2/32 ! -i docker0 -o docker0 -p tcp -m tcp --dport 5432 -j ACCEPT
--A DOCKER -d 172.27.0.2/32 ! -i br-0910a98c6158 -o br-0910a98c6158 -p tcp -m tcp --dport 5678 -j ACCEPT
--A DOCKER -d 172.17.0.21/32 ! -i docker0 -o docker0 -p tcp -m tcp --dport 3579 -j ACCEPT
--A DOCKER -d 172.17.0.19/32 ! -i docker0 -o docker0 -p tcp -m tcp --dport 8181 -j ACCEPT
--A DOCKER -d 172.17.0.17/32 ! -i docker0 -o docker0 -p tcp -m tcp --dport 8787 -j ACCEPT
--A DOCKER -d 172.17.0.16/32 ! -i docker0 -o docker0 -p tcp -m tcp --dport 6767 -j ACCEPT
--A DOCKER -d 172.17.0.12/32 ! -i docker0 -o docker0 -p tcp -m tcp --dport 3000 -j ACCEPT
--A DOCKER -d 172.17.0.11/32 ! -i docker0 -o docker0 -p tcp -m tcp --dport 80 -j ACCEPT
--A DOCKER -d 172.17.0.10/32 ! -i docker0 -o docker0 -p tcp -m tcp --dport 9443 -j ACCEPT
--A DOCKER -d 172.17.0.10/32 ! -i docker0 -o docker0 -p tcp -m tcp --dport 9000 -j ACCEPT
--A DOCKER -d 172.17.0.9/32 ! -i docker0 -o docker0 -p tcp -m tcp --dport 3000 -j ACCEPT
--A DOCKER -d 172.17.0.7/32 ! -i docker0 -o docker0 -p tcp -m tcp --dport 1880 -j ACCEPT
--A DOCKER -d 172.28.0.2/32 ! -i br-b11461b5b028 -o br-b11461b5b028 -p tcp -m tcp --dport 80 -j ACCEPT
--A DOCKER -d 172.23.0.14/32 ! -i br-66ffa5c1cba5 -o br-66ffa5c1cba5 -p tcp -m tcp --dport 6543 -j ACCEPT
--A DOCKER -d 172.23.0.14/32 ! -i br-66ffa5c1cba5 -o br-66ffa5c1cba5 -p tcp -m tcp --dport 5432 -j ACCEPT
--A DOCKER -d 172.23.0.5/32 ! -i br-66ffa5c1cba5 -o br-66ffa5c1cba5 -p tcp -m tcp --dport 8000 -j ACCEPT
--A DOCKER -d 172.26.0.3/32 ! -i br-b0fec361ccaa -o br-b0fec361ccaa -p tcp -m tcp --dport 6167 -j ACCEPT
--A DOCKER -d 172.26.0.2/32 ! -i br-b0fec361ccaa -o br-b0fec361ccaa -p tcp -m tcp --dport 80 -j ACCEPT
--A DOCKER -d 172.17.0.8/32 ! -i docker0 -o docker0 -p tcp -m tcp --dport 8000 -j ACCEPT
--A DOCKER -d 172.17.0.6/32 ! -i docker0 -o docker0 -p udp -m udp --dport 10001 -j ACCEPT
--A DOCKER -d 172.17.0.6/32 ! -i docker0 -o docker0 -p tcp -m tcp --dport 8880 -j ACCEPT
--A DOCKER -d 172.17.0.6/32 ! -i docker0 -o docker0 -p tcp -m tcp --dport 8843 -j ACCEPT
--A DOCKER -d 172.17.0.6/32 ! -i docker0 -o docker0 -p tcp -m tcp --dport 8443 -j ACCEPT
--A DOCKER -d 172.17.0.6/32 ! -i docker0 -o docker0 -p tcp -m tcp --dport 8080 -j ACCEPT
--A DOCKER -d 172.17.0.6/32 ! -i docker0 -o docker0 -p tcp -m tcp --dport 6789 -j ACCEPT
--A DOCKER -d 172.17.0.6/32 ! -i docker0 -o docker0 -p udp -m udp --dport 5514 -j ACCEPT
--A DOCKER -d 172.17.0.6/32 ! -i docker0 -o docker0 -p udp -m udp --dport 3478 -j ACCEPT
--A DOCKER -d 172.17.0.6/32 ! -i docker0 -o docker0 -p udp -m udp --dport 1900 -j ACCEPT
--A DOCKER -d 172.25.0.3/32 ! -i br-b98821f7dc38 -o br-b98821f7dc38 -p tcp -m tcp --dport 8000 -j ACCEPT
--A DOCKER -d 172.18.0.3/32 ! -i br-442a0bfc65f8 -o br-442a0bfc65f8 -p tcp -m tcp --dport 1433 -j ACCEPT
--A DOCKER -d 172.20.0.3/32 ! -i br-afa37ac8b33d -o br-afa37ac8b33d -p tcp -m tcp --dport 8081 -j ACCEPT
--A DOCKER -d 172.20.0.3/32 ! -i br-afa37ac8b33d -o br-afa37ac8b33d -p tcp -m tcp --dport 1883 -j ACCEPT
--A DOCKER -d 172.17.0.4/32 ! -i docker0 -o docker0 -p tcp -m tcp --dport 8086 -j ACCEPT
--A DOCKER -d 172.21.0.2/32 ! -i br-df15d8e19ec7 -o br-df15d8e19ec7 -p tcp -m tcp --dport 6379 -j ACCEPT
--A DOCKER -d 172.30.0.3/32 ! -i br-521eab9a3a5e -o br-521eab9a3a5e -p tcp -m tcp --dport 8283 -j ACCEPT
--A DOCKER -d 172.17.0.3/32 ! -i docker0 -o docker0 -p tcp -m tcp --dport 3000 -j ACCEPT
--A DOCKER ! -i br-32062158f584 -o br-32062158f584 -j DROP
--A DOCKER ! -i docker0 -o docker0 -j DROP
--A DOCKER ! -i br-521eab9a3a5e -o br-521eab9a3a5e -j DROP
--A DOCKER ! -i br-df15d8e19ec7 -o br-df15d8e19ec7 -j DROP
--A DOCKER ! -i br-afa37ac8b33d -o br-afa37ac8b33d -j DROP
--A DOCKER ! -i br-442a0bfc65f8 -o br-442a0bfc65f8 -j DROP
--A DOCKER ! -i br-b98821f7dc38 -o br-b98821f7dc38 -j DROP
--A DOCKER ! -i br-b0fec361ccaa -o br-b0fec361ccaa -j DROP
--A DOCKER ! -i br-66ffa5c1cba5 -o br-66ffa5c1cba5 -j DROP
--A DOCKER ! -i br-b11461b5b028 -o br-b11461b5b028 -j DROP
--A DOCKER ! -i br-2df4e541b877 -o br-2df4e541b877 -j DROP
--A DOCKER ! -i br-0910a98c6158 -o br-0910a98c6158 -j DROP
--A DOCKER-BRIDGE -o br-32062158f584 -j DOCKER
--A DOCKER-BRIDGE -o docker0 -j DOCKER
--A DOCKER-BRIDGE -o br-521eab9a3a5e -j DOCKER
--A DOCKER-BRIDGE -o br-df15d8e19ec7 -j DOCKER
--A DOCKER-BRIDGE -o br-afa37ac8b33d -j DOCKER
--A DOCKER-BRIDGE -o br-442a0bfc65f8 -j DOCKER
--A DOCKER-BRIDGE -o br-b98821f7dc38 -j DOCKER
--A DOCKER-BRIDGE -o br-b0fec361ccaa -j DOCKER
--A DOCKER-BRIDGE -o br-66ffa5c1cba5 -j DOCKER
--A DOCKER-BRIDGE -o br-b11461b5b028 -j DOCKER
--A DOCKER-BRIDGE -o br-2df4e541b877 -j DOCKER
--A DOCKER-BRIDGE -o br-0910a98c6158 -j DOCKER
--A DOCKER-CT -o br-32062158f584 -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
--A DOCKER-CT -o docker0 -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
--A DOCKER-CT -o br-521eab9a3a5e -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
--A DOCKER-CT -o br-df15d8e19ec7 -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
--A DOCKER-CT -o br-afa37ac8b33d -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
--A DOCKER-CT -o br-442a0bfc65f8 -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
--A DOCKER-CT -o br-b98821f7dc38 -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
--A DOCKER-CT -o br-b0fec361ccaa -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
--A DOCKER-CT -o br-66ffa5c1cba5 -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
--A DOCKER-CT -o br-b11461b5b028 -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
--A DOCKER-CT -o br-2df4e541b877 -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
--A DOCKER-CT -o br-0910a98c6158 -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
--A DOCKER-FORWARD -j DOCKER-CT
--A DOCKER-FORWARD -j DOCKER-INTERNAL
--A DOCKER-FORWARD -j DOCKER-BRIDGE
--A DOCKER-FORWARD -i br-32062158f584 -j ACCEPT
--A DOCKER-FORWARD -i docker0 -j ACCEPT
--A DOCKER-FORWARD -i br-521eab9a3a5e -j ACCEPT
--A DOCKER-FORWARD -i br-df15d8e19ec7 -j ACCEPT
--A DOCKER-FORWARD -i br-afa37ac8b33d -j ACCEPT
--A DOCKER-FORWARD -i br-442a0bfc65f8 -j ACCEPT
--A DOCKER-FORWARD -i br-b98821f7dc38 -j ACCEPT
--A DOCKER-FORWARD -i br-b0fec361ccaa -j ACCEPT
--A DOCKER-FORWARD -i br-66ffa5c1cba5 -j ACCEPT
--A DOCKER-FORWARD -i br-b11461b5b028 -j ACCEPT
--A DOCKER-FORWARD -i br-2df4e541b877 -j ACCEPT
--A DOCKER-FORWARD -i br-0910a98c6158 -j ACCEPT
--A DOCKER-USER -p tcp -j f2b-route-proxy
--A f2b-route-proxy -s 13.70.107.184/32 -j REJECT --reject-with icmp-port-unreachable
--A f2b-route-proxy -s 45.138.12.51/32 -j REJECT --reject-with icmp-port-unreachable
--A f2b-route-proxy -s 20.214.191.94/32 -j REJECT --reject-with icmp-port-unreachable
--A f2b-route-proxy -j RETURN

internal/outward/links.go

@@ -29,32 +29,17 @@ import (
 // routing table without one.
 const ProcNet = "/proc/net"
 
-// SysClassNet is where the kernel lists the machine's network interfaces, one directory each. A
-// parameter for the same reason.
-const SysClassNet = "/sys/class/net"
-
-// Links are the interfaces carrying a default route, for both address families, and every interface
-// backed by a physical device, sorted and without repeats.
-//
-// **A physical link faces outside whether or not it is up** (novox/hq issue 197). The filter accepts
-// whatever did not arrive on a link named here, so a link left out of this list is not filtered at
-// all. A cable unplugged when the machine last reported carries no default route, and was left out:
-// plugged in, everything arriving on it was accepted until the next report and the next push — and a
-// second physical link that never carries the default route was never filtered. A physical device is
-// read from the kernel's own list, where it has a `device` entry; a bridge, a veth, the tunnel and the
-// loopback have none, and stay what they are, this machine's own.
+// Links are the interfaces carrying a default route, for both address families, sorted and without
+// repeats.
 //
 // A machine may have more than one: a laptop with a cable and a radio has two, and both face
 // outside. A machine with none — no route off itself — returns nothing, and the mesh refuses to
 // compose a filter for it rather than writing a rule around a link with no name, which would be a
 // rule set that does not load and a machine filtering nothing while its unit reports success.
-func Links(procNet, sysClassNet string) ([]string, error) {
+func Links(procNet string) ([]string, error) {
 	if procNet == "" {
 		procNet = ProcNet
 	}
-	if sysClassNet == "" {
-		sysClassNet = SysClassNet
-	}
 	seen := map[string]bool{}
 
 	four, err := defaultsV4(filepath.Join(procNet, "route"))
@@ -65,11 +50,7 @@ func Links(procNet, sysClassNet string) ([]string, error) {
 	if err != nil {
 		return nil, err
 	}
-	devices, err := physical(sysClassNet)
-	if err != nil {
-		return nil, err
-	}
-	for _, name := range append(append(four, six...), devices...) {
+	for _, name := range append(four, six...) {
 		if name != "" && name != "lo" {
 			seen[name] = true
 		}
@@ -83,25 +64,6 @@ func Links(procNet, sysClassNet string) ([]string, error) {
 	return out, nil
 }
 
-// physical is every interface the kernel lists with a device behind it. A list that is not there is
-// not an error — a machine without sysfs mounted reports what its routing table says, as before.
-func physical(sysClassNet string) ([]string, error) {
-	entries, err := os.ReadDir(sysClassNet)
-	if os.IsNotExist(err) {
-		return nil, nil
-	}
-	if err != nil {
-		return nil, err
-	}
-	var out []string
-	for _, e := range entries {
-		if _, err := os.Stat(filepath.Join(sysClassNet, e.Name(), "device")); err == nil {
-			out = append(out, e.Name())
-		}
-	}
-	return out, nil
-}
-
 // defaultsV4 reads /proc/net/route, whose columns are
 //
 //	Iface Destination Gateway Flags RefCnt Use Metric Mask ...

internal/outward/links_test.go

@@ -32,7 +32,7 @@ func TestLinksAreTheOnesCarryingADefaultRoute(t *testing.T) {
 	write(t, dir, "route", routeV4)
 	write(t, dir, "ipv6_route", routeV6)
 
-	got, err := Links(dir, t.TempDir())
+	got, err := Links(dir)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -52,7 +52,7 @@ func TestAZeroDestinationWithAMaskIsNotADefaultRoute(t *testing.T) {
 	write(t, dir, "route", `Iface	Destination	Gateway 	Flags	RefCnt	Use	Metric	Mask		MTU	Window	IRTT
 br-abc	00000000	00000000	0001	0	0	0	00FFFFFF	0	0	0
 `)
-	got, err := Links(dir, t.TempDir())
+	got, err := Links(dir)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -67,7 +67,7 @@ br-abc	00000000	00000000	0001	0	0	0	00FFFFFF	0	0	0
 func TestNoDefaultRouteIsNoLinks(t *testing.T) {
 	dir := t.TempDir()
 	write(t, dir, "route", "Iface\tDestination\tGateway \tFlags\tRefCnt\tUse\tMetric\tMask\t\tMTU\tWindow\tIRTT\n")
-	got, err := Links(dir, t.TempDir())
+	got, err := Links(dir)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -81,7 +81,7 @@ func TestNoDefaultRouteIsNoLinks(t *testing.T) {
 func TestAMissingTableIsNotAFailure(t *testing.T) {
 	dir := t.TempDir()
 	write(t, dir, "route", routeV4)
-	got, err := Links(dir, t.TempDir())
+	got, err := Links(dir)
 	if err != nil {
 		t.Fatalf("a missing v6 table should not fail: %v", err)
 	}
@@ -97,7 +97,7 @@ func TestALinkIsReportedOnce(t *testing.T) {
 	write(t, dir, "ipv6_route",
 		"00000000000000000000000000000000 00 00000000000000000000000000000000 00 "+
 			"fe800000000000000000000000000001 00000400 00000001 00000000 00000003     enp9s0\n")
-	got, err := Links(dir, t.TempDir())
+	got, err := Links(dir)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -109,7 +109,7 @@ func TestALinkIsReportedOnce(t *testing.T) {
 // Against this machine's own routing table, so the parse is held to what the kernel actually writes
 // and not only to a fixture written to agree with it.
 func TestAgainstThisMachinesOwnTable(t *testing.T) {
-	got, err := Links("", "")
+	got, err := Links("")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -118,39 +118,3 @@ func TestAgainstThisMachinesOwnTable(t *testing.T) {
 	}
 	t.Logf("this machine's outward links: %v", got)
 }
-
-// sysNet is a /sys/class/net: each name a directory, with a `device` entry when a device backs it.
-func sysNet(t *testing.T, physical []string, virtual []string) string {
-	t.Helper()
-	dir := t.TempDir()
-	for _, name := range physical {
-		if err := os.MkdirAll(filepath.Join(dir, name, "device"), 0o755); err != nil {
-			t.Fatal(err)
-		}
-	}
-	for _, name := range virtual {
-		if err := os.MkdirAll(filepath.Join(dir, name), 0o755); err != nil {
-			t.Fatal(err)
-		}
-	}
-	return dir
-}
-
-// **A physical link faces outside whether or not it carries the default route** (novox/hq issue
-// 197). A machine on its radio with its cable unplugged reported only the radio, and the filter then
-// accepted everything arriving on the cable the moment it was plugged in. Bridges, veths, the tunnel
-// and the loopback have no device behind them and stay this machine's own.
-func TestEveryPhysicalLinkFacesOutsideUpOrDown(t *testing.T) {
-	proc := t.TempDir()
-	write(t, proc, "route", `Iface	Destination	Gateway 	Flags	RefCnt	Use	Metric	Mask		MTU	Window	IRTT
-wlp5s0	00000000	01FEA8C0	0003	0	0	600	00000000	0	0	0
-`)
-	sys := sysNet(t, []string{"wlp5s0", "enp6s0"}, []string{"lo", "docker0", "br-0123456789ab", "veth1", "mesh0"})
-	got, err := Links(proc, sys)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if want := []string{"enp6s0", "wlp5s0"}; !reflect.DeepEqual(got, want) {
-		t.Fatalf("outward links are %v, want %v", got, want)
-	}
-}

internal/profile/detectors.go

@@ -15,9 +15,6 @@ const (
 	CapServiceManager   = "service-manager"
 	CapFirewall         = "firewall"
 	CapOverlay          = "overlay"
-	// CapVirtualisation is a running virtualisation daemon: what the lab raises its machines on
-	// (novox/hq ADR 0172), and what grants a module the daemon's socket.
-	CapVirtualisation   = "virtualisation"
 	CapGraphicalSession = "graphical-session"
 	// CapSeat is hardware: somewhere a display server COULD run. CapGraphicalSession above is
 	// state: whether one IS running. Assignment needs the first.
@@ -208,11 +205,6 @@ func Default(runner Runner) []Detector {
 			why:    "lists the ruleset — needs the tool AND the privilege to use it",
 			runner: runner,
 		},
-		commandCapability{
-			name: CapVirtualisation, command: "incus", args: []string{"info"},
-			why:    "asks the virtualisation daemon about itself — a running daemon, not an installed client",
-			runner: runner,
-		},
 		commandCapability{
 			name: CapOverlay, command: "wg", args: []string{"show", "interfaces"},
 			why:    "asks the kernel for interfaces — needs the module, not just the tool",

internal/system/alpine.go

@@ -46,11 +46,6 @@ func (a alpine) PackageInstalled(ctx context.Context, run Runner, name string) (
 	return strings.TrimSpace(out) != "", nil
 }
 
-func (alpine) RemovePackage(ctx context.Context, run Runner, name string) error {
-	_, err := run(ctx, "apk", "del", name)
-	return err
-}
-
 func (alpine) InstallPackage(ctx context.Context, run Runner, name string) error {
 	_, err := run(ctx, "apk", "add", "--no-cache", name)
 	return err

internal/system/android.go

@@ -65,10 +65,6 @@ func (a android) InstallPackage(context.Context, Runner, string) error {
 	return fmt.Errorf("%w: package", ErrUnsupported)
 }
 
-func (a android) RemovePackage(context.Context, Runner, string) error {
-	return fmt.Errorf("%w: package", ErrUnsupported)
-}
-
 func (a android) ServiceState(context.Context, Runner, string) (string, error) {
 	return "", fmt.Errorf("%w: service (init is not reachable without root)", ErrUnsupported)
 }

internal/system/arch.go

@@ -39,14 +39,6 @@ func (a arch) PackageInstalled(ctx context.Context, run Runner, name string) (bo
 	return true, nil
 }
 
-// RemovePackage removes one package and nothing it depends on: `-R`, not `-Rs`, because what else
-// relied on a dependency is not this declaration's to know. pacman keeps a configuration file the
-// operator changed as `.pacsave`, which is what "never flushed" comes to once the front end is gone.
-func (arch) RemovePackage(ctx context.Context, run Runner, name string) error {
-	_, err := run(ctx, "pacman", "-R", "--noconfirm", name)
-	return err
-}
-
 func (arch) InstallPackage(ctx context.Context, run Runner, name string) error {
 	out, err := run(ctx, "pacman", "-S", "--noconfirm", "--needed", name)
 	if err == nil {

internal/system/system.go

@@ -51,9 +51,6 @@ type System interface {
 
 	PackageInstalled(ctx context.Context, run Runner, name string) (bool, error)
 	InstallPackage(ctx context.Context, run Runner, name string) error
-	// RemovePackage uninstalls one package, leaving its dependencies and anything the operator
-	// changed in its configuration where the package manager leaves them (novox/hq ADR 0180).
-	RemovePackage(ctx context.Context, run Runner, name string) error
 
 	// ServiceState is "running" or "stopped". A unit that does not exist is an error, never
 	// "stopped" — reporting absence as satisfaction is the fault this host exists to prevent.