ContainerRegistry: Return a ContentDescriptor from putManifest()

Returning a ContentDescriptor provides the information needed to
add the manifest to an image index, making it possible to build
multi-architecture images.

Author: euanh

Sources/ContainerRegistry/ImageManifest+Digest.swift

@@ -15,31 +15,31 @@
 public extension RegistryClient {
     func putManifest(
         repository: ImageReference.Repository,
-        reference: any ImageReference.Reference,
+        reference: (any ImageReference.Reference)? = nil,
         manifest: ImageManifest
-    ) async throws -> String {
+    ) async throws -> ContentDescriptor {
         // See https://github.com/opencontainers/distribution-spec/blob/main/spec.md#pushing-manifests
-        let httpResponse = try await executeRequestThrowing(
-            // All blob uploads have Content-Type: application/octet-stream on the wire, even if mediatype is different
+
+        let encoded = try encoder.encode(manifest)
+        let digest = digest(of: encoded)
+        let mediaType = manifest.mediaType ?? "application/vnd.oci.image.manifest.v1+json"
+
+        let _ = try await executeRequestThrowing(
             .put(
                 repository,
-                path: "manifests/\(reference)",
-                contentType: manifest.mediaType ?? "application/vnd.oci.image.manifest.v1+json"
+                path: "manifests/\(reference ?? digest)",
+                contentType: mediaType
             ),
-            uploading: manifest,
+            uploading: encoded,
             expectingStatus: .created,
             decodingErrors: [.notFound]
         )
 
-        // The distribution spec says the response MUST contain a Location header
-        // providing a URL from which the saved manifest can be downloaded.
-        // However some registries return URLs which cannot be fetched, and
-        // ECR does not set this header at all.
-        // If the header is not present, create a suitable value.
-        // https://github.com/opencontainers/distribution-spec/blob/main/spec.md#pulling-manifests
-        return httpResponse.response.headerFields[.location]
-            ?? registryURL.distributionEndpoint(forRepository: repository, andEndpoint: "manifests/\(manifest.digest)")
-            .absoluteString
+        return ContentDescriptor(
+            mediaType: mediaType,
+            digest: "\(digest)",
+            size: Int64(encoded.count)
+        )
     }
 
     func getManifest(

Sources/ContainerRegistry/Manifests.swift

@@ -19,9 +19,6 @@ extension RegistryClient {
     func getImageManifest(forImage image: ImageReference, architecture: String) async throws -> (
         ImageManifest, ContentDescriptor
     ) {
-        // We pushed the amd64 tag but it points to a single-architecture index, not directly to a manifest
-        // if we get an index we should get a manifest, otherwise we might get a manifest directly
-
         do {
             // Try to retrieve a manifest.   If the object with this reference is actually an index, the content-type will not match and
             // an error will be thrown.

Sources/containertool/Extensions/RegistryClient+Layers.swift

@@ -255,7 +255,7 @@ extension RegistryClient {
                 forImage: baseImage,
                 architecture: architecture
             )
-            log("Found base image manifest: \(baseImageDescriptor.digest)")
+            try log("Found base image manifest: \(ImageReference.Digest(baseImageDescriptor.digest))")
 
             baseImageConfiguration = try await source.getImageConfiguration(
                 forImage: baseImage,
@@ -369,22 +369,25 @@ extension RegistryClient {
 
         // MARK: Upload application manifest
 
+        let manifestDescriptor = try await self.putManifest(
+            repository: destinationImage.repository,
+            reference: destinationImage.reference,
+            manifest: manifest
+        )
+
+        if verbose {
+            log("manifest: \(manifestDescriptor.digest) (\(manifestDescriptor.size) bytes)")
+        }
+
         // Use the manifest's digest if the user did not provide a human-readable tag
         // To support multiarch images, we should also create an an index pointing to
         // this manifest.
         let reference: ImageReference.Reference
         if let tag {
             reference = try ImageReference.Tag(tag)
         } else {
-            reference = manifest.digest
+            reference = try ImageReference.Digest(manifestDescriptor.digest)
         }
-        let location = try await self.putManifest(
-            repository: destinationImage.repository,
-            reference: destinationImage.reference,
-            manifest: manifest
-        )
-
-        if verbose { log(location) }
 
         var result = destinationImage
         result.reference = reference

Sources/containertool/containertool.swift

@@ -184,15 +184,14 @@ struct SmokeTests {
             layers: [image_descriptor]
         )
 
-        let _ = try await client.putManifest(
+        let descriptor = try await client.putManifest(
             repository: repository,
-            reference: test_manifest.digest,
             manifest: test_manifest
         )
 
         let (manifest, _) = try await client.getManifest(
             repository: repository,
-            reference: test_manifest.digest
+            reference: ImageReference.Digest(descriptor.digest)
         )
         #expect(manifest.schemaVersion == 2)
         #expect(manifest.config.mediaType == "application/vnd.docker.container.image.v1+json")