set MTU default in Utility, remove MTU from network helper

realrajaryan · realrajaryan · commit b374bb7a2621 · 2026-03-03T15:51:42.000-08:00
diff --git a/Sources/ContainerResource/Network/Attachment.swift b/Sources/ContainerResource/Network/Attachment.swift
@@ -31,7 +31,7 @@ public struct Attachment: Codable, Sendable {
     public let ipv6Address: CIDRv6?
     /// The MAC address associated with the attachment (optional).
     public let macAddress: MACAddress?
-    /// The MTU for the network interface (optional). Defaults to 1280 if not specified.
+    /// The MTU for the network interface.
     public let mtu: UInt32?
 
     public init(
diff --git a/Sources/ContainerResource/Network/AttachmentConfiguration.swift b/Sources/ContainerResource/Network/AttachmentConfiguration.swift
@@ -38,7 +38,7 @@ public struct AttachmentOptions: Codable, Sendable {
     /// The MAC address associated with the attachment (optional).
     public let macAddress: MACAddress?
 
-    /// The MTU for the network interface (optional). Defaults to 1280 if not specified.
+    /// The MTU for the network interface.
     public let mtu: UInt32?
 
     public init(hostname: String, macAddress: MACAddress? = nil, mtu: UInt32? = nil) {
diff --git a/Sources/Services/ContainerAPIService/Client/Utility.swift b/Sources/Services/ContainerAPIService/Client/Utility.swift
@@ -297,15 +297,16 @@ public struct Utility {
             // attach the first network using the fqdn, and the rest using just the container ID
             return try networks.enumerated().map { item in
                 let macAddress = try item.element.macAddress.map { try MACAddress($0) }
+                let mtu = item.element.mtu ?? 1280
                 guard item.offset == 0 else {
                     return AttachmentConfiguration(
                         network: item.element.name,
-                        options: AttachmentOptions(hostname: containerId, macAddress: macAddress, mtu: item.element.mtu)
+                        options: AttachmentOptions(hostname: containerId, macAddress: macAddress, mtu: mtu)
                     )
                 }
                 return AttachmentConfiguration(
                     network: item.element.name,
-                    options: AttachmentOptions(hostname: fqdn ?? containerId, macAddress: macAddress, mtu: item.element.mtu)
+                    options: AttachmentOptions(hostname: fqdn ?? containerId, macAddress: macAddress, mtu: mtu)
                 )
             }
         }
@@ -314,7 +315,7 @@ public struct Utility {
         guard let builtinNetworkId else {
             throw ContainerizationError(.invalidState, message: "builtin network is not present")
         }
-        return [AttachmentConfiguration(network: builtinNetworkId, options: AttachmentOptions(hostname: fqdn ?? containerId, macAddress: nil))]
+        return [AttachmentConfiguration(network: builtinNetworkId, options: AttachmentOptions(hostname: fqdn ?? containerId, macAddress: nil, mtu: 1280))]
     }
 
     private static func getKernel(management: Flags.Management) async throws -> Kernel {
diff --git a/Sources/Services/ContainerAPIService/Server/Containers/ContainersService.swift b/Sources/Services/ContainerAPIService/Server/Containers/ContainersService.swift
@@ -415,12 +415,28 @@ public actor ContainersService {
                     let allocatedAttach = try await self.networksService?.allocate(
                         id: n.network,
                         hostname: n.options.hostname,
-                        macAddress: n.options.macAddress,
-                        mtu: n.options.mtu
+                        macAddress: n.options.macAddress
                     )
-                    guard let allocatedAttach = allocatedAttach else {
+                    guard var allocatedAttach = allocatedAttach else {
                         throw ContainerizationError(.internalError, message: "failed to allocate a network")
                     }
+
+                    if let mtu = n.options.mtu {
+                        let a = allocatedAttach.attachment
+                        allocatedAttach = AllocatedAttachment(
+                            attachment: Attachment(
+                                network: a.network,
+                                hostname: a.hostname,
+                                ipv4Address: a.ipv4Address,
+                                ipv4Gateway: a.ipv4Gateway,
+                                ipv6Address: a.ipv6Address,
+                                macAddress: a.macAddress,
+                                mtu: mtu
+                            ),
+                            additionalData: allocatedAttach.additionalData,
+                            pluginInfo: allocatedAttach.pluginInfo
+                        )
+                    }
                     allocatedAttachments.append(allocatedAttach)
                 }
 
diff --git a/Sources/Services/ContainerAPIService/Server/Networks/NetworksService.swift b/Sources/Services/ContainerAPIService/Server/Networks/NetworksService.swift
@@ -351,14 +351,14 @@ public actor NetworksService {
         }
     }
 
-    public func allocate(id: String, hostname: String, macAddress: MACAddress?, mtu: UInt32?) async throws -> AllocatedAttachment {
+    public func allocate(id: String, hostname: String, macAddress: MACAddress?) async throws -> AllocatedAttachment {
         guard let serviceState = serviceStates[id] else {
             throw ContainerizationError(.notFound, message: "no network for id \(id)")
         }
         guard let pluginInfo = serviceState.networkState.pluginInfo else {
             throw ContainerizationError(.internalError, message: "network \(id) missing plugin information")
         }
-        let (attach, additionalData) = try await serviceState.client.allocate(hostname: hostname, macAddress: macAddress, mtu: mtu)
+        let (attach, additionalData) = try await serviceState.client.allocate(hostname: hostname, macAddress: macAddress)
         return AllocatedAttachment(
             attachment: attach,
             additionalData: additionalData,
diff --git a/Sources/Services/ContainerNetworkService/Client/NetworkClient.swift b/Sources/Services/ContainerNetworkService/Client/NetworkClient.swift
@@ -55,17 +55,13 @@ extension NetworkClient {
 
     public func allocate(
         hostname: String,
-        macAddress: MACAddress? = nil,
-        mtu: UInt32? = nil
+        macAddress: MACAddress? = nil
     ) async throws -> (attachment: Attachment, additionalData: XPCMessage?) {
         let request = XPCMessage(route: NetworkRoutes.allocate.rawValue)
         request.set(key: NetworkKeys.hostname.rawValue, value: hostname)
         if let macAddress = macAddress {
             request.set(key: NetworkKeys.macAddress.rawValue, value: macAddress.description)
         }
-        if let mtu = mtu {
-            request.set(key: NetworkKeys.mtu.rawValue, value: String(mtu))
-        }
 
         let client = createClient()
 
diff --git a/Sources/Services/ContainerNetworkService/Client/NetworkKeys.swift b/Sources/Services/ContainerNetworkService/Client/NetworkKeys.swift
@@ -20,7 +20,6 @@ public enum NetworkKeys: String {
     case attachment
     case hostname
     case macAddress
-    case mtu
     case network
     case state
 }
diff --git a/Sources/Services/ContainerNetworkService/Server/NetworkService.swift b/Sources/Services/ContainerNetworkService/Server/NetworkService.swift
@@ -27,7 +27,6 @@ public actor NetworkService: Sendable {
     private let log: Logger
     private var allocator: AttachmentAllocator
     private var macAddresses: [UInt32: MACAddress]
-    private var mtus: [UInt32: UInt32]
 
     /// Set up a network service for the specified network.
     public init(
@@ -44,7 +43,6 @@ public actor NetworkService: Sendable {
         let size = Int(subnet.upper.value - subnet.lower.value - 3)
         self.allocator = try AttachmentAllocator(lower: subnet.lower.value + 2, size: size)
         self.macAddresses = [:]
-        self.mtus = [:]
         self.network = network
         self.log = log
     }
@@ -72,12 +70,6 @@ public actor NetworkService: Sendable {
             try message.string(key: NetworkKeys.macAddress.rawValue)
             .map { try MACAddress($0) }
             ?? MACAddress((UInt64.random(in: 0...UInt64.max) & 0x0cff_ffff_ffff) | 0xf200_0000_0000)
-        let mtu = try message.string(key: NetworkKeys.mtu.rawValue).map {
-            guard let value = UInt32($0), value > 0 else {
-                throw ContainerizationError(.invalidArgument, message: "invalid mtu value: \($0)")
-            }
-            return value
-        }
         let index = try await allocator.allocate(hostname: hostname)
         let ipv6Address = try status.ipv6Subnet
             .map { try CIDRv6(macAddress.ipv6Address(network: $0.lower), prefix: $0.prefix) }
@@ -88,8 +80,7 @@ public actor NetworkService: Sendable {
             ipv4Address: try CIDRv4(ip, prefix: status.ipv4Subnet.prefix),
             ipv4Gateway: status.ipv4Gateway,
             ipv6Address: ipv6Address,
-            macAddress: macAddress,
-            mtu: mtu
+            macAddress: macAddress
         )
         log.info(
             "allocated attachment",
@@ -108,9 +99,6 @@ public actor NetworkService: Sendable {
             }
         }
         macAddresses[index] = macAddress
-        if let mtu {
-            mtus[index] = mtu
-        }
         return reply
     }
 
@@ -122,7 +110,6 @@ public actor NetworkService: Sendable {
         let hostname = try message.hostname()
         if let index = try await allocator.deallocate(hostname: hostname) {
             macAddresses.removeValue(forKey: index)
-            mtus.removeValue(forKey: index)
         }
         log.info("released attachments", metadata: ["hostname": "\(hostname)"])
         return message.reply()
@@ -158,8 +145,7 @@ public actor NetworkService: Sendable {
             ipv4Address: ipv4Address,
             ipv4Gateway: status.ipv4Gateway,
             ipv6Address: ipv6Address,
-            macAddress: macAddress,
-            mtu: mtus[index]
+            macAddress: macAddress
         )
         log.debug(
             "lookup attachment",

Original file line number	Diff line number	Diff line change
`@@ -297,15 +297,16 @@ public struct Utility {`
`297`	`297`	`// attach the first network using the fqdn, and the rest using just the container ID`
`298`	`298`	`return try networks.enumerated().map { item in`
`299`	`299`	`let macAddress = try item.element.macAddress.map { try MACAddress($0) }`
	`300`	`+ let mtu = item.element.mtu ?? 1280`
`300`	`301`	`guard item.offset == 0 else {`
`301`	`302`	`return AttachmentConfiguration(`
`302`	`303`	`network: item.element.name,`
`303`		`- options: AttachmentOptions(hostname: containerId, macAddress: macAddress, mtu: item.element.mtu)`
	`304`	`+ options: AttachmentOptions(hostname: containerId, macAddress: macAddress, mtu: mtu)`
`304`	`305`	`)`
`305`	`306`	`}`
`306`	`307`	`return AttachmentConfiguration(`
`307`	`308`	`network: item.element.name,`
`308`		`- options: AttachmentOptions(hostname: fqdn ?? containerId, macAddress: macAddress, mtu: item.element.mtu)`
	`309`	`+ options: AttachmentOptions(hostname: fqdn ?? containerId, macAddress: macAddress, mtu: mtu)`
`309`	`310`	`)`
`310`	`311`	`}`
`311`	`312`	`}`
`@@ -314,7 +315,7 @@ public struct Utility {`
`314`	`315`	`guard let builtinNetworkId else {`
`315`	`316`	`throw ContainerizationError(.invalidState, message: "builtin network is not present")`
`316`	`317`	`}`
`317`		`- return [AttachmentConfiguration(network: builtinNetworkId, options: AttachmentOptions(hostname: fqdn ?? containerId, macAddress: nil))]`
	`318`	`+ return [AttachmentConfiguration(network: builtinNetworkId, options: AttachmentOptions(hostname: fqdn ?? containerId, macAddress: nil, mtu: 1280))]`
`318`	`319`	`}`
`319`	`320`
`320`	`321`	`private static func getKernel(management: Flags.Management) async throws -> Kernel {`
Original file line number	Diff line number	Diff line change
`@@ -351,14 +351,14 @@ public actor NetworksService {`
`351`	`351`	`}`
`352`	`352`	`}`
`353`	`353`
`354`		`- public func allocate(id: String, hostname: String, macAddress: MACAddress?, mtu: UInt32?) async throws -> AllocatedAttachment {`
	`354`	`+ public func allocate(id: String, hostname: String, macAddress: MACAddress?) async throws -> AllocatedAttachment {`
`355`	`355`	`guard let serviceState = serviceStates[id] else {`
`356`	`356`	`throw ContainerizationError(.notFound, message: "no network for id \(id)")`
`357`	`357`	`}`
`358`	`358`	`guard let pluginInfo = serviceState.networkState.pluginInfo else {`
`359`	`359`	`throw ContainerizationError(.internalError, message: "network \(id) missing plugin information")`
`360`	`360`	`}`
`361`		`- let (attach, additionalData) = try await serviceState.client.allocate(hostname: hostname, macAddress: macAddress, mtu: mtu)`
	`361`	`+ let (attach, additionalData) = try await serviceState.client.allocate(hostname: hostname, macAddress: macAddress)`
`362`	`362`	`return AllocatedAttachment(`
`363`	`363`	`attachment: attach,`
`364`	`364`	`additionalData: additionalData,`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,6 @@ public enum NetworkKeys: String {`
`20`	`20`	`case attachment`
`21`	`21`	`case hostname`
`22`	`22`	`case macAddress`
`23`		`- case mtu`
`24`	`23`	`case network`
`25`	`24`	`case state`
`26`	`25`	`}`