A module may mirror an image it did not write

A module usually runs software somebody else built: a database module
ships configuration and a provisioner and does not build a database. It
could name the upstream reference directly, and then every machine needs
a route to a public registry and the reference is a tag somebody else can
move — which is what pinning exists to prevent.

So an artifact may be `upstream`: pulled by the reference the module
names, pushed into the mesh's own registry, and pinned by the digest that
registry assigns. This is what the bootstrap already does by hand; it is
now something a module can say.

Refused: an upstream reference with no tag or digest, because what gets
mirrored would be whatever `latest` means today and a module pinned to
that is not pinned. And the rule that a build reads only its own
repository does not apply to it — applying it anyway refused every
reference with a registry host in it, which the test caught.

Written by trying to write a real postgres module and finding it could
not be said. It can now: two directories, two containers pinned by
digest, a superuser password sealed to the machine, and the grants
manifest — six resources from one assignment, all accepted by the host's
own parser.

That exercise also found my manifest wrong rather than the host: a
container declared `restart-on`, which is a service field, and the host
refused it by name. It is right to. A container whose own definition
changes is recreated, and a file it mounts is read by the process inside,
which is that image's business.

internal/catalogue/build.go

@@ -86,14 +86,14 @@ func (m Manifest) Resolve(built []Built) (Manifest, error) {
 		}
 		delete(filled, "artifact")
 		switch artifact.Kind {
-		case ArtifactImage:
+		case ArtifactImage, ArtifactUpstream:
 			filled["image"] = artifact.Reference
 		case ArtifactArchive:
 			filled["source"] = artifact.Reference
 			filled["digest"] = artifact.Digest
 		default:
-			return Manifest{}, fmt.Errorf("%s: %q is a %q, and an artifact is %q or %q",
-				m.Module, named, artifact.Kind, ArtifactImage, ArtifactArchive)
+			return Manifest{}, fmt.Errorf("%s: %q is a %q, and an artifact is %q, %q or %q",
+				m.Module, named, artifact.Kind, ArtifactImage, ArtifactArchive, ArtifactUpstream)
 		}
 		out.Resources = append(out.Resources, filled)
 	}
@@ -118,21 +118,34 @@ func (b *Build) problems(module string) []string {
 				module, a.Name))
 		}
 		seen[a.Name] = true
-		if a.Kind != ArtifactImage && a.Kind != ArtifactArchive {
-			problems = append(problems, fmt.Sprintf("%s: %q is a %q, and an artifact is %q or %q",
-				module, a.Name, a.Kind, ArtifactImage, ArtifactArchive))
+		switch a.Kind {
+		case ArtifactImage, ArtifactArchive, ArtifactUpstream:
+		default:
+			problems = append(problems, fmt.Sprintf(
+				"%s: %q is a %q, and an artifact is %q, %q or %q",
+				module, a.Name, a.Kind, ArtifactImage, ArtifactArchive, ArtifactUpstream))
 		}
 		if a.From == "" {
 			problems = append(problems, fmt.Sprintf(
 				"%s: %q says nothing about what it is built from", module, a.Name))
 		}
-		if strings.HasPrefix(a.From, "/") || strings.Contains(a.From, "..") {
+		// An upstream image is named, not read from the repository, so the path rule does not
+		// apply to it — and applying it anyway would refuse every reference with a registry host
+		// in it.
+		if a.Kind != ArtifactUpstream &&
+			(strings.HasPrefix(a.From, "/") || strings.Contains(a.From, "..")) {
 			// A build reads its own repository and nothing else. A path leaving it would make
 			// what gets built depend on whatever happens to be on the machine building it.
 			problems = append(problems, fmt.Sprintf(
 				"%s: %q is built from %q, which is outside its own repository",
 				module, a.Name, a.From))
 		}
+		if a.Kind == ArtifactUpstream && !strings.Contains(a.From, ":") {
+			// Without a tag or digest, what gets mirrored is whatever `latest` means today, and
+			// a module pinned to that is not pinned.
+			problems = append(problems, fmt.Sprintf(
+				"%s: %q mirrors %q, which names no tag or digest", module, a.Name, a.From))
+		}
 	}
 	return problems
 }