jschoubben
8ceec32692
A node carries its operator account (name + home; migration 0036, Node.Account,
SetAccount, 'node account' CLI). The account and its home are offered as
machine facts ${machine:account} / ${machine:account-home}, and machineInto
now resolves placeholders in a resource's path and owner (not just content), so
a module writes into a person's home naming what it cannot know. A RosterFile
gains Home: the file is placed under the account's home and chowned to it, its
template sees each node's Account, and a machine with no account gets none —
this is how the ssh Host blocks for every node reach a person's ~/.ssh. Roster
carries per-node accounts (Rendering.Accounts). Tested, including ssh-client
composed end-to-end. Not deployed.
261 lines
12 KiB
Go
261 lines
12 KiB
Go
package catalogue
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
// Keyed by the internal name, as the control plane hands them (issue 079). bart has no address —
|
|
// the ordinary state between adding a machine and it joining.
|
|
var threeMachines = map[string]string{"homer.internal": "10.42.0.1", "marge.internal": "10.42.0.2", "bart.internal": ""}
|
|
|
|
// A module says where it wants a roster file and in what format, and is given the rendered file.
|
|
func TestAModuleIsGivenTheFileItAskedFor(t *testing.T) {
|
|
m := Manifest{Module: "resolver", Facts: map[string]RosterFile{
|
|
"zones": {Path: "/etc/mesh/zones.conf", Template: "{{range .Machines}}address=/{{.FQDN}}/{{.Address}}\n{{end}}"},
|
|
}}
|
|
given, err := FactsInto(m, Resolution{Node: "homer"}, threeMachines, threeMachines, nil, "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(given) != 1 {
|
|
t.Fatalf("expected one file, got %d", len(given))
|
|
}
|
|
if given[0]["path"] != "/etc/mesh/zones.conf" || given[0]["type"] != "file" {
|
|
t.Fatalf("not written where it was asked for: %v", given[0])
|
|
}
|
|
// The id is fact-<name>, which is what a restart-on names when the roster changes.
|
|
if given[0]["id"] != "fact-zones" {
|
|
t.Fatalf("the file's id is not fact-<name>, so a restart-on cannot find it: %v", given[0]["id"])
|
|
}
|
|
if !strings.Contains(given[0]["content"].(string), "address=/homer.internal/10.42.0.1") {
|
|
t.Fatalf("the file does not hold the fact: %v", given[0]["content"])
|
|
}
|
|
}
|
|
|
|
// **A shared fact is written into a region of the machine's file, not over it** (novox/hq issue
|
|
// 128). A hosts file is the machine's — its localhost, the operator's lines, other tools' blocks —
|
|
// so the mesh owns only a marked region (`into: block`); a resolver's zones file is the mesh's
|
|
// whole, and carries no `into`.
|
|
func TestASharedFactIsWrittenIntoARegion(t *testing.T) {
|
|
roster := map[string]string{"homer.internal": "10.42.0.1"}
|
|
m := Manifest{Module: "net", Facts: map[string]RosterFile{
|
|
"node-names": {Path: "/etc/hosts", Template: "{{range .Names}}{{.FQDN}}\n{{end}}", Shared: true},
|
|
"node-zones": {Path: "/etc/zones", Template: "{{range .Machines}}{{.FQDN}}\n{{end}}"},
|
|
}}
|
|
given, err := FactsInto(m, Resolution{Node: "homer"}, roster, roster, nil, "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
by := map[string]map[string]any{}
|
|
for _, f := range given {
|
|
by[f["path"].(string)] = f
|
|
}
|
|
if by["/etc/hosts"]["into"] != "block" {
|
|
t.Fatalf("a shared fact is not written into a region, so the mesh writes the file whole: %v", by["/etc/hosts"])
|
|
}
|
|
if _, has := by["/etc/zones"]["into"]; has {
|
|
t.Fatalf("an unshared fact was written into a region, so the mesh does not own its own file whole: %v", by["/etc/zones"])
|
|
}
|
|
}
|
|
|
|
// **The format is the module's — the mesh renders whatever template it gives.** The same roster
|
|
// through two templates is two entirely different files, and the control plane reads neither.
|
|
func TestTheFormatIsTheModulesOwn(t *testing.T) {
|
|
roster := map[string]string{"homer.internal": "10.42.0.1"}
|
|
hostsish := Manifest{Module: "a", Facts: map[string]RosterFile{
|
|
"f": {Path: "/f", Template: "{{range .Names}}{{.Address}}\t{{.Name}}\n{{end}}"}}}
|
|
sshish := Manifest{Module: "b", Facts: map[string]RosterFile{
|
|
"f": {Path: "/f", Template: "{{range .Names}}Host {{.Name}}\n HostName {{.FQDN}}\n{{end}}"}}}
|
|
|
|
h, err := FactsInto(hostsish, Resolution{Node: "homer"}, roster, roster, nil, "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
s, err := FactsInto(sshish, Resolution{Node: "homer"}, roster, roster, nil, "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if h[0]["content"] != "10.42.0.1\thomer\n" {
|
|
t.Fatalf("the hosts-shaped template did not render its format: %q", h[0]["content"])
|
|
}
|
|
if s[0]["content"] != "Host homer\n HostName homer.internal\n" {
|
|
t.Fatalf("the ssh-shaped template did not render its format: %q", s[0]["content"])
|
|
}
|
|
}
|
|
|
|
// **A template that will not parse is refused here, not on a machine.** A daemon that starts, reads
|
|
// a file the mesh could not render, and answers nothing is a much worse way to find out.
|
|
func TestABrokenTemplateIsRefusedHere(t *testing.T) {
|
|
m := Manifest{Module: "resolver", Facts: map[string]RosterFile{
|
|
"zones": {Path: "/etc/zones", Template: "{{range .Machines}}oops"}}}
|
|
_, err := FactsInto(m, Resolution{}, nil, nil, nil, "")
|
|
if err == nil {
|
|
t.Fatal("a template that does not parse was accepted, so the machine gets an empty file")
|
|
}
|
|
if !strings.Contains(err.Error(), "resolver") || !strings.Contains(err.Error(), "zones") {
|
|
t.Fatalf("the refusal does not say whose template, or which: %v", err)
|
|
}
|
|
}
|
|
|
|
// A template reading something the mesh does not compute is refused, not rendered empty. The roster
|
|
// is a closed shape; asking it for the weather fails where the manifest is.
|
|
func TestATemplateReadingWhatTheMeshDoesNotHaveIsRefused(t *testing.T) {
|
|
m := Manifest{Module: "resolver", Facts: map[string]RosterFile{
|
|
"zones": {Path: "/etc/zones", Template: "{{.Weather}}"}}}
|
|
if _, err := FactsInto(m, Resolution{}, nil, nil, nil, ""); err == nil {
|
|
t.Fatal("a template read a field nobody computes and rendered anyway, silently")
|
|
}
|
|
}
|
|
|
|
// A relative path is refused, or a module decides where the mesh writes on a machine.
|
|
func TestAFactMustBeAskedForAtAnAbsolutePath(t *testing.T) {
|
|
m := Manifest{Module: "resolver", Facts: map[string]RosterFile{
|
|
"hosts": {Path: "etc/hosts", Template: "x"}}}
|
|
if _, err := FactsInto(m, Resolution{}, nil, nil, nil, ""); err == nil {
|
|
t.Fatal("a relative path was accepted")
|
|
}
|
|
}
|
|
|
|
// A machine the mesh has a record for and cannot place is left out of the roster.
|
|
//
|
|
// **Not an oversight — the alternative is worse.** A name written with no address resolves to
|
|
// nothing, and a connection to that hangs. Leaving it out fails at once and says the name is
|
|
// unknown, which is a thing somebody can act on.
|
|
func TestAMachineWithNoAddressIsNotInTheRoster(t *testing.T) {
|
|
m := Manifest{Module: "a", Facts: map[string]RosterFile{
|
|
"f": {Path: "/f", Template: "{{range .Machines}}{{.Name}}\n{{end}}"}}}
|
|
given, err := FactsInto(m, Resolution{Node: "homer"}, threeMachines, threeMachines, nil, "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if strings.Contains(given[0]["content"].(string), "bart") {
|
|
t.Fatalf("a machine with no address was in the roster, so its name resolves to nothing:\n%s", given[0]["content"])
|
|
}
|
|
}
|
|
|
|
// **The names the control plane hands a resolution are already internal names** — `homer.internal`,
|
|
// the same map every container gets as its hosts. A roster entry's FQDN is that name, not it with
|
|
// the suffix appended a second time; either key gives the same entries.
|
|
func TestNamesAreNotSuffixedTwice(t *testing.T) {
|
|
internal := map[string]string{"homer.internal": "10.42.0.1"}
|
|
bare := map[string]string{"homer": "10.42.0.1"}
|
|
tmpl := RosterFile{Path: "/f", Template: "{{range .Machines}}{{.FQDN}} {{.Name}}\n{{end}}"}
|
|
|
|
fromInternal, err := FactsInto(Manifest{Module: "a", Facts: map[string]RosterFile{"f": tmpl}}, Resolution{Node: "homer"}, internal, internal, nil, "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
fromBare, err := FactsInto(Manifest{Module: "a", Facts: map[string]RosterFile{"f": tmpl}}, Resolution{Node: "homer"}, bare, bare, nil, "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if fromInternal[0]["content"] != fromBare[0]["content"] {
|
|
t.Fatalf("the roster differs by how the names were keyed:\n%q\n%q", fromInternal[0]["content"], fromBare[0]["content"])
|
|
}
|
|
got := fromInternal[0]["content"].(string)
|
|
if strings.Contains(got, "internal.internal") || !strings.Contains(got, "homer.internal homer") {
|
|
t.Fatalf("the entry carries a doubled suffix or the wrong bare name:\n%s", got)
|
|
}
|
|
}
|
|
|
|
// The suffix the control plane composed the names with is the one a template sees — an operator who
|
|
// chose another does not get `.internal`. `.Suffix` is the bare form, and FQDNs carry it.
|
|
func TestTheSuffixIsCarriedAsComposed(t *testing.T) {
|
|
names := map[string]string{"homer.lan": "10.42.0.1"}
|
|
m := Manifest{Module: "a", Facts: map[string]RosterFile{
|
|
"f": {Path: "/f", Template: "local=/{{.Suffix}}/\n{{range .Machines}}{{.FQDN}}\n{{end}}"}}}
|
|
given, err := FactsInto(m, Resolution{Node: "homer"}, names, names, nil, "lan")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got := given[0]["content"].(string)
|
|
if !strings.Contains(got, "local=/lan/") || strings.Contains(got, "internal") {
|
|
t.Fatalf("the operator's suffix was not carried, so its names would be wrong:\n%s", got)
|
|
}
|
|
if !strings.Contains(got, "homer.lan") {
|
|
t.Fatalf("the FQDN does not carry the operator's suffix:\n%s", got)
|
|
}
|
|
}
|
|
|
|
// novox/hq 04-ISSUES/111: a template is given both sets and chooses. `.Names` is every name the mesh
|
|
// serves — the machines and the names it was told to route; `.Machines` is only the machines. A
|
|
// container's hosts wants every name so a routed name resolves to the machine serving it; a resolver
|
|
// told the suffix is its own wants only the machines, or a routed name written there with the suffix
|
|
// is a name nobody will ever ask for, standing beside the machines and looking as real.
|
|
func TestATemplateChoosesMachinesOrEveryName(t *testing.T) {
|
|
machines := map[string]string{"homer.internal": "10.42.0.1", "marge.internal": "10.42.0.2"}
|
|
every := map[string]string{
|
|
"homer.internal": "10.42.0.1", "marge.internal": "10.42.0.2",
|
|
"drive.example.test": "10.42.0.1", "git.example.test": "10.42.0.2",
|
|
}
|
|
m := Manifest{Module: "resolver", Facts: map[string]RosterFile{
|
|
"zones": {Path: "/etc/zones", Template: "{{range .Machines}}{{.FQDN}}\n{{end}}"},
|
|
"hosts": {Path: "/etc/hosts", Template: "{{range .Names}}{{.FQDN}}\n{{end}}"},
|
|
}}
|
|
given, err := FactsInto(m, Resolution{Node: "homer"}, every, machines, nil, "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
by := map[string]string{}
|
|
for _, f := range given {
|
|
by[f["path"].(string)] = f["content"].(string)
|
|
}
|
|
|
|
zones := by["/etc/zones"]
|
|
for _, served := range []string{"drive.example.test", "git.example.test"} {
|
|
if strings.Contains(zones, served) {
|
|
t.Fatalf("a template over .Machines saw %q, a name the mesh serves rather than a machine:\n%s", served, zones)
|
|
}
|
|
}
|
|
if !strings.Contains(zones, "homer.internal") {
|
|
t.Fatalf("a template over .Machines did not see the machines:\n%s", zones)
|
|
}
|
|
|
|
hosts := by["/etc/hosts"]
|
|
for _, name := range []string{"homer.internal", "drive.example.test", "git.example.test"} {
|
|
if !strings.Contains(hosts, name) {
|
|
t.Fatalf("a template over .Names did not see %q, so a container would not resolve it:\n%s", name, hosts)
|
|
}
|
|
}
|
|
}
|
|
|
|
// A home fact is placed under the operator account's home and chowned to it, and its template sees
|
|
// each node's account (novox/hq to-be 29) — the ssh-client config is the case.
|
|
func TestAHomeFactIsPlacedUnderTheAccountsHomeAndOwnedByIt(t *testing.T) {
|
|
names := map[string]string{"homer.internal": "10.42.0.1", "marge.internal": "10.42.0.2"}
|
|
accounts := map[string]string{"homer": "jo", "marge": "jo"}
|
|
m := Manifest{Module: "ssh-client", Facts: map[string]RosterFile{
|
|
"ssh-config": {Path: ".ssh/config.d/mesh", Home: true,
|
|
Template: "{{range .Names}}Host {{.Name}}\n HostName {{.FQDN}}\n User {{.Account}}\n{{end}}"}}}
|
|
given, err := FactsInto(m, Resolution{Node: "homer", Account: "jo"}, names, names, accounts, "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
f := given[0]
|
|
if f["path"] != "/home/jo/.ssh/config.d/mesh" {
|
|
t.Fatalf("the home fact was not placed under the account's home: %v", f["path"])
|
|
}
|
|
if f["owner"] != "jo" {
|
|
t.Fatalf("the home fact is not owned by the account: %v", f["owner"])
|
|
}
|
|
if !strings.Contains(f["content"].(string), "Host marge\n HostName marge.internal\n User jo") {
|
|
t.Fatalf("the config does not name the peer's account:\n%s", f["content"])
|
|
}
|
|
}
|
|
|
|
// A machine with no operator account gets no home fact — it cannot be placed, so it is left out
|
|
// rather than written to nowhere.
|
|
func TestAHomeFactIsSkippedWhereThereIsNoAccount(t *testing.T) {
|
|
names := map[string]string{"homer.internal": "10.42.0.1"}
|
|
m := Manifest{Module: "ssh-client", Facts: map[string]RosterFile{
|
|
"ssh-config": {Path: ".ssh/config", Home: true, Template: "x"}}}
|
|
given, err := FactsInto(m, Resolution{Node: "homer"}, names, names, nil, "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(given) != 0 {
|
|
t.Fatalf("a home fact was placed on a machine with no operator account: %v", given)
|
|
}
|
|
}
|