# This is a combination of 3 commits.

# This is the 1st commit message:

Moving bundle creation to sandboxService

# This is the commit message #2:

make fmt

# This is the commit message #3:

removing stray comment

Author: ajemory

Package.swift

@@ -338,6 +338,7 @@ let package = Package(
             dependencies: [
                 .product(name: "Containerization", package: "containerization"),
                 .product(name: "ContainerizationExtras", package: "containerization"),
+                "ContainerAPIService",
                 "ContainerResource",
             ]
         ),

Sources/ContainerResource/Container/Bundle.swift

@@ -18,6 +18,59 @@ import Containerization
 import ContainerizationError
 import Foundation
 
+public struct BundleMetadata: Codable, Sendable {
+    static let bundleMetadataFileName = "bundle-metadata.json"
+
+    public let path: URL
+    public let initialFilesystem: Filesystem
+    public let kernel: Kernel
+    public let containerConfiguration: ContainerConfiguration?
+    public let containerRootFilesystem: Filesystem?
+    public let options: ContainerCreateOptions?
+
+    public init(
+        path: URL,
+        initialFilesystem: Filesystem,
+        kernel: Kernel,
+        containerConfiguration: ContainerConfiguration? = nil,
+        containerRootFilesystem: Filesystem? = nil,
+        options: ContainerCreateOptions? = nil
+    ) {
+        self.path = path
+        self.initialFilesystem = initialFilesystem
+        self.kernel = kernel
+        self.containerConfiguration = containerConfiguration
+        self.containerRootFilesystem = containerRootFilesystem
+        self.options = options
+    }
+
+    public var bundleMetadataPath: URL {
+        self.path.appendingPathComponent(Self.bundleMetadataFileName)
+    }
+
+    public static func writeMetadata(_ metadata: BundleMetadata) throws {
+        // Ensure the parent directory exists
+        let directory = metadata.bundleMetadataPath.deletingLastPathComponent()
+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+
+        let data = try JSONEncoder().encode(metadata)
+        try data.write(to: metadata.bundleMetadataPath)
+    }
+
+    public static func readMetadata(from bundlePath: URL) throws -> BundleMetadata {
+        let metadataPath = bundlePath.appendingPathComponent(BundleMetadata.bundleMetadataFileName)
+        guard FileManager.default.fileExists(atPath: metadataPath.path) else {
+            throw ContainerizationError(
+                .notFound,
+                message: "bundle metadata file not found at path: \(metadataPath.path)"
+            )
+        }
+
+        let data = try Data(contentsOf: metadataPath)
+        return try JSONDecoder().decode(BundleMetadata.self, from: data)
+    }
+}
+
 public struct Bundle: Sendable {
     private static let initfsFilename = "initfs.ext4"
     private static let kernelFilename = "kernel.json"
@@ -109,6 +162,26 @@ extension Bundle {
         }
         return bundle
     }
