Add container.cpus and container.memory system properties

Author: realrajaryan

Sources/ContainerCommands/System/Property/PropertySet.swift

@@ -69,6 +69,16 @@ extension Application {
                 }
                 DefaultsStore.set(value: value, key: key)
                 return
+            case .defaultContainerCPUs:
+                guard let cpuCount = Int(value), cpuCount > 0 else {
+                    throw ContainerizationError(.invalidArgument, message: "invalid CPU count: \(value)")
+                }
+                DefaultsStore.set(value: value, key: key)
+            case .defaultContainerMemory:
+                guard let memoryMiB = try? Parser.memoryString(value), memoryMiB > 0 else {
+                    throw ContainerizationError(.invalidArgument, message: "invalid memory value: \(value)")
+                }
+                DefaultsStore.set(value: value, key: key)
             case .defaultSubnet:
                 guard (try? CIDRv4(value)) != nil else {
                     throw ContainerizationError(.invalidArgument, message: "invalid CIDRv4 address: \(value)")

Sources/ContainerPersistence/DefaultsStore.swift

@@ -24,6 +24,8 @@ public enum DefaultsStore {
 
     public enum Keys: String {
         case buildRosetta = "build.rosetta"
+        case defaultContainerCPUs = "container.cpus"
+        case defaultContainerMemory = "container.memory"
         case defaultDNSDomain = "dns.domain"
         case defaultBuilderImage = "image.builder"
         case defaultInitImage = "image.init"
@@ -69,6 +71,8 @@ public enum DefaultsStore {
     public static func allValues() -> [DefaultsStoreValue] {
         let allKeys: [(Self.Keys, (Self.Keys) -> Any?)] = [
             (.buildRosetta, { Self.getBool(key: $0) }),
+            (.defaultContainerCPUs, { Self.getOptional(key: $0) }),
+            (.defaultContainerMemory, { Self.getOptional(key: $0) }),
             (.defaultBuilderImage, { Self.get(key: $0) }),
             (.defaultInitImage, { Self.get(key: $0) }),
             (.defaultKernelBinaryPath, { Self.get(key: $0) }),
@@ -122,6 +126,10 @@ extension DefaultsStore.Keys {
         switch self {
         case .buildRosetta:
             return "Build amd64 images on arm64 using Rosetta, instead of QEMU."
+        case .defaultContainerCPUs:
+            return "If defined, the default number of CPUs to allocate to a container."
+        case .defaultContainerMemory:
+            return "If defined, the default amount of memory to allocate to a container."
         case .defaultDNSDomain:
             return "If defined, the local DNS domain to use for containers with unqualified names."
         case .defaultBuilderImage:
@@ -145,6 +153,10 @@ extension DefaultsStore.Keys {
         switch self {
         case .buildRosetta:
             return Bool.self
+        case .defaultContainerCPUs:
+            return String.self
+        case .defaultContainerMemory:
+            return String.self
         case .defaultDNSDomain:
             return String.self
         case .defaultBuilderImage:
@@ -169,6 +181,12 @@ extension DefaultsStore.Keys {
         case .buildRosetta:
             // This is a boolean key, not used with the string get() method
             return "true"
+        case .defaultContainerCPUs:
+            // This key is read with getOptional(), not get(); this value is never used
+            return "4"
+        case .defaultContainerMemory:
+            // This key is read with getOptional(), not get(); this value is never used
+            return "1g"
         case .defaultDNSDomain:
             return "test"
         case .defaultBuilderImage:

Sources/Services/ContainerAPIService/Client/Parser.swift

@@ -14,6 +14,7 @@
 // limitations under the License.
 //===----------------------------------------------------------------------===//
 
+import ContainerPersistence
 import ContainerResource
 import Containerization
 import ContainerizationError
@@ -90,9 +91,15 @@ public struct Parser {
         var resource = ContainerConfiguration.Resources()
         if let cpus {
             resource.cpus = Int(cpus)
+        } else if let cpuStr = DefaultsStore.getOptional(key: .defaultContainerCPUs),
+            let cpuVal = Int(cpuStr), cpuVal > 0
+        {
+            resource.cpus = cpuVal
         }
         if let memory {
             resource.memoryInBytes = try Parser.memoryString(memory).mib()
+        } else if let memStr = DefaultsStore.getOptional(key: .defaultContainerMemory) {
+            resource.memoryInBytes = try Parser.memoryString(memStr).mib()
         }
         return resource
     }

Tests/ContainerAPIClientTests/ParserTest.swift

@@ -16,6 +16,7 @@
 
 import ContainerizationError
 import ContainerizationExtras
+import ContainerPersistence
 import Foundation
 import Testing
 
@@ -1043,4 +1044,35 @@ struct ParserTest {
         #expect(result[0].soft == UInt64.max - 1)
         #expect(result[0].hard == UInt64.max)
     }
+
+    // MARK: - Parser.resources
+
+    @Test
+    func testResourcesCPUsFromProperty() throws {
+        DefaultsStore.set(value: "8", key: .defaultContainerCPUs)
+        defer { DefaultsStore.unset(key: .defaultContainerCPUs) }
+        let result = try Parser.resources(cpus: nil, memory: nil)
+        #expect(result.cpus == 8)
+    }
+
+    @Test
+    func testResourcesMemoryFromProperty() throws {
+        DefaultsStore.set(value: "2g", key: .defaultContainerMemory)
+        defer { DefaultsStore.unset(key: .defaultContainerMemory) }
+        let result = try Parser.resources(cpus: nil, memory: nil)
+        #expect(result.memoryInBytes == 2048.mib())
+    }
+
+    @Test
+    func testResourcesFlagOverridesProperty() throws {
+        DefaultsStore.set(value: "8", key: .defaultContainerCPUs)
+        DefaultsStore.set(value: "2g", key: .defaultContainerMemory)
+        defer {
+            DefaultsStore.unset(key: .defaultContainerCPUs)
+            DefaultsStore.unset(key: .defaultContainerMemory)
+        }
+        let result = try Parser.resources(cpus: 1, memory: "256m")
+        #expect(result.cpus == 1)
+        #expect(result.memoryInBytes == 256.mib())
+    }
 }