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,33 +15,28 @@
 public extension RegistryClient {
     func putManifest(
         repository: ImageReference.Repository,
-        reference: any ImageReference.Reference,
+        reference: (any ImageReference.Reference)? = nil,
         manifest: ImageManifest
     ) async throws
-        -> String
+        -> ContentDescriptor
     {
+        let encoded = try encoder.encode(manifest)
+        let digest = digest(of: encoded)
+        let mediaType = manifest.mediaType ?? "application/vnd.oci.image.manifest.v1+json"
+
         // 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 _ = 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 .init(mediaType: mediaType, digest: "\(digest)", size: Int64(encoded.count))
     }
 
     func getManifest(repository: ImageReference.Repository, reference: any ImageReference.Reference) async throws

Sources/ContainerRegistry/Manifests.swift

@@ -254,7 +254,7 @@ extension RegistryClient {
                 forImage: baseImage,
                 architecture: architecture
             )
-            log("Found base image manifest: \(baseImageManifest.digest)")
+            //try log("Found base image manifest: \(digest(of: baseImageManifest))")
 
             baseImageConfiguration = try await source.getImageConfiguration(
                 forImage: baseImage,
@@ -371,22 +371,25 @@ extension RegistryClient {
         // 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
-        }
-        let location = try await self.putManifest(
+        let reference = try tag.map { try ImageReference.Tag($0) }
+
+        let manifestDescriptor = try await self.putManifest(
             repository: destinationImage.repository,
-            reference: destinationImage.reference,
+            reference: reference,
             manifest: manifest
         )
 
-        if verbose { log(location) }
+        if verbose {
+            log("manifest: \(manifestDescriptor.digest) (\(manifestDescriptor.size) bytes)")
+        }
 
-        var result = destinationImage
-        result.reference = reference
-        return result
+        // If the user supplied a tag, use it in place of the hash in the image reference
+        if tag != nil {
+            return destinationImage
+        } else {
+            var result = destinationImage
+            result.reference = try ImageReference.Digest(manifestDescriptor.digest)
+            return result
+        }
     }
 }

Sources/containertool/containertool.swift

@@ -181,15 +181,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")