jschoubben
385bc5b9bf
The mesh assigns the machine-side port and a module does not choose one (ADR
0038). For a container that is invisible: the mesh rewrites ports into
assigned:wanted, the software binds the number it always bound, and the machine
publishes another.
A process has no such layer. It runs on the machine, there is nothing to rewrite,
and it binds whatever its configuration says. So every process bound the number
written in its own config, two modules declaring the same one would collide, and
the mesh's whole reason for assigning ports was defeated by the resource kind
that most needs it — introduced, by me, three commits ago.
So a module asks. ${port:8080} is "the machine-side port you gave me for the 8080
I said I listen on", written into its own configuration exactly as an address it
was bound to is.
Asking about a port it never declared is refused, and the refusal says what it
did declare: the module is asking about something the mesh has no opinion on, and
answering would put a guess into a configuration file as a port number. With
nothing assigned yet it is told what it asked for, so a mesh that has made no
assignment still composes something coherent rather than writing a zero.
Claude-Session: https://claude.ai/code/session_01D6qtiYU3P9jk3pnAXyAFyx
84 lines
2.7 KiB
Go
84 lines
2.7 KiB
Go
package catalogue
|
|
|
|
import (
|
|
"os"
|
|
"testing"
|
|
)
|
|
|
|
// **The showcase module is parsed by the real parser, in the real test suite.**
|
|
//
|
|
// A module that exercises every capability is only worth having if something checks it still does.
|
|
// Written as a test rather than a script so it runs whenever anything about manifests changes —
|
|
// which is exactly when a module using all of it would quietly stop being valid.
|
|
func TestTheShowcaseModuleIsAValidManifest(t *testing.T) {
|
|
raw, err := os.ReadFile("../../../mesh-catalog/modules/showcase/module.json")
|
|
if err != nil {
|
|
t.Skipf("the catalogue is not beside this checkout: %v", err)
|
|
}
|
|
m, err := ParseManifest(raw)
|
|
if err != nil {
|
|
t.Fatalf("the module that exercises everything does not parse:\n%v", err)
|
|
}
|
|
|
|
// Every resource kind a MODULE may use, actually in it.
|
|
//
|
|
// Two of the host's eleven are deliberately absent, and the reasons are worth keeping:
|
|
//
|
|
// - `action` is refused to modules outright. The link may not carry a command to run (ADR
|
|
// 0005), so a module that needs something done ships a program that reads what the mesh
|
|
// delivered and reconciles — which is what a run-once `process` is.
|
|
// - `service` puts an EXISTING unit into a state and deliberately installs none, which is
|
|
// right for software that ships its own unit. A module whose code the mesh built has no
|
|
// such unit until the mesh writes one, and that is a `process`.
|
|
kinds := map[string]bool{}
|
|
for _, r := range m.Resources {
|
|
kind, _ := r["type"].(string)
|
|
kinds[kind] = true
|
|
}
|
|
for _, want := range []string{
|
|
"access", "archive", "container", "directory", "file", "network", "package",
|
|
"process", "user",
|
|
} {
|
|
if !kinds[want] {
|
|
t.Errorf("showcase no longer exercises %q", want)
|
|
}
|
|
}
|
|
|
|
// And all three ways a module's own code can run, which is the thing most easily lost.
|
|
var stays, once, scheduled bool
|
|
for _, r := range m.Resources {
|
|
if kind, _ := r["type"].(string); kind != "process" {
|
|
continue
|
|
}
|
|
switch {
|
|
case r["run-once"] == true:
|
|
once = true
|
|
case r["schedule"] != nil:
|
|
scheduled = true
|
|
default:
|
|
stays = true
|
|
}
|
|
}
|
|
if !stays || !once || !scheduled {
|
|
t.Errorf("showcase does not exercise all three process modes: stays=%v once=%v scheduled=%v",
|
|
stays, once, scheduled)
|
|
}
|
|
|
|
// And the artifact kinds, including the one that compiles.
|
|
var bundle, archive, upstream bool
|
|
for _, a := range m.Build.Artifacts {
|
|
switch a.Kind {
|
|
case ArtifactBundle:
|
|
bundle = true
|
|
case ArtifactArchive:
|
|
archive = true
|
|
case ArtifactUpstream:
|
|
upstream = true
|
|
}
|
|
}
|
|
if !bundle || !archive || !upstream {
|
|
t.Errorf("showcase does not exercise every artifact kind: bundle=%v archive=%v upstream=%v",
|
|
bundle, archive, upstream)
|
|
}
|
|
}
|