Create ImageResource conforming to ManagedResource (apple#1619)

- Closes apple#1625.
- For now, the ImageResource compliance happens
  at the CLI level. We will work on pushing that into or
  closer to the APIServer at a later time.

## Testing
- [x] Tested locally

---------

Signed-off-by: Kathryn Baldauf <k_baldauf@apple.com>

Author: katiewasnothere

Sources/ContainerCommands/Image/ImageInspect.swift

@@ -50,7 +50,7 @@ extension Application {
                 )
             }
 
-            var printable: [ImageDetail] = []
+            var printable: [ImageResource] = []
             for image in result.images {
                 guard
                     !Utility.isInfraImage(
@@ -59,10 +59,15 @@ extension Application {
                         initImage: containerSystemConfig.vminit.image
                     )
                 else { continue }
-                printable.append(try await image.details())
+                let resolved = try await image.resolvedManifests()
+                printable.append(ImageResource(config: image.description, index: resolved.index, manifests: resolved.manifests))
             }
 
-            try Output.emit(Output.renderJSON(printable))
+            let options = JSONOptions(
+                outputFormatting: [.prettyPrinted, .sortedKeys],
+                dateEncodingStrategy: .iso8601
+            )
+            try Output.emit(Output.renderJSON(printable, options: options))
         }
     }
 }

Sources/ContainerCommands/Image/ImageList.swift

@@ -18,11 +18,11 @@ import ArgumentParser
 import ContainerAPIClient
 import ContainerPersistence
 import ContainerPlugin
+import ContainerResource
 import Containerization
 import ContainerizationError
 import ContainerizationOCI
 import Foundation
