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 `--`.
104 lines
3.8 KiB
Go
104 lines
3.8 KiB
Go
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) {
|
|
args = oldShape(name, args)
|
|
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) {
|
|
args = oldShape(name, args)
|
|
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) {
|
|
args = oldShape(name, args)
|
|
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())
|
|
}
|