julian.kiedaischandClaude Opus 5.5
e80be3bbdf
engine.ts ports the UDP part of Swift's "UDP sockets and Router RIP": a socket bound to a given port or to a free one drawn from 49152–65534 with Java's random numbers on Swift's seed; sending, also as a limited broadcast on every interface (or the bound one) with TTL 1; delivery into the queue of every socket on the destination port, which then answers to the last sender; receiving, with a timeout that advances the virtual clock; closing. Stopping forgets sockets and queues. RIP stays not ported; Swift's DHCP handling of a datagram has nothing to do until DHCP is in the snapshot. The oracle gets the steps bindUdp, sendUdp, receiveUdp and closeSocket on both sides and reports the sockets. Two new scenarios — a LAN, and two networks through a router with a UDP firewall rule and a broadcast that does not cross it — match the Swift engine trace for trace, the random ports included. Swift's four UDP engine tests are ported, with a test for stopping. 11 mutation probes were all caught (one only after the stop test was added). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
810 lines
38 KiB
Swift
810 lines
38 KiB
Swift
// Replays scenario files in the filius-ipad runtime engine and writes what
|
|
// happened: every trace event, the result of every step, and the end state.
|
|
// The TypeScript port replays the same files (packages/core/test/oracle.test.ts)
|
|
// and must produce the same output.
|
|
//
|
|
// Usage: Oracle <directory> — reads <name>.scenario.json, writes <name>.swift.json
|
|
|
|
@testable import FiliusCore
|
|
import CryptoKit
|
|
import Foundation
|
|
|
|
// MARK: - Scenario format (shared with packages/core/test/oracle/scenario.ts)
|
|
|
|
struct ScenarioPort: Decodable { let id: String; let label: String; let mac: String? }
|
|
struct ScenarioNode: Decodable { let id: String; let kind: String; let ports: [ScenarioPort] }
|
|
struct ScenarioLink: Decodable {
|
|
let id: String
|
|
let sourceNode: String; let sourcePort: String
|
|
let targetNode: String; let targetPort: String
|
|
}
|
|
struct ScenarioDevice: Decodable { let ip: String; let mask: String; let gateway: String?; let dns: String? }
|
|
struct ScenarioInterface: Decodable { let node: String; let port: String; let ip: String; let mask: String }
|
|
struct ScenarioRoute: Decodable { let destination: String; let mask: String; let gateway: String; let interface: String }
|
|
struct ScenarioSwitch: Decodable { let ssid: String; let retention: UInt64? }
|
|
struct ScenarioFirewallRule: Decodable {
|
|
let source: String?; let sourceMask: String?
|
|
let destination: String?; let destinationMask: String?
|
|
let port: Int?; let `protocol`: String?; let action: String?
|
|
}
|
|
struct ScenarioFirewall: Decodable {
|
|
let active: Bool?; let defaultPolicy: String?; let dropIcmp: Bool?
|
|
let synOnly: Bool?; let filterUdp: Bool?; let rules: [ScenarioFirewallRule]?
|
|
}
|
|
struct ScenarioStep: Decodable {
|
|
let op: String
|
|
let from: String?; let node: String?; let target: String?
|
|
let ttl: UInt8?; let identifier: UInt16?; let sequence: UInt16?; let maxTtl: UInt8?
|
|
let to: UInt64?; let enabled: Bool?; let percent: Int?
|
|
// UDP: a socket is named by the id bindUdp returned.
|
|
let port: UInt16?; let localIp: String?; let remoteIp: String?; let remotePort: UInt16?
|
|
let socket: String?; let payload: String?; let timeout: UInt64?
|
|
}
|
|
struct Scenario: Decodable {
|
|
let seed: UInt64
|
|
let speedPercent: Int?
|
|
let nodes: [ScenarioNode]
|
|
let links: [ScenarioLink]
|
|
let devices: [String: ScenarioDevice]?
|
|
let interfaces: [ScenarioInterface]?
|
|
let routes: [String: [ScenarioRoute]]?
|
|
let switches: [String: ScenarioSwitch]?
|
|
let firewalls: [String: ScenarioFirewall]?
|
|
let steps: [ScenarioStep]
|
|
}
|
|
|
|
// MARK: - Building the snapshot
|
|
|
|
func uuid(_ value: String) -> UUID {
|
|
guard let id = UUID(uuidString: value) else { fatalError("not a UUID: \(value)") }
|
|
return id
|
|
}
|
|
|
|
func firewallAction(_ value: String?) -> TopologyFirewallAction {
|
|
value == "accept" ? .accept : .drop
|
|
}
|
|
|
|
func firewallProtocol(_ value: String?) -> TopologyFirewallProtocol {
|
|
switch value {
|
|
case "all": return .all
|
|
case "icmp": return .icmp
|
|
case "udp": return .udp
|
|
default: return .tcp
|
|
}
|
|
}
|
|
|
|
func snapshot(of scenario: Scenario) -> TopologyNetworkRuntimeTopologySnapshot {
|
|
let nodes = scenario.nodes.map { node -> TopologyNetworkRuntimeNodeSnapshot in
|
|
guard let kind = TopologyNodeKind(rawValue: node.kind) else { fatalError("unknown kind \(node.kind)") }
|
|
return TopologyNetworkRuntimeNodeSnapshot(
|
|
id: uuid(node.id),
|
|
kind: kind,
|
|
ports: node.ports.map { TopologyNetworkRuntimePortSnapshot(id: uuid($0.id), label: $0.label, macAddress: $0.mac) }
|
|
)
|
|
}
|
|
let links = scenario.links.map {
|
|
TopologyNetworkRuntimeLinkSnapshot(
|
|
id: uuid($0.id),
|
|
sourceNodeID: uuid($0.sourceNode), sourcePortID: uuid($0.sourcePort),
|
|
targetNodeID: uuid($0.targetNode), targetPortID: uuid($0.targetPort)
|
|
)
|
|
}
|
|
var devices: [UUID: TopologyRuntimeDeviceConfiguration] = [:]
|
|
for (node, device) in scenario.devices ?? [:] {
|
|
devices[uuid(node)] = TopologyRuntimeDeviceConfiguration(
|
|
ipAddress: device.ip, subnetMask: device.mask,
|
|
defaultGateway: device.gateway ?? "", dnsServer: device.dns ?? ""
|
|
)
|
|
}
|
|
var interfaces: [TopologyRuntimeInterfaceKey: TopologyRuntimeInterfaceConfiguration] = [:]
|
|
for item in scenario.interfaces ?? [] {
|
|
interfaces[TopologyRuntimeInterfaceKey(nodeID: uuid(item.node), portID: uuid(item.port))] =
|
|
TopologyRuntimeInterfaceConfiguration(ipAddress: item.ip, subnetMask: item.mask)
|
|
}
|
|
var routes: [UUID: [TopologyRuntimeManualRoute]] = [:]
|
|
for (node, rows) in scenario.routes ?? [:] {
|
|
routes[uuid(node)] = rows.map {
|
|
TopologyRuntimeManualRoute(
|
|
destinationNetwork: $0.destination, subnetMask: $0.mask,
|
|
gateway: $0.gateway, interfaceIPAddress: $0.interface
|
|
)
|
|
}
|
|
}
|
|
var switches: [UUID: TopologySwitchConfiguration] = [:]
|
|
for (node, config) in scenario.switches ?? [:] {
|
|
switches[uuid(node)] = TopologySwitchConfiguration(
|
|
ssid: config.ssid,
|
|
retentionTimeMilliseconds: config.retention ?? TopologySwitchConfiguration.defaultRetentionTimeMilliseconds
|
|
)
|
|
}
|
|
var firewalls: [UUID: TopologyFirewallConfiguration] = [:]
|
|
for (node, config) in scenario.firewalls ?? [:] {
|
|
firewalls[uuid(node)] = TopologyFirewallConfiguration(
|
|
isActive: config.active ?? false,
|
|
defaultPolicy: firewallAction(config.defaultPolicy),
|
|
dropICMP: config.dropIcmp ?? false,
|
|
filterSYNSegmentsOnly: config.synOnly ?? true,
|
|
filterUDP: config.filterUdp ?? true,
|
|
rules: (config.rules ?? []).map {
|
|
TopologyFirewallRule(
|
|
sourceIPAddress: $0.source ?? "", sourceSubnetMask: $0.sourceMask ?? "",
|
|
destinationIPAddress: $0.destination ?? "", destinationSubnetMask: $0.destinationMask ?? "",
|
|
port: $0.port ?? TopologyFirewallRule.allPorts,
|
|
protocolType: firewallProtocol($0.protocol),
|
|
action: firewallAction($0.action)
|
|
)
|
|
}
|
|
)
|
|
}
|
|
return TopologyNetworkRuntimeTopologySnapshot(
|
|
nodes: nodes, links: links,
|
|
deviceConfigurations: devices, interfaceConfigurations: interfaces,
|
|
manualRoutesByNodeID: routes,
|
|
firewallConfigurationsByNodeID: firewalls,
|
|
switchConfigurationsByNodeID: switches
|
|
)
|
|
}
|
|
|
|
// MARK: - Output
|
|
|
|
typealias JSON = [String: Any]
|
|
|
|
func headers(_ fields: [TopologyPacketHeaderField]) -> [[String]] {
|
|
fields.map { [$0.name, $0.value] }
|
|
}
|
|
|
|
func trace(_ event: TopologyPacketTraceEvent) -> JSON {
|
|
var result: JSON = [
|
|
"id": event.id,
|
|
"time": event.timeMilliseconds,
|
|
"node": event.nodeID.uuidString,
|
|
"direction": event.direction.rawValue,
|
|
"layer": event.layer.rawValue,
|
|
"operation": event.operation.rawValue,
|
|
"before": headers(event.beforeHeaders),
|
|
"after": headers(event.afterHeaders),
|
|
]
|
|
if let frame = event.frameIdentity { result["frame"] = frame }
|
|
if let packet = event.packetIdentity { result["packet"] = packet }
|
|
if let interface = event.interfaceID { result["interface"] = interface.uuidString }
|
|
if let detail = event.detail { result["detail"] = detail }
|
|
return result
|
|
}
|
|
|
|
func delivery(_ result: TopologyIPv4DeliveryResult) -> JSON {
|
|
switch result {
|
|
case let .delivered(packet, node): return ["type": "delivered", "packet": packet, "node": node.uuidString]
|
|
case let .icmpError(packet, node, kind):
|
|
return ["type": "icmpError", "packet": packet, "node": node.uuidString, "kind": kind.rawValue]
|
|
case let .dropped(packet, node):
|
|
var json: JSON = ["type": "dropped", "packet": packet]
|
|
if let node { json["node"] = node.uuidString }
|
|
return json
|
|
}
|
|
}
|
|
|
|
func observation(_ item: TopologyRuntimeICMPObservation) -> JSON {
|
|
[
|
|
"kind": item.message.kind.rawValue,
|
|
"identifier": item.message.identifier,
|
|
"sequence": item.message.sequenceNumber,
|
|
"sender": item.packet.senderIPAddress,
|
|
]
|
|
}
|
|
|
|
func run(_ scenario: Scenario) -> JSON {
|
|
var engine = TopologyNetworkRuntimeEngine(seed: scenario.seed)
|
|
if let percent = scenario.speedPercent { engine.setSimulationSpeed(percent: percent) }
|
|
engine.handle(.start(snapshot: snapshot(of: scenario), seed: scenario.seed, initialTimeMilliseconds: 0))
|
|
|
|
var results: [Any] = []
|
|
for step in scenario.steps {
|
|
switch step.op {
|
|
case "ping":
|
|
results.append(delivery(engine.sendICMPEcho(
|
|
fromNodeID: uuid(step.from!), targetIPAddress: step.target!,
|
|
timeToLive: step.ttl ?? 64, identifier: step.identifier ?? 1, sequenceNumber: step.sequence ?? 1
|
|
)))
|
|
case "traceroute":
|
|
results.append(engine.traceICMPEcho(
|
|
fromNodeID: uuid(step.from!), targetIPAddress: step.target!,
|
|
maximumTimeToLive: step.maxTtl ?? 64, identifier: step.identifier ?? 1
|
|
).map(observation))
|
|
case "resolveMac":
|
|
results.append(engine.resolveMACAddress(nodeID: uuid(step.node!), targetIPAddress: step.target!) ?? NSNull())
|
|
case "advance":
|
|
engine.handle(.advance(toMilliseconds: step.to!))
|
|
results.append(engine.state.currentTimeMilliseconds)
|
|
case "packetLoss":
|
|
engine.setGlobalPacketLossEnabled(step.enabled!)
|
|
results.append(engine.state.globalPacketLossEnabled)
|
|
case "sat":
|
|
results.append(engine.switchSATEntries(nodeID: uuid(step.node!)).map {
|
|
["mac": $0.macAddress, "port": $0.portLabel, "updated": $0.updatedAtMilliseconds] as JSON
|
|
})
|
|
case "speed":
|
|
engine.setSimulationSpeed(percent: step.percent!)
|
|
results.append(engine.simulationSpeed.percent)
|
|
case "bindUdp":
|
|
results.append(engine.bindUDPSocket(
|
|
nodeID: uuid(step.node!), localPort: step.port, localIPAddress: step.localIp,
|
|
remoteIPAddress: step.remoteIp, remotePort: step.remotePort
|
|
)?.uuidString ?? NSNull())
|
|
case "sendUdp":
|
|
results.append(engine.sendUDP(
|
|
socketID: uuid(step.socket!), payload: Data((step.payload ?? "").utf8),
|
|
destinationIPAddress: step.target, destinationPort: step.port
|
|
).map(delivery) ?? NSNull())
|
|
case "receiveUdp":
|
|
let received = step.timeout.map { engine.receiveUDP(socketID: uuid(step.socket!), timeoutMilliseconds: $0) }
|
|
?? engine.receiveUDP(socketID: uuid(step.socket!))
|
|
results.append(received.map { item -> JSON in
|
|
[
|
|
"sender": item.senderIPAddress, "receiver": item.receiverIPAddress,
|
|
"sourcePort": item.datagram.sourcePort, "destinationPort": item.datagram.destinationPort,
|
|
"payload": String(decoding: item.datagram.payload, as: UTF8.self), "at": item.receivedAtMilliseconds,
|
|
]
|
|
} ?? NSNull())
|
|
case "closeSocket":
|
|
engine.closeSocket(socketID: uuid(step.socket!))
|
|
results.append(engine.state.socketsByID[uuid(step.socket!)] == nil)
|
|
default:
|
|
fatalError("unknown step \(step.op)")
|
|
}
|
|
}
|
|
|
|
let state = engine.state
|
|
var arp: JSON = [:]
|
|
for (node, cache) in state.arpCachesByNodeID {
|
|
arp[node.uuidString] = cache.mapValues { $0.macAddress }
|
|
}
|
|
var switchTables: JSON = [:]
|
|
for (node, table) in state.switchForwardingTablesByNodeID {
|
|
switchTables[node.uuidString] = table.mapValues { $0.uuidString }
|
|
}
|
|
var observations: JSON = [:]
|
|
for (node, items) in state.icmpObservationsByNodeID {
|
|
observations[node.uuidString] = items.map(observation)
|
|
}
|
|
return [
|
|
"results": results,
|
|
"traces": state.packetTraces.map(trace),
|
|
"time": state.currentTimeMilliseconds,
|
|
"pendingEvents": state.pendingEvents.count,
|
|
"arp": arp,
|
|
"switchTables": switchTables,
|
|
"icmpObservations": observations,
|
|
"sockets": state.socketsByID.values.sorted { $0.id.uuidString < $1.id.uuidString }.map { socket -> JSON in
|
|
[
|
|
"id": socket.id.uuidString, "node": socket.nodeID.uuidString, "protocol": socket.protocolKind.rawValue,
|
|
"localIp": socket.localIPAddress ?? NSNull(), "localPort": socket.localPort,
|
|
"remoteIp": socket.remoteIPAddress ?? NSNull(), "remotePort": socket.remotePort.map { $0 as Any } ?? NSNull(),
|
|
"queued": state.udpReceiveQueuesBySocketID[socket.id]?.count ?? 0,
|
|
]
|
|
},
|
|
"firewallDecisions": state.firewallDecisions.map { decision -> JSON in
|
|
var json: JSON = [
|
|
"packet": decision.packetIdentity, "node": decision.nodeID.uuidString, "accepted": decision.accepted,
|
|
]
|
|
if let rule = decision.ruleIndex { json["rule"] = rule }
|
|
return json
|
|
},
|
|
]
|
|
}
|
|
|
|
// MARK: - .fls corpus
|
|
|
|
/// Imports every .fls under `root` and summarizes what the Swift reader made of it.
|
|
func readCorpus(root: URL) throws -> JSON {
|
|
var result: JSON = [:]
|
|
let enumerator = FileManager.default.enumerator(at: root, includingPropertiesForKeys: nil)
|
|
var files: [URL] = []
|
|
while let item = enumerator?.nextObject() as? URL {
|
|
if item.pathExtension == "fls" { files.append(item) }
|
|
}
|
|
for file in files.sorted(by: { $0.path < $1.path }) {
|
|
let name = String(file.path.dropFirst(root.path.count + 1))
|
|
do {
|
|
let imported = try TopologyProjectStore.importFiliusArchive(Data(contentsOf: file))
|
|
let state = imported.state
|
|
var kinds: [String: Int] = [:]
|
|
for node in state.graph.nodes { kinds[node.kind.rawValue, default: 0] += 1 }
|
|
result[name] = [
|
|
"version": imported.report.filiusVersion ?? NSNull(),
|
|
"nodes": imported.report.importedNodeCount,
|
|
"links": imported.report.importedLinkCount,
|
|
"documentation": imported.report.importedDocumentationItemCount,
|
|
"skipped": imported.report.skippedNodeCount,
|
|
"warnings": imported.report.warnings,
|
|
"residual": imported.opaqueContent.residualCount,
|
|
"kinds": kinds,
|
|
"state": describeImportedState(state),
|
|
] as JSON
|
|
} catch {
|
|
result[name] = ["error": String(describing: error)] as JSON
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
/// The imported model without its random UUIDs: nodes, ports and links by
|
|
/// index; the IP configurations the runtime starts from; documentation items
|
|
/// with their deterministic ids.
|
|
func describeImportedState(_ state: TopologyEditorState) -> JSON {
|
|
let nodeIndex = Dictionary(uniqueKeysWithValues: state.graph.nodes.enumerated().map { ($1.id, $0) })
|
|
func portIndex(_ nodeID: UUID, _ portID: UUID) -> Int {
|
|
state.graph.node(withID: nodeID)?.ports.firstIndex { $0.id == portID } ?? -1
|
|
}
|
|
let nodes: [JSON] = state.graph.nodes.map { node in
|
|
let device: Any = state.runtimeDeviceConfigurations[node.id].map { configuration -> JSON in
|
|
[
|
|
"ipAddress": configuration.ipAddress,
|
|
"subnetMask": configuration.subnetMask,
|
|
"defaultGateway": configuration.defaultGateway,
|
|
"dnsServer": configuration.dnsServer,
|
|
]
|
|
} ?? NSNull()
|
|
let interfaces: [Any] = node.ports.map { port in
|
|
state.runtimeInterfaceConfigurations[TopologyRuntimeInterfaceKey(nodeID: node.id, portID: port.id)]
|
|
.map { ["ipAddress": $0.ipAddress, "subnetMask": $0.subnetMask] as JSON } ?? NSNull()
|
|
}
|
|
return [
|
|
"kind": node.kind.rawValue,
|
|
"displayName": node.displayName,
|
|
"hostLabelPolicy": node.hostLabelPolicy.rawValue,
|
|
"position": [Double(node.position.x), Double(node.position.y)],
|
|
"ports": node.ports.map { port -> JSON in
|
|
["label": port.label, "mac": port.importedMACAddress ?? NSNull(), "occupied": port.isOccupied]
|
|
},
|
|
"device": device,
|
|
"interfaces": interfaces,
|
|
"system": describeSystem(state, node),
|
|
"fileSystem": state.virtualFileSystemsByNodeID[node.id].map { describeFileEntries($0.allEntries()) } ?? NSNull(),
|
|
]
|
|
}
|
|
let links: [[Int]] = state.graph.links.map { link in
|
|
[
|
|
nodeIndex[link.sourceNodeID] ?? -1, portIndex(link.sourceNodeID, link.sourcePortID),
|
|
nodeIndex[link.targetNodeID] ?? -1, portIndex(link.targetNodeID, link.targetPortID),
|
|
]
|
|
}
|
|
let documentation: [JSON] = state.documentationItems.map { item in
|
|
[
|
|
"id": item.id.uuidString,
|
|
"kind": item.kind.rawValue,
|
|
"frame": [item.frame.origin.x, item.frame.origin.y, item.frame.width, item.frame.height].map { Double($0) },
|
|
"text": item.text,
|
|
"color": [item.color.red, item.color.green, item.color.blue, item.color.alpha],
|
|
"fontName": item.fontName,
|
|
"fontSize": Double(item.fontSize),
|
|
"isBold": item.isBold,
|
|
"order": item.order,
|
|
]
|
|
}
|
|
return ["nodes": nodes, "links": links, "documentation": documentation]
|
|
}
|
|
|
|
/// The system software settings of a node in the imported state. A switch
|
|
/// SSID Swift derives from the (random) node id is written as a marker.
|
|
func describeSystem(_ state: TopologyEditorState, _ node: TopologyNode) -> JSON {
|
|
var json: JSON = [:]
|
|
if let configuration = state.switchConfigurationsByNodeID[node.id] {
|
|
let derived = TopologySwitchConfiguration.defaultConfiguration(nodeID: node.id).ssid
|
|
json["switch"] = [
|
|
"ssid": configuration.ssid == derived ? "<from node id>" : configuration.ssid,
|
|
"retentionTimeMilliseconds": Int(configuration.retentionTimeMilliseconds),
|
|
] as JSON
|
|
}
|
|
if let wireless = state.hostWirelessConfigurationsByNodeID[node.id] {
|
|
json["hostWireless"] = ["isEnabled": wireless.isEnabled, "ssid": wireless.ssid] as JSON
|
|
}
|
|
if let routes = state.runtimeManualRoutesByNodeID[node.id] {
|
|
json["manualRoutes"] = routes.map { [$0.destinationNetwork, $0.subnetMask, $0.gateway, $0.interfaceIPAddress] }
|
|
}
|
|
if let rip = state.runtimeRIPEnabledByNodeID[node.id] { json["ripEnabled"] = rip }
|
|
if let client = state.runtimeDHCPClientConfigurationsByNodeID[node.id] { json["dhcpClient"] = client.isEnabled }
|
|
if let server = state.runtimeDHCPServerConfigurationsByNodeID[node.id] {
|
|
json["dhcpServer"] = [
|
|
"isActive": server.isActive,
|
|
"lowerBoundIPAddress": server.lowerBoundIPAddress,
|
|
"upperBoundIPAddress": server.upperBoundIPAddress,
|
|
"gatewayIPAddress": server.gatewayIPAddress,
|
|
"dnsServerIPAddress": server.dnsServerIPAddress,
|
|
"useOwnSettings": server.useOwnSettings,
|
|
// The assignments' ids are random.
|
|
"staticAssignments": server.staticAssignments.map { [$0.macAddress, $0.ipAddress] },
|
|
] as JSON
|
|
}
|
|
if let rows = state.runtimePortForwardingRowsByNodeID[node.id] {
|
|
json["portForwarding"] = rows.map { [$0.protocolValue, $0.publicPortValue, $0.lanIPAddress, $0.lanPortValue] }
|
|
}
|
|
if let programs = state.runtimeInstalledProgramsByNodeID[node.id] {
|
|
json["installedPrograms"] = programs.map(\.rawValue).sorted()
|
|
}
|
|
if let web = state.runtimeWebServerConfigurationsByNodeID[node.id] {
|
|
json["webServer"] = [
|
|
"port": web.port,
|
|
"documentRoot": web.documentRoot,
|
|
"virtualHosts": web.virtualHostConfiguration != nil,
|
|
] as JSON
|
|
}
|
|
if let gnutella = state.runtimeGnutellaConfigurationsByNodeID[node.id] {
|
|
json["gnutella"] = ["maximumKnownPeers": gnutella.maximumKnownPeers] as JSON
|
|
}
|
|
if let dns = state.runtimeDNSServerConfigurationsByNodeID[node.id] {
|
|
json["dnsServer"] = [
|
|
"recursiveResolutionEnabled": dns.recursiveResolutionEnabled,
|
|
"forwardingServerIPAddress": dns.forwardingServerIPAddress ?? NSNull(),
|
|
"records": dns.typedRecords.map { dnsRecordJSON($0) },
|
|
] as JSON
|
|
}
|
|
if let client = state.runtimeEmailClientConfigurationsByNodeID[node.id] {
|
|
json["emailClient"] = [
|
|
"pop3Host": client.pop3Host, "pop3Port": client.pop3Port,
|
|
"smtpHost": client.smtpHost, "smtpPort": client.smtpPort,
|
|
"username": client.username, "password": client.password,
|
|
"name": client.name, "email": client.email,
|
|
"inbox": client.inbox.map(emailMessageJSON),
|
|
"sent": client.sent.map(emailMessageJSON),
|
|
"drafts": client.drafts.map(emailMessageJSON),
|
|
"nextMessageID": Int(client.nextMessageID),
|
|
] as JSON
|
|
}
|
|
if let server = state.runtimeEmailServerConfigurationsByNodeID[node.id] {
|
|
json["emailServer"] = [
|
|
"domain": server.domain, "pop3Port": server.pop3Port,
|
|
"accounts": server.accounts.map { account in
|
|
[
|
|
"username": account.username, "password": account.password, "name": account.name,
|
|
"mailbox": account.mailbox.map(emailMessageJSON),
|
|
] as JSON
|
|
},
|
|
"nextMessageID": Int(server.nextMessageID),
|
|
] as JSON
|
|
}
|
|
if let link = state.remoteLinkConfigurationsByNodeID[node.id] {
|
|
json["remoteLink"] = [
|
|
"pairIdentifier": link.pairIdentifier,
|
|
"latencyMilliseconds": Int(link.latencyMilliseconds),
|
|
"isEnabled": link.isEnabled,
|
|
] as JSON
|
|
}
|
|
if let firewall = state.runtimeFirewallConfigurationsByNodeID[node.id] {
|
|
json["firewall"] = [
|
|
"isActive": firewall.isActive,
|
|
"defaultPolicy": firewall.defaultPolicy.rawValue,
|
|
"dropICMP": firewall.dropICMP,
|
|
"filterSYNSegmentsOnly": firewall.filterSYNSegmentsOnly,
|
|
"filterUDP": firewall.filterUDP,
|
|
"rules": firewall.rules.map { rule -> [Any] in
|
|
[rule.sourceIPAddress, rule.sourceSubnetMask, rule.destinationIPAddress, rule.destinationSubnetMask,
|
|
rule.port, rule.protocolType.rawValue, rule.action.rawValue]
|
|
},
|
|
] as JSON
|
|
}
|
|
return json
|
|
}
|
|
|
|
// MARK: - Virtual file system
|
|
|
|
/// One step of a file system case (packages/core/test/vfs.cases.json).
|
|
struct FileSystemStep: Decodable {
|
|
let op: String
|
|
let path: String?
|
|
let to: String?
|
|
let name: String?
|
|
let text: String?
|
|
let size: Int?
|
|
let byte: UInt8?
|
|
let mediaType: String?
|
|
let recursive: Bool?
|
|
let overwrite: Bool?
|
|
let entries: [FileSystemCaseEntry]?
|
|
}
|
|
|
|
struct FileSystemCaseEntry: Decodable { let path: String; let kind: String; let text: String? }
|
|
struct FileSystemCase: Decodable { let name: String; let steps: [FileSystemStep] }
|
|
|
|
func describeFileSystemError(_ error: Error) -> JSON {
|
|
guard let error = error as? TopologyVirtualFileSystemError else {
|
|
return ["error": "other", "values": [String(describing: error)]]
|
|
}
|
|
func result(_ code: String, _ values: [Any] = []) -> JSON { ["error": code, "values": values] }
|
|
switch error {
|
|
case let .pathMustBeAbsolute(path): return result("pathMustBeAbsolute", [path])
|
|
case let .pathEscapesRoot(path): return result("pathEscapesRoot", [path])
|
|
case let .invalidPathComponent(component): return result("invalidPathComponent", [component])
|
|
case let .itemAlreadyExists(path): return result("itemAlreadyExists", [path])
|
|
case let .caseInsensitiveSiblingCollision(existing, attempted):
|
|
return result("caseInsensitiveSiblingCollision", [existing, attempted])
|
|
case let .itemNotFound(path): return result("itemNotFound", [path])
|
|
case let .parentDirectoryNotFound(path): return result("parentDirectoryNotFound", [path])
|
|
case let .expectedDirectory(path): return result("expectedDirectory", [path])
|
|
case let .expectedFile(path): return result("expectedFile", [path])
|
|
case let .expectedTextFile(path): return result("expectedTextFile", [path])
|
|
case let .expectedImageFile(path): return result("expectedImageFile", [path])
|
|
case let .directoryNotEmpty(path): return result("directoryNotEmpty", [path])
|
|
case .cannotMutateRoot: return result("cannotMutateRoot")
|
|
case let .cannotMoveDirectoryIntoItself(source, destination):
|
|
return result("cannotMoveDirectoryIntoItself", [source, destination])
|
|
case let .fileSizeQuotaExceeded(path, actual, limit): return result("fileSizeQuotaExceeded", [path, actual, limit])
|
|
case let .deviceSizeQuotaExceeded(actual, limit): return result("deviceSizeQuotaExceeded", [actual, limit])
|
|
case let .deviceEntryQuotaExceeded(actual, limit): return result("deviceEntryQuotaExceeded", [actual, limit])
|
|
case let .totalSizeQuotaExceeded(actual, limit): return result("totalSizeQuotaExceeded", [actual, limit])
|
|
case let .totalEntryQuotaExceeded(actual, limit): return result("totalEntryQuotaExceeded", [actual, limit])
|
|
}
|
|
}
|
|
|
|
func describeFileEntries(_ entries: [TopologyVirtualFileEntry]) -> [JSON] {
|
|
entries.map { entry in
|
|
var json: JSON = ["path": entry.path]
|
|
switch entry.content {
|
|
case .directory: json["kind"] = "directory"
|
|
case let .text(value): json["kind"] = "text"; json["text"] = value
|
|
case let .binary(data, mediaType):
|
|
json["kind"] = "binary"; json["bytes"] = data.count; json["mediaType"] = mediaType ?? NSNull()
|
|
json["sha256"] = SHA256.hash(data: data).map { String(format: "%02x", $0) }.joined()
|
|
case let .image(data, mediaType):
|
|
json["kind"] = "image"; json["bytes"] = data.count; json["mediaType"] = mediaType
|
|
json["sha256"] = SHA256.hash(data: data).map { String(format: "%02x", $0) }.joined()
|
|
}
|
|
return json
|
|
}
|
|
}
|
|
|
|
func runFileSystemCases(_ cases: [FileSystemCase]) -> [JSON] {
|
|
cases.map { item in
|
|
var fileSystem = TopologyVirtualFileSystem()
|
|
var results: [JSON] = []
|
|
for step in item.steps {
|
|
do {
|
|
let path = step.path ?? "/"
|
|
switch step.op {
|
|
case "createDirectory": try fileSystem.createDirectory(at: path, recursive: step.recursive ?? false)
|
|
case "writeText": try fileSystem.writeTextFile(at: path, text: step.text ?? "", overwrite: step.overwrite ?? true)
|
|
case "writeBinary":
|
|
try fileSystem.writeBinaryFile(
|
|
at: path, data: Data(repeating: step.byte ?? 0, count: step.size ?? 0),
|
|
mediaType: step.mediaType, overwrite: step.overwrite ?? true)
|
|
case "writeImage":
|
|
try fileSystem.writeImageFile(
|
|
at: path, data: Data(repeating: step.byte ?? 0, count: step.size ?? 0),
|
|
mediaType: step.mediaType ?? "image/png", overwrite: step.overwrite ?? true)
|
|
case "copy": try fileSystem.copyItem(at: path, to: step.to ?? "/", overwrite: step.overwrite ?? false)
|
|
case "move": try fileSystem.moveItem(at: path, to: step.to ?? "/", overwrite: step.overwrite ?? false)
|
|
case "rename": results.append(["ok": try fileSystem.renameItem(at: path, to: step.name ?? "")]); continue
|
|
case "delete": try fileSystem.deleteItem(at: path, recursive: step.recursive ?? false)
|
|
case "entry": results.append(["ok": describeFileEntries([try fileSystem.entry(at: path)])[0]]); continue
|
|
case "entries": results.append(["ok": describeFileEntries(try fileSystem.entries(in: path))]); continue
|
|
case "text": results.append(["ok": try fileSystem.textFile(at: path)]); continue
|
|
case "contains": results.append(["ok": fileSystem.contains(path)]); continue
|
|
case "normalize": results.append(["ok": try TopologyVirtualFileSystem.normalizedAbsolutePath(path)]); continue
|
|
case "default": fileSystem = .defaultForDevice()
|
|
case "fromEntries":
|
|
fileSystem = try TopologyVirtualFileSystem(entries: (step.entries ?? []).map { entry in
|
|
TopologyVirtualFileEntry(
|
|
path: entry.path,
|
|
content: entry.kind == "directory" ? .directory : .text(entry.text ?? ""))
|
|
})
|
|
default: results.append(["error": "unknown step \(step.op)"]); continue
|
|
}
|
|
results.append(["ok": true])
|
|
} catch {
|
|
results.append(describeFileSystemError(error))
|
|
}
|
|
}
|
|
return ["name": item.name, "results": results, "entries": describeFileEntries(fileSystem.allEntries())]
|
|
}
|
|
}
|
|
|
|
// MARK: - String semantics
|
|
|
|
struct StringCases: Decodable {
|
|
let trim: [String]
|
|
let lowercased: [String]
|
|
let equal: [[String]]
|
|
let sort: [[String]]
|
|
let base64: [String]
|
|
let controlCharacters: [String]
|
|
let pathExtension: [String]
|
|
}
|
|
|
|
/// What Swift makes of strings where JavaScript differs (packages/core/test/strings.cases.json).
|
|
func measureStrings(_ cases: StringCases) -> JSON {
|
|
[
|
|
"trim": cases.trim.map { $0.trimmingCharacters(in: .whitespacesAndNewlines) },
|
|
"lowercased": cases.lowercased.map { $0.lowercased() },
|
|
"equal": cases.equal.map { $0[0] == $0[1] },
|
|
"sort": cases.sort.map { $0.sorted() },
|
|
"base64": cases.base64.map { text -> Any in
|
|
Data(base64Encoded: text, options: .ignoreUnknownCharacters).map { Array($0) } ?? NSNull()
|
|
},
|
|
"controlCharacters": cases.controlCharacters.map { text in
|
|
text.unicodeScalars.contains(where: { CharacterSet.controlCharacters.contains($0) })
|
|
},
|
|
"pathExtension": cases.pathExtension.map { ($0 as NSString).pathExtension },
|
|
// The whole sets, scalar by scalar, as ranges [first, last].
|
|
"whitespacesAndNewlinesSet": scalarRanges(in: .whitespacesAndNewlines),
|
|
"controlCharactersSet": scalarRanges(in: .controlCharacters),
|
|
]
|
|
}
|
|
|
|
func scalarRanges(in set: CharacterSet) -> [[Int]] {
|
|
var ranges: [[Int]] = []
|
|
for value in 0...0x10FFFF {
|
|
guard let scalar = Unicode.Scalar(value), set.contains(scalar) else { continue }
|
|
if let last = ranges.last, last[1] == value - 1 {
|
|
ranges[ranges.count - 1][1] = value
|
|
} else {
|
|
ranges.append([value, value])
|
|
}
|
|
}
|
|
return ranges
|
|
}
|
|
|
|
// MARK: - Archive path folding
|
|
|
|
struct PathCase: Decodable { let name: String; let first: String; let second: String }
|
|
|
|
/// Whether Swift's archive writer treats two entry paths as the same file.
|
|
/// The folding itself is file-private in Swift; the export reports it as a
|
|
/// duplicate entry when two carried entries collide.
|
|
func foldPaths(_ cases: [PathCase]) -> [JSON] {
|
|
cases.map { item in
|
|
var result: JSON = ["name": item.name]
|
|
// Swift compares strings by canonical equivalence: "é" and "e\u{301}"
|
|
// are one dictionary key, so they never reach the archive writer.
|
|
if item.first == item.second {
|
|
result["outcome"] = "sameKey"
|
|
return result
|
|
}
|
|
do {
|
|
_ = try TopologyProjectStore.exportFiliusArchiveWithReport(
|
|
from: TopologyEditorState(),
|
|
supplementalEntries: [item.first: Data("1".utf8), item.second: Data("2".utf8)]
|
|
)
|
|
result["outcome"] = "distinct"
|
|
} catch let error as TopologyFLSArchiveError {
|
|
result["outcome"] = error.code == .duplicateEntry ? "collide" : error.code.rawValue
|
|
} catch {
|
|
result["outcome"] = "error: \(error)"
|
|
}
|
|
return result
|
|
}
|
|
}
|
|
|
|
func emailAddressJSON(_ address: TopologyRuntimeEmailAddress) -> [Any] {
|
|
[address.name ?? NSNull(), address.mailAddress]
|
|
}
|
|
|
|
func emailMessageJSON(_ message: TopologyRuntimeEmailMessage) -> JSON {
|
|
[
|
|
"id": Int(message.id),
|
|
"from": emailAddressJSON(message.from),
|
|
"to": message.to.map(emailAddressJSON),
|
|
"cc": message.cc.map(emailAddressJSON),
|
|
"bcc": message.bcc.map(emailAddressJSON),
|
|
"subject": message.subject,
|
|
"body": message.body,
|
|
"deliveryIdentity": message.deliveryIdentity ?? NSNull(),
|
|
"receivedAtMilliseconds": message.receivedAtMilliseconds.map { Int($0) } ?? NSNull(),
|
|
"isNew": message.isNew,
|
|
"isMarkedForDeletion": message.isMarkedForDeletion,
|
|
"isSent": message.isSent,
|
|
]
|
|
}
|
|
|
|
// MARK: - /dns/hosts cases (packages/fls/test/dns-hosts.cases.txt)
|
|
|
|
func dnsRecordJSON(_ record: TopologyDNSResourceRecord) -> [Any] {
|
|
[record.name.rawValue, record.type.rawValue, Int(record.ttlSeconds), record.target]
|
|
}
|
|
|
|
/// One case per line: a whole file (hosts, e-mail accounts), ASCII with Java-style unicode
|
|
/// escapes (backslash, u, four hex digits) — the file the Java oracle reads.
|
|
func readDNSHostsCases(_ url: URL) throws -> [(line: String, text: String)] {
|
|
let lines = try String(contentsOf: url, encoding: .ascii).components(separatedBy: "\n")
|
|
return lines.dropLast().map { line in
|
|
var units: [UInt16] = []
|
|
var rest = Substring(line)
|
|
while let first = rest.first {
|
|
if rest.hasPrefix("\\u"), rest.count >= 6, let unit = UInt16(rest.dropFirst(2).prefix(4), radix: 16) {
|
|
units.append(unit)
|
|
rest = rest.dropFirst(6)
|
|
} else {
|
|
units.append(contentsOf: String(first).utf16)
|
|
rest = rest.dropFirst()
|
|
}
|
|
}
|
|
return (line, String(decoding: units, as: UTF16.self))
|
|
}
|
|
}
|
|
|
|
// MARK: - Main
|
|
|
|
if CommandLine.arguments.count == 4, CommandLine.arguments[1] == "--path-folding" {
|
|
let cases = try JSONDecoder().decode([PathCase].self, from: Data(contentsOf: URL(fileURLWithPath: CommandLine.arguments[2])))
|
|
let data = try JSONSerialization.data(withJSONObject: foldPaths(cases), options: [.prettyPrinted, .sortedKeys])
|
|
try (data + Data("\n".utf8)).write(to: URL(fileURLWithPath: CommandLine.arguments[3]))
|
|
print("path folding: \(cases.count) cases")
|
|
exit(0)
|
|
}
|
|
|
|
if CommandLine.arguments.count == 4, CommandLine.arguments[1] == "--vfs" {
|
|
let cases = try JSONDecoder().decode([FileSystemCase].self, from: Data(contentsOf: URL(fileURLWithPath: CommandLine.arguments[2])))
|
|
let output = runFileSystemCases(cases)
|
|
let data = try JSONSerialization.data(withJSONObject: output, options: [.prettyPrinted, .sortedKeys])
|
|
try (data + Data("\n".utf8)).write(to: URL(fileURLWithPath: CommandLine.arguments[3]))
|
|
print("vfs: \(output.count) cases")
|
|
exit(0)
|
|
}
|
|
|
|
if CommandLine.arguments.count == 4, CommandLine.arguments[1] == "--strings" {
|
|
let cases = try JSONDecoder().decode(StringCases.self, from: Data(contentsOf: URL(fileURLWithPath: CommandLine.arguments[2])))
|
|
let data = try JSONSerialization.data(withJSONObject: measureStrings(cases), options: [.prettyPrinted, .sortedKeys])
|
|
try (data + Data("\n".utf8)).write(to: URL(fileURLWithPath: CommandLine.arguments[3]))
|
|
print("strings: measured")
|
|
exit(0)
|
|
}
|
|
|
|
if CommandLine.arguments.count == 4, CommandLine.arguments[1] == "--dns-hosts" {
|
|
let cases = try readDNSHostsCases(URL(fileURLWithPath: CommandLine.arguments[2]))
|
|
let output: [[Any]] = cases.map { [$0.line, TopologyDNSHostsFileCodec.records(from: $0.text).map { dnsRecordJSON($0) }] }
|
|
let data = try JSONSerialization.data(withJSONObject: output, options: [.prettyPrinted, .sortedKeys])
|
|
try (data + Data("\n".utf8)).write(to: URL(fileURLWithPath: CommandLine.arguments[3]))
|
|
print("dns hosts: \(cases.count) cases")
|
|
exit(0)
|
|
}
|
|
|
|
if CommandLine.arguments.count == 5, CommandLine.arguments[1] == "--email-files" {
|
|
let server = CommandLine.arguments[2] == "server"
|
|
let cases = try readDNSHostsCases(URL(fileURLWithPath: CommandLine.arguments[3]))
|
|
let output: [[Any]] = cases.map { item in
|
|
do {
|
|
if server {
|
|
let configuration = try TopologyRuntimeEmailStorage.decodeJavaServer(item.text)
|
|
return [item.line, configuration.accounts.map { account in
|
|
[
|
|
"username": account.username, "password": account.password, "name": account.name,
|
|
"mailbox": account.mailbox.map(emailMessageJSON),
|
|
] as JSON
|
|
}]
|
|
}
|
|
let client = try TopologyRuntimeEmailStorage.decodeJavaClient(item.text)
|
|
return [item.line, [
|
|
"pop3Host": client.pop3Host, "pop3Port": client.pop3Port,
|
|
"smtpHost": client.smtpHost, "smtpPort": client.smtpPort,
|
|
"username": client.username, "password": client.password,
|
|
"name": client.name, "email": client.email,
|
|
] as JSON]
|
|
} catch {
|
|
return [item.line, "!\(error)"]
|
|
}
|
|
}
|
|
let data = try JSONSerialization.data(withJSONObject: output, options: [.prettyPrinted, .sortedKeys])
|
|
try (data + Data("\n".utf8)).write(to: URL(fileURLWithPath: CommandLine.arguments[4]))
|
|
print("email \(CommandLine.arguments[2]) files: \(cases.count) cases")
|
|
exit(0)
|
|
}
|
|
|
|
if CommandLine.arguments.count == 4, CommandLine.arguments[1] == "--corpus" {
|
|
let summary = try readCorpus(root: URL(fileURLWithPath: CommandLine.arguments[2]))
|
|
let data = try JSONSerialization.data(withJSONObject: summary, options: [.prettyPrinted, .sortedKeys])
|
|
try (data + Data("\n".utf8)).write(to: URL(fileURLWithPath: CommandLine.arguments[3]))
|
|
print("corpus: \(summary.count) files")
|
|
exit(0)
|
|
}
|
|
|
|
let directory = URL(fileURLWithPath: CommandLine.arguments.dropFirst().first ?? ".")
|
|
let files = try FileManager.default.contentsOfDirectory(at: directory, includingPropertiesForKeys: nil)
|
|
.filter { $0.lastPathComponent.hasSuffix(".scenario.json") }
|
|
.sorted { $0.lastPathComponent < $1.lastPathComponent }
|
|
for file in files {
|
|
let scenario = try JSONDecoder().decode(Scenario.self, from: Data(contentsOf: file))
|
|
let output = run(scenario)
|
|
let data = try JSONSerialization.data(withJSONObject: output, options: [.prettyPrinted, .sortedKeys])
|
|
let name = file.lastPathComponent.replacingOccurrences(of: ".scenario.json", with: ".swift.json")
|
|
try (data + Data("\n".utf8)).write(to: directory.appendingPathComponent(name))
|
|
print("\(name): \((output["traces"] as? [Any])?.count ?? 0) trace events")
|
|
}
|