Where the answer to a requirement is allowed to live

Two different things were both written `requires`. A shell, a display
server and a private network have to be on the machine that needs them.
A database does not — it runs somewhere and is reached over the network.
Both were answered the same way, so requiring a database installed
PostgreSQL on every machine that ran a web application.

What a module provides now carries a scope, the same idea claims already
use, written short in the ordinary case:

  "provides": ["shell"]
  "provides": [{"name": "database", "scope": "mesh"}]

A mesh-scoped requirement is answered by finding the node already running
it — never by installing it here. Choosing a machine to put a database on
is a decision with consequences, and nothing resolving a web application
should make it silently. With nothing anywhere it refuses and says which
module to assign; with two it refuses and says how to choose.

Choosing is `pin <node> <provision> <from>`, kept per node because that
is the granularity the choice has. A pin at a machine that does not
provide it refuses rather than falling back — a fallback would quietly
move somebody's data. One provider does not overrule a pin either.

Resolving a node now needs to know what the others offer, and working
that out needs them resolved, so it is two passes: the first answers only
what each node offers, the second answers everything. Nothing is ever
declared from the first.

A node's plan says what it takes from elsewhere. It is the only part of a
set that stops working when a different machine goes away, and nothing
else in that output would have said so. It is also where a credential
will hang once there is a mechanism for handing one back.

One test found passing for the wrong reason: it read pins through a join
on the provider, which hides a dangling row whether or not it was cleaned
up. It counts rows now, and bites when the cascade is removed.

internal/catalogue/domain_test.go

@@ -16,10 +16,10 @@ func networkingShelf(extra ...Manifest) map[string]Manifest {
 	base := []Manifest{
 		{Module: "networking", Requires: []string{"private-network", "name-resolution"}},
 		{Module: "mesh-wireguard", Computed: "mesh-wireguard",
-			Provides: []string{"private-network", "mesh-addressing"},
+			Provides: Offers("private-network", "mesh-addressing"),
 			Claims:   []Claim{{Name: "the-private-network", Scope: ScopeNode}}},
 		{Module: "mesh-names", Computed: "mesh-names",
-			Provides: []string{"name-resolution"}, Requires: []string{"mesh-addressing"}},
+			Provides: Offers("name-resolution"), Requires: []string{"mesh-addressing"}},
 	}
 	return shelf(append(base, extra...)...)
 }
@@ -27,7 +27,7 @@ func networkingShelf(extra ...Manifest) map[string]Manifest {
 func TestOneWordBringsUpTheNetwork(t *testing.T) {
 	// The case that has to stay easy. Nothing is asked, because with one answer to each
 	// requirement there was never a question.
-	got, err := Resolve(networkingShelf(), []string{"networking"}, workstation(), nil)
+	got, err := Resolve(networkingShelf(), []string{"networking"}, workstation(), World{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -43,9 +43,10 @@ func TestASecondVPNTurnsItIntoAChoice(t *testing.T) {
 	// And the choice is offered rather than made. A default here would be the flavor field coming
 	// back under another name.
 	_, err := Resolve(networkingShelf(
-		Manifest{Module: "tailscale", Provides: []string{"private-network"},
+		Manifest{Module: "tailscale", Provides: Offers("private-network"),
 			Claims: []Claim{{Name: "the-private-network", Scope: ScopeNode}}},
-	), []string{"networking"}, workstation(), nil)
+	), []string{"networking"}, workstation(), World{})
+
 	if err == nil {
 		t.Fatal("two VPNs and one was picked silently")
 	}
@@ -60,9 +61,10 @@ func TestChoosingIsAssigning(t *testing.T) {
 	// No second verb. Assigning the one you want answers the requirement, and the bundle takes it.
 	got, err := Resolve(networkingShelf(
 		Manifest{Module: "tailscale",
-			Provides: []string{"private-network", "name-resolution"},
+			Provides: Offers("private-network", "name-resolution"),
 			Claims:   []Claim{{Name: "the-private-network", Scope: ScopeNode}}},
-	), []string{"networking", "tailscale"}, workstation(), nil)
+	), []string{"networking", "tailscale"}, workstation(), World{})
+
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -82,9 +84,10 @@ func TestChoosingOneVPNCannotDragTheOtherBackIn(t *testing.T) {
 	// The claim is what catches it. Providing a private network is not the singular part — a
 	// machine could run two VPNs for two purposes — but being *the* one the mesh runs over is.
 	_, err := Resolve(networkingShelf(
-		Manifest{Module: "tailscale", Provides: []string{"private-network"},
+		Manifest{Module: "tailscale", Provides: Offers("private-network"),
 			Claims: []Claim{{Name: "the-private-network", Scope: ScopeNode}}},
-	), []string{"networking", "tailscale"}, workstation(), nil)
+	), []string{"networking", "tailscale"}, workstation(), World{})
+
 	if err == nil {
 		t.Fatal("a machine was given two private networks without being told")
 	}
@@ -100,9 +103,10 @@ func TestNamesNeedTheMeshsOwnAddresses(t *testing.T) {
 	// mean nothing on it.
 	_, err := Resolve(shelf(
 		Manifest{Module: "mesh-names", Computed: "mesh-names",
-			Provides: []string{"name-resolution"}, Requires: []string{"mesh-addressing"}},
-		Manifest{Module: "tailscale", Provides: []string{"private-network"}},
-	), []string{"mesh-names", "tailscale"}, workstation(), nil)
+			Provides: Offers("name-resolution"), Requires: []string{"mesh-addressing"}},
+		Manifest{Module: "tailscale", Provides: Offers("private-network")},
+	), []string{"mesh-names", "tailscale"}, workstation(), World{})
+
 	if err == nil {
 		t.Fatal("the mesh's names were installed over a VPN whose addresses it does not hand out")
 	}
@@ -117,9 +121,10 @@ func TestARequirementWantedTwiceIsReportedOnce(t *testing.T) {
 	_, err := Resolve(shelf(
 		Manifest{Module: "one", Requires: []string{"shell"}},
 		Manifest{Module: "two", Requires: []string{"shell"}},
-		Manifest{Module: "bash", Provides: []string{"shell"}},
-		Manifest{Module: "zsh", Provides: []string{"shell"}},
-	), []string{"one", "two"}, workstation(), nil)
+		Manifest{Module: "bash", Provides: Offers("shell")},
+		Manifest{Module: "zsh", Provides: Offers("shell")},
+	), []string{"one", "two"}, workstation(), World{})
+
 	if err == nil {
 		t.Fatal("two shells and one was picked silently")
 	}