+
+    public static func createFromMetadata(_ metadata: BundleMetadata) throws -> Bundle {
+        let bundle = try create(
+            path: metadata.path,
+            initialFilesystem: metadata.initialFilesystem,
+            kernel: metadata.kernel,
+            containerConfiguration: metadata.containerConfiguration
+        )
+
+        if let containerRootFs = metadata.containerRootFilesystem {
+            let readonly = metadata.containerConfiguration?.readOnly ?? false
+            try bundle.setContainerRootFs(cloning: containerRootFs, readonly: readonly)
+        }
+
+        if let options = metadata.options {
+            try bundle.write(filename: "options.json", value: options)
+        }
+
+        return bundle
+    }
 }
 
 extension Bundle {

Sources/Helpers/RuntimeLinux/RuntimeLinuxHelper+Start.swift

@@ -69,6 +69,7 @@ extension RuntimeLinuxHelper {
                 }
 
                 nonisolated(unsafe) let anonymousConnection = xpc_connection_create(nil, nil)
+
                 let server = SandboxService(
                     root: .init(fileURLWithPath: root),
                     interfaceStrategy: interfaceStrategy,

Sources/Services/ContainerAPIService/Server/Containers/ContainersService.swift

@@ -238,17 +238,20 @@ public actor ContainersService {
             self.log.info("Using init image: \(initImage ?? ClientImage.initImageRef)")
             let initFilesystem = try await self.getInitBlock(for: systemPlatform.ociPlatform(), imageRef: initImage)
 
-            let bundle = try ContainerResource.Bundle.create(
-                path: path,
-                initialFilesystem: initFilesystem,
-                kernel: kernel,
-                containerConfiguration: configuration
-            )
             do {
                 let containerImage = ClientImage(description: configuration.image)
                 let imageFs = try await containerImage.getCreateSnapshot(platform: configuration.platform)
-                try bundle.setContainerRootFs(cloning: imageFs, readonly: configuration.readOnly)
-                try bundle.write(filename: "options.json", value: options)
+
+                let completeMetadata = BundleMetadata(
+                    path: path,
+                    initialFilesystem: initFilesystem,
+                    kernel: kernel,
+                    containerConfiguration: configuration,
+                    containerRootFilesystem: imageFs,
+                    options: options
+                )
+
+                try ContainerResource.BundleMetadata.writeMetadata(completeMetadata)
 
                 let snapshot = ContainerSnapshot(
                     configuration: configuration,
@@ -258,11 +261,6 @@ public actor ContainersService {
                 )
                 await self.setContainerState(configuration.id, ContainerState(snapshot: snapshot), context: context)
             } catch {
-                do {
-                    try bundle.delete()
-                } catch {
-                    self.log.error("failed to delete bundle for container \(configuration.id): \(error)")
-                }
                 throw error
             }
         }
@@ -282,8 +280,7 @@ public actor ContainersService {
             }
 
             let path = self.containerRoot.appendingPathComponent(id)
-            let bundle = ContainerResource.Bundle(path: path)
-            let config = try bundle.configuration
+            let config = try await self.getContainerConfiguration(at: path)
 
             do {
                 try Self.registerService(
@@ -298,6 +295,7 @@ public actor ContainersService {
                     id: id,
                     runtime: runtime
                 )
+
                 try await sandboxClient.bootstrap(stdio: stdio)
 
                 try await self.exitMonitor.registerProcess(
@@ -602,15 +600,33 @@ public actor ContainersService {
         // the OCI runtime.
         await self.exitMonitor.stopTracking(id: id)
         let path = self.containerRoot.appendingPathComponent(id)
+
+        // Try to get config for service deregistration
+        // Don't fail if bundle is incomplete
+        var config: ContainerConfiguration?
         let bundle = ContainerResource.Bundle(path: path)
-        let config = try bundle.configuration
+        do {
+            config = try bundle.configuration
+        } catch {
+            self.log.warning("Unable to read bundle configuration during cleanup for container \(id): \(error)")
+        }
+
+        // Only try to deregister service if we have a valid config
+        if let config = config {
+            let label = Self.fullLaunchdServiceLabel(
+                runtimeName: config.runtimeHandler,
+                instanceId: id
+            )
+            try? ServiceManager.deregister(fullServiceLabel: label)
+        }
+
+        // Always try to delete the bundle directory, even if it's incomplete
+        do {
+            try bundle.delete()
+        } catch {
+            self.log.warning("Failed to delete bundle for container \(id): \(error)")
+        }
 
-        let label = Self.fullLaunchdServiceLabel(
-            runtimeName: config.runtimeHandler,
-            instanceId: id
-        )
-        try ServiceManager.deregister(fullServiceLabel: label)
-        try bundle.delete()
         self.containers.removeValue(forKey: id)
     }
 
@@ -675,6 +691,35 @@ public actor ContainersService {
     private static func isInitProcess(id: String, processID: String) -> Bool {
         id == processID
     }
+
+    /// Check if a bundle exists at the given path
+    private func bundleExists(at path: URL) async -> ContainerResource.ContainerConfiguration? {
+        guard FileManager.default.fileExists(atPath: path.path) else {
+            return nil
+        }
+
+        let bundle = ContainerResource.Bundle(path: path)
+        do {
+            let config = try bundle.configuration
+            return config
+        } catch {
+            return nil
+        }
+    }
+
+    /// Get container configuration, either from existing bundle or from metadata
+    private func getContainerConfiguration(at path: URL) async throws -> ContainerConfiguration {
+        guard let config = await bundleExists(at: path) else {
+            // Bundle doesn't exist, get config from metadata
+            let metadata = try ContainerResource.BundleMetadata.readMetadata(from: path)
+            guard let config = metadata.containerConfiguration else {
+                throw ContainerizationError(.internalError, message: "metadata missing container configuration")
+            }
+            return config
+        }
+        // Bundle exists, read config normally
+        return config
+    }
 }
 
 extension XPCMessage {

Sources/Services/ContainerSandboxService/Server/SandboxService.swift

@@ -60,13 +60,6 @@ public actor SandboxService {
         return nil
     }
 
-    /// Create an instance with a bundle that describes the container.
-    ///
-    /// - Parameters:
-    ///   - root: The file URL for the bundle root.
-    ///   - interfaceStrategy: The strategy for producing network interface
-    ///     objects for each network to which the container attaches.
-    ///   - log: The destination for log messages.
     public init(
         root: URL,
         interfaceStrategy: InterfaceStrategy,
@@ -108,6 +101,12 @@ public actor SandboxService {
     @Sendable
     public func bootstrap(_ message: XPCMessage) async throws -> XPCMessage {
         self.log.info("`bootstrap` xpc handler")
+
+        // Create the bundle if it doesn't exist yet
+        if !self.bundleExists(at: self.root) {
+            try self.createBundle()
+        }
+
         return try await self.lock.withLock { _ in
             guard await self.state == .created else {
                 throw ContainerizationError(
@@ -1225,7 +1224,7 @@ extension FileHandle: @retroactive ReaderStream, @retroactive Writer {
     }
 }
 
-// MARK: State handler helpers
+// MARK: State handler and bundle creation helpers
 
 extension SandboxService {
     private func addWaiter(id: String, cont: CheckedContinuation<ExitStatus, Never>) {
@@ -1300,4 +1299,33 @@ extension SandboxService {
     func setState(_ new: State) {
         self.state = new
     }
+
+    /// Check if a bundle exists at the given path
+    private func bundleExists(at path: URL) -> Bool {
+        guard FileManager.default.fileExists(atPath: path.path) else {
+            return false
+        }
+
+        let bundle = ContainerResource.Bundle(path: path)
+        do {
+            _ = try bundle.configuration
+            return true
+        } catch {
+            return false
+        }
+    }
+
+    /// Create bundle from metadata
+    private func createBundle() throws {
+        do {
+            let metadata = try ContainerResource.BundleMetadata.readMetadata(from: self.root)
+            _ = try ContainerResource.Bundle.createFromMetadata(metadata)
+            self.log.info("Created bundle from metadata at \(metadata.path)")
+            // Could remove the metadata file at this point, but will be
+            // cleaned up along with the bundle anyway
+        } catch {
+            self.log.error("Failed to create bundle \(error)")
+            throw error
+        }
+    }
 }