140 lines
6.2 KiB
Go
140 lines
6.2 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/novox/mesh-controller/internal/catalogue"
|
|
"github.com/novox/mesh-controller/internal/link"
|
|
)
|
|
|
|
// An address is read from the node's settings where it is used, never recorded with a port
|
|
// (novox/hq 04-ISSUES/102). Three readers did not follow the setting; each is held to it here.
|
|
|
|
var aDigest = "sha256:" + strings.Repeat("e", 64)
|
|
|
|
// **A build is recorded by digest and path**, whatever address the builder pushed to — what it
|
|
// made and what it stood on both; an image the module runs from elsewhere is left where it says.
|
|
func TestABuildIsRecordedWithoutTheStoresAddress(t *testing.T) {
|
|
manifest, _ := json.Marshal(map[string]any{
|
|
"module": "gitea", "version": "1",
|
|
"resources": []map[string]any{
|
|
{"id": "server", "type": "container", "name": "mesh-gitea",
|
|
"image": "anchor.internal:5100/gitea/server@" + aDigest},
|
|
{"id": "config", "type": "archive", "path": "/etc/gitea", "digest": aDigest,
|
|
"source": "http://anchor.internal:5100/v2/gitea/config/blobs/" + aDigest},
|
|
{"id": "cache", "type": "container", "name": "mesh-gitea-cache",
|
|
"image": "valkey/valkey@" + aDigest},
|
|
},
|
|
})
|
|
kept := buildFrom(link.BuildResult{
|
|
ID: "b1", Repository: "https://forge.example/gitea.git", Commit: "abc", On: "laptop",
|
|
Manifest: manifest,
|
|
Made: []link.MadeArtifact{
|
|
{Name: "server", Kind: "image", Reference: "anchor.internal:5100/gitea/server@" + aDigest},
|
|
{Name: "config", Kind: "archive", Reference: "http://anchor.internal:5100/v2/gitea/config/blobs/" + aDigest},
|
|
},
|
|
Against: []string{"anchor.internal:5100/mesh-tools/runtime@" + aDigest},
|
|
})
|
|
if kept.Module != "gitea" {
|
|
t.Fatalf("the module was not read from the recorded manifest: %q", kept.Module)
|
|
}
|
|
if kept.Made[0].Reference != catalogue.ArtifactStoreScheme+"gitea/server@"+aDigest {
|
|
t.Errorf("the image is recorded as %q, address and all", kept.Made[0].Reference)
|
|
}
|
|
if kept.Made[1].Reference != catalogue.ArtifactStoreScheme+"gitea/config/blobs/"+aDigest {
|
|
t.Errorf("the archive is recorded as %q, address and all", kept.Made[1].Reference)
|
|
}
|
|
recorded, err := catalogue.ParseManifest(kept.Manifest)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := recorded.Resources[0]["image"]; got != catalogue.ArtifactStoreScheme+"gitea/server@"+aDigest {
|
|
t.Errorf("the recorded manifest's image is %v", got)
|
|
}
|
|
if got := recorded.Resources[1]["source"]; got != catalogue.ArtifactStoreScheme+"gitea/config/blobs/"+aDigest {
|
|
t.Errorf("the recorded manifest's archive is %v", got)
|
|
}
|
|
if got := recorded.Resources[2]["image"]; got != "valkey/valkey@"+aDigest {
|
|
t.Errorf("an image the build did not make was rewritten: %v", got)
|
|
}
|
|
if strings.Contains(string(kept.Manifest), "anchor.internal:5100") {
|
|
t.Errorf("the recorded manifest still carries the store's address:\n%s", kept.Manifest)
|
|
}
|
|
// What the build stood on is an edge to another module's artifact, and it is recorded the way
|
|
// that artifact is: by path in the store, so the edge still names the same thing when the
|
|
// store answers at another address.
|
|
if kept.Against[0] != catalogue.ArtifactStoreScheme+"mesh-tools/runtime@"+aDigest {
|
|
t.Errorf("what the build stood on was recorded by address: %v", kept.Against)
|
|
}
|
|
}
|
|
|
|
// aStore is a module offering the artifact store on 5000, published the long way as the
|
|
// distribution module does, so a node may be given another number for it.
|
|
func aStore() catalogue.Manifest {
|
|
return catalogue.Manifest{Module: "distribution", Version: "1",
|
|
Provides: []catalogue.Offer{{Name: catalogue.ArtifactStoreProvision, Scope: catalogue.ScopeMesh}},
|
|
Serves: map[string]map[string]any{catalogue.ArtifactStoreProvision: {"port": float64(5000)}},
|
|
Listens: []catalogue.Listening{{Port: 5000, From: catalogue.FromMesh}},
|
|
Resources: []map[string]any{{"id": "store", "type": "container", "name": "mesh-registry",
|
|
"ports": []any{"5000:5000"}, "image": "registry@" + aDigest}}}
|
|
}
|
|
|
|
// **The trust a machine writes for the store, and the address every built image is fetched
|
|
// through, say the port the node gave the store** — not the catalogue's number.
|
|
|
|
// **The control plane's own connections say the port the node gave the store and the broker.**
|
|
//
|
|
// Composed from the control plane's own manifest against a real inventory: the store's module is
|
|
// given 6852 on this node the way genesis or an operator gives it, and the control plane's
|
|
// process is told so beside the sealed connection genesis wrote.
|
|
|
|
// withSeatPorts is the control plane's manifest with the seat placeholders in its environment —
|
|
// added here until module.json carries them (the manifest lands one commit after the code that
|
|
// fills it, so a control plane one build behind never sees a placeholder it cannot fill).
|
|
func withSeatPorts(m catalogue.Manifest) catalogue.Manifest {
|
|
seatPorts := map[string]string{
|
|
"MESH_STORE_INVENTORY_PORT": "${seat:mesh-store:5432}",
|
|
"MESH_STORE_IDENTITY_PORT": "${seat:mesh-store:5432}",
|
|
"MESH_STORE_LICENCES_PORT": "${seat:mesh-store:5432}",
|
|
"MESH_BROKER_AMQP_PORT": "${seat:mesh-broker:5672}",
|
|
"MESH_BROKER_MANAGEMENT_PORT": "${seat:mesh-broker:15672}",
|
|
"MESH_BROKER_ADDRESS_PORT": "${seat:mesh-broker:5671}",
|
|
}
|
|
out := m
|
|
out.Resources = nil
|
|
for _, r := range m.Resources {
|
|
if r["type"] != "container" && r["type"] != "process" {
|
|
out.Resources = append(out.Resources, r)
|
|
continue
|
|
}
|
|
copied := map[string]any{}
|
|
for k, v := range r {
|
|
copied[k] = v
|
|
}
|
|
env := map[string]any{}
|
|
if had, ok := r["env"].(map[string]any); ok {
|
|
for k, v := range had {
|
|
env[k] = v
|
|
}
|
|
}
|
|
for k, v := range seatPorts {
|
|
if _, said := env[k]; !said {
|
|
env[k] = v
|
|
}
|
|
}
|
|
copied["env"] = env
|
|
out.Resources = append(out.Resources, copied)
|
|
}
|
|
return out
|
|
}
|
|
|
|
// aLoneNode is one capable machine with nothing placed on any network — the control-node during
|
|
// genesis, before the "network" step, which is after the store, the broker, the vault and the
|
|
// catalogue have each been built and pushed (finding F2).
|
|
|
|
// **Before the network exists, the store's own node reaches it by loopback** — never refused,
|
|
// never handed the scheme: a genesis pushes the store, the broker, the vault and the catalogue to
|
|
// a node on no network, and builds the catalogue on a base it must be able to pull.
|