jochen
a018ebd1ca
Third review of mesh-catalog #147. A unit's name can now come from a setting (a template's instance), so every systemctl call that names a unit passes `--` before it, and a name can never be read as an option. On removal, a unit is started or enabled again only when it is exactly the stopped and disabled the mesh held it to. A masked unit, or one somebody started or enabled since, is left as it is, and the report says why. A restore that fails (the start refused, or the unit not running after it) puts back what this attempt changed and is reported as waiting, so no apply is made fatal by it and the next one tries again. The tests' fake service managers read systemctl's arguments in the shape they were written for (oldShape); internal/system's own test holds the `--`.
297 lines
10 KiB
Go
297 lines
10 KiB
Go
package apply
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/novox/mesh-host/internal/store"
|
|
"github.com/novox/mesh-host/internal/system"
|
|
)
|
|
|
|
// Defends novox/hq ADR 0176 §2 and issue 228: a login the mesh set is given back when its holding
|
|
// moves, undeclaring one never stops the node applying, and a shell is checked before it is set.
|
|
|
|
// logins is a fake user database: each account's shell by name, and every command it was asked.
|
|
type logins struct {
|
|
shells map[string]string
|
|
asked []string
|
|
}
|
|
|
|
func (l *logins) run(_ context.Context, name string, args ...string) (string, error) {
|
|
|
|
args = oldShape(name, args)
|
|
l.asked = append(l.asked, name+" "+strings.Join(args, " "))
|
|
who := args[len(args)-1]
|
|
switch name {
|
|
case "getent":
|
|
if shell, ok := l.shells[who]; ok {
|
|
return who + ":x:1500:1500::/home/" + who + ":" + shell + "\n", nil
|
|
}
|
|
return "", errors.New("getent exited 2: ") // the host's runner's words for "no such key"
|
|
case "useradd":
|
|
shell := ""
|
|
for i, a := range args {
|
|
if a == "--shell" {
|
|
shell = args[i+1]
|
|
}
|
|
}
|
|
l.shells[who] = shell
|
|
case "usermod":
|
|
if args[0] == "--shell" {
|
|
l.shells[who] = args[1]
|
|
}
|
|
case "userdel":
|
|
delete(l.shells, who)
|
|
case "id":
|
|
return "\n", nil
|
|
}
|
|
return "", nil
|
|
}
|
|
|
|
func (l *logins) did(prefix string) bool {
|
|
for _, a := range l.asked {
|
|
if strings.HasPrefix(a, prefix) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// shellsOn makes a machine's shells in a directory a test owns: each name an executable file,
|
|
// listed or not in the machine's list of shells as said, which this test's apply then reads.
|
|
func shellsOn(t *testing.T, listed []string, unlisted ...string) string {
|
|
t.Helper()
|
|
dir := t.TempDir()
|
|
var list strings.Builder
|
|
list.WriteString("# Pathnames of valid login shells.\n")
|
|
for _, name := range append(append([]string{}, listed...), unlisted...) {
|
|
if err := os.WriteFile(filepath.Join(dir, name), []byte("#!/bin/sh\n"), 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
for _, name := range listed {
|
|
list.WriteString(filepath.Join(dir, name) + "\n")
|
|
}
|
|
if err := os.WriteFile(filepath.Join(dir, "shells"), []byte(list.String()), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(system.ShellsIn(filepath.Join(dir, "shells")))
|
|
return dir
|
|
}
|
|
|
|
func applyUsers(t *testing.T, l *logins, known store.State, resources string) (Report, store.State, error) {
|
|
t.Helper()
|
|
if resources == "" {
|
|
// Undeclared: something else stays, since a declaration with nothing in it is refused.
|
|
resources = `{"id":"other.dir","type":"directory","path":"` + t.TempDir() + `/other"}`
|
|
}
|
|
return Apply(context.Background(), archHost(t), parse(t, `{"declaration":1,"resources":[`+resources+`]}`),
|
|
known, store.OriginDeclared, l.run, nil, nil)
|
|
}
|
|
|
|
func userWith(shell string) string {
|
|
return `{"id":"shell.login","type":"user","name":"operator","shell":"` + shell + `"}`
|
|
}
|
|
|
|
func TestAnUndeclaredUserNoLongerStopsTheApply(t *testing.T) {
|
|
// Before issue 228 the host had no removal for a user, the orphan failed with "no way to
|
|
// remove", and an orphan's failure aborts the apply before its first resource — on every
|
|
// apply after, since the record stayed.
|
|
dir := shellsOn(t, []string{"bash", "zsh"})
|
|
l := &logins{shells: map[string]string{"operator": dir + "/bash"}}
|
|
_, state, err := applyUsers(t, l, store.State{}, userWith(dir+"/zsh"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
page := filepath.Join(t.TempDir(), "page")
|
|
report, state, err := applyUsers(t, l, state,
|
|
`{"id":"web.page","type":"file","path":"`+page+`","content":"hello\n"}`)
|
|
if err != nil {
|
|
t.Fatalf("an undeclared user stopped the apply: %v", err)
|
|
}
|
|
if _, err := os.Stat(page); err != nil {
|
|
t.Errorf("a file in the same declaration was not written: %v", err)
|
|
}
|
|
if o := outcomeOf(report, "shell.login"); o.Action == "" {
|
|
t.Errorf("the user's removal was not reported: %+v", report.Outcomes)
|
|
}
|
|
if _, still := state.Find("shell.login"); still {
|
|
t.Error("the user is still recorded, so the next apply would meet it again")
|
|
}
|
|
}
|
|
|
|
func TestTheShellFoundIsGivenBackWhenTheUserIsUndeclared(t *testing.T) {
|
|
dir := shellsOn(t, []string{"bash", "zsh"})
|
|
l := &logins{shells: map[string]string{"operator": dir + "/bash"}}
|
|
_, state, err := applyUsers(t, l, store.State{}, userWith(dir+"/zsh"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if l.shells["operator"] != dir+"/zsh" {
|
|
t.Fatalf("the declared shell was not set: %q", l.shells["operator"])
|
|
}
|
|
if r, _ := state.Find("shell.login"); r.Shell == nil || r.Shell.Found != dir+"/bash" {
|
|
t.Fatalf("the shell the account had was not recorded: %+v", r.Shell)
|
|
}
|
|
|
|
report, _, err := applyUsers(t, l, state, "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if l.shells["operator"] != dir+"/bash" {
|
|
t.Errorf("the shell the account had was not given back: %q", l.shells["operator"])
|
|
}
|
|
if o := outcomeOf(report, "shell.login"); o.Action != "restored" {
|
|
t.Errorf("the give-back was not said: %+v", o)
|
|
}
|
|
if l.did("userdel") {
|
|
t.Error("the account was deleted")
|
|
}
|
|
}
|
|
|
|
func TestAShellAPersonChangedSinceIsLeftAlone(t *testing.T) {
|
|
dir := shellsOn(t, []string{"bash", "zsh", "fish"})
|
|
l := &logins{shells: map[string]string{"operator": dir + "/bash"}}
|
|
_, state, err := applyUsers(t, l, store.State{}, userWith(dir+"/zsh"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
l.shells["operator"] = dir + "/fish" // chsh, by the person whose login it is
|
|
l.asked = nil
|
|
|
|
report, _, err := applyUsers(t, l, state, "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if l.did("usermod") || l.shells["operator"] != dir+"/fish" {
|
|
t.Errorf("a shell a person chose was taken from them: %q, %v", l.shells["operator"], l.asked)
|
|
}
|
|
if o := outcomeOf(report, "shell.login"); o.Action != "forgotten" || !strings.Contains(o.Detail, "changed since") {
|
|
t.Errorf("the outcome does not say why the shell was left: %+v", o)
|
|
}
|
|
}
|
|
|
|
func TestAFoundShellThatIsGoneIsNotGivenBack(t *testing.T) {
|
|
// Giving back a shell uninstalled since would break the logins the giving back is for.
|
|
dir := shellsOn(t, []string{"bash", "zsh"})
|
|
l := &logins{shells: map[string]string{"operator": dir + "/bash"}}
|
|
_, state, err := applyUsers(t, l, store.State{}, userWith(dir+"/zsh"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.Remove(dir + "/bash"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
l.asked = nil
|
|
report, _, err := applyUsers(t, l, state, "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if l.did("usermod") || l.shells["operator"] != dir+"/zsh" {
|
|
t.Errorf("a shell no longer on the machine was given back: %q", l.shells["operator"])
|
|
}
|
|
if o := outcomeOf(report, "shell.login"); !strings.Contains(o.Detail, "cannot be given back") {
|
|
t.Errorf("the outcome does not say why the shell was left: %+v", o)
|
|
}
|
|
}
|
|
|
|
func TestAShellThatIsMissingOrUnlistedIsRefusedBeforeItIsSet(t *testing.T) {
|
|
dir := shellsOn(t, []string{"bash"}, "unlisted")
|
|
for name, shell := range map[string]string{
|
|
"missing": dir + "/zsh",
|
|
"unlisted": dir + "/unlisted",
|
|
} {
|
|
t.Run(name, func(t *testing.T) {
|
|
l := &logins{shells: map[string]string{"operator": dir + "/bash"}}
|
|
page := filepath.Join(t.TempDir(), "page")
|
|
report, state, err := applyUsers(t, l, store.State{}, userWith(shell)+`,
|
|
{"id":"web.page","type":"file","path":"`+page+`","content":"hello\n"}`)
|
|
if err == nil {
|
|
t.Fatal("the refused shell did not fail its resource")
|
|
}
|
|
if l.did("usermod") || l.shells["operator"] != dir+"/bash" {
|
|
t.Errorf("the account was changed: %q, %v", l.shells["operator"], l.asked)
|
|
}
|
|
if _, recorded := state.Find("shell.login"); recorded {
|
|
t.Error("a refused user was recorded")
|
|
}
|
|
if o := outcomeOf(report, "web.page"); o.Action != "created" {
|
|
t.Errorf("the refusal stopped the rest of the declaration: %+v", report.Outcomes)
|
|
}
|
|
})
|
|
}
|
|
t.Run("an account not yet made", func(t *testing.T) {
|
|
l := &logins{shells: map[string]string{}}
|
|
if _, _, err := applyUsers(t, l, store.State{}, userWith(dir+"/zsh")); err == nil {
|
|
t.Fatal("the missing shell was not refused")
|
|
}
|
|
if l.did("useradd") {
|
|
t.Errorf("the account was made with a shell that is not there: %v", l.asked)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestAnAccountThatRefusesLoginsNeedNotBeListed(t *testing.T) {
|
|
// A service's account has nologin, which no distribution lists among its shells; refusing it
|
|
// would refuse the controller's own account.
|
|
dir := shellsOn(t, []string{"bash"}, "nologin")
|
|
l := &logins{shells: map[string]string{}}
|
|
if _, _, err := applyUsers(t, l, store.State{}, userWith(dir+"/nologin")); err != nil {
|
|
t.Fatalf("a service account was refused: %v", err)
|
|
}
|
|
if l.shells["operator"] != dir+"/nologin" {
|
|
t.Errorf("the account was not made: %v", l.asked)
|
|
}
|
|
}
|
|
|
|
func TestACreatedAccountSurvivesItsRemoval(t *testing.T) {
|
|
dir := shellsOn(t, []string{"zsh"})
|
|
l := &logins{shells: map[string]string{}}
|
|
report, state, err := applyUsers(t, l, store.State{}, userWith(dir+"/zsh"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if o := outcomeOf(report, "shell.login"); o.Action != "created" {
|
|
t.Fatalf("the account was not created: %+v", o)
|
|
}
|
|
l.asked = nil
|
|
report, _, err = applyUsers(t, l, state, "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, still := l.shells["operator"]; !still || l.did("userdel") || l.did("usermod") {
|
|
t.Errorf("a created account was not left as it is: %v", l.asked)
|
|
}
|
|
if o := outcomeOf(report, "shell.login"); !strings.Contains(o.Detail, "account is kept") {
|
|
t.Errorf("the outcome does not say the account was kept: %+v", o)
|
|
}
|
|
}
|
|
|
|
func TestTheFoundShellIsNotOverwrittenByASecondChange(t *testing.T) {
|
|
// The holding moves from one shell module to another: what is given back in the end is the
|
|
// shell from before the mesh, not the first module's.
|
|
dir := shellsOn(t, []string{"bash", "zsh", "fish"})
|
|
l := &logins{shells: map[string]string{"operator": dir + "/bash"}}
|
|
_, state, err := applyUsers(t, l, store.State{}, userWith(dir+"/zsh"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, state, err = applyUsers(t, l, state, userWith(dir+"/fish"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if r, _ := state.Find("shell.login"); r.Shell == nil || r.Shell.Found != dir+"/bash" || r.Shell.Set != dir+"/fish" {
|
|
t.Fatalf("the record is not the shell found and the one set last: %+v", r.Shell)
|
|
}
|
|
if _, _, err := applyUsers(t, l, state, ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if l.shells["operator"] != dir+"/bash" {
|
|
t.Errorf("given back %q, not the shell from before the mesh", l.shells["operator"])
|
|
}
|
|
}
|