jochen
a3e8a4185b
`assign` recorded a module and `push` sealed a random own secret where its bus credential belongs; the process crash-looped until a person ran `module issue` and pushed again, and the only warning was one line in a list printed on every push. Now assigning a module that declares a broker secret issues the credential in the same act — kept when one exists, so re-assigning rotates nothing — and when the bus cannot be reached from here the assignment says which verb to run. A push never seals a placeholder in a credential's place: a module whose bus user is unminted is refused by name, with the verb. The control plane's own user is the installer's, seeded at genesis, which the test now says. And what reads one of a module's own secrets is restarted when it changes — composed for a container or daemon that names the secret's path in its volumes, environment or env-files, so a manifest need not say it: the build machine ran on an hour-old credential because its manifest restarted it on its environment file alone (issue 206). A scheduled or run-once process is left alone; it reads afresh.
91 lines
3.3 KiB
Go
91 lines
3.3 KiB
Go
package main
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/novox/mesh-controller/internal/catalogue"
|
|
"github.com/novox/mesh-controller/internal/inventory"
|
|
)
|
|
|
|
// A fresh assignment is pushed before its credential exists (novox/hq issue 203): `assign` recorded
|
|
// the module, `push` sealed a random own secret where the bus credential belongs, and the process
|
|
// crash-looped until a person ran `module issue` and pushed again. Now assigning a module that speaks
|
|
// on the bus issues its credential in the same act — or, when the bus cannot be reached from here,
|
|
// says which verb to run — and a push never seals a placeholder in a credential's place.
|
|
|
|
func aTalker() catalogue.Manifest {
|
|
return catalogue.Manifest{Module: "talker", Version: "1",
|
|
OwnSecrets: catalogue.OwnSecrets{"broker": {Path: "/var/lib/mesh/talker/broker"}},
|
|
Resources: []map[string]any{
|
|
{"id": "state", "type": "directory", "path": "/var/lib/mesh/talker", "mode": "0700"},
|
|
}}
|
|
}
|
|
|
|
func TestAssigningAModuleThatSpeaksOnTheBusNamesItsCredential(t *testing.T) {
|
|
open := aMesh(t)
|
|
ctx := t.Context()
|
|
register(t, open, aTalker())
|
|
|
|
// No bus is known to this process, so the credential cannot be issued here: the assignment
|
|
// stands and says exactly what must happen before a push — never silently.
|
|
said, err := assign(ctx, open, "laptop", "talker")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !strings.Contains(said, "module issue talker --node laptop") {
|
|
t.Fatalf("an assignment whose credential could not be issued does not name the verb:\n%s", said)
|
|
}
|
|
|
|
// And the push refuses to send it, naming the same verb, rather than sealing a placeholder.
|
|
plan, settings, err := planFor(ctx, open, "laptop")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, err = declarationFor(ctx, open, "laptop", plan, settings)
|
|
if err == nil {
|
|
t.Fatal("a push sealed a placeholder where talker's bus credential belongs")
|
|
}
|
|
if !strings.Contains(err.Error(), "module issue talker --node laptop") || !strings.Contains(err.Error(), "issue 203") {
|
|
t.Fatalf("the refusal does not say what to run: %v", err)
|
|
}
|
|
|
|
// Once the user is minted, the push goes on to the credential the mesh sealed, and re-assigning
|
|
// does not mint again: a credential rotates on purpose, never by habit.
|
|
if _, err := open.inventory.MintBusPassword(ctx, inventory.BusUser{
|
|
Username: "laptop.talker", Kind: inventory.BusModule, Node: "laptop", Module: "talker"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
hash, _, err := open.inventory.BusUserHash(ctx, "laptop.talker")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
said, err = assign(ctx, open, "laptop", "talker")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if strings.Contains(said, "module issue") {
|
|
t.Fatalf("a module with a minted credential was told to issue one:\n%s", said)
|
|
}
|
|
again, _, err := open.inventory.BusUserHash(ctx, "laptop.talker")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if again != hash {
|
|
t.Fatal("re-assigning rotated the credential")
|
|
}
|
|
}
|
|
|
|
// A module that declares no broker secret is left alone: nothing to issue, nothing said.
|
|
func TestAssigningAModuleThatDoesNotSpeakSaysNothingOfCredentials(t *testing.T) {
|
|
open := aMesh(t)
|
|
register(t, open, helloWeb())
|
|
said, err := assign(t.Context(), open, "laptop", "hello-web")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if strings.Contains(said, "credential") {
|
|
t.Fatalf("a module without a broker secret was told about credentials:\n%s", said)
|
|
}
|
|
}
|