give the tuple field names and rename size to sizeInBytes

Author: realrajaryan

Sources/ContainerClient/Core/ClientImage.swift

@@ -296,7 +296,7 @@ extension ClientImage {
     /// Calculate disk usage for images
     /// - Parameter activeReferences: Set of image references currently in use by containers
     /// - Returns: Tuple of (total count, active count, total size, reclaimable size)
-    public static func calculateDiskUsage(activeReferences: Set<String>) async throws -> (Int, Int, UInt64, UInt64) {
+    public static func calculateDiskUsage(activeReferences: Set<String>) async throws -> (totalCount: Int, activeCount: Int, totalSize: UInt64, reclaimableSize: UInt64) {
         let client = newXPCClient()
         let request = newRequest(.imageDiskUsage)
 
@@ -310,7 +310,7 @@ extension ClientImage {
         let size = response.uint64(key: .imageSize)
         let reclaimable = response.uint64(key: .reclaimableSize)
 
-        return (total, active, size, reclaimable)
+        return (totalCount: total, activeCount: active, totalSize: size, reclaimableSize: reclaimable)
     }
 
     public static func fetch(reference: String, platform: Platform? = nil, scheme: RequestScheme = .auto, progressUpdate: ProgressUpdateHandler? = nil) async throws -> ClientImage

Sources/ContainerClient/Core/DiskUsage.swift

@@ -43,15 +43,15 @@ public struct ResourceUsage: Sendable, Codable {
     public var active: Int
 
     /// Total size in bytes
-    public var size: UInt64
+    public var sizeInBytes: UInt64
 
     /// Reclaimable size in bytes (from unused/inactive resources)
     public var reclaimable: UInt64
 
-    public init(total: Int, active: Int, size: UInt64, reclaimable: UInt64) {
+    public init(total: Int, active: Int, sizeInBytes: UInt64, reclaimable: UInt64) {
         self.total = total
         self.active = active
-        self.size = size
+        self.sizeInBytes = sizeInBytes
         self.reclaimable = reclaimable
     }
 }

Sources/ContainerCommands/System/SystemDF.swift

@@ -65,26 +65,26 @@ extension Application {
                 "Images",
                 "\(stats.images.total)",
                 "\(stats.images.active)",
-                formatSize(stats.images.size),
-                formatReclaimable(stats.images.reclaimable, total: stats.images.size),
+                formatSize(stats.images.sizeInBytes),
+                formatReclaimable(stats.images.reclaimable, total: stats.images.sizeInBytes),
             ])
 
             // Containers row
             rows.append([
                 "Containers",
                 "\(stats.containers.total)",
                 "\(stats.containers.active)",
-                formatSize(stats.containers.size),
-                formatReclaimable(stats.containers.reclaimable, total: stats.containers.size),
+                formatSize(stats.containers.sizeInBytes),
+                formatReclaimable(stats.containers.reclaimable, total: stats.containers.sizeInBytes),
             ])
 
             // Volumes row
             rows.append([
                 "Local Volumes",
                 "\(stats.volumes.total)",
                 "\(stats.volumes.active)",
-                formatSize(stats.volumes.size),
-                formatReclaimable(stats.volumes.reclaimable, total: stats.volumes.size),
+                formatSize(stats.volumes.sizeInBytes),
+                formatReclaimable(stats.volumes.reclaimable, total: stats.volumes.sizeInBytes),
             ])
 
             let tableFormatter = TableOutput(rows: rows)

Sources/Services/ContainerAPIService/DiskUsage/DiskUsageService.swift

@@ -49,29 +49,29 @@ public actor DiskUsageService {
 
         let stats = DiskUsageStats(
             images: ResourceUsage(
-                total: imageData.0,
-                active: imageData.1,
-                size: imageData.2,
-                reclaimable: imageData.3
+                total: imageData.totalCount,
+                active: imageData.activeCount,
+                sizeInBytes: imageData.totalSize,
+                reclaimable: imageData.reclaimableSize
             ),
             containers: ResourceUsage(
                 total: containerData.0,
                 active: containerData.1,
-                size: containerData.2,
+                sizeInBytes: containerData.2,
                 reclaimable: containerData.3
             ),
             volumes: ResourceUsage(
                 total: volumeData.0,
                 active: volumeData.1,
-                size: volumeData.2,
+                sizeInBytes: volumeData.2,
                 reclaimable: volumeData.3
             )
         )
 
         log.debug(
             "disk usage calculation complete",
             metadata: [
-                "images_total": "\(imageData.0)",
+                "images_total": "\(imageData.totalCount)",
                 "containers_total": "\(containerData.0)",
                 "volumes_total": "\(volumeData.0)",
             ])

Tests/ContainerClientTests/DiskUsageTests.swift

@@ -24,9 +24,9 @@ struct DiskUsageTests {
     @Test("DiskUsageStats JSON encoding and decoding")
     func testJSONSerialization() throws {
         let stats = DiskUsageStats(
-            images: ResourceUsage(total: 10, active: 5, size: 1024, reclaimable: 512),
-            containers: ResourceUsage(total: 3, active: 2, size: 2048, reclaimable: 1024),
-            volumes: ResourceUsage(total: 7, active: 4, size: 4096, reclaimable: 2048)
+            images: ResourceUsage(total: 10, active: 5, sizeInBytes: 1024, reclaimable: 512),
+            containers: ResourceUsage(total: 3, active: 2, sizeInBytes: 2048, reclaimable: 1024),
+            volumes: ResourceUsage(total: 7, active: 4, sizeInBytes: 4096, reclaimable: 2048)
         )
 
         let encoder = JSONEncoder()
@@ -37,23 +37,23 @@ struct DiskUsageTests {
 
         #expect(decoded.images.total == stats.images.total)
         #expect(decoded.images.active == stats.images.active)
-        #expect(decoded.images.size == stats.images.size)
+        #expect(decoded.images.sizeInBytes == stats.images.sizeInBytes)
         #expect(decoded.images.reclaimable == stats.images.reclaimable)
 
         #expect(decoded.containers.total == stats.containers.total)
         #expect(decoded.containers.active == stats.containers.active)
-        #expect(decoded.containers.size == stats.containers.size)
+        #expect(decoded.containers.sizeInBytes == stats.containers.sizeInBytes)
         #expect(decoded.containers.reclaimable == stats.containers.reclaimable)
 
         #expect(decoded.volumes.total == stats.volumes.total)
         #expect(decoded.volumes.active == stats.volumes.active)
-        #expect(decoded.volumes.size == stats.volumes.size)
+        #expect(decoded.volumes.sizeInBytes == stats.volumes.sizeInBytes)
         #expect(decoded.volumes.reclaimable == stats.volumes.reclaimable)
     }
 
     @Test("ResourceUsage with zero values")
     func testZeroValues() throws {
-        let emptyUsage = ResourceUsage(total: 0, active: 0, size: 0, reclaimable: 0)
+        let emptyUsage = ResourceUsage(total: 0, active: 0, sizeInBytes: 0, reclaimable: 0)
 
         let encoder = JSONEncoder()
         let data = try encoder.encode(emptyUsage)
@@ -63,7 +63,7 @@ struct DiskUsageTests {
 
         #expect(decoded.total == 0)
         #expect(decoded.active == 0)
-        #expect(decoded.size == 0)
+        #expect(decoded.sizeInBytes == 0)
         #expect(decoded.reclaimable == 0)
     }
 
@@ -72,7 +72,7 @@ struct DiskUsageTests {
         let largeUsage = ResourceUsage(
             total: 1000,
             active: 500,
-            size: UInt64.max,
+            sizeInBytes: UInt64.max,
             reclaimable: UInt64.max / 2
         )
 
@@ -84,22 +84,22 @@ struct DiskUsageTests {
 
         #expect(decoded.total == 1000)
         #expect(decoded.active == 500)
-        #expect(decoded.size == UInt64.max)
+        #expect(decoded.sizeInBytes == UInt64.max)
         #expect(decoded.reclaimable == UInt64.max / 2)
     }
 
     @Test("ResourceUsage percentage calculations")
     func testPercentageCalculations() throws {
         // 0% reclaimable
-        let noneReclaimable = ResourceUsage(total: 10, active: 10, size: 1000, reclaimable: 0)
-        #expect(Double(noneReclaimable.reclaimable) / Double(noneReclaimable.size) == 0.0)
+        let noneReclaimable = ResourceUsage(total: 10, active: 10, sizeInBytes: 1000, reclaimable: 0)
+        #expect(Double(noneReclaimable.reclaimable) / Double(noneReclaimable.sizeInBytes) == 0.0)
 
         // 50% reclaimable
-        let halfReclaimable = ResourceUsage(total: 10, active: 5, size: 1000, reclaimable: 500)
-        #expect(Double(halfReclaimable.reclaimable) / Double(halfReclaimable.size) == 0.5)
+        let halfReclaimable = ResourceUsage(total: 10, active: 5, sizeInBytes: 1000, reclaimable: 500)
+        #expect(Double(halfReclaimable.reclaimable) / Double(halfReclaimable.sizeInBytes) == 0.5)
 
         // 100% reclaimable
-        let allReclaimable = ResourceUsage(total: 10, active: 0, size: 1000, reclaimable: 1000)
-        #expect(Double(allReclaimable.reclaimable) / Double(allReclaimable.size) == 1.0)
+        let allReclaimable = ResourceUsage(total: 10, active: 0, sizeInBytes: 1000, reclaimable: 1000)
+        #expect(Double(allReclaimable.reclaimable) / Double(allReclaimable.sizeInBytes) == 1.0)
     }
 }