package catalogue import ( "testing" ) // The mesh has two resolvers (novox/hq ADR 0223): `mesh-dns-resolver` is replicated, held on the // anchor and on the home server, each answering the same names; every machine's resolver file lists // every holder — its own first when it is one — and no public resolver. ADR 0196 listed the mesh's // resolver then a public one, and musl asks both at once and takes the first reply: from the home // server the public "no such name" for the anchor's mesh name won, every time, in every Alpine build. // The file is written by the module holding the machine's uplink (ADR 0223 part 2). // resolverMachines is the anchor and the home server holding the resolver, and a laptop holding nothing. var resolverMachines = map[string]string{ "anchor.internal": "10.42.0.1", "laptop.internal": "10.42.0.2", "home.internal": "10.42.0.3"} // bothResolvers is the two holders on record, as `seat mesh-dns-resolver --add` leaves them. var bothResolvers = []Held{ {Claim: "mesh-dns-resolver", Scope: ScopeMesh, Node: "anchor", Module: "dnsmasq"}, {Claim: "mesh-dns-resolver", Scope: ScopeMesh, Node: "home", Module: "dnsmasq"}, } // uplinks is every module in the catalogue holding node-uplink, and so writing the machine's resolver // file (novox/hq ADR 0223 part 2): the program that would otherwise rewrite it is the one that writes it. // dhcpcd's left the catalogue with ADR 0226, held by no machine. var uplinks = []string{"networkmanager", "systemd-networkd"} // managing is a machine as each uplink module needs it: able to install, run a service and run the // manager that module is for. func managing(node string) Node { caps := map[string]bool{"package-manager": true, "service-manager": true} for _, u := range uplinks { caps["uplink-"+u] = true } return Node{Name: node, At: node + ".internal", Capabilities: caps} } // twoResolverShelf is the resolver, the uplink modules that write what a machine asks, and a stand-in // answering `mesh-addressing`. func twoResolverShelf(t *testing.T) map[string]Manifest { t.Helper() out := map[string]Manifest{ "net": {Module: "net", Version: "1", Provides: []Offer{{Name: "mesh-addressing"}}}, "dnsmasq": catalogueManifest(t, "dnsmasq"), } for _, u := range uplinks { out[u] = catalogueManifest(t, u) } return out } // worldWithout is the rest of the mesh as a plan for one machine sees it: every other holder's claim // and offer, and both holders on record. func worldWithout(node string) World { w := World{Holdings: bothResolvers, Offered: map[string][]Provider{}} for _, h := range bothResolvers { if h.Node == node { continue } w.Held = append(w.Held, h) w.Offered["wildcard-resolution"] = append(w.Offered["wildcard-resolution"], Provider{Node: h.Node, At: h.Node + ".internal", Module: h.Module}) } return w } // One file, whichever manager the machine runs: the three modules carry the same template, so a // machine changing its manager changes nothing in what it asks, and a fix made to one is made to all. func TestEveryUplinkWritesTheSameResolverFile(t *testing.T) { var first, firstOf string for _, uplink := range uplinks { fact, ok := catalogueManifest(t, uplink).Facts["resolvers"] if !ok || fact.Path != "/etc/resolv.conf" || fact.Shared || fact.Home { t.Fatalf("%s does not write the machine's resolver file whole: %+v", uplink, fact) } if first == "" { first, firstOf = fact.Template, uplink continue } if fact.Template != first { t.Errorf("%s's resolver file differs from %s's; the three are kept identical", uplink, firstOf) } } } // Only the mesh's resolver is replicated: a seat being replicated is a decision, recorded. func TestOnlyTheResolverIsReplicated(t *testing.T) { for _, s := range Seats() { if s.Replicated != (s.Name == "mesh-dns-resolver") { t.Errorf("%s replicated = %v; only mesh-dns-resolver is (ADR 0223)", s.Name, s.Replicated) } } }