diff --git a/go/buildcpu/buildcpu_agree_test.go b/go/buildcpu/buildcpu_agree_test.go new file mode 100644 index 0000000..bf61988 --- /dev/null +++ b/go/buildcpu/buildcpu_agree_test.go @@ -0,0 +1,14 @@ +package buildcpu + +import ( + "testing" + + "git.novox.be/novox/mesh-sdk/go/catalogue" +) + +// The share's names the composer gives are the build modules' (catalogue writes them too, so it does not import this). +func TestTheShareNamesAgreeWithTheCatalogues(t *testing.T) { + if ShareSetting != catalogue.BuildCPUShareSetting || ShareWord != catalogue.BuildCPUShareWord || DefaultPercent != catalogue.BuildCPUDefaultPercent { + t.Fatal("buildcpu's share names differ from catalogue's") + } +} diff --git a/go/catalogue/yields.go b/go/catalogue/yields.go index cd9bbfa..afedce1 100644 --- a/go/catalogue/yields.go +++ b/go/catalogue/yields.go @@ -2,18 +2,28 @@ package catalogue import ( "strconv" +) - "git.novox.be/novox/mesh-sdk/go/buildcpu" +// The build processor share's names (novox/hq ADR 0553 §3, §4), written here as well as in the build modules' package +// (BuildCPUShareSetting, ShareWord, DefaultPercent), so a manifest reader does not reach the build runner's code; a +// test of the build modules keeps them agreeing. +const ( + // BuildCPUShareSetting is the node-engine's config value of the node's processor share for its builds, in percent. + BuildCPUShareSetting = "build-cpu-share" + // BuildCPUShareWord is the word the composer gives every yielding module: the node's share, in percent. + BuildCPUShareWord = "MESH_BUILD_CPU_SHARE" + // BuildCPUDefaultPercent is the share where nothing sets one. + BuildCPUDefaultPercent = 50 ) // yieldsOf is how the runtime of its own a module is served by gives way on this node (novox/hq ADR 0553), or nil when // it does not, and the word its steps size their threads from: // // - a module holding a seat that yields (Seat.Yields, the build seats) runs at idle priority under the node's one share -// of its processors: the node-engine's own config build-cpu-share (buildcpu.ShareSetting) as this node's layers give +// of its processors: the node-engine's own config build-cpu-share (BuildCPUShareSetting) as this node's layers give // it, its default where none does. Every yielding module of the node carries the same share, so the node-engine's // one yielding slice has one quota (ADR 0553 §2, §3). -// - its word: that share (buildcpu.ShareWord), which a step divides by its own module's capacity (ADR 0553 §4). +// - its word: that share (BuildCPUShareWord), which a step divides by its own module's capacity (ADR 0553 §4). // // Never a refusal: a share out of range is the default, so a mistyped value bounds the builds at the default and never // stops the node's whole composition. @@ -27,16 +37,16 @@ func (r Resolution) yieldsOf(m Manifest, with Rendering) (map[string]any, map[st engine = e } } - share := buildcpu.DefaultPercent + share := BuildCPUDefaultPercent for _, s := range Effective(engine, with.Settings[engineModule]) { - if s.Key == buildcpu.ShareSetting { + if s.Key == BuildCPUShareSetting { if n, ok := percentOf(s.Value); ok { share = n } } } return map[string]any{"priority": "idle", "cpu-share": share}, - map[string]string{buildcpu.ShareWord: strconv.Itoa(share)} + map[string]string{BuildCPUShareWord: strconv.Itoa(share)} } // yields is whether a module claims a seat that yields. diff --git a/go/delivery/provided.go b/go/delivery/provided.go index bcb58e6..f3bcc05 100644 --- a/go/delivery/provided.go +++ b/go/delivery/provided.go @@ -5,19 +5,39 @@ import ( "fmt" "git.novox.be/novox/mesh-sdk/go/catalogue" - "git.novox.be/novox/mesh-sdk/go/overlay" ) +// The private network's names as its manifest says them, written here as well as in overlay (Name, Requirement, +// Addressing, TheNetwork), which delivery does not import so its many readers do not reach the network's generator; +// a test keeps them agreeing. +const ( + overlayName = "mesh-wireguard" + overlayRequirement = "private-network" + overlayAddressing = "mesh-addressing" + overlayTheNetwork = "the-private-network" +) + +// overlayManifest is overlay.Manifest(): the module the mesh provides for itself. +func overlayManifest() map[string]any { + return map[string]any{ + "module": overlayName, + "version": "1", + "computed": overlayName, + "provides": []string{overlayRequirement, overlayAddressing}, + "claims": []map[string]any{{"name": overlayTheNetwork, "scope": "node"}}, + } +} + // The modules the mesh provides itself (issue 1126): no repository holds them, so the indexer reads none; their // manifests come with mesh-sdk, built in code, and always win over any other. Today the private network alone -// (overlay.Name), built by nobody and run inside each node's own composition. One predicate for every part that judges +// (overlay's mesh-wireguard), built by nobody and run inside each node's own composition. One predicate for every part that judges // or composes a placement: CheckPlacements, the seat's holder, the composer's input (frombus) and the grants part. // ProvidedModules is every module the mesh provides itself, sorted. -func ProvidedModules() []string { return []string{overlay.Name} } +func ProvidedModules() []string { return []string{overlayName} } // ProvidedByMesh says whether the mesh provides module itself, so a placement may name it with no repository holding it. -func ProvidedByMesh(module string) bool { return module == overlay.Name } +func ProvidedByMesh(module string) bool { return module == overlayName } // ProvidedManifest is a provided module's manifest, as its readers parse it, and its raw JSON; an error for a module the // mesh does not provide or a manifest its own reader refuses. @@ -25,7 +45,7 @@ func ProvidedManifest(module string) (catalogue.Manifest, []byte, error) { if !ProvidedByMesh(module) { return catalogue.Manifest{}, nil, fmt.Errorf("delivery: the mesh provides no module %s", module) } - raw, err := json.Marshal(overlay.Manifest()) + raw, err := json.Marshal(overlayManifest()) if err != nil { return catalogue.Manifest{}, nil, err } diff --git a/go/delivery/provided_overlay_test.go b/go/delivery/provided_overlay_test.go new file mode 100644 index 0000000..05523d3 --- /dev/null +++ b/go/delivery/provided_overlay_test.go @@ -0,0 +1,21 @@ +package delivery_test + +import ( + "encoding/json" + "testing" + + "git.novox.be/novox/mesh-sdk/go/delivery" + "git.novox.be/novox/mesh-sdk/go/overlay" +) + +// The private network's manifest delivery provides is overlay's, though delivery does not import overlay. +func TestTheProvidedNetworkIsOverlays(t *testing.T) { + _, raw, err := delivery.ProvidedManifest(overlay.Name) + if err != nil { + t.Fatal(err) + } + want, _ := json.Marshal(overlay.Manifest()) + if string(raw) != string(want) { + t.Fatalf("delivery provides\n%s\noverlay says\n%s", raw, want) + } +}