bastion 0.55.3

client-go/ops_names_linux_test.go

@@ -0,0 +1,79 @@
+package main
+
+// THE SUITE NEVER NAMES THE UNITS A RUNNING BASTION OWNS.
+//
+// The startup sweep (ops_action_linux.go opStartupSweep) stops every unit in
+// the ops' slice whose name has an op's prefix, and a test runs it for real.
+// Under the production names, a suite run on a machine whose own bastion is
+// running an op would stop that op; under names shared between runs, two
+// suites at once would stop each other's. So before any test runs (TestMain),
+// this run takes a slice and prefixes of its own, with its pid and a random
+// number in each.
+
+import (
+	"crypto/rand"
+	"encoding/binary"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// The names every bastion so far gives its ops' slice and units. Written out
+// rather than read from the code: they are what a bastion already installed
+// on the machine uses, whatever this tree says.
+const (
+	opBastionSlice       = "privatae_ops.slice"
+	opBastionActionUnits = "privatae-op-"
+	opBastionScopeUnits  = "privatae-opfiles-"
+)
+
+// opIsolateOpsUnits gives this run its own ops' slice and unit prefixes. A
+// slice name has no "-", which systemd would read as a slice inside another.
+func opIsolateOpsUnits() {
+	var b [4]byte
+	_, _ = rand.Read(b[:])
+	run := fmt.Sprintf("%dx%08x", os.Getpid(), binary.BigEndian.Uint32(b[:]))
+	opActionSlice = "privatae_optest" + run + ".slice"
+	opActionUnitPrefix = "privatae-optest" + run + "-"
+	opScopeUnitPrefix = "privatae-optest" + run + "files-"
+}
+
+// opIsolatedOpsUnitsDone stops this run's own slice, which systemd keeps
+// after its last unit ends. Never a slice a bastion uses.
+func opIsolatedOpsUnitsDone() {
+	if opActionSlice == opBastionSlice || !strings.HasPrefix(opActionSlice, "privatae_optest") {
+		return
+	}
+	if _, err := os.Stat(filepath.Join("/sys/fs/cgroup", opActionSlice)); err == nil {
+		_ = exec.Command("systemctl", "stop", opActionSlice).Run()
+	}
+}
+
+// No name this run gives the ops' slice or units is a bastion's, sits in a
+// bastion's slice, or shares a prefix with a bastion's units either way (so
+// neither sweep takes the other's), and each holds this run's pid.
+func TestTheSuiteNeverNamesTheUnitsABastionOwns(t *testing.T) {
+	if opActionSlice == opBastionSlice || strings.HasPrefix(opActionSlice, strings.TrimSuffix(opBastionSlice, ".slice")+"-") {
+		t.Errorf("the suite's ops' slice is %q: a bastion's own, or inside it", opActionSlice)
+	}
+	for _, mine := range []string{opActionUnitPrefix, opScopeUnitPrefix} {
+		for _, theirs := range []string{opBastionActionUnits, opBastionScopeUnits} {
+			if strings.HasPrefix(mine, theirs) || strings.HasPrefix(theirs, mine) {
+				t.Errorf("the suite's unit prefix %q and a bastion's %q: a sweep under one takes the other's units", mine, theirs)
+			}
+		}
+	}
+	if strings.HasPrefix(opScopeUnitPrefix, opActionUnitPrefix) {
+		t.Errorf("the suite's scope prefix %q starts with its action prefix %q: the action sweep would take a scope for its own", opScopeUnitPrefix, opActionUnitPrefix)
+	}
+	pid := strconv.Itoa(os.Getpid())
+	for _, n := range []string{opActionSlice, opActionUnitPrefix, opScopeUnitPrefix} {
+		if !strings.Contains(n, pid) {
+			t.Errorf("%q does not hold this run's pid %s", n, pid)
+		}
+	}
+}