-import SwiftProtobuf
 
 extension Application {
     public struct ImageList: AsyncLoggableCommand {
@@ -53,27 +53,30 @@ extension Application {
             }
             images.sort { $0.reference < $1.reference }
 
-            if format == .json {
-                try await Self.emitJSON(images: images)
-                return
-            }
-
-            if quiet {
+            // Quiet mode prints references directly and skips the more expensive
+            // per-image manifest resolution. `--format json` takes precedence.
+            if quiet && format != .json {
                 for image in images {
                     let processedReferenceString = try ClientImage.denormalizeReference(image.reference, containerSystemConfig: containerSystemConfig)
                     print(processedReferenceString)
                 }
                 return
             }
 
+            let resources = try await Self.buildResources(images: images, containerSystemConfig: containerSystemConfig)
+
+            if format == .json {
+                try Self.emitJSON(resources: resources)
+                return
+            }
+
             if verbose {
-                let items = try await Self.buildVerboseItems(images: images, containerSystemConfig: containerSystemConfig)
-                Output.emit(Output.renderTable(items))
+                let rows = resources.flatMap { VerboseImageRow.rows(for: $0) }
+                Output.emit(Output.renderTable(rows))
                 return
             }
 
-            let items = try await Self.buildTableItems(images: images, containerSystemConfig: containerSystemConfig)
-            Output.emit(Output.renderTable(items))
+            Output.emit(Output.renderTable(resources))
         }
 
         private static func validate(quiet: Bool, verbose: Bool) throws {
@@ -82,111 +85,27 @@ extension Application {
             }
         }
 
-        private static func emitJSON(images: [ClientImage]) async throws {
-            let formatter = ByteCountFormatter()
-            var printableImages: [PrintableImage] = []
+        /// Builds the resource for each image, denormalizing the reference so the
+        /// display name omits the default registry.
+        private static func buildResources(images: [ClientImage], containerSystemConfig: ContainerSystemConfig) async throws -> [ImageResource] {
+            var resources: [ImageResource] = []
             for image in images {
-                let size = try await ClientImage.getFullImageSize(image: image)
-                let formattedSize = formatter.string(fromByteCount: size)
-                printableImages.append(
-                    PrintableImage(reference: image.reference, fullSize: formattedSize, descriptor: image.descriptor)
-                )
-            }
-            try Output.emit(Output.renderJSON(printableImages))
-        }
-
-        private static func buildTableItems(images: [ClientImage], containerSystemConfig: ContainerSystemConfig) async throws -> [ImageRow] {
-            var items: [ImageRow] = []
-            for image in images {
-                let processedReferenceString = try ClientImage.denormalizeReference(image.reference, containerSystemConfig: containerSystemConfig)
-                let reference = try ContainerizationOCI.Reference.parse(processedReferenceString)
-                let digest = try await image.resolved().digest
-                items.append(
-                    ImageRow(
-                        name: reference.name,
-                        tag: reference.tag ?? "<none>",
-                        trimmedDigest: Utility.trimDigest(digest: digest)
-                    ))
-            }
-            return items
-        }
-
-        private static func buildVerboseItems(images: [ClientImage], containerSystemConfig: ContainerSystemConfig) async throws -> [VerboseImageRow] {
-            let formatter = ByteCountFormatter()
-            var items: [VerboseImageRow] = []
-            for image in images {
-                let imageDigest = try await image.resolved().digest
-                let processedReferenceString = try ClientImage.denormalizeReference(image.reference, containerSystemConfig: containerSystemConfig)
-                let reference = try ContainerizationOCI.Reference.parse(processedReferenceString)
-                for descriptor in try await image.index().manifests {
-                    if let referenceType = descriptor.annotations?["vnd.docker.reference.type"],
-                        referenceType == "attestation-manifest"
-                    {
-                        continue
-                    }
-
-                    guard let platform = descriptor.platform else {
-                        continue
-                    }
-
-                    var config: ContainerizationOCI.Image
-                    var manifest: ContainerizationOCI.Manifest
-                    do {
-                        config = try await image.config(for: platform)
-                        manifest = try await image.manifest(for: platform)
-                    } catch {
-                        continue
-                    }
-
-                    let created = config.created ?? ""
-                    let size = descriptor.size + manifest.config.size + manifest.layers.reduce(0) { $0 + $1.size }
-                    let formattedSize = formatter.string(fromByteCount: size)
-
-                    items.append(
-                        VerboseImageRow(
-                            name: reference.name,
-                            tag: reference.tag ?? "<none>",
-                            indexDigest: Utility.trimDigest(digest: imageDigest),
-                            os: platform.os,
-                            arch: platform.architecture,
-                            variant: platform.variant ?? "",
-                            fullSize: formattedSize,
-                            created: created,
-                            manifestDigest: Utility.trimDigest(digest: descriptor.digest)
-                        ))
-                }
+                let resolved = try await image.resolvedManifests()
+                let displayReference = try ClientImage.denormalizeReference(image.reference, containerSystemConfig: containerSystemConfig)
+                resources.append(
+                    ImageResource(config: image.description, index: resolved.index, manifests: resolved.manifests, displayReference: displayReference))
             }
-            return items
+            return resources
         }
 
-        struct PrintableImage: Codable {
-            let reference: String
-            let fullSize: String
-            let descriptor: Descriptor
+        private static func emitJSON(resources: [ImageResource]) throws {
+            let options = JSONOptions(dateEncodingStrategy: .iso8601)
+            try Output.emit(Output.renderJSON(resources, options: options))
         }
     }
 }
 
-private struct ImageRow: ListDisplayable {
-    let name: String
-    let tag: String
-    let trimmedDigest: String
-
-    static var tableHeader: [String] {
-        ["NAME", "TAG", "DIGEST"]
-    }
-
-    var tableRow: [String] {
-        [name, tag, trimmedDigest]
-    }
-
-    // Required by ListDisplayable but unused — ImageList handles quiet mode
-    // separately to avoid expensive digest resolution.
-    var quietValue: String {
-        name
-    }
-}
-
+/// A single row of the verbose image listing — one per platform variant.
 private struct VerboseImageRow: ListDisplayable {
     let name: String
     let tag: String
@@ -209,4 +128,30 @@ private struct VerboseImageRow: ListDisplayable {
     var quietValue: String {
         name
     }
+
+    /// Flattens an ImageResource into one verbose image row entry per platform variant.
+    static func rows(for resource: ImageResource) -> [VerboseImageRow] {
+        let formatter = ByteCountFormatter()
+        let reference = try? ContainerizationOCI.Reference.parse(resource.displayReference)
+        let name = reference?.name ?? resource.displayReference
+        let tag = reference?.tag ?? "<none>"
+        let indexDigest = Utility.trimDigest(digest: resource.index.digest)
+        return
+            resource.variants
+            // Skip attestation manifests, which use the `unknown/unknown` platform.
+            .filter { !($0.platform.os == "unknown" && $0.platform.architecture == "unknown") }
+            .map { variant in
+                VerboseImageRow(
+                    name: name,
+                    tag: tag,
+                    indexDigest: indexDigest,
+                    os: variant.platform.os,
+                    arch: variant.platform.architecture,
+                    variant: variant.platform.variant ?? "",
+                    fullSize: formatter.string(fromByteCount: variant.size),
+                    created: variant.config.created ?? "",
+                    manifestDigest: Utility.trimDigest(digest: variant.digest)
+                )
+            }
+    }
 }

…ontainerResource/Image/ImageDetail.swift …mage/ImageResource+ListDisplayable.swiftSources/ContainerResource/Image/ImageDetail.swift renamed to Sources/ContainerCommands/Image/ImageResource+ListDisplayable.swift Sources/ContainerResource/Image/ImageDetail.swift renamed to Sources/ContainerCommands/Image/ImageResource+ListDisplayable.swift

@@ -14,29 +14,26 @@
 // limitations under the License.
 //===----------------------------------------------------------------------===//
 
-import Containerization
+import ContainerAPIClient
+import ContainerResource
 import ContainerizationOCI
 
-public struct ImageDetail: Codable {
-    public let name: String
-    public let index: Descriptor
-    public let variants: [Variants]
-
-    public struct Variants: Codable {
-        public let platform: Platform
-        public let config: ContainerizationOCI.Image
-        public let size: Int64
+extension ImageResource: ListDisplayable {
+    public static var tableHeader: [String] {
+        ["NAME", "TAG", "DIGEST"]
+    }
 
-        public init(platform: Platform, size: Int64, config: ContainerizationOCI.Image) {
-            self.platform = platform
-            self.config = config
-            self.size = size
-        }
+    public var tableRow: [String] {
+        // `displayReference` is already denormalized by the caller.
+        let reference = try? ContainerizationOCI.Reference.parse(displayReference)
+        return [
+            reference?.name ?? displayReference,
+            reference?.tag ?? "<none>",
+            Utility.trimDigest(digest: index.digest),
+        ]
     }
 
-    public init(name: String, index: Descriptor, variants: [Variants]) {
-        self.name = name
-        self.index = index
-        self.variants = variants
+    public var quietValue: String {
+        name
     }
 }