From fdef8efe3d28c2e2b415c6672a696e88e75adae0 Mon Sep 17 00:00:00 2001 From: Yuta Saito Date: Tue, 9 Jan 2024 10:45:52 +0000 Subject: [PATCH 01/13] Version 1.0.0: SwiftPM Plugin Support See CHANGELOG.md --- CHANGELOG.md | 54 +- Package.swift | 117 +- Plugins/CartonBundle/CartonPluginShared | 1 + Plugins/CartonBundle/Plugin.swift | 89 + Plugins/CartonDev/CartonPluginShared | 1 + Plugins/CartonDev/Plugin.swift | 151 ++ Plugins/CartonPluginShared/Environment.swift | 52 + Plugins/CartonPluginShared/PluginShared.swift | 187 ++ Plugins/CartonPluginShared/README.md | 1 + Plugins/CartonTest/CartonPluginShared | 1 + Plugins/CartonTest/Plugin.swift | 121 ++ Sources/CartonCLI/Carton.swift | 4 +- Sources/CartonCLI/Commands/Bundle.swift | 151 +- Sources/CartonCLI/Commands/Dev.swift | 123 +- Sources/CartonCLI/Commands/Init.swift | 70 - .../CartonCLI/Commands/ListTemplates.swift | 33 - Sources/CartonCLI/Commands/Options.swift | 25 - Sources/CartonCLI/Commands/Package.swift | 37 - Sources/CartonCLI/Commands/SDK/Install.swift | 33 - Sources/CartonCLI/Commands/SDK/Local.swift | 49 - Sources/CartonCLI/Commands/SDK/SDK.swift | 22 - Sources/CartonCLI/Commands/SDK/Versions.swift | 43 - Sources/CartonCLI/Commands/Test.swift | 67 +- .../TestRunners/BrowserTestRunner.swift | 41 +- .../Commands/TestRunners/NodeTestRunner.swift | 1 - .../TestRunners/WasmerTestRunner.swift | 1 - Sources/{Carton => CartonFrontend}/Main.swift | 7 +- Sources/CartonHelpers/Async.swift | 55 - Sources/CartonHelpers/AsyncFileDownload.swift | 94 +- Sources/CartonHelpers/Basics/ByteString.swift | 160 ++ .../CartonHelpers/Basics/CStringArray.swift | 35 + Sources/CartonHelpers/Basics/Closable.swift | 15 + .../Basics/CollectionExtensions.swift | 42 + Sources/CartonHelpers/Basics/FileInfo.swift | 66 + Sources/CartonHelpers/Basics/FileSystem.swift | 699 ++++++++ .../CartonHelpers/Basics/HashAlgorithms.swift | 260 +++ Sources/CartonHelpers/Basics/Path.swift | 1072 ++++++++++++ Sources/CartonHelpers/Basics/PathShims.swift | 185 ++ .../Basics/Process/Process.swift | 1521 +++++++++++++++++ .../Basics/Process/ProcessEnv.swift | 107 ++ Sources/CartonHelpers/Basics/README.md | 3 + .../Basics/StringConversions.swift | 126 ++ .../Basics/TerminalController.swift | 211 +++ .../Basics/WritableByteStream.swift | 837 +++++++++ Sources/CartonHelpers/Basics/misc.swift | 328 ++++ Sources/CartonHelpers/DefaultToolchain.swift | 2 +- ...t => FileSystem+traverseRecursively.swift} | 27 +- Sources/CartonHelpers/HTTPClient.swift | 33 - Sources/CartonHelpers/InteractiveWriter.swift | 6 +- .../Parsers/DiagnosticsParser.swift | 240 --- .../{Process.swift => Process+run.swift} | 37 +- ...ift => TerminalController+logLookup.swift} | 11 - Sources/CartonKit/Helpers/Expectation.swift | 29 - Sources/CartonKit/Helpers/URL.swift | 26 - Sources/CartonKit/Model/Entrypoint.swift | 26 +- Sources/CartonKit/Model/Project.swift | 27 - Sources/CartonKit/Model/Template.swift | 238 --- .../Parsers/ChromeStackTrace.swift | 24 +- .../CartonKit/Parsers/DiagnosticsParser.swift | 42 + .../Parsers/FirefoxStackTrace.swift | 24 +- .../Parsers/SafariStackTrace.swift | 24 +- .../Parsers}/StackTrace.swift | 12 +- .../Parsers/String+Regex.swift | 0 .../Parsers/String+color.swift | 0 .../Parsers/TestsParser.swift | 9 +- Sources/CartonKit/Server/Application.swift | 321 +++- .../Server/Environment+UserAgent.swift | 22 +- Sources/CartonKit/Server/HTML.swift | 17 +- Sources/CartonKit/Server/Server.swift | 187 +- Sources/CartonKit/Server/StaticArchive.swift | 13 +- Sources/CartonKit/Utilities/FSWatch.swift | 871 ++++++++++ Sources/CartonKit/Utilities/README.md | 3 + Sources/SwiftToolchain/BuildDescription.swift | 22 - Sources/SwiftToolchain/BuildFlavor.swift | 48 - Sources/SwiftToolchain/Builder.swift | 124 -- .../DestinationEnvironment.swift | 35 - Sources/SwiftToolchain/Manifest.swift | 66 - Sources/SwiftToolchain/Toolchain.swift | 402 +---- .../ToolchainInstallation.swift | 13 +- .../SwiftToolchain/ToolchainManagement.swift | 77 +- .../SwiftToolchain/ToolchainResolver.swift | 2 +- .../Utilities/ProgressAnimation.swift | 311 ++++ Sources/SwiftToolchain/Utilities/README.md | 3 + Sources/WebDriverClient/WebDriverClient.swift | 40 +- .../main.swift} | 13 +- Sources/carton-release/Formula.swift | 70 - Sources/carton-release/HashArchive.swift | 74 +- Sources/carton-release/Main.swift | 10 +- Sources/carton/main.swift | 198 +++ .../BundleCommandTests.swift | 41 +- .../CommandTestHelper.swift | 378 +--- .../CartonCommandTests/DevCommandTests.swift | 87 +- .../CartonCommandTests/InitCommandTests.swift | 90 - .../CartonCommandTests/IntegrationTests.swift | 28 - .../CartonCommandTests/SDKCommandTests.swift | 67 - Tests/CartonCommandTests/StringHelpers.swift | 27 - .../CartonCommandTests/TestCommandTests.swift | 71 +- Tests/CartonCommandTests/Testable.swift | 25 +- Tests/CartonTests/CartonTests.swift | 50 - Tests/CartonTests/StackTraceTests.swift | 1 + Tests/Fixtures/CrashTest/Package.swift | 1 + Tests/Fixtures/EchoExecutable/Package.swift | 1 + Tests/Fixtures/FailTest/Package.swift | 1 + Tests/Fixtures/NodeJSKitTest/Package.resolved | 72 + Tests/Fixtures/NodeJSKitTest/Package.swift | 3 +- Tests/Fixtures/PluginTest/.gitignore | 8 + Tests/Fixtures/PluginTest/Package.swift | 17 + .../Sources/PluginTest/PluginTest.swift | 1 + .../Sources/PluginTestExe/main.swift | 7 + .../PluginTestTests/PluginTestTests.swift | 7 + Tests/Fixtures/TestApp/Package.resolved | 63 + Tests/Fixtures/TestApp/Package.swift | 3 +- .../WebDriverClientTests.swift | 9 +- 113 files changed, 9033 insertions(+), 3102 deletions(-) create mode 120000 Plugins/CartonBundle/CartonPluginShared create mode 100644 Plugins/CartonBundle/Plugin.swift create mode 120000 Plugins/CartonDev/CartonPluginShared create mode 100644 Plugins/CartonDev/Plugin.swift create mode 100644 Plugins/CartonPluginShared/Environment.swift create mode 100644 Plugins/CartonPluginShared/PluginShared.swift create mode 100644 Plugins/CartonPluginShared/README.md create mode 120000 Plugins/CartonTest/CartonPluginShared create mode 100644 Plugins/CartonTest/Plugin.swift delete mode 100644 Sources/CartonCLI/Commands/Init.swift delete mode 100644 Sources/CartonCLI/Commands/ListTemplates.swift delete mode 100644 Sources/CartonCLI/Commands/Options.swift delete mode 100644 Sources/CartonCLI/Commands/Package.swift delete mode 100644 Sources/CartonCLI/Commands/SDK/Install.swift delete mode 100644 Sources/CartonCLI/Commands/SDK/Local.swift delete mode 100644 Sources/CartonCLI/Commands/SDK/SDK.swift delete mode 100644 Sources/CartonCLI/Commands/SDK/Versions.swift rename Sources/{Carton => CartonFrontend}/Main.swift (89%) delete mode 100644 Sources/CartonHelpers/Async.swift create mode 100644 Sources/CartonHelpers/Basics/ByteString.swift create mode 100644 Sources/CartonHelpers/Basics/CStringArray.swift create mode 100644 Sources/CartonHelpers/Basics/Closable.swift create mode 100644 Sources/CartonHelpers/Basics/CollectionExtensions.swift create mode 100644 Sources/CartonHelpers/Basics/FileInfo.swift create mode 100644 Sources/CartonHelpers/Basics/FileSystem.swift create mode 100644 Sources/CartonHelpers/Basics/HashAlgorithms.swift create mode 100644 Sources/CartonHelpers/Basics/Path.swift create mode 100644 Sources/CartonHelpers/Basics/PathShims.swift create mode 100644 Sources/CartonHelpers/Basics/Process/Process.swift create mode 100644 Sources/CartonHelpers/Basics/Process/ProcessEnv.swift create mode 100644 Sources/CartonHelpers/Basics/README.md create mode 100644 Sources/CartonHelpers/Basics/StringConversions.swift create mode 100644 Sources/CartonHelpers/Basics/TerminalController.swift create mode 100644 Sources/CartonHelpers/Basics/WritableByteStream.swift create mode 100644 Sources/CartonHelpers/Basics/misc.swift rename Sources/CartonHelpers/{FileSystem.swift => FileSystem+traverseRecursively.swift} (56%) delete mode 100644 Sources/CartonHelpers/HTTPClient.swift delete mode 100644 Sources/CartonHelpers/Parsers/DiagnosticsParser.swift rename Sources/CartonHelpers/{Process.swift => Process+run.swift} (81%) rename Sources/CartonHelpers/{TerminalController.swift => TerminalController+logLookup.swift} (87%) delete mode 100644 Sources/CartonKit/Helpers/Expectation.swift delete mode 100644 Sources/CartonKit/Helpers/URL.swift delete mode 100644 Sources/CartonKit/Model/Project.swift delete mode 100644 Sources/CartonKit/Model/Template.swift rename Sources/{CartonHelpers => CartonKit}/Parsers/ChromeStackTrace.swift (61%) create mode 100644 Sources/CartonKit/Parsers/DiagnosticsParser.swift rename Sources/{CartonHelpers => CartonKit}/Parsers/FirefoxStackTrace.swift (60%) rename Sources/{CartonHelpers => CartonKit}/Parsers/SafariStackTrace.swift (61%) rename Sources/{CartonHelpers => CartonKit/Parsers}/StackTrace.swift (90%) rename Sources/{CartonHelpers => CartonKit}/Parsers/String+Regex.swift (100%) rename Sources/{CartonHelpers => CartonKit}/Parsers/String+color.swift (100%) rename Sources/{CartonHelpers => CartonKit}/Parsers/TestsParser.swift (97%) create mode 100644 Sources/CartonKit/Utilities/FSWatch.swift create mode 100644 Sources/CartonKit/Utilities/README.md delete mode 100644 Sources/SwiftToolchain/BuildDescription.swift delete mode 100644 Sources/SwiftToolchain/BuildFlavor.swift delete mode 100644 Sources/SwiftToolchain/Builder.swift delete mode 100644 Sources/SwiftToolchain/DestinationEnvironment.swift delete mode 100644 Sources/SwiftToolchain/Manifest.swift create mode 100644 Sources/SwiftToolchain/Utilities/ProgressAnimation.swift create mode 100644 Sources/SwiftToolchain/Utilities/README.md rename Sources/{CartonKit/Helpers/ByteString.swift => carton-plugin-helper/main.swift} (72%) delete mode 100644 Sources/carton-release/Formula.swift create mode 100644 Sources/carton/main.swift delete mode 100644 Tests/CartonCommandTests/InitCommandTests.swift delete mode 100644 Tests/CartonCommandTests/IntegrationTests.swift delete mode 100644 Tests/CartonCommandTests/SDKCommandTests.swift delete mode 100644 Tests/CartonCommandTests/StringHelpers.swift create mode 100644 Tests/Fixtures/PluginTest/.gitignore create mode 100644 Tests/Fixtures/PluginTest/Package.swift create mode 100644 Tests/Fixtures/PluginTest/Sources/PluginTest/PluginTest.swift create mode 100644 Tests/Fixtures/PluginTest/Sources/PluginTestExe/main.swift create mode 100644 Tests/Fixtures/PluginTest/Tests/PluginTestTests/PluginTestTests.swift diff --git a/CHANGELOG.md b/CHANGELOG.md index ee96943b..c171b281 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,53 @@ +# 1.0.0 (XX XXX 2024) + +**Breaking changes:** + +`carton` CLI is now slimmed down to be a SwiftPM Plugin. +This means that you can now use `carton` by just declaring it as a dependency in your `Package.swift` file. + +```swift +dependencies: [ + .package(url: "https://github.com/swiftwasm/carton", from: "1.0.0"), +], +``` + +Each `carton` subcommand is now split into a separate SwiftPM plugin. + +| Old command | New command | +| --------------- | ------------------------- | +| `carton dev` | `swift run carton dev` | +| `carton test` | `swift run carton test` | +| `carton bundle` | `swift run carton bundle` | + +Also `carton` no longer supports the following features: + +- `carton init` command (use `swift package init --type executable` instead) + +**Internal changes:** + +- Reduce build time by removing unnecessary dependencies: 96.97s -> 25.26s +- No longer directly depend on SwiftPM as a library. This means that `carton` no longer has to be updated when SwiftPM is updated (hopefully). + +Our new SwiftPM plugin oriented architecture is illustrated in the following diagram: + +```mermaid +sequenceDiagram + participant SwiftRunCarton as swift run carton + participant SwiftPM + participant CartonDevPlugin as carton-dev Plugin + participant CartonFrontend + SwiftRunCarton->>SwiftPM: exec + SwiftPM->>CartonDevPlugin: spawn + CartonDevPlugin->>SwiftPM: Build product + SwiftPM->>CartonDevPlugin: Build artifacts + CartonDevPlugin->>CartonFrontend: spawn + note right of CartonDevPlugin: Establish IPC + CartonFrontend->>CartonDevPlugin: File changed + CartonDevPlugin->>SwiftPM: Build product + SwiftPM->>CartonDevPlugin: Build artifacts + CartonDevPlugin->>CartonFrontend: Reload browsers +``` + # 0.20.1 (25 Jan 2024) This release fixes a bug in `carton test` where it reports missing `sock_accept` syscall. @@ -12,10 +62,9 @@ This release adds SwiftWasm 5.9 toolchain support. - Add Swift 5.9 to Build Action by @STREGA in https://github.com/swiftwasm/carton/pull/409 - Swift 5.9 toolchain & macOS Sonoma beta by @furby-tm in https://github.com/swiftwasm/carton/pull/402 - Add 5.9 support by @STREGA in https://github.com/swiftwasm/carton/pull/412 -- Stop bothering WASI apps including unimplemented syscalls by @kateinoigakukun in https://github.com/swiftwasm/carton/pull/415 +- Stop bothering WASI apps including unimplemented syscalls by @kateinoigakukun in https://github.com/swiftwasm/carton/pull/415 - Update default toolchain version to 5.9.1 by @kateinoigakukun in https://github.com/swiftwasm/carton/pull/416 - # 0.19.1 (9 May 2023) This release fixes the wrong toolchain version installed in docker image. @@ -32,7 +81,6 @@ This release adds SwiftWasm 5.8 toolchain support. - Support jammy and amazonlinux2 for toolchain install by @kateinoigakukun in https://github.com/swiftwasm/carton/pull/397 - Update default toolchain version to 5.8 channel snapshot by @kateinoigakukun in https://github.com/swiftwasm/carton/pull/398 - # 0.18.0 (3 April 2023) This release adds an extra size stripping optimization. diff --git a/Package.swift b/Package.swift index 55c50ec8..58fc35e2 100644 --- a/Package.swift +++ b/Package.swift @@ -5,105 +5,126 @@ import PackageDescription let package = Package( name: "carton", - platforms: [.macOS("10.15.4")], + platforms: [.macOS(.v13)], products: [ .library(name: "SwiftToolchain", targets: ["SwiftToolchain"]), .library(name: "CartonHelpers", targets: ["CartonHelpers"]), .library(name: "CartonKit", targets: ["CartonKit"]), .library(name: "CartonCLI", targets: ["CartonCLI"]), - .executable(name: "carton", targets: ["Carton"]), + .executable(name: "carton", targets: ["carton"]), .executable(name: "carton-release", targets: ["carton-release"]), + .plugin(name: "CartonBundle", targets: ["CartonBundle"]), + .plugin(name: "CartonTest", targets: ["CartonTest"]), + .plugin(name: "CartonDev", targets: ["CartonDev"]), + .executable(name: "carton-plugin-helper", targets: ["carton-plugin-helper"]), ], dependencies: [ - .package( - url: "https://github.com/swift-server/async-http-client.git", - from: "1.8.1" - ), + .package(url: "https://github.com/apple/swift-log.git", from: "1.5.4"), .package( url: "https://github.com/apple/swift-argument-parser.git", - .upToNextMinor(from: "1.2.3") + .upToNextMinor(from: "1.3.0") ), .package(url: "https://github.com/apple/swift-nio.git", from: "2.34.0"), - .package( - url: "https://github.com/apple/swift-package-manager.git", - branch: "release/5.9" - ), - .package( - url: "https://github.com/apple/swift-tools-support-core.git", - branch: "release/5.9" - ), - .package(url: "https://github.com/vapor/vapor.git", from: "4.57.1"), - .package(url: "https://github.com/apple/swift-crypto.git", from: "2.2.0"), - .package(url: "https://github.com/JohnSundell/Splash.git", from: "0.16.0"), .package( url: "https://github.com/swiftwasm/WasmTransformer", .upToNextMinor(from: "0.5.0") ), ], targets: [ - // Targets are the basic building blocks of a package. A target can define a module - // or a test suite. Targets can depend on other targets in this package, and on - // products in packages which this package depends on. .executableTarget( - name: "Carton", + name: "carton", + dependencies: [ + "SwiftToolchain", + "CartonHelpers", + ] + ), + .executableTarget( + name: "CartonFrontend", dependencies: [ "CartonCLI", ] ), + .plugin( + name: "CartonBundle", + capability: .command( + intent: .custom( + verb: "carton-bundle", + description: "Produces an optimized app bundle for distribution." + ) + ), + dependencies: ["CartonFrontend"], + exclude: ["CartonPluginShared/README.md"] + ), + .plugin( + name: "CartonTest", + capability: .command( + intent: .custom( + verb: "carton-test", + description: "Run the tests in a WASI environment." + ) + ), + dependencies: ["CartonFrontend"], + exclude: ["CartonPluginShared/README.md"] + ), + .plugin( + name: "CartonDev", + capability: .command( + intent: .custom( + verb: "carton-dev", + description: "Watch the current directory, host the app, rebuild on change." + ) + ), + dependencies: ["CartonFrontend"], + exclude: ["CartonPluginShared/README.md"] + ), + .executableTarget(name: "carton-plugin-helper"), .target( name: "CartonCLI", - dependencies: ["CartonKit"] + dependencies: [ + .product(name: "Logging", package: "swift-log"), + "CartonKit", + ] ), .target( name: "CartonKit", dependencies: [ - .product(name: "AsyncHTTPClient", package: "async-http-client"), - .product(name: "Crypto", package: "swift-crypto"), - .product(name: "Vapor", package: "vapor"), + .product(name: "NIOWebSocket", package: "swift-nio"), + .product(name: "NIOHTTP1", package: "swift-nio"), + .product(name: "NIO", package: "swift-nio"), + .product(name: "ArgumentParser", package: "swift-argument-parser"), "CartonHelpers", - "SwiftToolchain", "WebDriverClient", - ] + "WasmTransformer", + ], + exclude: ["Utilities/README.md"] ), .target( name: "SwiftToolchain", dependencies: [ - .product(name: "AsyncHTTPClient", package: "async-http-client"), - .product(name: "NIOFoundationCompat", package: "swift-nio"), - .product(name: "SwiftPMDataModel-auto", package: "swift-package-manager"), "CartonHelpers", - "WasmTransformer", - ] + ], + exclude: ["Utilities/README.md"] ), .target( name: "CartonHelpers", - dependencies: [ - .product(name: "AsyncHTTPClient", package: "async-http-client"), - .product(name: "ArgumentParser", package: "swift-argument-parser"), - .product(name: "SwiftToolsSupport-auto", package: "swift-tools-support-core"), - "Splash", - "WasmTransformer", - ] + dependencies: [], + exclude: ["Basics/README.md"] ), - .target(name: "WebDriverClient", dependencies: [ - .product(name: "AsyncHTTPClient", package: "async-http-client"), - .product(name: "NIOFoundationCompat", package: "swift-nio"), - ]), + .target(name: "WebDriverClient", dependencies: []), // This target is used only for release automation tasks and // should not be installed by `carton` users. .executableTarget( name: "carton-release", dependencies: [ .product(name: "ArgumentParser", package: "swift-argument-parser"), - .product(name: "AsyncHTTPClient", package: "async-http-client"), - .product(name: "SwiftToolsSupport-auto", package: "swift-tools-support-core"), "CartonHelpers", + "WasmTransformer", ] ), .testTarget( name: "CartonTests", dependencies: [ - "Carton", + "CartonFrontend", "CartonHelpers", .product(name: "ArgumentParser", package: "swift-argument-parser"), ] @@ -113,8 +134,6 @@ let package = Package( dependencies: [ "CartonCLI", .product(name: "ArgumentParser", package: "swift-argument-parser"), - .product(name: "AsyncHTTPClient", package: "async-http-client"), - .product(name: "TSCTestSupport", package: "swift-tools-support-core"), ] ), .testTarget(name: "WebDriverClientTests", dependencies: ["WebDriverClient"]), diff --git a/Plugins/CartonBundle/CartonPluginShared b/Plugins/CartonBundle/CartonPluginShared new file mode 120000 index 00000000..14b828b7 --- /dev/null +++ b/Plugins/CartonBundle/CartonPluginShared @@ -0,0 +1 @@ +../CartonPluginShared \ No newline at end of file diff --git a/Plugins/CartonBundle/Plugin.swift b/Plugins/CartonBundle/Plugin.swift new file mode 100644 index 00000000..4955359d --- /dev/null +++ b/Plugins/CartonBundle/Plugin.swift @@ -0,0 +1,89 @@ +// Copyright 2024 Carton contributors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +import Foundation +import PackagePlugin + +@main +struct CartonBundlePlugin: CommandPlugin { + + struct Options { + var product: String? + var outputDir: String? + var debug: Bool + + static func parse(from extractor: inout ArgumentExtractor) -> Options { + let product = extractor.extractOption(named: "product").last + let outputDir = extractor.extractOption(named: "output").last + let debug = extractor.extractFlag(named: "debug") + return Options(product: product, outputDir: outputDir, debug: debug != 0) + } + } + + func performCommand(context: PluginContext, arguments: [String]) async throws { + try checkSwiftVersion() + try checkHelpFlag(arguments, subcommand: "bundle", context: context) + + var extractor = ArgumentExtractor(arguments) + let options = Options.parse(from: &extractor) + + let productName = try options.product ?? deriveDefaultProduct(package: context.package) + + // Build products + let parameters = PackageManager.BuildParameters( + configuration: options.debug ? .debug : .release, + logging: .verbose + ) + print("Building \"\(productName)\"") + let build = try self.packageManager.build(.product(productName), parameters: parameters) + + guard build.succeeded else { + print(build.logText) + exit(1) + } + + guard let product = try context.package.products(named: [productName]).first else { + throw CartonPluginError("Failed to find product named \"\(productName)\"") + } + guard let executableProduct = product as? ExecutableProduct else { + throw CartonPluginError( + "Product type of \"\(productName)\" is not supported. Only executable products are supported." + ) + } + + let productArtifact = try build.findWasmArtifact(for: productName) + + let resourcesPaths = deriveResourcesPaths( + productArtifactPath: productArtifact.path, + sourceTargets: executableProduct.targets, + package: context.package + ) + + let bundleDirectory = + options.outputDir ?? context.pluginWorkDirectory.appending(subpath: "Bundle").string + let frontendArguments = + ["bundle", productArtifact.path.string, "--output", bundleDirectory] + + resourcesPaths.flatMap { + ["--resources", $0.string] + } + extractor.remainingArguments + let frontend = try makeCartonFrontendProcess(context: context, arguments: frontendArguments) + frontend.forwardTerminationSignals() + try frontend.run() + frontend.waitUntilExit() + if frontend.terminationStatus == 0 { + print("Bundle written in \(bundleDirectory)") + } + frontend.checkNonZeroExit() + } +} diff --git a/Plugins/CartonDev/CartonPluginShared b/Plugins/CartonDev/CartonPluginShared new file mode 120000 index 00000000..14b828b7 --- /dev/null +++ b/Plugins/CartonDev/CartonPluginShared @@ -0,0 +1 @@ +../CartonPluginShared \ No newline at end of file diff --git a/Plugins/CartonDev/Plugin.swift b/Plugins/CartonDev/Plugin.swift new file mode 100644 index 00000000..bd3a437f --- /dev/null +++ b/Plugins/CartonDev/Plugin.swift @@ -0,0 +1,151 @@ +// Copyright 2024 Carton contributors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +import Foundation +import PackagePlugin + +@main +struct CartonDevPlugin: CommandPlugin { + struct Options { + var product: String? + var release: Bool + + static func parse(from extractor: inout ArgumentExtractor) throws -> Options { + let product = extractor.extractOption(named: "product").last + let release = extractor.extractFlag(named: "release") + return Options(product: product, release: release != 0) + } + } + + typealias Error = CartonPluginError + + func performCommand(context: PluginContext, arguments: [String]) async throws { + try checkSwiftVersion() + try checkHelpFlag(arguments, subcommand: "dev", context: context) + + var extractor = ArgumentExtractor(arguments) + let options = try Options.parse(from: &extractor) + + let productName = try options.product ?? self.defaultProduct(context: context) + + // Build products + var parameters = PackageManager.BuildParameters( + configuration: options.release ? .release : .debug, + logging: .verbose + ) + Environment.browser.applyBuildParameters(¶meters) + + print("Building \"\(productName)\"") + let buildSubset = PackageManager.BuildSubset.product(productName) + let build = try self.packageManager.build(buildSubset, parameters: parameters) + guard build.succeeded else { + print(build.logText) + exit(1) + } + + guard let product = try context.package.products(named: [productName]).first else { + throw Error("Failed to find product named \"\(productName)\"") + } + guard let executableProduct = product as? ExecutableProduct else { + throw Error( + "Product type of \"\(productName)\" is not supported. Only executable products are supported." + ) + } + + let productArtifact = try build.findWasmArtifact(for: productName) + let pathsToWatch = context.package.targets.map { $0.directory.string } + let resourcesPaths = deriveResourcesPaths( + productArtifactPath: productArtifact.path, + sourceTargets: executableProduct.targets, + package: context.package + ) + + let tempDirectory = try createTemporaryDirectory(under: context.pluginWorkDirectory) + defer { try? FileManager.default.removeItem(atPath: tempDirectory.string) } + let buildRequestPipe = try createFifo(hint: "build-request", directory: tempDirectory) + let buildResponsePipe = try createFifo(hint: "build-response", directory: tempDirectory) + + let frontend = try! makeCartonFrontendProcess( + context: context, + arguments: [ + "dev", + "--verbose", + "--main-wasm-path", productArtifact.path.string, + "--build-request", buildRequestPipe, + "--build-response", buildResponsePipe, + ] + + resourcesPaths.flatMap { ["--resources", $0.string] } + + pathsToWatch.flatMap { ["--watch-path", $0] } + + extractor.remainingArguments + ) + frontend.forwardTerminationSignals() + + try frontend.run() + + let buildRequestFileHandle = FileHandle(forReadingAtPath: buildRequestPipe)! + let buildResponseFileHandle = FileHandle(forWritingAtPath: buildResponsePipe)! + while let _ = try buildRequestFileHandle.read(upToCount: 1) { + Diagnostics.remark("[Plugin] Received build request") + let buildResult = try self.packageManager.build(buildSubset, parameters: parameters) + if !buildResult.succeeded { + Diagnostics.remark("[Plugin] **Build Failed**") + print(buildResult.logText) + } else { + Diagnostics.remark("[Plugin] **Build Succeeded**") + } + try buildResponseFileHandle.write(contentsOf: Data([1])) + } + + frontend.waitUntilExit() + frontend.checkNonZeroExit() + } + + private func defaultProduct(context: PluginContext) throws -> String { + let executableProducts = context.package.products(ofType: ExecutableProduct.self) + guard !executableProducts.isEmpty else { + throw Error("Make sure there's at least one executable product in your Package.swift") + } + guard executableProducts.count == 1 else { + throw Error( + "Failed to disambiguate the product. Pass one of \(executableProducts.map(\.name).joined(separator: ", ")) to the --product option" + ) + + } + return executableProducts[0].name + } +} + +private func createTemporaryDirectory(under directory: Path) throws -> Path { + var template = directory.appending("carton-XXXXXX").string + let result = try template.withUTF8 { template in + let copy = UnsafeMutableBufferPointer.allocate(capacity: template.count + 1) + defer { copy.deallocate() } + template.copyBytes(to: copy) + copy[template.count] = 0 + guard let result = mkdtemp(copy.baseAddress) else { + throw CartonPluginError("Failed to create a temporary directory") + } + return String(cString: result) + } + return Path(result) +} + +private func createFifo(hint: String, directory: Path) throws -> String { + let fifoPath = directory.appending("\(hint).fifo").string + guard mkfifo(fifoPath, 0o600) == 0 else { + let error = String(cString: strerror(errno)) + throw CartonPluginError("Failed to create fifo at \(fifoPath): \(error)") + } + return fifoPath +} diff --git a/Plugins/CartonPluginShared/Environment.swift b/Plugins/CartonPluginShared/Environment.swift new file mode 100644 index 00000000..66044d76 --- /dev/null +++ b/Plugins/CartonPluginShared/Environment.swift @@ -0,0 +1,52 @@ +// Copyright 2024 Carton contributors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/// The target environment to build for. +/// `Environment` doesn't specify the concrete environment, but the type of environments enough for build planning. +internal enum Environment: String, CaseIterable { + case command + case node + case browser + + static func parse(_ string: String) -> (Environment?, diagnostics: String?) { + // Find from canonical names + if let found = allCases.first(where: { $0.rawValue == string }) { + return (found, nil) + } + + // Find from deprecated names + switch string { + case "wasmer": + return (.command, "The 'wasmer' environment is renamed to 'commandLine'") + case "defaultBrowser": + return (.browser, "The 'defaultBrowser' environment is renamed to 'browser'") + default: + return (nil, nil) + } + } + + struct Parameters { + var otherSwiftcFlags: [String] = [] + var otherLinkerFlags: [String] = [] + } + + func applyBuildParameters(_ parameters: inout Parameters) { + switch self { + case .command: break + case .node, .browser: + parameters.otherSwiftcFlags += ["-Xclang-linker", "-mexec-model=reactor"] + parameters.otherLinkerFlags += ["--export=main"] + } + } +} diff --git a/Plugins/CartonPluginShared/PluginShared.swift b/Plugins/CartonPluginShared/PluginShared.swift new file mode 100644 index 00000000..73d4fb5f --- /dev/null +++ b/Plugins/CartonPluginShared/PluginShared.swift @@ -0,0 +1,187 @@ +// Copyright 2024 Carton contributors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +import Foundation +import PackagePlugin + +struct CartonPluginError: Swift.Error, CustomStringConvertible { + let description: String + + init(_ message: String) { + self.description = "Error: " + message + } +} + +/// Derive default product from the package +internal func deriveDefaultProduct(package: Package) throws -> String { + let executableProducts = package.products(ofType: ExecutableProduct.self) + guard !executableProducts.isEmpty else { + throw CartonPluginError( + "Make sure there's at least one executable product in your Package.swift") + } + guard executableProducts.count == 1 else { + throw CartonPluginError( + "Failed to disambiguate the product. Pass one of \(executableProducts.map(\.name).joined(separator: ", ")) to the --product option" + ) + + } + return executableProducts[0].name +} + +/// Returns the list of resource bundle paths for the given targets +internal func deriveResourcesPaths( + productArtifactPath: Path, + sourceTargets: [any PackagePlugin.Target], + package: Package +) -> [Path] { + sourceTargets.compactMap { target -> Path? in + // NOTE: The resource bundle file name is constructed from `displayName` instead of `id` for some reason + // https://github.com/apple/swift-package-manager/blob/swift-5.9.2-RELEASE/Sources/PackageLoading/PackageBuilder.swift#L908 + let bundleName = package.displayName + "_" + target.name + ".resources" + let resourcesPath = productArtifactPath.removingLastComponent().appending(subpath: bundleName) + guard FileManager.default.fileExists(atPath: resourcesPath.string) else { return nil } + return resourcesPath + } +} + +extension Environment { + static func parse(from extractor: inout ArgumentExtractor) throws -> Environment { + guard let rawValue = extractor.extractOption(named: "environment").last else { + return Environment.command + } + let (parsed, diagnostic) = Environment.parse(rawValue) + if let diagnostic { + Diagnostics.warning(diagnostic) + } + guard let parsed else { + throw CartonPluginError( + "Environment '\(rawValue)' is not recognized. Use one of \(Environment.allCases.map(\.rawValue).joined(separator: ", "))" + ) + } + return parsed + } + + func applyBuildParameters(_ parameters: inout PackageManager.BuildParameters) { + var output = Environment.Parameters() + applyBuildParameters(&output) + parameters.otherSwiftcFlags += output.otherSwiftcFlags + parameters.otherLinkerFlags += output.otherLinkerFlags + } +} + +extension PackageManager.BuildResult { + /// Find `.wasm` executable artifact + internal func findWasmArtifact(for product: String) throws + -> PackageManager.BuildResult.BuiltArtifact + { + let executables = self.builtArtifacts.filter { + $0.kind == .executable && $0.path.lastComponent == "\(product).wasm" + } + guard !executables.isEmpty else { + throw CartonPluginError( + "Failed to find '\(product).wasm' from executable artifacts of product '\(product)'") + } + guard executables.count == 1, let executable = executables.first else { + throw CartonPluginError( + "Failed to disambiguate executable product artifacts from \(executables.map(\.path.string).joined(separator: ", "))" + ) + } + return executable + } +} + +internal func checkSwiftVersion() throws { + var doesSwiftPMSupportXCompilationWithPlugin: Bool { + #if swift(>=5.9.2) + return true + #else + return false + #endif + } + + let magicEnvVar = "CARTON_SKIP_SWIFTPM_VERSION_CHECK" + guard ProcessInfo.processInfo.environment[magicEnvVar] == nil else { + // Skip SwiftPM version check + return + } + + guard doesSwiftPMSupportXCompilationWithPlugin else { + throw CartonPluginError( + """ + SwiftPM version below 5.9.2 is not supported by carton plugin due to the lack of cross-compilation support \ + with SwiftPM plugins. + You can skip this check by setting the environment variable \(magicEnvVar) to any value \ + if you are sure that your SwiftPM version supports cross-compilation with plugins. + """) + } +} + +internal func checkHelpFlag(_ arguments: [String], subcommand: String, context: PluginContext) + throws +{ + if arguments.contains("--help") || arguments.contains("-h") { + let frontend = try makeCartonFrontendProcess( + context: context, arguments: [subcommand, "--help"]) + frontend.forwardTerminationSignals() + try frontend.run() + frontend.waitUntilExit() + exit(frontend.terminationStatus) + } +} + +internal func makeCartonFrontendProcess(context: PluginContext, arguments: [String]) throws + -> Process +{ + let frontend = try context.tool(named: "CartonFrontend") + + Diagnostics.remark( + "Running " + ([frontend.path.string] + arguments).map { "\"\($0)\"" }.joined(separator: " ")) + let process = Process() + process.executableURL = URL(fileURLWithPath: frontend.path.string) + process.arguments = arguments + return process +} + +internal func runCartonFrontend(context: PluginContext, arguments: [String]) throws -> Process { + let process = try makeCartonFrontendProcess(context: context, arguments: arguments) + try process.run() + return process +} + +extension Process { + internal func forwardTerminationSignals() { + // Monitor termination/interrruption signals to forward them to child process + func setSignalForwarding(_ signalNo: Int32) { + signal(signalNo, SIG_IGN) + let signalSource = DispatchSource.makeSignalSource(signal: signalNo) + signalSource.setEventHandler { + signalSource.cancel() + self.interrupt() + } + signalSource.resume() + } + setSignalForwarding(SIGINT) + setSignalForwarding(SIGTERM) + + self.terminationHandler = { + // Exit plugin process itself when child process exited + exit($0.terminationStatus) + } + } + internal func checkNonZeroExit() { + if terminationStatus != 0 { + exit(terminationStatus) + } + } +} diff --git a/Plugins/CartonPluginShared/README.md b/Plugins/CartonPluginShared/README.md new file mode 100644 index 00000000..f544093b --- /dev/null +++ b/Plugins/CartonPluginShared/README.md @@ -0,0 +1 @@ +This directory contains symbolic links to shared source code among the Carton plugins. This is a temporary workaround until SwiftPM supports it natively. diff --git a/Plugins/CartonTest/CartonPluginShared b/Plugins/CartonTest/CartonPluginShared new file mode 120000 index 00000000..14b828b7 --- /dev/null +++ b/Plugins/CartonTest/CartonPluginShared @@ -0,0 +1 @@ +../CartonPluginShared \ No newline at end of file diff --git a/Plugins/CartonTest/Plugin.swift b/Plugins/CartonTest/Plugin.swift new file mode 100644 index 00000000..e612b6bc --- /dev/null +++ b/Plugins/CartonTest/Plugin.swift @@ -0,0 +1,121 @@ +// Copyright 2024 Carton contributors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +import Foundation +import PackagePlugin + +@main +struct CartonTestPlugin: CommandPlugin { + struct Options { + var environment: Environment + + static func parse(from extractor: inout ArgumentExtractor) throws -> Options { + let environment = try Environment.parse(from: &extractor) + return Options(environment: environment) + } + } + + typealias Error = CartonPluginError + + func performCommand(context: PluginContext, arguments: [String]) async throws { + try checkSwiftVersion() + try checkHelpFlag(arguments, subcommand: "test", context: context) + + let productName = "\(context.package.displayName)PackageTests" + let wasmFileName = "\(productName).wasm" + + if arguments.first == "internal-get-build-command" { + var extractor = ArgumentExtractor(Array(arguments.dropFirst())) + let options = try Options.parse(from: &extractor) + var buildParameters = Environment.Parameters() + options.environment.applyBuildParameters(&buildParameters) + var buildCommand = ["build", "--product", productName] + buildCommand += buildParameters.otherSwiftcFlags.flatMap { ["-Xswiftc", $0] } + buildCommand += buildParameters.otherLinkerFlags.flatMap { ["-Xlinker", $0] } + + let outputFile = extractor.extractOption(named: "output").last! + try buildCommand.joined(separator: "\n").write( + toFile: outputFile, atomically: true, encoding: .utf8) + return + } + + var extractor = ArgumentExtractor(arguments) + let options = try Options.parse(from: &extractor) + let buildDirectory = try self.buildDirectory(context: context) + let testProductArtifactPath = buildDirectory.appending(subpath: wasmFileName) + + // TODO: SwiftPM does not allow to build *only tests* from plugin + guard FileManager.default.fileExists(atPath: testProductArtifactPath.string) else { + throw Error( + "Failed to find \"\(wasmFileName)\" in \(buildDirectory). Please build \"\(productName)\" product first" + ) + } + + let testTargets = context.package.targets(ofType: SwiftSourceModuleTarget.self).filter { + $0.kind == .test + } + + let resourcesPaths = deriveResourcesPaths( + productArtifactPath: testProductArtifactPath, + sourceTargets: testTargets, + package: context.package + ) + + let frontendArguments = + [ + "test", + "--prebuilt-test-bundle-path", testProductArtifactPath.string, + "--environment", options.environment.rawValue, + ] + + resourcesPaths.flatMap { + ["--resources", $0.string] + } + extractor.remainingArguments + let frontend = try makeCartonFrontendProcess(context: context, arguments: frontendArguments) + frontend.forwardTerminationSignals() + try frontend.run() + frontend.waitUntilExit() + frontend.checkNonZeroExit() + } + + private func defaultProduct(context: PluginContext) throws -> String { + let executableProducts = context.package.products(ofType: ExecutableProduct.self) + guard !executableProducts.isEmpty else { + throw Error("Make sure there's at least one executable product in your Package.swift") + } + guard executableProducts.count == 1 else { + throw Error( + "Failed to disambiguate the product. Pass one of \(executableProducts.map(\.name).joined(separator: ", ")) to the --product option" + ) + + } + return executableProducts[0].name + } + + private func buildDirectory(context: PluginContext) throws -> Path { + let build = try packageManager.build( + .product("carton-plugin-helper"), parameters: PackageManager.BuildParameters()) + guard build.succeeded else { + throw Error("Failed to build carton-plugin-helper: \(build.logText)") + } + guard !build.builtArtifacts.isEmpty else { + throw Error("No built artifacts found for carton-plugin-helper") + } + guard build.builtArtifacts.count == 1 else { + throw Error( + "Multiple built artifacts found for carton-plugin-helper!?: \(build.builtArtifacts.map(\.path.string).joined(separator: ", "))" + ) + } + return build.builtArtifacts[0].path.removingLastComponent() + } +} diff --git a/Sources/CartonCLI/Carton.swift b/Sources/CartonCLI/Carton.swift index ffc5b257..9d33bc75 100644 --- a/Sources/CartonCLI/Carton.swift +++ b/Sources/CartonCLI/Carton.swift @@ -15,11 +15,11 @@ import ArgumentParser import CartonHelpers -public struct Carton: ParsableCommand { +public struct Carton: AsyncParsableCommand { public static let configuration = CommandConfiguration( abstract: "📦 Watcher, bundler, and test runner for your SwiftWasm apps.", version: cartonVersion, - subcommands: [Bundle.self, Dev.self, Init.self, SDK.self, Test.self, Package.self] + subcommands: [Bundle.self, Dev.self, Test.self] ) public init() {} diff --git a/Sources/CartonCLI/Commands/Bundle.swift b/Sources/CartonCLI/Commands/Bundle.swift index 8771d3d8..395be6cb 100644 --- a/Sources/CartonCLI/Commands/Bundle.swift +++ b/Sources/CartonCLI/Commands/Bundle.swift @@ -15,10 +15,7 @@ import ArgumentParser import CartonHelpers import CartonKit -import Crypto -import PackageModel -import SwiftToolchain -import TSCBasic +import Foundation import WasmTransformer private let dependency = Entrypoint( @@ -31,8 +28,22 @@ enum WasmOptimizations: String, CaseIterable, ExpressibleByArgument { } struct Bundle: AsyncParsableCommand { - @Option(help: "Specify name of an executable product to produce the bundle for.") - var product: String? + @Argument( + help: ArgumentHelp( + "Internal: Path to the main WebAssembly file built by the SwiftPM Plugin process.", + visibility: .private + ) + ) + var mainWasmPath: String + + @Option( + name: .long, + help: ArgumentHelp( + "Internal: Path to resources directory built by the SwiftPM Plugin process.", + visibility: .private + ) + ) + var resources: [String] = [] @Option( help: "Specify a path to a custom `index.html` file to be used for your app.", @@ -40,9 +51,6 @@ struct Bundle: AsyncParsableCommand { ) var customIndexPage: String? - @Flag(help: "When specified, build in the debug mode.") - var debug = false - @Flag(help: "Emit names and DWARF sections in the .wasm file.") var debugInfo: Bool = false @@ -57,66 +65,62 @@ struct Bundle: AsyncParsableCommand { ) var wasmOptimizations: WasmOptimizations = .size - @OptionGroup() - var buildOptions: BuildOptions + @Option + var output: String static let configuration = CommandConfiguration( abstract: "Produces an optimized app bundle for distribution." ) - func buildFlavor() -> BuildFlavor { - BuildFlavor( - isRelease: !debug, environment: .defaultBrowser, - sanitize: nil, swiftCompilerFlags: buildOptions.swiftCompilerFlags - ) - } - func run() async throws { - let terminal = InteractiveWriter.stdout + let terminal = InteractiveWriter.stderr try dependency.check(on: localFileSystem, terminal) - let toolchain = try await Toolchain(localFileSystem, terminal) - - let flavor = buildFlavor() - let build = try await toolchain.buildCurrentProject( - product: product, - flavor: flavor - ) + var mainWasmPath = try AbsolutePath( + validating: mainWasmPath, relativeTo: localFileSystem.currentWorkingDirectory!) try terminal.logLookup( "Right after building the main binary size is ", - localFileSystem.humanReadableFileSize(build.mainWasmPath), + localFileSystem.humanReadableFileSize(mainWasmPath), newline: true ) + let bundleDirectory = try AbsolutePath( + validating: output, relativeTo: localFileSystem.currentWorkingDirectory!) + try localFileSystem.removeFileTree(bundleDirectory) + try localFileSystem.createDirectory(bundleDirectory, recursive: false) + + let wasmOutputFilePath = try AbsolutePath(validating: "main.wasm", relativeTo: bundleDirectory) + if !debugInfo { - try strip(build.mainWasmPath) + try strip(mainWasmPath, output: wasmOutputFilePath) + mainWasmPath = wasmOutputFilePath try terminal.logLookup( "After stripping debug info the main binary size is ", - localFileSystem.humanReadableFileSize(build.mainWasmPath), + localFileSystem.humanReadableFileSize(mainWasmPath), newline: true ) } - let bundleDirectory = AbsolutePath(localFileSystem.currentWorkingDirectory!, "Bundle") - try localFileSystem.removeFileTree(bundleDirectory) - try localFileSystem.createDirectory(bundleDirectory) - - let wasmOutputFilePath = AbsolutePath(bundleDirectory, "main.wasm") - if wasmOptimizations == .size { - try await optimize(build.mainWasmPath, outputPath: wasmOutputFilePath, terminal: terminal) + do { + try await optimize(mainWasmPath, outputPath: wasmOutputFilePath, terminal: terminal) + } catch { + terminal.write( + "Warning: wasm-opt failed to optimize the binary, falling back to the original binary\n", + inColor: .yellow) + try localFileSystem.move(from: mainWasmPath, to: wasmOutputFilePath) + } } else { - try localFileSystem.move(from: build.mainWasmPath, to: wasmOutputFilePath) + try localFileSystem.move(from: mainWasmPath, to: wasmOutputFilePath) } try copyToBundle( terminal: terminal, wasmOutputFilePath: wasmOutputFilePath, - buildDirectory: build.mainWasmPath.parentDirectory, + buildDirectory: mainWasmPath.parentDirectory, bundleDirectory: bundleDirectory, - toolchain: toolchain, - product: build.product + resourcesPaths: resources ) terminal.write("Bundle generation finished successfully\n", inColor: .green, bold: true) @@ -125,7 +129,9 @@ struct Bundle: AsyncParsableCommand { func optimize(_ inputPath: AbsolutePath, outputPath: AbsolutePath, terminal: InteractiveWriter) async throws { - var wasmOptArgs = ["wasm-opt", "-Os", inputPath.pathString, "-o", outputPath.pathString] + var wasmOptArgs = [ + "wasm-opt", "-Os", "--enable-bulk-memory", inputPath.pathString, "-o", outputPath.pathString, + ] if debugInfo { wasmOptArgs.append("--debuginfo") } @@ -137,10 +143,10 @@ struct Bundle: AsyncParsableCommand { ) } - func strip(_ wasmPath: AbsolutePath) throws { + func strip(_ wasmPath: AbsolutePath, output: AbsolutePath) throws { let binary = try localFileSystem.readFileContents(wasmPath) let strippedBinary = try stripCustomSections(binary.contents) - try localFileSystem.writeFileContents(wasmPath, bytes: .init(strippedBinary)) + try localFileSystem.writeFileContents(output, bytes: .init(strippedBinary)) } func copyToBundle( @@ -148,13 +154,12 @@ struct Bundle: AsyncParsableCommand { wasmOutputFilePath: AbsolutePath, buildDirectory: AbsolutePath, bundleDirectory: AbsolutePath, - toolchain: SwiftToolchain.Toolchain, - product: ProductDescription + resourcesPaths: [String] ) throws { // Rename the final binary to use a part of its hash to bust browsers and CDN caches. - let wasmFileHash = try localFileSystem.readFileContents(wasmOutputFilePath).hexSHA256.prefix(16) + let wasmFileHash = try localFileSystem.readFileContents(wasmOutputFilePath).hexChecksum let mainModuleName = "\(wasmFileHash).wasm" - let mainModulePath = AbsolutePath(bundleDirectory, mainModuleName) + let mainModulePath = try AbsolutePath(validating: mainModuleName, relativeTo: bundleDirectory) try localFileSystem.move(from: wasmOutputFilePath, to: mainModulePath) // Copy the bundle entrypoint, point to the binary, and give it a cachebuster name. @@ -167,14 +172,14 @@ struct Bundle: AsyncParsableCommand { with: mainModuleName ) ) - let entrypointName = "\(entrypoint.hexSHA256.prefix(16)).js" + let entrypointName = "\(entrypoint.hexChecksum).js" try localFileSystem.writeFileContents( - AbsolutePath(bundleDirectory, entrypointName), + AbsolutePath(validating: entrypointName, relativeTo: bundleDirectory), bytes: entrypoint ) try localFileSystem.writeFileContents( - AbsolutePath(bundleDirectory, "index.html"), + AbsolutePath(validating: "index.html", relativeTo: bundleDirectory), bytes: ByteString( encodingAsUTF8: HTML.indexPage( customContent: HTML.readCustomIndexPage(at: customIndexPage, on: localFileSystem), @@ -182,38 +187,42 @@ struct Bundle: AsyncParsableCommand { )) ) - let manifest = try toolchain.manifest.get() - for directoryName in try localFileSystem.resourcesDirectoryNames(relativeTo: buildDirectory) { let resourcesPath = buildDirectory.appending(component: directoryName) let targetDirectory = bundleDirectory.appending(component: directoryName) - guard localFileSystem.exists(resourcesPath) else { continue } + guard localFileSystem.exists(resourcesPath, followSymlink: true) else { continue } terminal.logLookup("Copying resources to ", targetDirectory) try localFileSystem.copy(from: resourcesPath, to: targetDirectory) } - /* While a product may be composed of multiple targets, not sure this is widely used in - practice. Just assuming here that the first target of this product is an executable target, - at least until SwiftPM allows specifying executable targets explicitly, as proposed in - https://forums.swift.org/t/pitch-ability-to-declare-executable-targets-in-swiftpm-manifests-to-support-main/41968 - */ - let inferredMainTarget = manifest.targets.first { - product.targets.contains($0.name) - } + for resourcesPath in resourcesPaths { + let resourcesPath = try AbsolutePath( + validating: resourcesPath, relativeTo: localFileSystem.currentWorkingDirectory!) + for file in try localFileSystem.traverseRecursively(resourcesPath) { + let targetPath = bundleDirectory.appending(component: file.basename) - guard let mainTarget = inferredMainTarget else { return } + guard localFileSystem.exists(resourcesPath, followSymlink: true), + !localFileSystem.exists(targetPath, followSymlink: true) + else { continue } - let targetPath = manifest.resourcesPath(for: mainTarget) - let resourcesPath = buildDirectory.appending(component: targetPath) - for file in try localFileSystem.traverseRecursively(resourcesPath) { - let targetPath = bundleDirectory.appending(component: file.basename) + terminal.logLookup("Copying this resource to the root bundle directory ", file) + try localFileSystem.copy(from: file, to: targetPath) + } + } + } +} - guard localFileSystem.exists(resourcesPath) && !localFileSystem.exists(targetPath) - else { continue } +extension ByteString { + fileprivate var hexChecksum: String { + SHA256().hash(self).hexadecimalRepresentation + } +} - terminal.logLookup("Copying this resource to the root bundle directory ", file) - try localFileSystem.copy(from: file, to: targetPath) - } +extension FileSystem { + fileprivate func humanReadableFileSize(_ path: AbsolutePath) throws -> String { + // FIXME: should use `UnitInformationStorage`, but it's unavailable in open-source Foundation + let attrs = try FileManager.default.attributesOfItem(atPath: path.pathString) + return String(format: "%.2f MB", Double(attrs[.size] as! UInt64) / 1024 / 1024) } } diff --git a/Sources/CartonCLI/Commands/Dev.swift b/Sources/CartonCLI/Commands/Dev.swift index b16d972d..69f980fe 100644 --- a/Sources/CartonCLI/Commands/Dev.swift +++ b/Sources/CartonCLI/Commands/Dev.swift @@ -16,8 +16,6 @@ import ArgumentParser import CartonHelpers import CartonKit import Foundation -import SwiftToolchain -import TSCBasic struct Dev: AsyncParsableCommand { static let entrypoint = Entrypoint(fileName: "dev.js", sha256: devEntrypointSHA256) @@ -25,11 +23,6 @@ struct Dev: AsyncParsableCommand { @Option(help: "Specify name of an executable product in development.") var product: String? - @Option( - help: "This option has no effect and will be removed in a future version of `carton`" - ) - var destination: String? - @Option(help: "Specify a path to a custom `index.html` file to be used for your app.") var customIndexPage: String? @@ -54,55 +47,58 @@ struct Dev: AsyncParsableCommand { @Flag(name: .long, help: "Skip automatically opening app in system browser.") var skipAutoOpen = false - @OptionGroup() - var buildOptions: BuildOptions + @Option( + name: .customLong("watch-path"), + help: "Specify a path to a directory to watch for changes." + ) + var watchPaths: [String] = [] - static let configuration = CommandConfiguration( - abstract: "Watch the current directory, host the app, rebuild on change." + @Option( + name: .long, + help: ArgumentHelp( + "Internal: Path to resources directory built by the SwiftPM Plugin process.", + visibility: .private + ) + ) + var resources: [String] = [] + + @Option( + help: ArgumentHelp( + "Internal: Path to the named pipe used to send build requests to the SwiftPM Plugin process.", + visibility: .private + ) ) + var buildRequest: String - func buildFlavor() -> BuildFlavor { - let defaultSanitize: SanitizeVariant? = release ? nil : .stackOverflow - return BuildFlavor( - isRelease: release, environment: .defaultBrowser, - sanitize: sanitize ?? defaultSanitize, - swiftCompilerFlags: buildOptions.swiftCompilerFlags + @Option( + help: ArgumentHelp( + "Internal: Path to the named pipe used to receive build responses from the SwiftPM Plugin process.", + visibility: .private ) - } + ) + var buildResponse: String + + @Option( + help: ArgumentHelp( + "Internal: Path to the main WebAssembly file built by the SwiftPM Plugin process.", + visibility: .private + ) + ) + var mainWasmPath: String + + static let configuration = CommandConfiguration( + abstract: "Watch the current directory, host the app, rebuild on change." + ) func run() async throws { let terminal = InteractiveWriter.stdout try Self.entrypoint.check(on: localFileSystem, terminal) - let toolchain = try await Toolchain(localFileSystem, terminal) - - if !verbose { - terminal.clearWindow() - terminal.saveCursor() + let paths = try watchPaths.map { + try AbsolutePath(validating: $0, relativeTo: localFileSystem.currentWorkingDirectory!) } - if destination != nil { - terminal.write( - """ - --destination option is no longer needed when using latest SwiftWasm toolchains. \ - This option no longer has any effect and will be removed in a future version of `carton`. \ - You should be able to link with Foundation/XCTest without passing this option. If it is \ - still required in your build process for some reason, please report it as a bug at \ - https://github.com/swiftwasm/swift/issues/\n - """, - inColor: .red - ) - } - - let flavor = buildFlavor() - let build = try await toolchain.buildCurrentProject( - product: product, - flavor: flavor - ) - - let paths = try toolchain.inferSourcesPaths() - if !verbose { terminal.revertCursorAndClear() } @@ -110,28 +106,22 @@ struct Dev: AsyncParsableCommand { paths.forEach { terminal.logLookup("", $0) } terminal.write("\n") - let sources = try paths.flatMap { try localFileSystem.traverseRecursively($0) } - let server = try await Server( .init( - builder: Builder( - arguments: build.arguments, - mainWasmPath: build.mainWasmPath, - pathsToWatch: sources, - flavor, - localFileSystem, - terminal + builder: SwiftPMPluginBuilder( + pathsToWatch: paths, + buildRequest: FileHandle(forWritingAtPath: buildRequest)!, + buildResponse: FileHandle(forReadingAtPath: buildResponse)! ), - mainWasmPath: build.mainWasmPath, + mainWasmPath: AbsolutePath( + validating: mainWasmPath, relativeTo: localFileSystem.currentWorkingDirectory!), verbose: verbose, port: port, host: host, customIndexPath: customIndexPage.map { try AbsolutePath(validating: $0, relativeTo: localFileSystem.currentWorkingDirectory!) }, - // swiftlint:disable:next force_try - manifest: try! toolchain.manifest.get(), - product: build.product, + resourcesPaths: resources, entrypoint: Self.entrypoint, terminal: terminal ) @@ -143,3 +133,22 @@ struct Dev: AsyncParsableCommand { try await server.waitUntilStop() } } + +/// Builder for communicating with the SwiftPM Plugin process by IPC. +struct SwiftPMPluginBuilder: BuilderProtocol { + let pathsToWatch: [AbsolutePath] + let buildRequest: FileHandle + let buildResponse: FileHandle + + init(pathsToWatch: [AbsolutePath], buildRequest: FileHandle, buildResponse: FileHandle) { + self.pathsToWatch = pathsToWatch + self.buildRequest = buildRequest + self.buildResponse = buildResponse + } + + func run() async throws { + // We expect single response per request + try buildRequest.write(contentsOf: Data([1])) + _ = try buildResponse.read(upToCount: 1) + } +} diff --git a/Sources/CartonCLI/Commands/Init.swift b/Sources/CartonCLI/Commands/Init.swift deleted file mode 100644 index 4bfcf247..00000000 --- a/Sources/CartonCLI/Commands/Init.swift +++ /dev/null @@ -1,70 +0,0 @@ -// Copyright 2020 Carton contributors -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -import ArgumentParser -import CartonHelpers -import CartonKit -import Foundation -import SwiftToolchain -import TSCBasic - -struct Init: AsyncParsableCommand { - static let configuration = CommandConfiguration( - abstract: "Create a Swift package for a new SwiftWasm project.", - subcommands: [ListTemplates.self] - ) - - @Option( - name: .long, - help: "The template to base the project on.", - transform: { Templates(rawValue: $0.lowercased()) }) - var template: Templates? - - @Option( - name: .long, - help: "The name of the project") var name: String? - - func run() async throws { - let terminal = InteractiveWriter.stdout - - guard let name = name ?? localFileSystem.currentWorkingDirectory?.basename else { - terminal.write("Project name could not be inferred\n", inColor: .red) - return - } - guard let currentDir = localFileSystem.currentWorkingDirectory else { - terminal.write("Failed to get current working directory.\n", inColor: .red) - return - } - let template = self.template ?? .basic - terminal.write("Creating new project with template ") - terminal.write("\(template.rawValue)", inColor: .green) - terminal.write(" in ") - terminal.write("\(name)\n", inColor: .cyan) - - guard - let packagePath = try self.name == nil - ? localFileSystem.currentWorkingDirectory - : AbsolutePath(validating: name, relativeTo: currentDir) - else { - terminal.write("Path to project could be created.\n", inColor: .red) - return - } - try localFileSystem.createDirectory(packagePath) - try await template.template.create( - on: localFileSystem, - project: .init(name: name, path: packagePath, inPlace: self.name == nil), - terminal - ) - } -} diff --git a/Sources/CartonCLI/Commands/ListTemplates.swift b/Sources/CartonCLI/Commands/ListTemplates.swift deleted file mode 100644 index e4e69824..00000000 --- a/Sources/CartonCLI/Commands/ListTemplates.swift +++ /dev/null @@ -1,33 +0,0 @@ -// Copyright 2020 Carton contributors -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -import ArgumentParser -import CartonHelpers -import CartonKit -import TSCBasic - -struct ListTemplates: ParsableCommand { - static let configuration = CommandConfiguration( - abstract: "List the available templates" - ) - - func run() throws { - let terminal = InteractiveWriter.stdout - - Templates.allCases.forEach { - terminal.write($0.rawValue, inColor: .green, bold: true) - terminal.write("\t\($0.template.description)\n") - } - } -} diff --git a/Sources/CartonCLI/Commands/Options.swift b/Sources/CartonCLI/Commands/Options.swift deleted file mode 100644 index 55a28256..00000000 --- a/Sources/CartonCLI/Commands/Options.swift +++ /dev/null @@ -1,25 +0,0 @@ -// Copyright 2022 Carton contributors -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -import ArgumentParser - -struct BuildOptions: ParsableArguments { - @Option( - name: .customLong("Xswiftc", withSingleDash: true), - parsing: .unconditionalSingleValue, - help: "Pass flag through to all Swift compiler invocations") - var swiftCompilerFlags: [String] = [] - - init() {} -} diff --git a/Sources/CartonCLI/Commands/Package.swift b/Sources/CartonCLI/Commands/Package.swift deleted file mode 100644 index 6b1d07b1..00000000 --- a/Sources/CartonCLI/Commands/Package.swift +++ /dev/null @@ -1,37 +0,0 @@ -// Copyright 2020 Carton contributors -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -import ArgumentParser -import CartonHelpers -import CartonKit -import SwiftToolchain -import TSCBasic - -/// Proxy swift-package command to locally pinned toolchain version. -struct Package: AsyncParsableCommand { - static let configuration = CommandConfiguration( - abstract: """ - Perform operations on Swift packages. - """) - - @Argument(wrappedValue: [], parsing: .remaining) - var arguments: [String] - - func run() async throws { - let terminal = InteractiveWriter.stdout - - let toolchain = try await Toolchain(localFileSystem, terminal) - try await toolchain.runPackage(arguments) - } -} diff --git a/Sources/CartonCLI/Commands/SDK/Install.swift b/Sources/CartonCLI/Commands/SDK/Install.swift deleted file mode 100644 index 6f5cfb5d..00000000 --- a/Sources/CartonCLI/Commands/SDK/Install.swift +++ /dev/null @@ -1,33 +0,0 @@ -// Copyright 2020 Carton contributors -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -import ArgumentParser -import CartonHelpers -import SwiftToolchain -import TSCBasic - -struct Install: AsyncParsableCommand { - static let configuration = CommandConfiguration( - abstract: "Install new Swift toolchain/SDK." - ) - - @Argument() var version: String? - - func run() async throws { - let terminal = InteractiveWriter.stdout - - _ = try await Toolchain(for: version, localFileSystem, terminal) - terminal.write("\nSDK successfully installed!\n", inColor: .green) - } -} diff --git a/Sources/CartonCLI/Commands/SDK/Local.swift b/Sources/CartonCLI/Commands/SDK/Local.swift deleted file mode 100644 index 7014cff6..00000000 --- a/Sources/CartonCLI/Commands/SDK/Local.swift +++ /dev/null @@ -1,49 +0,0 @@ -// Copyright 2020 Carton contributors -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -import ArgumentParser -import CartonHelpers -import SwiftToolchain -import TSCBasic - -struct Local: ParsableCommand { - static let configuration = CommandConfiguration( - abstract: """ - Prints SDK version used for the current project or saves it \ - in the `.swift-version` file if a version is passed as an argument. - """) - - @Argument() var version: String? - - func run() throws { - let terminal = InteractiveWriter.stdout - let toolchainSystem = try ToolchainSystem(fileSystem: localFileSystem) - - if let version = version { - let versions = try toolchainSystem.fetchAllSwiftVersions() - if versions.contains(version) { - _ = try toolchainSystem.setLocalSwiftVersion(version) - } else { - terminal.write("The version \(version) hasn't been installed!", inColor: .red) - } - } else { - let localVersion = try toolchainSystem.fetchLocalSwiftVersion() - if let localVersion = localVersion { - terminal.write("\(localVersion)", inColor: .green) - } else { - terminal.logLookup("Version file is not present: ", toolchainSystem.swiftVersionPath) - } - } - } -} diff --git a/Sources/CartonCLI/Commands/SDK/SDK.swift b/Sources/CartonCLI/Commands/SDK/SDK.swift deleted file mode 100644 index 47e4ab67..00000000 --- a/Sources/CartonCLI/Commands/SDK/SDK.swift +++ /dev/null @@ -1,22 +0,0 @@ -// Copyright 2020 Carton contributors -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -import ArgumentParser - -struct SDK: ParsableCommand { - static let configuration = CommandConfiguration( - abstract: "Manage installed Swift toolchains and SDKs.", - subcommands: [Install.self, Versions.self, Local.self] - ) -} diff --git a/Sources/CartonCLI/Commands/SDK/Versions.swift b/Sources/CartonCLI/Commands/SDK/Versions.swift deleted file mode 100644 index a1f640c1..00000000 --- a/Sources/CartonCLI/Commands/SDK/Versions.swift +++ /dev/null @@ -1,43 +0,0 @@ -// Copyright 2020 Carton contributors -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -import ArgumentParser -import CartonHelpers -import SwiftToolchain -import TSCBasic - -struct Versions: ParsableCommand { - static let configuration = CommandConfiguration( - abstract: "Lists all installed toolchains/SDKs" - ) - - func run() throws { - let terminal = InteractiveWriter.stdout - - let toolchainSystem = try ToolchainSystem(fileSystem: localFileSystem) - let versions = try toolchainSystem.fetchAllSwiftVersions() - let localVersion = try toolchainSystem.fetchLocalSwiftVersion() - if versions.count > 0 { - versions.forEach { version in - if version == (localVersion ?? "") { - terminal.write("* \(version) (local)\n", inColor: .green) - } else { - terminal.write(" \(version)\n", inColor: .white) - } - } - } else { - terminal.write("No sdks installed\n") - } - } -} diff --git a/Sources/CartonCLI/Commands/Test.swift b/Sources/CartonCLI/Commands/Test.swift index 37a93a9a..893178ab 100644 --- a/Sources/CartonCLI/Commands/Test.swift +++ b/Sources/CartonCLI/Commands/Test.swift @@ -15,12 +15,20 @@ import ArgumentParser import CartonHelpers import CartonKit -import SwiftToolchain -import TSCBasic -extension Environment: ExpressibleByArgument {} +/// The target environment to build for. +/// `Environment` doesn't specify the concrete environment, but the type of environments enough for build planning. +enum Environment: String, CaseIterable, ExpressibleByArgument { + public static var allCasesNames: [String] { Environment.allCases.map { $0.rawValue } } -extension SanitizeVariant: ExpressibleByArgument {} + case command + case node + case browser +} + +enum SanitizeVariant: String, CaseIterable, ExpressibleByArgument { + case stackOverflow +} struct TestError: Error, CustomStringConvertible { let description: String @@ -43,7 +51,7 @@ struct Test: AsyncParsableCommand { help: "Environment used to run the tests. Available values: \(Environment.allCasesNames.joined(separator: ", "))" ) - private var environment = Environment.wasmer + private var environment = Environment.command /// It is implemented as a separate flag instead of a `--environment` variant because `--environment` /// is designed to accept specific browser names in the future like `--environment firefox`. @@ -67,22 +75,19 @@ struct Test: AsyncParsableCommand { var host = "127.0.0.1" @Option(help: "Use the given bundle instead of building the test target") - var prebuiltTestBundlePath: String? - - @OptionGroup() - var buildOptions: BuildOptions + var prebuiltTestBundlePath: String - private var buildFlavor: BuildFlavor { - BuildFlavor( - isRelease: release, - environment: environment, - sanitize: sanitize, - swiftCompilerFlags: buildOptions.swiftCompilerFlags + @Option( + name: .long, + help: ArgumentHelp( + "Internal: Path to resources directory built by the SwiftPM Plugin process.", + visibility: .private ) - } + ) + var resources: [String] = [] func validate() throws { - if headless && environment != .defaultBrowser { + if headless && environment != .browser { throw TestError( description: "The `--headless` flag can be applied only for browser environments") } @@ -90,38 +95,32 @@ struct Test: AsyncParsableCommand { func run() async throws { let terminal = InteractiveWriter.stdout - let toolchain = try await Toolchain(localFileSystem, terminal) let bundlePath: AbsolutePath - if let preBundlePath = self.prebuiltTestBundlePath { - bundlePath = try AbsolutePath( - validating: preBundlePath, relativeTo: localFileSystem.currentWorkingDirectory!) - guard localFileSystem.exists(bundlePath) else { - terminal.write( - "No prebuilt binary found at \(bundlePath)\n", - inColor: .red - ) - throw ExitCode.failure - } - } else { - bundlePath = try await toolchain.buildTestBundle(flavor: buildFlavor) + bundlePath = try AbsolutePath( + validating: prebuiltTestBundlePath, relativeTo: localFileSystem.currentWorkingDirectory!) + guard localFileSystem.exists(bundlePath, followSymlink: true) else { + terminal.write( + "No prebuilt binary found at \(bundlePath)\n", + inColor: .red + ) + throw ExitCode.failure } switch environment { - case .wasmer: + case .command: try await WasmerTestRunner( testFilePath: bundlePath, listTestCases: list, testCases: testCases, terminal: terminal ).run() - case .defaultBrowser: + case .browser: try await BrowserTestRunner( testFilePath: bundlePath, host: host, port: port, headless: headless, - // swiftlint:disable:next force_try - manifest: try! toolchain.manifest.get(), + resourcesPaths: resources, terminal: terminal ).run() case .node: diff --git a/Sources/CartonCLI/Commands/TestRunners/BrowserTestRunner.swift b/Sources/CartonCLI/Commands/TestRunners/BrowserTestRunner.swift index 3597e989..dd79b907 100644 --- a/Sources/CartonCLI/Commands/TestRunners/BrowserTestRunner.swift +++ b/Sources/CartonCLI/Commands/TestRunners/BrowserTestRunner.swift @@ -12,14 +12,11 @@ // See the License for the specific language governing permissions and // limitations under the License. -import AsyncHTTPClient import CartonHelpers import CartonKit import Foundation import NIOCore import NIOPosix -import PackageModel -import TSCBasic import WebDriverClient private enum Constants { @@ -50,26 +47,24 @@ struct BrowserTestRunner: TestRunner { let host: String let port: Int let headless: Bool - let manifest: Manifest + let resourcesPaths: [String] let terminal: InteractiveWriter let eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: 1) - let httpClient: HTTPClient init( testFilePath: AbsolutePath, host: String, port: Int, headless: Bool, - manifest: Manifest, + resourcesPaths: [String], terminal: InteractiveWriter ) { self.testFilePath = testFilePath self.host = host self.port = port self.headless = headless - self.manifest = manifest + self.resourcesPaths = resourcesPaths self.terminal = terminal - httpClient = HTTPClient(eventLoopGroupProvider: .shared(eventLoopGroup)) } typealias Disposer = () -> Void @@ -108,7 +103,7 @@ struct BrowserTestRunner: TestRunner { }, { terminal.logLookup("- checking WebDriver executable: ", "WEBDRIVER_PATH") - guard let executable = ProcessEnv.vars["WEBDRIVER_PATH"] else { + guard let executable = ProcessInfo.processInfo.environment["WEBDRIVER_PATH"] else { return nil } let (url, disposer) = try await launchDriver(executablePath: executable) @@ -135,9 +130,24 @@ struct BrowserTestRunner: TestRunner { throw BrowserTestRunnerError.failedToFindWebDriver } + func makeClient(endpoint: URL) async throws -> WebDriverClient { + let maxRetries = 3 + var retries = 0 + while true { + do { + return try await WebDriverClient.newSession( + endpoint: endpoint, httpClient: URLSession.shared) + } catch { + if retries >= maxRetries { + throw error + } + retries += 1 + try await _Concurrency.Task.sleep(nanoseconds: 1_000_000_000) + } + } + } + func run() async throws { - // swiftlint:disable force_try - defer { try! httpClient.syncShutdown() } try Constants.entrypoint.check(on: localFileSystem, terminal) let server = try await Server( .init( @@ -147,20 +157,17 @@ struct BrowserTestRunner: TestRunner { port: port, host: host, customIndexPath: nil, - manifest: manifest, - product: nil, + resourcesPaths: resourcesPaths, entrypoint: Constants.entrypoint, terminal: terminal - ), - .shared(eventLoopGroup) + ) ) let localURL = try await server.start() var disposer: () async throws -> Void = {} do { if headless { let (endpoint, clientDisposer) = try await selectWebDriver() - let client = try await WebDriverClient.newSession( - endpoint: endpoint, httpClient: httpClient) + let client = try await makeClient(endpoint: endpoint) disposer = { try await client.closeSession() clientDisposer() diff --git a/Sources/CartonCLI/Commands/TestRunners/NodeTestRunner.swift b/Sources/CartonCLI/Commands/TestRunners/NodeTestRunner.swift index c827fe68..bb90631d 100644 --- a/Sources/CartonCLI/Commands/TestRunners/NodeTestRunner.swift +++ b/Sources/CartonCLI/Commands/TestRunners/NodeTestRunner.swift @@ -15,7 +15,6 @@ import CartonHelpers import CartonKit import Foundation -import TSCBasic private enum Constants { static let entrypoint = Entrypoint(fileName: "testNode.js", sha256: testNodeEntrypointSHA256) diff --git a/Sources/CartonCLI/Commands/TestRunners/WasmerTestRunner.swift b/Sources/CartonCLI/Commands/TestRunners/WasmerTestRunner.swift index 7cf71cd2..24ee157f 100644 --- a/Sources/CartonCLI/Commands/TestRunners/WasmerTestRunner.swift +++ b/Sources/CartonCLI/Commands/TestRunners/WasmerTestRunner.swift @@ -15,7 +15,6 @@ import CartonHelpers import CartonKit import Foundation -import TSCBasic struct WasmerTestRunner: TestRunner { let testFilePath: AbsolutePath diff --git a/Sources/Carton/Main.swift b/Sources/CartonFrontend/Main.swift similarity index 89% rename from Sources/Carton/Main.swift rename to Sources/CartonFrontend/Main.swift index d13521a5..e83ea10c 100644 --- a/Sources/Carton/Main.swift +++ b/Sources/CartonFrontend/Main.swift @@ -13,9 +13,10 @@ // limitations under the License. import CartonCLI -import CartonHelpers @main -struct Main: AsyncMain { - typealias Command = Carton +struct Main { + static func main() async { + await Carton.main() + } } diff --git a/Sources/CartonHelpers/Async.swift b/Sources/CartonHelpers/Async.swift deleted file mode 100644 index 4f1f4631..00000000 --- a/Sources/CartonHelpers/Async.swift +++ /dev/null @@ -1,55 +0,0 @@ -// Copyright 2021 Carton contributors -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -import ArgumentParser - -extension Sequence { - public func asyncMap( - _ transform: (Element) async throws -> T - ) async rethrows -> [T] { - var values = [T]() - - for element in self { - try await values.append(transform(element)) - } - - return values - } -} - -/// A type that can be executed as part of a nested tree of commands. -extension AsyncParsableCommand { - public mutating func run() throws { - throw CleanExit.helpRequest(self) - } -} - -public protocol AsyncMain { - associatedtype Command: ParsableCommand -} - -extension AsyncMain { - public static func main() async { - do { - var command = try Command.parseAsRoot() - if var command = command as? AsyncParsableCommand { - try await command.run() - } else { - try command.run() - } - } catch { - Command.exit(withError: error) - } - } -} diff --git a/Sources/CartonHelpers/AsyncFileDownload.swift b/Sources/CartonHelpers/AsyncFileDownload.swift index 828c249e..38722ddf 100644 --- a/Sources/CartonHelpers/AsyncFileDownload.swift +++ b/Sources/CartonHelpers/AsyncFileDownload.swift @@ -12,7 +12,6 @@ // See the License for the specific language governing permissions and // limitations under the License. -import AsyncHTTPClient import Foundation public struct InvalidResponseCode: Error { @@ -26,41 +25,78 @@ public struct InvalidResponseCode: Error { } public final class AsyncFileDownload { - public let progressStream: AsyncThrowingStream + public struct Progress: Sendable { + public var totalBytes: Int? + public var receivedBytes: Int + } + class FileDownloadDelegate: NSObject, URLSessionDownloadDelegate { + let path: String + let onTotalBytes: (Int) -> Void + let continuation: AsyncThrowingStream.Continuation + var totalBytesToDownload: Int? - public init(path: String, _ url: URL, _ client: HTTPClient, onTotalBytes: @escaping (Int) -> Void) - { - progressStream = .init { continuation in - do { - let request = try HTTPClient.Request.get(url: url) + init( + path: String, + onTotalBytes: @escaping (Int) -> Void, + continuation: AsyncThrowingStream.Continuation + ) { + self.path = path + self.onTotalBytes = onTotalBytes + self.continuation = continuation + } - let delegate = try FileDownloadDelegate( - path: path, - reportHead: { - guard $0.status == .ok, - let totalBytes = $0.headers.first(name: "Content-Length").flatMap(Int.init) - else { - continuation - .finish(throwing: InvalidResponseCode(code: $0.status.code)) - return - } - onTotalBytes(totalBytes) - }, - reportProgress: { - continuation.yield($0) - } + func urlSession( + _ session: URLSession, + downloadTask: URLSessionDownloadTask, + didWriteData bytesWritten: Int64, + totalBytesWritten: Int64, + totalBytesExpectedToWrite: Int64 + ) { + let totalBytesToDownload = + totalBytesExpectedToWrite != NSURLSessionTransferSizeUnknown + ? Int(totalBytesExpectedToWrite) : nil + if self.totalBytesToDownload == nil { + self.totalBytesToDownload = totalBytesToDownload + self.onTotalBytes(totalBytesToDownload ?? .max) + } + continuation.yield( + AsyncFileDownload.Progress( + totalBytes: totalBytesToDownload, + receivedBytes: Int(totalBytesWritten) ) + ) + } - Task { - _ = try await client.execute(request: request, delegate: delegate) - .futureResult - .get() - - continuation.finish() - } + func urlSession( + _ session: URLSession, downloadTask: URLSessionDownloadTask, + didFinishDownloadingTo location: URL + ) { + do { + try FileManager.default.moveItem(atPath: location.path, toPath: self.path) + continuation.finish() } catch { continuation.finish(throwing: error) } } } + + public var progressStream: AsyncThrowingStream { + _progressStream + } + private var _progressStream: AsyncThrowingStream! + private var client: URLSession! = nil + + public init(path: String, _ url: URL, onTotalBytes: @escaping (Int) -> Void) { + _progressStream = .init { continuation in + let delegate = FileDownloadDelegate( + path: path, + onTotalBytes: onTotalBytes, + continuation: continuation + ) + self.client = URLSession(configuration: .default, delegate: delegate, delegateQueue: nil) + var request = URLRequest(url: url) + request.httpMethod = "GET" + client.downloadTask(with: request).resume() + } + } } diff --git a/Sources/CartonHelpers/Basics/ByteString.swift b/Sources/CartonHelpers/Basics/ByteString.swift new file mode 100644 index 00000000..d525b69a --- /dev/null +++ b/Sources/CartonHelpers/Basics/ByteString.swift @@ -0,0 +1,160 @@ +/* + This source file is part of the Swift.org open source project + + Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors + Licensed under Apache License v2.0 with Runtime Library Exception + + See http://swift.org/LICENSE.txt for license information + See http://swift.org/CONTRIBUTORS.txt for Swift project authors +*/ + +import Foundation + +/// A `ByteString` represents a sequence of bytes. +/// +/// This struct provides useful operations for working with buffers of +/// bytes. Conceptually it is just a contiguous array of bytes (UInt8), but it +/// contains methods and default behavior suitable for common operations done +/// using bytes strings. +/// +/// This struct *is not* intended to be used for significant mutation of byte +/// strings, we wish to retain the flexibility to micro-optimize the memory +/// allocation of the storage (for example, by inlining the storage for small +/// strings or and by eliminating wasted space in growable arrays). For +/// construction of byte arrays, clients should use the `WritableByteStream` class +/// and then convert to a `ByteString` when complete. +public struct ByteString: ExpressibleByArrayLiteral, Hashable, Sendable { + /// The buffer contents. + @usableFromInline + internal var _bytes: [UInt8] + + /// Create an empty byte string. + @inlinable + public init() { + _bytes = [] + } + + /// Create a byte string from a byte array literal. + @inlinable + public init(arrayLiteral contents: UInt8...) { + _bytes = contents + } + + /// Create a byte string from an array of bytes. + @inlinable + public init(_ contents: [UInt8]) { + _bytes = contents + } + + /// Create a byte string from an array slice. + @inlinable + public init(_ contents: ArraySlice) { + _bytes = Array(contents) + } + + /// Create a byte string from an byte buffer. + @inlinable + public init(_ contents: S) where S.Iterator.Element == UInt8 { + _bytes = [UInt8](contents) + } + + /// Create a byte string from the UTF8 encoding of a string. + @inlinable + public init(encodingAsUTF8 string: String) { + _bytes = [UInt8](string.utf8) + } + + /// Access the byte string contents as an array. + @inlinable + public var contents: [UInt8] { + return _bytes + } + + /// Return the byte string size. + @inlinable + public var count: Int { + return _bytes.count + } + + /// Gives a non-escaping closure temporary access to an immutable `Data` instance wrapping the `ByteString` without + /// copying any memory around. + /// + /// - Parameters: + /// - closure: The closure that will have access to a `Data` instance for the duration of its lifetime. + @inlinable + public func withData(_ closure: (Data) throws -> T) rethrows -> T { + return try _bytes.withUnsafeBytes { pointer -> T in + let mutatingPointer = UnsafeMutableRawPointer(mutating: pointer.baseAddress!) + let data = Data(bytesNoCopy: mutatingPointer, count: pointer.count, deallocator: .none) + return try closure(data) + } + } + + /// Returns a `String` lowercase hexadecimal representation of the contents of the `ByteString`. + @inlinable + public var hexadecimalRepresentation: String { + _bytes.reduce("") { + var str = String($1, radix: 16) + // The above method does not do zero padding. + if str.count == 1 { + str = "0" + str + } + return $0 + str + } + } +} + +/// Conform to CustomDebugStringConvertible. +extension ByteString: CustomStringConvertible { + /// Return the string decoded as a UTF8 sequence, or traps if not possible. + public var description: String { + return cString + } + + /// Return the string decoded as a UTF8 sequence, if possible. + @inlinable + public var validDescription: String? { + // FIXME: This is very inefficient, we need a way to pass a buffer. It + // is also wrong if the string contains embedded '\0' characters. + let tmp = _bytes + [UInt8(0)] + return tmp.withUnsafeBufferPointer { ptr in + return String(validatingUTF8: unsafeBitCast(ptr.baseAddress, to: UnsafePointer.self)) + } + } + + /// Return the string decoded as a UTF8 sequence, substituting replacement + /// characters for ill-formed UTF8 sequences. + @inlinable + public var cString: String { + return String(decoding: _bytes, as: Unicode.UTF8.self) + } + + @available(*, deprecated, message: "use description or validDescription instead") + public var asString: String? { + return validDescription + } +} + +/// ByteStreamable conformance for a ByteString. +extension ByteString: ByteStreamable { + @inlinable + public func write(to stream: WritableByteStream) { + stream.write(_bytes) + } +} + +/// StringLiteralConvertable conformance for a ByteString. +extension ByteString: ExpressibleByStringLiteral { + public typealias UnicodeScalarLiteralType = StringLiteralType + public typealias ExtendedGraphemeClusterLiteralType = StringLiteralType + + public init(unicodeScalarLiteral value: UnicodeScalarLiteralType) { + _bytes = [UInt8](value.utf8) + } + public init(extendedGraphemeClusterLiteral value: ExtendedGraphemeClusterLiteralType) { + _bytes = [UInt8](value.utf8) + } + public init(stringLiteral value: StringLiteralType) { + _bytes = [UInt8](value.utf8) + } +} diff --git a/Sources/CartonHelpers/Basics/CStringArray.swift b/Sources/CartonHelpers/Basics/CStringArray.swift new file mode 100644 index 00000000..b436e45e --- /dev/null +++ b/Sources/CartonHelpers/Basics/CStringArray.swift @@ -0,0 +1,35 @@ +/* + This source file is part of the Swift.org open source project + + Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors + Licensed under Apache License v2.0 with Runtime Library Exception + + See http://swift.org/LICENSE.txt for license information + See http://swift.org/CONTRIBUTORS.txt for Swift project authors + */ + +import Foundation + +/// `CStringArray` represents a C null-terminated array of pointers to C strings. +/// +/// The lifetime of the C strings will correspond to the lifetime of the `CStringArray` +/// instance so be careful about copying the buffer as it may contain dangling pointers. +public final class CStringArray { + /// The null-terminated array of C string pointers. + public let cArray: [UnsafeMutablePointer?] + + /// Creates an instance from an array of strings. + public init(_ array: [String]) { + #if os(Windows) + cArray = array.map({ $0.withCString({ _strdup($0) }) }) + [nil] + #else + cArray = array.map({ $0.withCString({ strdup($0) }) }) + [nil] + #endif + } + + deinit { + for case let element? in cArray { + free(element) + } + } +} diff --git a/Sources/CartonHelpers/Basics/Closable.swift b/Sources/CartonHelpers/Basics/Closable.swift new file mode 100644 index 00000000..83b9c20c --- /dev/null +++ b/Sources/CartonHelpers/Basics/Closable.swift @@ -0,0 +1,15 @@ +/* + This source file is part of the Swift.org open source project + + Copyright (c) 2020 Apple Inc. and the Swift project authors + Licensed under Apache License v2.0 with Runtime Library Exception + + See http://swift.org/LICENSE.txt for license information + See http://swift.org/CONTRIBUTORS.txt for Swift project authors +*/ + +/// Closable entity is one that manages underlying resources and needs to be closed for cleanup +/// The intent of this method is for the sole owner of the refernece/handle of the resource to close it completely, comapred to releasing a shared resource. +public protocol Closable { + func close() throws +} diff --git a/Sources/CartonHelpers/Basics/CollectionExtensions.swift b/Sources/CartonHelpers/Basics/CollectionExtensions.swift new file mode 100644 index 00000000..eaa4beb5 --- /dev/null +++ b/Sources/CartonHelpers/Basics/CollectionExtensions.swift @@ -0,0 +1,42 @@ +/* + This source file is part of the Swift.org open source project + + Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors + Licensed under Apache License v2.0 with Runtime Library Exception + + See http://swift.org/LICENSE.txt for license information + See http://swift.org/CONTRIBUTORS.txt for Swift project authors + */ + +extension Collection { + /// Returns the only element of the collection or nil. + public var spm_only: Element? { + return count == 1 ? self[startIndex] : nil + } + + /// Prints the element of array to standard output stream. + /// + /// This method should be used for debugging only. + public func spm_dump() { + for element in self { + print(element) + } + } +} + +extension Collection where Element: Hashable { + /// Returns a new list of element removing duplicate elements. + /// + /// Note: The order of elements is preseved. + /// Complexity: O(n) + public func spm_uniqueElements() -> [Element] { + var set = Set() + var result = [Element]() + for element in self { + if set.insert(element).inserted { + result.append(element) + } + } + return result + } +} diff --git a/Sources/CartonHelpers/Basics/FileInfo.swift b/Sources/CartonHelpers/Basics/FileInfo.swift new file mode 100644 index 00000000..38f4a315 --- /dev/null +++ b/Sources/CartonHelpers/Basics/FileInfo.swift @@ -0,0 +1,66 @@ +/* + This source file is part of the Swift.org open source project + + Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors + Licensed under Apache License v2.0 with Runtime Library Exception + + See http://swift.org/LICENSE.txt for license information + See http://swift.org/CONTRIBUTORS.txt for Swift project authors + */ + +import Foundation + +#if swift(<5.6) + extension FileAttributeType: UnsafeSendable {} + extension Date: UnsafeSendable {} +#endif + +/// File system information for a particular file. +public struct FileInfo: Equatable, Codable, Sendable { + + /// The device number. + public let device: UInt64 + + /// The inode number. + public let inode: UInt64 + + /// The size of the file. + public let size: UInt64 + + /// The modification time of the file. + public let modTime: Date + + /// Kind of file system entity. + public let posixPermissions: Int16 + + /// Kind of file system entity. + public let fileType: FileAttributeType + + public init(_ attrs: [FileAttributeKey: Any]) { + let device = (attrs[.systemNumber] as? NSNumber)?.uint64Value + assert(device != nil) + self.device = device! + + let inode = attrs[.systemFileNumber] as? UInt64 + assert(inode != nil) + self.inode = inode! + + let posixPermissions = (attrs[.posixPermissions] as? NSNumber)?.int16Value + assert(posixPermissions != nil) + self.posixPermissions = posixPermissions! + + let fileType = attrs[.type] as? FileAttributeType + assert(fileType != nil) + self.fileType = fileType! + + let size = attrs[.size] as? UInt64 + assert(size != nil) + self.size = size! + + let modTime = attrs[.modificationDate] as? Date + assert(modTime != nil) + self.modTime = modTime! + } +} + +extension FileAttributeType: Codable {} diff --git a/Sources/CartonHelpers/Basics/FileSystem.swift b/Sources/CartonHelpers/Basics/FileSystem.swift new file mode 100644 index 00000000..bd19bfd6 --- /dev/null +++ b/Sources/CartonHelpers/Basics/FileSystem.swift @@ -0,0 +1,699 @@ +/* + This source file is part of the Swift.org open source project + + Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors + Licensed under Apache License v2.0 with Runtime Library Exception + + See http://swift.org/LICENSE.txt for license information + See http://swift.org/CONTRIBUTORS.txt for Swift project authors + */ + +import Dispatch +import Foundation + +public struct FileSystemError: Error, Equatable, Sendable { + public enum Kind: Equatable, Sendable { + /// Access to the path is denied. + /// + /// This is used when an operation cannot be completed because a component of + /// the path cannot be accessed. + /// + /// Used in situations that correspond to the POSIX EACCES error code. + case invalidAccess + + /// IO Error encoding + /// + /// This is used when an operation cannot be completed due to an otherwise + /// unspecified IO error. + case ioError(code: Int32) + + /// Is a directory + /// + /// This is used when an operation cannot be completed because a component + /// of the path which was expected to be a file was not. + /// + /// Used in situations that correspond to the POSIX EISDIR error code. + case isDirectory + + /// No such path exists. + /// + /// This is used when a path specified does not exist, but it was expected + /// to. + /// + /// Used in situations that correspond to the POSIX ENOENT error code. + case noEntry + + /// Not a directory + /// + /// This is used when an operation cannot be completed because a component + /// of the path which was expected to be a directory was not. + /// + /// Used in situations that correspond to the POSIX ENOTDIR error code. + case notDirectory + + /// Unsupported operation + /// + /// This is used when an operation is not supported by the concrete file + /// system implementation. + case unsupported + + /// An unspecific operating system error at a given path. + case unknownOSError + + /// File or folder already exists at destination. + /// + /// This is thrown when copying or moving a file or directory but the destination + /// path already contains a file or folder. + case alreadyExistsAtDestination + + /// If an unspecified error occurs when trying to change directories. + case couldNotChangeDirectory + + /// If a mismatch is detected in byte count when writing to a file. + case mismatchedByteCount(expected: Int, actual: Int) + } + + /// The kind of the error being raised. + public let kind: Kind + + /// The absolute path to the file associated with the error, if available. + public let path: AbsolutePath? + + public init(_ kind: Kind, _ path: AbsolutePath? = nil) { + self.kind = kind + self.path = path + } +} + +extension FileSystemError: CustomNSError { + public var errorUserInfo: [String: Any] { + return [NSLocalizedDescriptionKey: "\(self)"] + } +} + +extension FileSystemError { + public init(errno: Int32, _ path: AbsolutePath) { + switch errno { + case EACCES: + self.init(.invalidAccess, path) + case EISDIR: + self.init(.isDirectory, path) + case ENOENT: + self.init(.noEntry, path) + case ENOTDIR: + self.init(.notDirectory, path) + case EEXIST: + self.init(.alreadyExistsAtDestination, path) + default: + self.init(.ioError(code: errno), path) + } + } +} + +/// Defines the file modes. +public enum FileMode: Sendable { + + public enum Option: Int, Sendable { + case recursive + case onlyFiles + } + + case userUnWritable + case userWritable + case executable + + public func setMode(_ originalMode: Int16) -> Int16 { + switch self { + case .userUnWritable: + // r-x rwx rwx + return originalMode & 0o577 + case .userWritable: + // -w- --- --- + return originalMode | 0o200 + case .executable: + // --x --x --x + return originalMode | 0o111 + } + } +} + +/// Extended file system attributes that can applied to a given file path. See also ``FileSystem/hasAttribute(_:_:)``. +public enum FileSystemAttribute: RawRepresentable { + #if canImport(Darwin) + case quarantine + #endif + + public init?(rawValue: String) { + switch rawValue { + #if canImport(Darwin) + case "com.apple.quarantine": + self = .quarantine + #endif + default: + return nil + } + } + + public var rawValue: String { + switch self { + #if canImport(Darwin) + case .quarantine: + return "com.apple.quarantine" + #endif + } + } +} + +// FIXME: Design an asynchronous story? +// +/// Abstracted access to file system operations. +/// +/// This protocol is used to allow most of the codebase to interact with a +/// natural filesystem interface, while still allowing clients to transparently +/// substitute a virtual file system or redirect file system operations. +/// +/// - Note: All of these APIs are synchronous and can block. +public protocol FileSystem: Sendable { + /// Check whether the given path exists and is accessible. + @_disfavoredOverload + func exists(_ path: AbsolutePath, followSymlink: Bool) -> Bool + + /// Check whether the given path is accessible and a directory. + func isDirectory(_ path: AbsolutePath) -> Bool + + /// Check whether the given path is accessible and a file. + func isFile(_ path: AbsolutePath) -> Bool + + /// Check whether the given path is an accessible and executable file. + func isExecutableFile(_ path: AbsolutePath) -> Bool + + /// Check whether the given path is accessible and is a symbolic link. + func isSymlink(_ path: AbsolutePath) -> Bool + + /// Check whether the given path is accessible and readable. + func isReadable(_ path: AbsolutePath) -> Bool + + /// Check whether the given path is accessible and writable. + func isWritable(_ path: AbsolutePath) -> Bool + + /// Returns any known item replacement directories for a given path. These may be used by platform-specific + /// libraries to handle atomic file system operations, such as deletion. + func itemReplacementDirectories(for path: AbsolutePath) throws -> [AbsolutePath] + + @available(*, deprecated, message: "use `hasAttribute(_:_:)` instead") + func hasQuarantineAttribute(_ path: AbsolutePath) -> Bool + + /// Returns `true` if a given path has an attribute with a given name applied when file system supports this + /// attribute. Returns `false` if such attribute is not applied or it isn't supported. + func hasAttribute(_ name: FileSystemAttribute, _ path: AbsolutePath) -> Bool + + // FIXME: Actual file system interfaces will allow more efficient access to + // more data than just the name here. + // + /// Get the contents of the given directory, in an undefined order. + func getDirectoryContents(_ path: AbsolutePath) throws -> [String] + + /// Get the current working directory (similar to `getcwd(3)`), which can be + /// different for different (virtualized) implementations of a FileSystem. + /// The current working directory can be empty if e.g. the directory became + /// unavailable while the current process was still working in it. + /// This follows the POSIX `getcwd(3)` semantics. + @_disfavoredOverload + var currentWorkingDirectory: AbsolutePath? { get } + + /// Change the current working directory. + /// - Parameters: + /// - path: The path to the directory to change the current working directory to. + func changeCurrentWorkingDirectory(to path: AbsolutePath) throws + + /// Get the home directory of current user + @_disfavoredOverload + var homeDirectory: AbsolutePath { get throws } + + /// Get the caches directory of current user + @_disfavoredOverload + var cachesDirectory: AbsolutePath? { get } + + /// Get the temp directory + @_disfavoredOverload + var tempDirectory: AbsolutePath { get throws } + + /// Create the given directory. + func createDirectory(_ path: AbsolutePath) throws + + /// Create the given directory. + /// + /// - recursive: If true, create missing parent directories if possible. + func createDirectory(_ path: AbsolutePath, recursive: Bool) throws + + /// Creates a symbolic link of the source path at the target path + /// - Parameters: + /// - path: The path at which to create the link. + /// - destination: The path to which the link points to. + /// - relative: If `relative` is true, the symlink contents will be a relative path, otherwise it will be absolute. + func createSymbolicLink( + _ path: AbsolutePath, pointingAt destination: AbsolutePath, relative: Bool) throws + + // FIXME: This is obviously not a very efficient or flexible API. + // + /// Get the contents of a file. + /// + /// - Returns: The file contents as bytes, or nil if missing. + func readFileContents(_ path: AbsolutePath) throws -> ByteString + + // FIXME: This is obviously not a very efficient or flexible API. + // + /// Write the contents of a file. + func writeFileContents(_ path: AbsolutePath, bytes: ByteString) throws + + // FIXME: This is obviously not a very efficient or flexible API. + // + /// Write the contents of a file. + func writeFileContents(_ path: AbsolutePath, bytes: ByteString, atomically: Bool) throws + + /// Recursively deletes the file system entity at `path`. + /// + /// If there is no file system entity at `path`, this function does nothing (in particular, this is not considered + /// to be an error). + func removeFileTree(_ path: AbsolutePath) throws + + /// Change file mode. + func chmod(_ mode: FileMode, path: AbsolutePath, options: Set) throws + + /// Returns the file info of the given path. + /// + /// The method throws if the underlying stat call fails. + func getFileInfo(_ path: AbsolutePath) throws -> FileInfo + + /// Copy a file or directory. + func copy(from sourcePath: AbsolutePath, to destinationPath: AbsolutePath) throws + + /// Move a file or directory. + func move(from sourcePath: AbsolutePath, to destinationPath: AbsolutePath) throws +} + +/// Convenience implementations (default arguments aren't permitted in protocol +/// methods). +extension FileSystem { + /// exists override with default value. + @_disfavoredOverload + public func exists(_ path: AbsolutePath) -> Bool { + return exists(path, followSymlink: true) + } + + /// Default implementation of createDirectory(_:) + public func createDirectory(_ path: AbsolutePath) throws { + try createDirectory(path, recursive: false) + } + + // Change file mode. + public func chmod(_ mode: FileMode, path: AbsolutePath) throws { + try chmod(mode, path: path, options: []) + } + + // Unless the file system type provides an override for this method, throw + // if `atomically` is `true`, otherwise fall back to whatever implementation already exists. + @_disfavoredOverload + public func writeFileContents(_ path: AbsolutePath, bytes: ByteString, atomically: Bool) throws { + guard !atomically else { + throw FileSystemError(.unsupported, path) + } + try writeFileContents(path, bytes: bytes) + } + + /// Write to a file from a stream producer. + @_disfavoredOverload + public func writeFileContents(_ path: AbsolutePath, body: (WritableByteStream) -> Void) throws { + let contents = BufferedOutputByteStream() + body(contents) + try createDirectory(path.parentDirectory, recursive: true) + try writeFileContents(path, bytes: contents.bytes) + } + + public func getFileInfo(_ path: AbsolutePath) throws -> FileInfo { + throw FileSystemError(.unsupported, path) + } + + public func hasQuarantineAttribute(_ path: AbsolutePath) -> Bool { false } + + public func hasAttribute(_ name: FileSystemAttribute, _ path: AbsolutePath) -> Bool { false } + + public func itemReplacementDirectories(for path: AbsolutePath) throws -> [AbsolutePath] { [] } +} + +/// Concrete FileSystem implementation which communicates with the local file system. +private struct LocalFileSystem: FileSystem { + func isExecutableFile(_ path: AbsolutePath) -> Bool { + // Our semantics doesn't consider directories. + return (self.isFile(path) || self.isSymlink(path)) + && FileManager.default.isExecutableFile(atPath: path.pathString) + } + + func exists(_ path: AbsolutePath, followSymlink: Bool) -> Bool { + if followSymlink { + return FileManager.default.fileExists(atPath: path.pathString) + } + return (try? FileManager.default.attributesOfItem(atPath: path.pathString)) != nil + } + + func isDirectory(_ path: AbsolutePath) -> Bool { + var isDirectory: ObjCBool = false + let exists: Bool = FileManager.default.fileExists( + atPath: path.pathString, isDirectory: &isDirectory) + return exists && isDirectory.boolValue + } + + func isFile(_ path: AbsolutePath) -> Bool { + guard let path = try? resolveSymlinks(path) else { + return false + } + let attrs = try? FileManager.default.attributesOfItem(atPath: path.pathString) + return attrs?[.type] as? FileAttributeType == .typeRegular + } + + func isSymlink(_ path: AbsolutePath) -> Bool { + let url = NSURL(fileURLWithPath: path.pathString) + // We are intentionally using `NSURL.resourceValues(forKeys:)` here since it improves performance on Darwin platforms. + let result = try? url.resourceValues(forKeys: [.isSymbolicLinkKey]) + return (result?[.isSymbolicLinkKey] as? Bool) == true + } + + func isReadable(_ path: AbsolutePath) -> Bool { + FileManager.default.isReadableFile(atPath: path.pathString) + } + + func isWritable(_ path: AbsolutePath) -> Bool { + FileManager.default.isWritableFile(atPath: path.pathString) + } + + func getFileInfo(_ path: AbsolutePath) throws -> FileInfo { + let attrs = try FileManager.default.attributesOfItem(atPath: path.pathString) + return FileInfo(attrs) + } + + func hasAttribute(_ name: FileSystemAttribute, _ path: AbsolutePath) -> Bool { + #if canImport(Darwin) + let bufLength = getxattr(path.pathString, name.rawValue, nil, 0, 0, 0) + + return bufLength > 0 + #else + return false + #endif + } + + var currentWorkingDirectory: AbsolutePath? { + let cwdStr = FileManager.default.currentDirectoryPath + + #if _runtime(_ObjC) + // The ObjC runtime indicates that the underlying Foundation has ObjC + // interoperability in which case the return type of + // `fileSystemRepresentation` is different from the Swift implementation + // of Foundation. + return try? AbsolutePath(validating: cwdStr) + #else + let fsr: UnsafePointer = cwdStr.fileSystemRepresentation + defer { fsr.deallocate() } + + return try? AbsolutePath(String(cString: fsr)) + #endif + } + + func changeCurrentWorkingDirectory(to path: AbsolutePath) throws { + guard isDirectory(path) else { + throw FileSystemError(.notDirectory, path) + } + + guard FileManager.default.changeCurrentDirectoryPath(path.pathString) else { + throw FileSystemError(.couldNotChangeDirectory, path) + } + } + + var homeDirectory: AbsolutePath { + get throws { + return try AbsolutePath(validating: NSHomeDirectory()) + } + } + + var cachesDirectory: AbsolutePath? { + return FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first.flatMap { + try? AbsolutePath(validating: $0.path) + } + } + + var tempDirectory: AbsolutePath { + get throws { + let override = + ProcessEnv.block["TMPDIR"] ?? ProcessEnv.block["TEMP"] ?? ProcessEnv.block["TMP"] + if let path = override.flatMap({ try? AbsolutePath(validating: $0) }) { + return path + } + return try AbsolutePath(validating: NSTemporaryDirectory()) + } + } + + func getDirectoryContents(_ path: AbsolutePath) throws -> [String] { + #if canImport(Darwin) + return try FileManager.default.contentsOfDirectory(atPath: path.pathString) + #else + do { + return try FileManager.default.contentsOfDirectory(atPath: path.pathString) + } catch let error as NSError { + // Fixup error from corelibs-foundation. + if error.code == CocoaError.fileReadNoSuchFile.rawValue, + !error.userInfo.keys.contains(NSLocalizedDescriptionKey) + { + var userInfo = error.userInfo + userInfo[NSLocalizedDescriptionKey] = "The folder “\(path.basename)” doesn’t exist." + throw NSError(domain: error.domain, code: error.code, userInfo: userInfo) + } + throw error + } + #endif + } + + func createDirectory(_ path: AbsolutePath, recursive: Bool) throws { + // Don't fail if path is already a directory. + if isDirectory(path) { return } + + try FileManager.default.createDirectory( + atPath: path.pathString, withIntermediateDirectories: recursive, attributes: [:]) + } + + func createSymbolicLink( + _ path: AbsolutePath, pointingAt destination: AbsolutePath, relative: Bool + ) throws { + let destString = + relative ? destination.relative(to: path.parentDirectory).pathString : destination.pathString + try FileManager.default.createSymbolicLink( + atPath: path.pathString, withDestinationPath: destString) + } + + func readFileContents(_ path: AbsolutePath) throws -> ByteString { + // Open the file. + guard let fp = fopen(path.pathString, "rb") else { + throw FileSystemError(errno: errno, path) + } + defer { fclose(fp) } + + // Read the data one block at a time. + let data = BufferedOutputByteStream() + var tmpBuffer = [UInt8](repeating: 0, count: 1 << 12) + while true { + let n = fread(&tmpBuffer, 1, tmpBuffer.count, fp) + if n < 0 { + if errno == EINTR { continue } + throw FileSystemError(.ioError(code: errno), path) + } + if n == 0 { + let errno = ferror(fp) + if errno != 0 { + throw FileSystemError(.ioError(code: errno), path) + } + break + } + data.send(tmpBuffer[0..) throws { + guard exists(path) else { return } + func setMode(path: String) throws { + let attrs = try FileManager.default.attributesOfItem(atPath: path) + // Skip if only files should be changed. + if options.contains(.onlyFiles) && attrs[.type] as? FileAttributeType != .typeRegular { + return + } + + // Compute the new mode for this file. + let currentMode = attrs[.posixPermissions] as! Int16 + let newMode = mode.setMode(currentMode) + guard newMode != currentMode else { return } + try FileManager.default.setAttributes( + [.posixPermissions: newMode], + ofItemAtPath: path) + } + + try setMode(path: path.pathString) + guard isDirectory(path) else { return } + + guard + let traverse = FileManager.default.enumerator( + at: URL(fileURLWithPath: path.pathString), + includingPropertiesForKeys: nil) + else { + throw FileSystemError(.noEntry, path) + } + + if !options.contains(.recursive) { + traverse.skipDescendants() + } + + while let path = traverse.nextObject() { + try setMode(path: (path as! URL).path) + } + } + + func copy(from sourcePath: AbsolutePath, to destinationPath: AbsolutePath) throws { + guard exists(sourcePath) else { throw FileSystemError(.noEntry, sourcePath) } + guard !exists(destinationPath) + else { throw FileSystemError(.alreadyExistsAtDestination, destinationPath) } + try FileManager.default.copyItem(at: sourcePath.asURL, to: destinationPath.asURL) + } + + func move(from sourcePath: AbsolutePath, to destinationPath: AbsolutePath) throws { + guard exists(sourcePath) else { throw FileSystemError(.noEntry, sourcePath) } + guard !exists(destinationPath) + else { throw FileSystemError(.alreadyExistsAtDestination, destinationPath) } + try FileManager.default.moveItem(at: sourcePath.asURL, to: destinationPath.asURL) + } + + func itemReplacementDirectories(for path: AbsolutePath) throws -> [AbsolutePath] { + let result = try FileManager.default.url( + for: .itemReplacementDirectory, in: .userDomainMask, appropriateFor: path.asURL, create: false + ) + let path = try AbsolutePath(validating: result.path) + // Foundation returns a path that is unique every time, so we return both that path, as well as its parent. + return [path, path.parentDirectory] + } +} + +private var _localFileSystem: FileSystem = LocalFileSystem() + +/// Public access to the local FS proxy. +public var localFileSystem: FileSystem { + get { + return _localFileSystem + } + + @available( + *, deprecated, + message: + "This global should never be mutable and is supposed to be read-only. Deprecated in Apr 2023." + ) + set { + _localFileSystem = newValue + } +} + +extension FileSystem { + /// Print the filesystem tree of the given path. + /// + /// For debugging only. + public func dumpTree(at path: AbsolutePath = .root) { + print(".") + do { + try recurse(fs: self, path: path) + } catch { + print("\(error)") + } + } + + /// Write bytes to the path if the given contents are different. + public func writeIfChanged(path: AbsolutePath, bytes: ByteString) throws { + try createDirectory(path.parentDirectory, recursive: true) + + // Return if the contents are same. + if isFile(path), try readFileContents(path) == bytes { + return + } + + try writeFileContents(path, bytes: bytes) + } + + /// Helper method to recurse and print the tree. + private func recurse(fs: FileSystem, path: AbsolutePath, prefix: String = "") throws { + let contents = try fs.getDirectoryContents(path) + + for (idx, entry) in contents.enumerated() { + let isLast = idx == contents.count - 1 + let line = prefix + (isLast ? "└── " : "├── ") + entry + print(line) + + let entryPath = path.appending(component: entry) + if fs.isDirectory(entryPath) { + let childPrefix = prefix + (isLast ? " " : "│ ") + try recurse(fs: fs, path: entryPath, prefix: String(childPrefix)) + } + } + } +} + +#if !os(Windows) + extension dirent { + /// Get the directory name. + /// + /// This returns nil if the name is not valid UTF8. + public var name: String? { + var d_name = self.d_name + return withUnsafePointer(to: &d_name) { + String(validatingUTF8: UnsafeRawPointer($0).assumingMemoryBound(to: CChar.self)) + } + } + } +#endif diff --git a/Sources/CartonHelpers/Basics/HashAlgorithms.swift b/Sources/CartonHelpers/Basics/HashAlgorithms.swift new file mode 100644 index 00000000..7f6e245d --- /dev/null +++ b/Sources/CartonHelpers/Basics/HashAlgorithms.swift @@ -0,0 +1,260 @@ +/* + This source file is part of the Swift.org open source project + + Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors + Licensed under Apache License v2.0 with Runtime Library Exception + + See http://swift.org/LICENSE.txt for license information + See http://swift.org/CONTRIBUTORS.txt for Swift project authors +*/ + +#if canImport(CryptoKit) + import CryptoKit +#endif + +public protocol HashAlgorithm: Sendable { + + /// Hashes the input bytes, returning the digest. + /// + /// - Parameters: + /// - bytes: The input bytes. + /// - Returns: The output digest. + func hash(_ bytes: ByteString) -> ByteString +} + +extension HashAlgorithm { + public func hash(_ string: String) -> ByteString { + hash(ByteString([UInt8](string.utf8))) + } +} + +/// SHA-256 implementation from Secure Hash Algorithm 2 (SHA-2) set of +/// cryptographic hash functions (FIPS PUB 180-2). +/// Uses CryptoKit where available +public struct SHA256: HashAlgorithm, Sendable { + private let underlying: HashAlgorithm + + public init() { + #if canImport(CryptoKit) + if #available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) { + self.underlying = _CryptoKitSHA256() + } else { + self.underlying = InternalSHA256() + } + #else + self.underlying = InternalSHA256() + #endif + } + public func hash(_ bytes: ByteString) -> ByteString { + self.underlying.hash(bytes) + } +} + +/// SHA-256 implementation from Secure Hash Algorithm 2 (SHA-2) set of +/// cryptographic hash functions (FIPS PUB 180-2). +struct InternalSHA256: HashAlgorithm { + /// The length of the output digest (in bits). + private static let digestLength = 256 + + /// The size of each blocks (in bits). + private static let blockBitSize = 512 + + /// The initial hash value. + private static let initalHashValue: [UInt32] = [ + 0x6a09_e667, 0xbb67_ae85, 0x3c6e_f372, 0xa54f_f53a, 0x510e_527f, 0x9b05_688c, 0x1f83_d9ab, + 0x5be0_cd19, + ] + + /// The constants in the algorithm (K). + private static let konstants: [UInt32] = [ + 0x428a_2f98, 0x7137_4491, 0xb5c0_fbcf, 0xe9b5_dba5, 0x3956_c25b, 0x59f1_11f1, 0x923f_82a4, + 0xab1c_5ed5, + 0xd807_aa98, 0x1283_5b01, 0x2431_85be, 0x550c_7dc3, 0x72be_5d74, 0x80de_b1fe, 0x9bdc_06a7, + 0xc19b_f174, + 0xe49b_69c1, 0xefbe_4786, 0x0fc1_9dc6, 0x240c_a1cc, 0x2de9_2c6f, 0x4a74_84aa, 0x5cb0_a9dc, + 0x76f9_88da, + 0x983e_5152, 0xa831_c66d, 0xb003_27c8, 0xbf59_7fc7, 0xc6e0_0bf3, 0xd5a7_9147, 0x06ca_6351, + 0x1429_2967, + 0x27b7_0a85, 0x2e1b_2138, 0x4d2c_6dfc, 0x5338_0d13, 0x650a_7354, 0x766a_0abb, 0x81c2_c92e, + 0x9272_2c85, + 0xa2bf_e8a1, 0xa81a_664b, 0xc24b_8b70, 0xc76c_51a3, 0xd192_e819, 0xd699_0624, 0xf40e_3585, + 0x106a_a070, + 0x19a4_c116, 0x1e37_6c08, 0x2748_774c, 0x34b0_bcb5, 0x391c_0cb3, 0x4ed8_aa4a, 0x5b9c_ca4f, + 0x682e_6ff3, + 0x748f_82ee, 0x78a5_636f, 0x84c8_7814, 0x8cc7_0208, 0x90be_fffa, 0xa450_6ceb, 0xbef9_a3f7, + 0xc671_78f2, + ] + + public init() { + } + + public func hash(_ bytes: ByteString) -> ByteString { + var input = bytes.contents + + // Pad the input. + pad(&input) + + // Break the input into N 512-bit blocks. + let messageBlocks = input.blocks(size: Self.blockBitSize / 8) + + /// The hash that is being computed. + var hash = Self.initalHashValue + + // Process each block. + for block in messageBlocks { + process(block, hash: &hash) + } + + // Finally, compute the result. + var result = [UInt8](repeating: 0, count: Self.digestLength / 8) + for (idx, element) in hash.enumerated() { + let pos = idx * 4 + result[pos + 0] = UInt8((element >> 24) & 0xff) + result[pos + 1] = UInt8((element >> 16) & 0xff) + result[pos + 2] = UInt8((element >> 8) & 0xff) + result[pos + 3] = UInt8(element & 0xff) + } + + return ByteString(result) + } + + /// Process and compute hash from a block. + private func process(_ block: ArraySlice, hash: inout [UInt32]) { + + // Compute message schedule. + var W = [UInt32](repeating: 0, count: Self.konstants.count) + for t in 0..> 10) + let σ0 = W[t - 15].rotateRight(by: 7) ^ W[t - 15].rotateRight(by: 18) ^ (W[t - 15] >> 3) + W[t] = σ1 &+ W[t - 7] &+ σ0 &+ W[t - 16] + } + } + + var a = hash[0] + var b = hash[1] + var c = hash[2] + var d = hash[3] + var e = hash[4] + var f = hash[5] + var g = hash[6] + var h = hash[7] + + // Run the main algorithm. + for t in 0.. ByteString { + self.underlying.hash(bytes) + } + } + + /// Wraps CryptoKit.SHA256 to provide a HashAlgorithm conformance to it. + @available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) + struct _CryptoKitSHA256: HashAlgorithm { + public init() { + } + public func hash(_ bytes: ByteString) -> ByteString { + return bytes.withData { data in + let digest = CryptoKit.SHA256.hash(data: data) + return ByteString(digest) + } + } + } +#endif + +// MARK:- Helpers + +extension UInt64 { + /// Converts the 64 bit integer into an array of single byte integers. + fileprivate func toByteArray() -> [UInt8] { + var value = self.littleEndian + return withUnsafeBytes(of: &value, Array.init) + } +} + +extension UInt32 { + /// Rotates self by given amount. + fileprivate func rotateRight(by amount: UInt32) -> UInt32 { + return (self >> amount) | (self << (32 - amount)) + } +} + +extension Array { + /// Breaks the array into the given size. + fileprivate func blocks(size: Int) -> AnyIterator> { + var currentIndex = startIndex + return AnyIterator { + if let nextIndex = self.index(currentIndex, offsetBy: size, limitedBy: self.endIndex) { + defer { currentIndex = nextIndex } + return self[currentIndex.. Bool { + return PathImpl.isValidComponent(name) + } + + /// Private implementation details, shared with the RelativePath struct. + private let _impl: PathImpl + + /// Private initializer when the backing storage is known. + private init(_ impl: PathImpl) { + _impl = impl + } + + /// Initializes an AbsolutePath from a string that may be either absolute + /// or relative; if relative, `basePath` is used as the anchor; if absolute, + /// it is used as is, and in this case `basePath` is ignored. + public init(validating str: String, relativeTo basePath: AbsolutePath) throws { + if PathImpl(string: str).isAbsolute { + try self.init(validating: str) + } else { + #if os(Windows) + assert(!basePath.pathString.isEmpty) + guard !str.isEmpty else { + self.init(basePath._impl) + return + } + + let base: UnsafePointer = + basePath.pathString.fileSystemRepresentation + defer { base.deallocate() } + + let path: UnsafePointer = str.fileSystemRepresentation + defer { path.deallocate() } + + var pwszResult: PWSTR! + _ = String(cString: base).withCString(encodedAs: UTF16.self) { pwszBase in + String(cString: path).withCString(encodedAs: UTF16.self) { pwszPath in + PathAllocCombine( + pwszBase, pwszPath, ULONG(PATHCCH_ALLOW_LONG_PATHS.rawValue), &pwszResult) + } + } + defer { LocalFree(pwszResult) } + + self.init(String(decodingCString: pwszResult, as: UTF16.self)) + #else + try self.init(basePath, RelativePath(validating: str)) + #endif + } + } + + /// Initializes the AbsolutePath by concatenating a relative path to an + /// existing absolute path, and renormalizing if necessary. + public init(_ absPath: AbsolutePath, _ relPath: RelativePath) { + self.init(absPath._impl.appending(relativePath: relPath._impl)) + } + + /// Convenience initializer that appends a string to a relative path. + public init(_ absPath: AbsolutePath, validating relStr: String) throws { + try self.init(absPath, RelativePath(validating: relStr)) + } + + /// Initializes the AbsolutePath from `absStr`, which must be an absolute + /// path (i.e. it must begin with a path separator; this initializer does + /// not interpret leading `~` characters as home directory specifiers). + /// The input string will be normalized if needed, as described in the + /// documentation for AbsolutePath. + public init(validating path: String) throws { + try self.init(PathImpl(validatingAbsolutePath: path)) + } + + /// Directory component. An absolute path always has a non-empty directory + /// component (the directory component of the root path is the root itself). + public var dirname: String { + return _impl.dirname + } + + /// Last path component (including the suffix, if any). it is never empty. + public var basename: String { + return _impl.basename + } + + /// Returns the basename without the extension. + public var basenameWithoutExt: String { + if let ext = self.extension { + return String(basename.dropLast(ext.count + 1)) + } + return basename + } + + /// Suffix (including leading `.` character) if any. Note that a basename + /// that starts with a `.` character is not considered a suffix, nor is a + /// trailing `.` character. + public var suffix: String? { + return _impl.suffix + } + + /// Extension of the give path's basename. This follow same rules as + /// suffix except that it doesn't include leading `.` character. + public var `extension`: String? { + return _impl.extension + } + + /// Absolute path of parent directory. This always returns a path, because + /// every directory has a parent (the parent directory of the root directory + /// is considered to be the root directory itself). + public var parentDirectory: AbsolutePath { + return AbsolutePath(_impl.parentDirectory) + } + + /// True if the path is the root directory. + public var isRoot: Bool { + return _impl.isRoot + } + + /// Returns the absolute path with the relative path applied. + public func appending(_ subpath: RelativePath) -> AbsolutePath { + return AbsolutePath(self, subpath) + } + + /// Returns the absolute path with an additional literal component appended. + /// + /// This method accepts pseudo-path like '.' or '..', but should not contain "/". + public func appending(component: String) -> AbsolutePath { + return AbsolutePath(_impl.appending(component: component)) + } + + /// Returns the absolute path with additional literal components appended. + /// + /// This method should only be used in cases where the input is guaranteed + /// to be a valid path component (i.e., it cannot be empty, contain a path + /// separator, or be a pseudo-path like '.' or '..'). + public func appending(components names: [String]) -> AbsolutePath { + // FIXME: This doesn't seem a particularly efficient way to do this. + return names.reduce( + self, + { path, name in + path.appending(component: name) + }) + } + + public func appending(components names: String...) -> AbsolutePath { + appending(components: names) + } + + /// NOTE: We will most likely want to add other `appending()` methods, such + /// as `appending(suffix:)`, and also perhaps `replacing()` methods, + /// such as `replacing(suffix:)` or `replacing(basename:)` for some + /// of the more common path operations. + + /// NOTE: We may want to consider adding operators such as `+` for appending + /// a path component. + + /// NOTE: We will want to add a method to return the lowest common ancestor + /// path. + + /// Root directory (whose string representation is just a path separator). + public static let root = AbsolutePath(PathImpl.root) + + /// Normalized string representation (the normalization rules are described + /// in the documentation of the initializer). This string is never empty. + public var pathString: String { + return _impl.string + } + + /// Returns an array of strings that make up the path components of the + /// absolute path. This is the same sequence of strings as the basenames + /// of each successive path component, starting from the root. Therefore + /// the first path component of an absolute path is always `/`. + public var components: [String] { + return _impl.components + } +} + +/// Represents a relative file system path. A relative path never starts with +/// a `/` character, and holds a normalized string representation. As with +/// AbsolutePath, the normalization is strictly syntactic, and does not access +/// the file system in any way. +/// +/// The relative path string is normalized by: +/// - Collapsing `..` path components that aren't at the beginning +/// - Removing extraneous `.` path components +/// - Removing any trailing path separator +/// - Removing any redundant path separators +/// - Replacing a completely empty path with a `.` +/// +/// This string manipulation may change the meaning of a path if any of the +/// path components are symbolic links on disk. However, the file system is +/// never accessed in any way when initializing a RelativePath. +public struct RelativePath: Hashable, Sendable { + /// Private implementation details, shared with the AbsolutePath struct. + fileprivate let _impl: PathImpl + + /// Private initializer when the backing storage is known. + private init(_ impl: PathImpl) { + _impl = impl + } + + /// Convenience initializer that verifies that the path is relative. + public init(validating path: String) throws { + try self.init(PathImpl(validatingRelativePath: path)) + } + + /// Directory component. For a relative path without any path separators, + /// this is the `.` string instead of the empty string. + public var dirname: String { + return _impl.dirname + } + + /// Last path component (including the suffix, if any). It is never empty. + public var basename: String { + return _impl.basename + } + + /// Returns the basename without the extension. + public var basenameWithoutExt: String { + if let ext = self.extension { + return String(basename.dropLast(ext.count + 1)) + } + return basename + } + + /// Suffix (including leading `.` character) if any. Note that a basename + /// that starts with a `.` character is not considered a suffix, nor is a + /// trailing `.` character. + public var suffix: String? { + return _impl.suffix + } + + /// Extension of the give path's basename. This follow same rules as + /// suffix except that it doesn't include leading `.` character. + public var `extension`: String? { + return _impl.extension + } + + /// Normalized string representation (the normalization rules are described + /// in the documentation of the initializer). This string is never empty. + public var pathString: String { + return _impl.string + } + + /// Returns an array of strings that make up the path components of the + /// relative path. This is the same sequence of strings as the basenames + /// of each successive path component. Therefore the returned array of + /// path components is never empty; even an empty path has a single path + /// component: the `.` string. + public var components: [String] { + return _impl.components + } + + /// Returns the relative path with the given relative path applied. + public func appending(_ subpath: RelativePath) -> RelativePath { + return RelativePath(_impl.appending(relativePath: subpath._impl)) + } + + /// Returns the relative path with an additional literal component appended. + /// + /// This method accepts pseudo-path like '.' or '..', but should not contain "/". + public func appending(component: String) -> RelativePath { + return RelativePath(_impl.appending(component: component)) + } + + /// Returns the relative path with additional literal components appended. + /// + /// This method should only be used in cases where the input is guaranteed + /// to be a valid path component (i.e., it cannot be empty, contain a path + /// separator, or be a pseudo-path like '.' or '..'). + public func appending(components names: [String]) -> RelativePath { + // FIXME: This doesn't seem a particularly efficient way to do this. + return names.reduce( + self, + { path, name in + path.appending(component: name) + }) + } + + public func appending(components names: String...) -> RelativePath { + appending(components: names) + } +} + +extension AbsolutePath: Codable { + public func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + try container.encode(pathString) + } + + public init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + try self.init(validating: container.decode(String.self)) + } +} + +extension RelativePath: Codable { + public func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + try container.encode(pathString) + } + + public init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + try self.init(validating: container.decode(String.self)) + } +} + +// Make absolute paths Comparable. +extension AbsolutePath: Comparable { + public static func < (lhs: AbsolutePath, rhs: AbsolutePath) -> Bool { + return lhs.pathString < rhs.pathString + } +} + +/// Make absolute paths CustomStringConvertible and CustomDebugStringConvertible. +extension AbsolutePath: CustomStringConvertible, CustomDebugStringConvertible { + public var description: String { + return pathString + } + + public var debugDescription: String { + // FIXME: We should really be escaping backslashes and quotes here. + return "" + } +} + +/// Make relative paths CustomStringConvertible and CustomDebugStringConvertible. +extension RelativePath: CustomStringConvertible { + public var description: String { + return _impl.string + } + + public var debugDescription: String { + // FIXME: We should really be escaping backslashes and quotes here. + return "" + } +} + +/// Private implementation shared between AbsolutePath and RelativePath. +protocol Path: Hashable { + + /// Root directory. + static var root: Self { get } + + /// Checks if a string is a valid component. + static func isValidComponent(_ name: String) -> Bool + + /// Normalized string of the (absolute or relative) path. Never empty. + var string: String { get } + + /// Returns whether the path is the root path. + var isRoot: Bool { get } + + /// Returns whether the path is an absolute path. + var isAbsolute: Bool { get } + + /// Returns the directory part of the stored path (relying on the fact that it has been normalized). Returns a + /// string consisting of just `.` if there is no directory part (which is the case if and only if there is no path + /// separator). + var dirname: String { get } + + /// Returns the last past component. + var basename: String { get } + + /// Returns the components of the path between each path separator. + var components: [String] { get } + + /// Path of parent directory. This always returns a path, because every directory has a parent (the parent + /// directory of the root directory is considered to be the root directory itself). + var parentDirectory: Self { get } + + /// Creates a path from its normalized string representation. + init(string: String) + + /// Creates a path from a string representation, validates that it is a valid absolute path and normalizes it. + init(validatingAbsolutePath: String) throws + + /// Creates a path from a string representation, validates that it is a valid relative path and normalizes it. + init(validatingRelativePath: String) throws + + /// Returns suffix with leading `.` if withDot is true otherwise without it. + func suffix(withDot: Bool) -> String? + + /// Returns a new Path by appending the path component. + func appending(component: String) -> Self + + /// Returns a path by concatenating a relative path and renormalizing if necessary. + func appending(relativePath: Self) -> Self +} + +extension Path { + var suffix: String? { + return suffix(withDot: true) + } + + var `extension`: String? { + return suffix(withDot: false) + } +} + +#if os(Windows) + private struct WindowsPath: Path, Sendable { + let string: String + + // NOTE: this is *NOT* a root path. It is a drive-relative path that needs + // to be specified due to assumptions in the APIs. Use the platform + // specific path separator as we should be normalizing the path normally. + // This is required to make the `InMemoryFileSystem` correctly iterate + // paths. + static let root = Self(string: "\\") + + static func isValidComponent(_ name: String) -> Bool { + return name != "" && name != "." && name != ".." && !name.contains("/") + } + + static func isAbsolutePath(_ path: String) -> Bool { + return !path.withCString(encodedAs: UTF16.self, PathIsRelativeW) + } + + var dirname: String { + let fsr: UnsafePointer = self.string.fileSystemRepresentation + defer { fsr.deallocate() } + + let path: String = String(cString: fsr) + return path.withCString(encodedAs: UTF16.self) { + let data = UnsafeMutablePointer(mutating: $0) + PathCchRemoveFileSpec(data, path.count) + return String(decodingCString: data, as: UTF16.self) + } + } + + var isAbsolute: Bool { + return Self.isAbsolutePath(self.string) + } + + public var isRoot: Bool { + return self.string.withCString(encodedAs: UTF16.self, PathCchIsRoot) + } + + var basename: String { + let path: String = self.string + return path.withCString(encodedAs: UTF16.self) { + PathStripPathW(UnsafeMutablePointer(mutating: $0)) + return String(decodingCString: $0, as: UTF16.self) + } + } + + // FIXME: We should investigate if it would be more efficient to instead + // return a path component iterator that does all its work lazily, moving + // from one path separator to the next on-demand. + // + var components: [String] { + let normalized: UnsafePointer = string.fileSystemRepresentation + defer { normalized.deallocate() } + + return String(cString: normalized).components(separatedBy: "\\").filter { !$0.isEmpty } + } + + var parentDirectory: Self { + return self == .root ? self : Self(string: dirname) + } + + init(string: String) { + if string.first?.isASCII ?? false, string.first?.isLetter ?? false, + string.first?.isLowercase ?? false, + string.count > 1, string[string.index(string.startIndex, offsetBy: 1)] == ":" + { + self.string = "\(string.first!.uppercased())\(string.dropFirst(1))" + } else { + self.string = string + } + } + + private static func repr(_ path: String) -> String { + guard !path.isEmpty else { return "" } + let representation: UnsafePointer = path.fileSystemRepresentation + defer { representation.deallocate() } + return String(cString: representation) + } + + init(validatingAbsolutePath path: String) throws { + let realpath = Self.repr(path) + if !Self.isAbsolutePath(realpath) { + throw PathValidationError.invalidAbsolutePath(path) + } + self.init(string: realpath) + } + + init(validatingRelativePath path: String) throws { + if path.isEmpty || path == "." { + self.init(string: ".") + } else { + let realpath: String = Self.repr(path) + // Treat a relative path as an invalid relative path... + if Self.isAbsolutePath(realpath) || realpath.first == "\\" { + throw PathValidationError.invalidRelativePath(path) + } + self.init(string: realpath) + } + } + + func suffix(withDot: Bool) -> String? { + return self.string.withCString(encodedAs: UTF16.self) { + if let pointer = PathFindExtensionW($0) { + let substring = String(decodingCString: pointer, as: UTF16.self) + guard substring.length > 0 else { return nil } + return withDot ? substring : String(substring.dropFirst(1)) + } + return nil + } + } + + func appending(component name: String) -> Self { + var result: PWSTR? + _ = string.withCString(encodedAs: UTF16.self) { root in + name.withCString(encodedAs: UTF16.self) { path in + PathAllocCombine(root, path, ULONG(PATHCCH_ALLOW_LONG_PATHS.rawValue), &result) + } + } + defer { LocalFree(result) } + return Self(string: String(decodingCString: result!, as: UTF16.self)) + } + + func appending(relativePath: Self) -> Self { + var result: PWSTR? + _ = string.withCString(encodedAs: UTF16.self) { root in + relativePath.string.withCString(encodedAs: UTF16.self) { path in + PathAllocCombine(root, path, ULONG(PATHCCH_ALLOW_LONG_PATHS.rawValue), &result) + } + } + defer { LocalFree(result) } + return Self(string: String(decodingCString: result!, as: UTF16.self)) + } + } +#else + private struct UNIXPath: Path, Sendable { + let string: String + + static let root = Self(string: "/") + + static func isValidComponent(_ name: String) -> Bool { + return name != "" && name != "." && name != ".." && !name.contains("/") + } + + var dirname: String { + // FIXME: This method seems too complicated; it should be simplified, + // if possible, and certainly optimized (using UTF8View). + // Find the last path separator. + guard let idx = string.lastIndex(of: "/") else { + // No path separators, so the directory name is `.`. + return "." + } + // Check if it's the only one in the string. + if idx == string.startIndex { + // Just one path separator, so the directory name is `/`. + return "/" + } + // Otherwise, it's the string up to (but not including) the last path + // separator. + return String(string.prefix(upTo: idx)) + } + + var isAbsolute: Bool { + return string.hasPrefix("/") + } + + var isRoot: Bool { + return self == Self.root + } + + var basename: String { + // FIXME: This method seems too complicated; it should be simplified, + // if possible, and certainly optimized (using UTF8View). + // Check for a special case of the root directory. + if string.spm_only == "/" { + // Root directory, so the basename is a single path separator (the + // root directory is special in this regard). + return "/" + } + // Find the last path separator. + guard let idx = string.lastIndex(of: "/") else { + // No path separators, so the basename is the whole string. + return string + } + // Otherwise, it's the string from (but not including) the last path + // separator. + return String(string.suffix(from: string.index(after: idx))) + } + + // FIXME: We should investigate if it would be more efficient to instead + // return a path component iterator that does all its work lazily, moving + // from one path separator to the next on-demand. + // + var components: [String] { + // FIXME: This isn't particularly efficient; needs optimization, and + // in fact, it might well be best to return a custom iterator so we + // don't have to allocate everything up-front. It would be backed by + // the path string and just return a slice at a time. + let components = string.components(separatedBy: "/").filter({ !$0.isEmpty }) + + if string.hasPrefix("/") { + return ["/"] + components + } else { + return components + } + } + + var parentDirectory: Self { + return self == .root ? self : Self(string: dirname) + } + + init(string: String) { + self.string = string + } + + init(normalizingAbsolutePath path: String) { + precondition( + path.first == "/", "Failure normalizing \(path), absolute paths should start with '/'") + + // At this point we expect to have a path separator as first character. + assert(path.first == "/") + // Fast path. + if !mayNeedNormalization(absolute: path) { + self.init(string: path) + } + + // Split the character array into parts, folding components as we go. + // As we do so, we count the number of characters we'll end up with in + // the normalized string representation. + var parts: [String] = [] + var capacity = 0 + for part in path.split(separator: "/") { + switch part.count { + case 0: + // Ignore empty path components. + continue + case 1 where part.first == ".": + // Ignore `.` path components. + continue + case 2 where part.first == "." && part.last == ".": + // If there's a previous part, drop it; otherwise, do nothing. + if let prev = parts.last { + parts.removeLast() + capacity -= prev.count + } + default: + // Any other component gets appended. + parts.append(String(part)) + capacity += part.count + } + } + capacity += max(parts.count, 1) + + // Create an output buffer using the capacity we've calculated. + // FIXME: Determine the most efficient way to reassemble a string. + var result = "" + result.reserveCapacity(capacity) + + // Put the normalized parts back together again. + var iter = parts.makeIterator() + result.append("/") + if let first = iter.next() { + result.append(contentsOf: first) + while let next = iter.next() { + result.append("/") + result.append(contentsOf: next) + } + } + + // Sanity-check the result (including the capacity we reserved). + assert(!result.isEmpty, "unexpected empty string") + assert(result.count == capacity, "count: " + "\(result.count), cap: \(capacity)") + + // Use the result as our stored string. + self.init(string: result) + } + + init(normalizingRelativePath path: String) { + precondition(path.first != "/") + + // FIXME: Here we should also keep track of whether anything actually has + // to be changed in the string, and if not, just return the existing one. + + // Split the character array into parts, folding components as we go. + // As we do so, we count the number of characters we'll end up with in + // the normalized string representation. + var parts: [String] = [] + var capacity = 0 + for part in path.split(separator: "/") { + switch part.count { + case 0: + // Ignore empty path components. + continue + case 1 where part.first == ".": + // Ignore `.` path components. + continue + case 2 where part.first == "." && part.last == ".": + // If at beginning, fall through to treat the `..` literally. + guard let prev = parts.last else { + fallthrough + } + // If previous component is anything other than `..`, drop it. + if !(prev.count == 2 && prev.first == "." && prev.last == ".") { + parts.removeLast() + capacity -= prev.count + continue + } + // Otherwise, fall through to treat the `..` literally. + fallthrough + default: + // Any other component gets appended. + parts.append(String(part)) + capacity += part.count + } + } + capacity += max(parts.count - 1, 0) + + // Create an output buffer using the capacity we've calculated. + // FIXME: Determine the most efficient way to reassemble a string. + var result = "" + result.reserveCapacity(capacity) + + // Put the normalized parts back together again. + var iter = parts.makeIterator() + if let first = iter.next() { + result.append(contentsOf: first) + while let next = iter.next() { + result.append("/") + result.append(contentsOf: next) + } + } + + // Sanity-check the result (including the capacity we reserved). + assert(result.count == capacity, "count: " + "\(result.count), cap: \(capacity)") + + // If the result is empty, return `.`, otherwise we return it as a string. + self.init(string: result.isEmpty ? "." : result) + } + + init(validatingAbsolutePath path: String) throws { + switch path.first { + case "/": + self.init(normalizingAbsolutePath: path) + case "~": + throw PathValidationError.startsWithTilde(path) + default: + throw PathValidationError.invalidAbsolutePath(path) + } + } + + init(validatingRelativePath path: String) throws { + switch path.first { + case "/": + throw PathValidationError.invalidRelativePath(path) + default: + self.init(normalizingRelativePath: path) + } + } + + func suffix(withDot: Bool) -> String? { + // FIXME: This method seems too complicated; it should be simplified, + // if possible, and certainly optimized (using UTF8View). + // Find the last path separator, if any. + let sIdx = string.lastIndex(of: "/") + // Find the start of the basename. + let bIdx = (sIdx != nil) ? string.index(after: sIdx!) : string.startIndex + // Find the last `.` (if any), starting from the second character of + // the basename (a leading `.` does not make the whole path component + // a suffix). + let fIdx = string.index(bIdx, offsetBy: 1, limitedBy: string.endIndex) ?? string.startIndex + if let idx = string[fIdx...].lastIndex(of: ".") { + // Unless it's just a `.` at the end, we have found a suffix. + if string.distance(from: idx, to: string.endIndex) > 1 { + let fromIndex = withDot ? idx : string.index(idx, offsetBy: 1) + return String(string.suffix(from: fromIndex)) + } else { + return nil + } + } + // If we get this far, there is no suffix. + return nil + } + + func appending(component name: String) -> Self { + assert(!name.contains("/"), "\(name) is invalid path component") + + // Handle pseudo paths. + switch name { + case "", ".": + return self + case "..": + return self.parentDirectory + default: + break + } + + if self == Self.root { + return Self(string: "/" + name) + } else { + return Self(string: string + "/" + name) + } + } + + func appending(relativePath: Self) -> Self { + // Both paths are already normalized. The only case in which we have + // to renormalize their concatenation is if the relative path starts + // with a `..` path component. + var newPathString = string + if self != .root { + newPathString.append("/") + } + + let relativePathString = relativePath.string + newPathString.append(relativePathString) + + // If the relative string starts with `.` or `..`, we need to normalize + // the resulting string. + // FIXME: We can actually optimize that case, since we know that the + // normalization of a relative path can leave `..` path components at + // the beginning of the path only. + if relativePathString.hasPrefix(".") { + if newPathString.hasPrefix("/") { + return Self(normalizingAbsolutePath: newPathString) + } else { + return Self(normalizingRelativePath: newPathString) + } + } else { + return Self(string: newPathString) + } + } + } +#endif + +/// Describes the way in which a path is invalid. +public enum PathValidationError: Error { + case startsWithTilde(String) + case invalidAbsolutePath(String) + case invalidRelativePath(String) +} + +extension PathValidationError: CustomStringConvertible { + public var description: String { + switch self { + case .startsWithTilde(let path): + return "invalid absolute path '\(path)'; absolute path must begin with '/'" + case .invalidAbsolutePath(let path): + return "invalid absolute path '\(path)'" + case .invalidRelativePath(let path): + return + "invalid relative path '\(path)'; relative path should not begin with '\(AbsolutePath.root.pathString)'" + } + } +} + +extension AbsolutePath { + /// Returns a relative path that, when concatenated to `base`, yields the + /// callee path itself. If `base` is not an ancestor of the callee, the + /// returned path will begin with one or more `..` path components. + /// + /// Because both paths are absolute, they always have a common ancestor + /// (the root path, if nothing else). Therefore, any path can be made + /// relative to any other path by using a sufficient number of `..` path + /// components. + /// + /// This method is strictly syntactic and does not access the file system + /// in any way. Therefore, it does not take symbolic links into account. + public func relative(to base: AbsolutePath) -> RelativePath { + let result: RelativePath + // Split the two paths into their components. + // FIXME: The is needs to be optimized to avoid unncessary copying. + let pathComps = self.components + let baseComps = base.components + + // It's common for the base to be an ancestor, so try that first. + if pathComps.starts(with: baseComps) { + // Special case, which is a plain path without `..` components. It + // might be an empty path (when self and the base are equal). + let relComps = pathComps.dropFirst(baseComps.count) + #if os(Windows) + let pathString = relComps.joined(separator: "\\") + #else + let pathString = relComps.joined(separator: "/") + #endif + do { + result = try RelativePath(validating: pathString) + } catch { + preconditionFailure("invalid relative path computed from \(pathString)") + } + + } else { + // General case, in which we might well need `..` components to go + // "up" before we can go "down" the directory tree. + var newPathComps = ArraySlice(pathComps) + var newBaseComps = ArraySlice(baseComps) + while newPathComps.prefix(1) == newBaseComps.prefix(1) { + // First component matches, so drop it. + newPathComps = newPathComps.dropFirst() + newBaseComps = newBaseComps.dropFirst() + } + // Now construct a path consisting of as many `..`s as are in the + // `newBaseComps` followed by what remains in `newPathComps`. + var relComps = Array(repeating: "..", count: newBaseComps.count) + relComps.append(contentsOf: newPathComps) + #if os(Windows) + let pathString = relComps.joined(separator: "\\") + #else + let pathString = relComps.joined(separator: "/") + #endif + do { + result = try RelativePath(validating: pathString) + } catch { + preconditionFailure("invalid relative path computed from \(pathString)") + } + } + + assert(AbsolutePath(base, result) == self) + return result + } + + /// Returns true if the path contains the given path. + /// + /// This method is strictly syntactic and does not access the file system + /// in any way. + @available(*, deprecated, renamed: "isDescendantOfOrEqual(to:)") + public func contains(_ other: AbsolutePath) -> Bool { + return isDescendantOfOrEqual(to: other) + } + + /// Returns true if the path is an ancestor of the given path. + /// + /// This method is strictly syntactic and does not access the file system + /// in any way. + public func isAncestor(of descendant: AbsolutePath) -> Bool { + return descendant.components.dropLast().starts(with: self.components) + } + + /// Returns true if the path is an ancestor of or equal to the given path. + /// + /// This method is strictly syntactic and does not access the file system + /// in any way. + public func isAncestorOfOrEqual(to descendant: AbsolutePath) -> Bool { + return descendant.components.starts(with: self.components) + } + + /// Returns true if the path is a descendant of the given path. + /// + /// This method is strictly syntactic and does not access the file system + /// in any way. + public func isDescendant(of ancestor: AbsolutePath) -> Bool { + return self.components.dropLast().starts(with: ancestor.components) + } + + /// Returns true if the path is a descendant of or equal to the given path. + /// + /// This method is strictly syntactic and does not access the file system + /// in any way. + public func isDescendantOfOrEqual(to ancestor: AbsolutePath) -> Bool { + return self.components.starts(with: ancestor.components) + } +} + +extension PathValidationError: CustomNSError { + public var errorUserInfo: [String: Any] { + return [NSLocalizedDescriptionKey: self.description] + } +} + +// FIXME: We should consider whether to merge the two `normalize()` functions. +// The argument for doing so is that some of the code is repeated; the argument +// against doing so is that some of the details are different, and since any +// given path is either absolute or relative, it's wasteful to keep checking +// for whether it's relative or absolute. Possibly we can do both by clever +// use of generics that abstract away the differences. + +/// Fast check for if a string might need normalization. +/// +/// This assumes that paths containing dotfiles are rare: +private func mayNeedNormalization(absolute string: String) -> Bool { + var last = UInt8(ascii: "0") + for c in string.utf8 { + switch c { + case UInt8(ascii: "/") where last == UInt8(ascii: "/"): + return true + case UInt8(ascii: ".") where last == UInt8(ascii: "/"): + return true + default: + break + } + last = c + } + if last == UInt8(ascii: "/") { + return true + } + return false +} + +// MARK: - `AbsolutePath` backwards compatibility, delete after deprecation period. + +extension AbsolutePath { + @_disfavoredOverload + @available(*, deprecated, message: "use throwing `init(validating:)` variant instead") + public init(_ absStr: String) { + try! self.init(validating: absStr) + } + + @_disfavoredOverload + @available(*, deprecated, message: "use throwing `init(validating:relativeTo:)` variant instead") + public init(_ str: String, relativeTo basePath: AbsolutePath) { + try! self.init(validating: str, relativeTo: basePath) + } + + @_disfavoredOverload + @available(*, deprecated, message: "use throwing variant instead") + public init(_ absPath: AbsolutePath, _ relStr: String) { + try! self.init(absPath, validating: relStr) + } +} + +// MARK: - `AbsolutePath` backwards compatibility, delete after deprecation period. + +extension RelativePath { + @_disfavoredOverload + @available(*, deprecated, message: "use throwing variant instead") + public init(_ string: String) { + try! self.init(validating: string) + } +} diff --git a/Sources/CartonHelpers/Basics/PathShims.swift b/Sources/CartonHelpers/Basics/PathShims.swift new file mode 100644 index 00000000..155932f2 --- /dev/null +++ b/Sources/CartonHelpers/Basics/PathShims.swift @@ -0,0 +1,185 @@ +/* + This source file is part of the Swift.org open source project + + Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors + Licensed under Apache License v2.0 with Runtime Library Exception + + See http://swift.org/LICENSE.txt for license information + See http://swift.org/CONTRIBUTORS.txt for Swift project authors + ------------------------------------------------------------------------- + + This file contains temporary shim functions for use during the adoption of + AbsolutePath and RelativePath. The eventual plan is to use the FileSystem + API for all of this, at which time this file will go way. But since it is + important to have a quality FileSystem API, we will evolve it slowly. + + Meanwhile this file bridges the gap to let call sites be as clean as possible, + while making it fairly easy to find those calls later. +*/ + +import Foundation + +/// Returns the "real path" corresponding to `path` by resolving any symbolic links. +public func resolveSymlinks(_ path: AbsolutePath) throws -> AbsolutePath { + #if os(Windows) + let handle: HANDLE = path.pathString.withCString(encodedAs: UTF16.self) { + CreateFileW( + $0, GENERIC_READ, DWORD(FILE_SHARE_READ), nil, + DWORD(OPEN_EXISTING), DWORD(FILE_FLAG_BACKUP_SEMANTICS), nil) + } + if handle == INVALID_HANDLE_VALUE { return path } + defer { CloseHandle(handle) } + return try withUnsafeTemporaryAllocation(of: WCHAR.self, capacity: 261) { + let dwLength: DWORD = + GetFinalPathNameByHandleW( + handle, $0.baseAddress!, DWORD($0.count), + DWORD(FILE_NAME_NORMALIZED)) + let path = String(decodingCString: $0.baseAddress!, as: UTF16.self) + return try AbsolutePath(path) + } + #else + let pathStr = path.pathString + + // FIXME: We can't use FileManager's destinationOfSymbolicLink because + // that implements readlink and not realpath. + if let resultPtr = realpath(pathStr, nil) { + let result = String(cString: resultPtr) + // If `resolved_path` is specified as NULL, then `realpath` uses + // malloc(3) to allocate a buffer [...]. The caller should deallocate + // this buffer using free(3). + // + // String.init(cString:) creates a new string by copying the + // null-terminated UTF-8 data referenced by the given pointer. + resultPtr.deallocate() + // FIXME: We should measure if it's really more efficient to compare the strings first. + return result == pathStr ? path : try AbsolutePath(validating: result) + } + + return path + #endif +} + +/// Creates a new, empty directory at `path`. If needed, any non-existent ancestor paths are also created. If there is +/// already a directory at `path`, this function does nothing (in particular, this is not considered to be an error). +public func makeDirectories(_ path: AbsolutePath) throws { + try FileManager.default.createDirectory( + atPath: path.pathString, withIntermediateDirectories: true, attributes: [:]) +} + +/// Creates a symbolic link at `path` whose content points to `dest`. If `relative` is true, the symlink contents will +/// be a relative path, otherwise it will be absolute. +@available(*, deprecated, renamed: "localFileSystem.createSymbolicLink") +public func createSymlink( + _ path: AbsolutePath, pointingAt dest: AbsolutePath, relative: Bool = true +) throws { + let destString = relative ? dest.relative(to: path.parentDirectory).pathString : dest.pathString + try FileManager.default.createSymbolicLink( + atPath: path.pathString, withDestinationPath: destString) +} + +/// - Returns: a generator that walks the specified directory producing all +/// files therein. If recursively is true will enter any directories +/// encountered recursively. +/// +/// - Warning: directories that cannot be entered due to permission problems +/// are silently ignored. So keep that in mind. +/// +/// - Warning: Symbolic links that point to directories are *not* followed. +/// +/// - Note: setting recursively to `false` still causes the generator to feed +/// you the directory; just not its contents. +public func walk( + _ path: AbsolutePath, + fileSystem: FileSystem = localFileSystem, + recursively: Bool = true +) throws -> RecursibleDirectoryContentsGenerator { + return try RecursibleDirectoryContentsGenerator( + path: path, + fileSystem: fileSystem, + recursionFilter: { _ in recursively }) +} + +/// - Returns: a generator that walks the specified directory producing all +/// files therein. Directories are recursed based on the return value of +/// `recursing`. +/// +/// - Warning: directories that cannot be entered due to permissions problems +/// are silently ignored. So keep that in mind. +/// +/// - Warning: Symbolic links that point to directories are *not* followed. +/// +/// - Note: returning `false` from `recursing` still produces that directory +/// from the generator; just not its contents. +public func walk( + _ path: AbsolutePath, + fileSystem: FileSystem = localFileSystem, + recursing: @escaping (AbsolutePath) -> Bool +) throws -> RecursibleDirectoryContentsGenerator { + return try RecursibleDirectoryContentsGenerator( + path: path, fileSystem: fileSystem, recursionFilter: recursing) +} + +/// Produced by `walk`. +public class RecursibleDirectoryContentsGenerator: IteratorProtocol, Sequence { + private var current: (path: AbsolutePath, iterator: IndexingIterator<[String]>) + private var towalk = [AbsolutePath]() + + private let shouldRecurse: (AbsolutePath) -> Bool + private let fileSystem: FileSystem + + fileprivate init( + path: AbsolutePath, + fileSystem: FileSystem, + recursionFilter: @escaping (AbsolutePath) -> Bool + ) throws { + self.fileSystem = fileSystem + // FIXME: getDirectoryContents should have an iterator version. + current = (path, try fileSystem.getDirectoryContents(path).makeIterator()) + shouldRecurse = recursionFilter + } + + public func next() -> AbsolutePath? { + outer: while true { + guard let entry = current.iterator.next() else { + while !towalk.isEmpty { + // FIXME: This looks inefficient. + let path = towalk.removeFirst() + guard shouldRecurse(path) else { continue } + // Ignore if we can't get content for this path. + guard let current = try? fileSystem.getDirectoryContents(path).makeIterator() else { + continue + } + self.current = (path, current) + continue outer + } + return nil + } + + let path = current.path.appending(component: entry) + if fileSystem.isDirectory(path) && !fileSystem.isSymlink(path) { + towalk.append(path) + } + return path + } + } +} + +extension AbsolutePath { + /// Returns a path suitable for display to the user (if possible, it is made + /// to be relative to the current working directory). + public func prettyPath(cwd: AbsolutePath? = localFileSystem.currentWorkingDirectory) -> String { + guard let dir = cwd else { + // No current directory, display as is. + return self.pathString + } + // FIXME: Instead of string prefix comparison we should add a proper API + // to AbsolutePath to determine ancestry. + if self == dir { + return "." + } else if self.pathString.hasPrefix(dir.pathString + "/") { + return "./" + self.relative(to: dir).pathString + } else { + return self.pathString + } + } +} diff --git a/Sources/CartonHelpers/Basics/Process/Process.swift b/Sources/CartonHelpers/Basics/Process/Process.swift new file mode 100644 index 00000000..a7f23545 --- /dev/null +++ b/Sources/CartonHelpers/Basics/Process/Process.swift @@ -0,0 +1,1521 @@ +/* + This source file is part of the Swift.org open source project + + Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors + Licensed under Apache License v2.0 with Runtime Library Exception + + See http://swift.org/LICENSE.txt for license information + See http://swift.org/CONTRIBUTORS.txt for Swift project authors +*/ + +import Dispatch +import Foundation +import _Concurrency + +import protocol Foundation.CustomNSError +import var Foundation.NSLocalizedDescriptionKey +import class Foundation.NSLock +import class Foundation.ProcessInfo +import class Foundation.Thread + +/// Process result data which is available after process termination. +public struct ProcessResult: CustomStringConvertible, Sendable { + + public enum Error: Swift.Error, Sendable { + /// The output is not a valid UTF8 sequence. + case illegalUTF8Sequence + + /// The process had a non zero exit. + case nonZeroExit(ProcessResult) + + /// The process failed with a `SystemError` (this is used to still provide context on the process that was launched). + case systemError(arguments: [String], underlyingError: Swift.Error) + } + + public enum ExitStatus: Equatable, Sendable { + /// The process was terminated normally with a exit code. + case terminated(code: Int32) + #if os(Windows) + /// The process was terminated abnormally. + case abnormal(exception: UInt32) + #else + /// The process was terminated due to a signal. + case signalled(signal: Int32) + #endif + } + + /// The arguments with which the process was launched. + public let arguments: [String] + + /// The environment with which the process was launched. + public let environmentBlock: ProcessEnvironmentBlock + + @available(*, deprecated, renamed: "env") + public var environment: [String: String] { + [String: String](uniqueKeysWithValues: self.environmentBlock.map { ($0.key.value, $0.value) }) + } + + /// The exit status of the process. + public let exitStatus: ExitStatus + + /// The output bytes of the process. Available only if the process was + /// asked to redirect its output and no stdout output closure was set. + public let output: Result<[UInt8], Swift.Error> + + /// The output bytes of the process. Available only if the process was + /// asked to redirect its output and no stderr output closure was set. + public let stderrOutput: Result<[UInt8], Swift.Error> + + /// Create an instance using a POSIX process exit status code and output result. + /// + /// See `waitpid(2)` for information on the exit status code. + public init( + arguments: [String], + environmentBlock: ProcessEnvironmentBlock, + exitStatusCode: Int32, + normal: Bool, + output: Result<[UInt8], Swift.Error>, + stderrOutput: Result<[UInt8], Swift.Error> + ) { + let exitStatus: ExitStatus + #if os(Windows) + if normal { + exitStatus = .terminated(code: exitStatusCode) + } else { + exitStatus = .abnormal(exception: UInt32(exitStatusCode)) + } + #else + if WIFSIGNALED(exitStatusCode) { + exitStatus = .signalled(signal: WTERMSIG(exitStatusCode)) + } else { + precondition(WIFEXITED(exitStatusCode), "unexpected exit status \(exitStatusCode)") + exitStatus = .terminated(code: WEXITSTATUS(exitStatusCode)) + } + #endif + self.init( + arguments: arguments, environmentBlock: environmentBlock, exitStatus: exitStatus, + output: output, stderrOutput: stderrOutput) + } + + @available( + *, deprecated, + message: "use `init(arguments:environmentBlock:exitStatusCode:output:stderrOutput:)`" + ) + public init( + arguments: [String], + environment: [String: String], + exitStatusCode: Int32, + normal: Bool, + output: Result<[UInt8], Swift.Error>, + stderrOutput: Result<[UInt8], Swift.Error> + ) { + self.init( + arguments: arguments, + environmentBlock: .init(environment), + exitStatusCode: exitStatusCode, + normal: normal, + output: output, + stderrOutput: stderrOutput + ) + } + + /// Create an instance using an exit status and output result. + public init( + arguments: [String], + environmentBlock: ProcessEnvironmentBlock, + exitStatus: ExitStatus, + output: Result<[UInt8], Swift.Error>, + stderrOutput: Result<[UInt8], Swift.Error> + ) { + self.arguments = arguments + self.environmentBlock = environmentBlock + self.output = output + self.stderrOutput = stderrOutput + self.exitStatus = exitStatus + } + + @available( + *, deprecated, message: "use `init(arguments:environmentBlock:exitStatus:output:stderrOutput:)`" + ) + public init( + arguments: [String], + environment: [String: String], + exitStatus: ExitStatus, + output: Result<[UInt8], Swift.Error>, + stderrOutput: Result<[UInt8], Swift.Error> + ) { + self.init( + arguments: arguments, + environmentBlock: .init(environment), + exitStatus: exitStatus, + output: output, + stderrOutput: stderrOutput + ) + } + + /// Converts stdout output bytes to string, assuming they're UTF8. + public func utf8Output() throws -> String { + return String(decoding: try output.get(), as: Unicode.UTF8.self) + } + + /// Converts stderr output bytes to string, assuming they're UTF8. + public func utf8stderrOutput() throws -> String { + return String(decoding: try stderrOutput.get(), as: Unicode.UTF8.self) + } + + public var description: String { + return """ + + """ + } +} + +extension Process: @unchecked Sendable {} + +extension DispatchQueue { + // a shared concurrent queue for running concurrent asynchronous operations + static let processConcurrent = DispatchQueue( + label: "swift.org.swift-tsc.process.concurrent", + attributes: .concurrent + ) +} + +/// Process allows spawning new subprocesses and working with them. +/// +/// Note: This class is thread safe. +public final class Process { + /// Errors when attempting to invoke a process + public enum Error: Swift.Error, Sendable { + /// The program requested to be executed cannot be found on the existing search paths, or is not executable. + case missingExecutableProgram(program: String) + + /// The current OS does not support the workingDirectory API. + case workingDirectoryNotSupported + + /// The stdin could not be opened. + case stdinUnavailable + } + + public enum OutputRedirection { + /// Do not redirect the output + case none + /// Collect stdout and stderr output and provide it back via ProcessResult object. If redirectStderr is true, + /// stderr be redirected to stdout. + case collect(redirectStderr: Bool) + /// Stream stdout and stderr via the corresponding closures. If redirectStderr is true, stderr be redirected to + /// stdout. + case stream(stdout: OutputClosure, stderr: OutputClosure, redirectStderr: Bool) + + /// Default collect OutputRedirection that defaults to not redirect stderr. Provided for API compatibility. + public static let collect: OutputRedirection = .collect(redirectStderr: false) + + /// Default stream OutputRedirection that defaults to not redirect stderr. Provided for API compatibility. + public static func stream(stdout: @escaping OutputClosure, stderr: @escaping OutputClosure) + -> Self + { + return .stream(stdout: stdout, stderr: stderr, redirectStderr: false) + } + + public var redirectsOutput: Bool { + switch self { + case .none: + return false + case .collect, .stream: + return true + } + } + + public var outputClosures: (stdoutClosure: OutputClosure, stderrClosure: OutputClosure)? { + switch self { + case let .stream(stdoutClosure, stderrClosure, _): + return (stdoutClosure: stdoutClosure, stderrClosure: stderrClosure) + case .collect, .none: + return nil + } + } + + public var redirectStderr: Bool { + switch self { + case let .collect(redirectStderr): + return redirectStderr + case let .stream(_, _, redirectStderr): + return redirectStderr + default: + return false + } + } + } + + // process execution mutable state + private enum State { + case idle + case readingOutput(sync: DispatchGroup) + case outputReady(stdout: Result<[UInt8], Swift.Error>, stderr: Result<[UInt8], Swift.Error>) + case complete(ProcessResult) + case failed(Swift.Error) + } + + /// Typealias for process id type. + #if !os(Windows) + public typealias ProcessID = pid_t + #else + public typealias ProcessID = DWORD + #endif + + /// Typealias for stdout/stderr output closure. + public typealias OutputClosure = ([UInt8]) -> Void + + /// Typealias for logging handling closure + public typealias LoggingHandler = (String) -> Void + + private static var _loggingHandler: LoggingHandler? + private static let loggingHandlerLock = NSLock() + + /// Global logging handler. Use with care! preferably use instance level instead of setting one globally. + @available( + *, deprecated, + message: + "use instance level `loggingHandler` passed via `init` instead of setting one globally." + ) + public static var loggingHandler: LoggingHandler? { + get { + Self.loggingHandlerLock.withLock { + self._loggingHandler + } + } + set { + Self.loggingHandlerLock.withLock { + self._loggingHandler = newValue + } + } + } + + public let loggingHandler: LoggingHandler? + + /// The current environment. + @available(*, deprecated, message: "use ProcessEnv.vars instead") + static public var env: [String: String] { + ProcessEnv.vars + } + + /// The arguments to execute. + public let arguments: [String] + + /// The environment with which the process was executed. + @available(*, deprecated, message: "use `environmentBlock` instead") + public var environment: [String: String] { + [String: String](uniqueKeysWithValues: environmentBlock.map { ($0.key.value, $0.value) }) + } + + public let environmentBlock: ProcessEnvironmentBlock + + /// The path to the directory under which to run the process. + public let workingDirectory: AbsolutePath? + + /// The process id of the spawned process, available after the process is launched. + #if os(Windows) + private var _process: Foundation.Process? + public var processID: ProcessID { + return DWORD(_process?.processIdentifier ?? 0) + } + #else + public private(set) var processID = ProcessID() + #endif + + // process execution mutable state + private var state: State = .idle + private let stateLock = NSLock() + + private static let sharedCompletionQueue = DispatchQueue( + label: "org.swift.tools-support-core.process-completion") + private var completionQueue = Process.sharedCompletionQueue + + /// The result of the process execution. Available after process is terminated. + /// This will block while the process is awaiting result + @available(*, deprecated, message: "use waitUntilExit instead") + public var result: ProcessResult? { + return self.stateLock.withLock { + switch self.state { + case .complete(let result): + return result + default: + return nil + } + } + } + + // ideally we would use the state for this, but we need to access it while the waitForExit is locking state + private var _launched = false + private let launchedLock = NSLock() + + public var launched: Bool { + return self.launchedLock.withLock { + return self._launched + } + } + + /// How process redirects its output. + public let outputRedirection: OutputRedirection + + /// Indicates if a new progress group is created for the child process. + private let startNewProcessGroup: Bool + + /// Cache of validated executables. + /// + /// Key: Executable name or path. + /// Value: Path to the executable, if found. + private static var validatedExecutablesMap = [String: AbsolutePath?]() + private static let validatedExecutablesMapLock = NSLock() + + /// Create a new process instance. + /// + /// - Parameters: + /// - arguments: The arguments for the subprocess. + /// - environment: The environment to pass to subprocess. By default the current process environment + /// will be inherited. + /// - workingDirectory: The path to the directory under which to run the process. + /// - outputRedirection: How process redirects its output. Default value is .collect. + /// - startNewProcessGroup: If true, a new progress group is created for the child making it + /// continue running even if the parent is killed or interrupted. Default value is true. + /// - loggingHandler: Handler for logging messages + /// + public init( + arguments: [String], + environmentBlock: ProcessEnvironmentBlock = ProcessEnv.block, + workingDirectory: AbsolutePath, + outputRedirection: OutputRedirection = .collect, + startNewProcessGroup: Bool = true, + loggingHandler: LoggingHandler? = .none + ) { + self.arguments = arguments + self.environmentBlock = environmentBlock + self.workingDirectory = workingDirectory + self.outputRedirection = outputRedirection + self.startNewProcessGroup = startNewProcessGroup + self.loggingHandler = loggingHandler + } + + @_disfavoredOverload + @available(macOS 10.15, *) + @available( + *, deprecated, + renamed: + "init(arguments:environmentBlock:workingDirectory:outputRedirection:startNewProcessGroup:loggingHandler:)" + ) + public convenience init( + arguments: [String], + environment: [String: String] = ProcessEnv.vars, + workingDirectory: AbsolutePath, + outputRedirection: OutputRedirection = .collect, + startNewProcessGroup: Bool = true, + loggingHandler: LoggingHandler? = .none + ) { + self.init( + arguments: arguments, + environmentBlock: .init(environment), + workingDirectory: workingDirectory, + outputRedirection: outputRedirection, + startNewProcessGroup: startNewProcessGroup, + loggingHandler: loggingHandler + ) + } + + /// Create a new process instance. + /// + /// - Parameters: + /// - arguments: The arguments for the subprocess. + /// - environment: The environment to pass to subprocess. By default the current process environment + /// will be inherited. + /// - outputRedirection: How process redirects its output. Default value is .collect. + /// - verbose: If true, launch() will print the arguments of the subprocess before launching it. + /// - startNewProcessGroup: If true, a new progress group is created for the child making it + /// continue running even if the parent is killed or interrupted. Default value is true. + /// - loggingHandler: Handler for logging messages + public init( + arguments: [String], environmentBlock: ProcessEnvironmentBlock = ProcessEnv.block, + outputRedirection: OutputRedirection = .collect, startNewProcessGroup: Bool = true, + loggingHandler: LoggingHandler? = .none + ) { + self.arguments = arguments + self.environmentBlock = environmentBlock + self.workingDirectory = nil + self.outputRedirection = outputRedirection + self.startNewProcessGroup = startNewProcessGroup + self.loggingHandler = loggingHandler + } + + @_disfavoredOverload + @available( + *, deprecated, + renamed: + "init(arguments:environmentBlock:outputRedirection:startNewProcessGroup:loggingHandler:)" + ) + public convenience init( + arguments: [String], + environment: [String: String] = ProcessEnv.vars, + outputRedirection: OutputRedirection = .collect, + startNewProcessGroup: Bool = true, + loggingHandler: LoggingHandler? = .none + ) { + self.init( + arguments: arguments, + environmentBlock: .init(environment), + outputRedirection: outputRedirection, + startNewProcessGroup: startNewProcessGroup, + loggingHandler: loggingHandler + ) + } + + public convenience init( + args: String..., + environmentBlock: ProcessEnvironmentBlock = ProcessEnv.block, + outputRedirection: OutputRedirection = .collect, + loggingHandler: LoggingHandler? = .none + ) { + self.init( + arguments: args, + environmentBlock: environmentBlock, + outputRedirection: outputRedirection, + loggingHandler: loggingHandler + ) + } + + @_disfavoredOverload + @available( + *, deprecated, renamed: "init(args:environmentBlock:outputRedirection:loggingHandler:)" + ) + public convenience init( + args: String..., + environment: [String: String] = ProcessEnv.vars, + outputRedirection: OutputRedirection = .collect, + loggingHandler: LoggingHandler? = .none + ) { + self.init( + arguments: args, + environmentBlock: .init(environment), + outputRedirection: outputRedirection, + loggingHandler: loggingHandler + ) + } + + /// Returns the path of the the given program if found in the search paths. + /// + /// The program can be executable name, relative path or absolute path. + public static func findExecutable( + _ program: String, + workingDirectory: AbsolutePath? = nil + ) -> AbsolutePath? { + if let abs = try? AbsolutePath(validating: program) { + return abs + } + let cwdOpt = workingDirectory ?? localFileSystem.currentWorkingDirectory + // The program might be a multi-component relative path. + if let rel = try? RelativePath(validating: program), rel.components.count > 1 { + if let cwd = cwdOpt { + let abs = AbsolutePath(cwd, rel) + if localFileSystem.isExecutableFile(abs) { + return abs + } + } + return nil + } + // From here on out, the program is an executable name, i.e. it doesn't contain a "/" + let lookup: () -> AbsolutePath? = { + let envSearchPaths = getEnvSearchPaths( + pathString: ProcessEnv.path, + currentWorkingDirectory: cwdOpt + ) + let value = lookupExecutablePath( + filename: program, + currentWorkingDirectory: cwdOpt, + searchPaths: envSearchPaths + ) + return value + } + // This should cover the most common cases, i.e. when the cache is most helpful. + if workingDirectory == localFileSystem.currentWorkingDirectory { + return Process.validatedExecutablesMapLock.withLock { + if let value = Process.validatedExecutablesMap[program] { + return value + } + let value = lookup() + Process.validatedExecutablesMap[program] = value + return value + } + } else { + return lookup() + } + } + + /// Launch the subprocess. Returns a WritableByteStream object that can be used to communicate to the process's + /// stdin. If needed, the stream can be closed using the close() API. Otherwise, the stream will be closed + /// automatically. + @discardableResult + public func launch() throws -> WritableByteStream { + precondition( + arguments.count > 0 && !arguments[0].isEmpty, + "Need at least one argument to launch the process.") + + self.launchedLock.withLock { + precondition(!self._launched, "It is not allowed to launch the same process object again.") + self._launched = true + } + + // Print the arguments if we are verbose. + if let loggingHandler = self.loggingHandler { + loggingHandler(arguments.map({ $0.spm_shellEscaped() }).joined(separator: " ")) + } + + // Look for executable. + let executable = arguments[0] + guard + let executablePath = Process.findExecutable(executable, workingDirectory: workingDirectory) + else { + throw Process.Error.missingExecutableProgram(program: executable) + } + + #if os(Windows) + let process = Foundation.Process() + _process = process + process.arguments = Array(arguments.dropFirst()) // Avoid including the executable URL twice. + if let workingDirectory { + process.currentDirectoryURL = workingDirectory.asURL + } + process.executableURL = executablePath.asURL + process.environment = [String: String]( + uniqueKeysWithValues: environmentBlock.map { ($0.key.value, $0.value) }) + + let stdinPipe = Pipe() + process.standardInput = stdinPipe + + let group = DispatchGroup() + + var stdout: [UInt8] = [] + let stdoutLock = Lock() + + var stderr: [UInt8] = [] + let stderrLock = Lock() + + if outputRedirection.redirectsOutput { + let stdoutPipe = Pipe() + let stderrPipe = Pipe() + + group.enter() + stdoutPipe.fileHandleForReading.readabilityHandler = { (fh: FileHandle) -> Void in + let data = fh.availableData + if data.count == 0 { + stdoutPipe.fileHandleForReading.readabilityHandler = nil + group.leave() + } else { + let contents = data.withUnsafeBytes { [UInt8]($0) } + self.outputRedirection.outputClosures?.stdoutClosure(contents) + stdoutLock.withLock { + stdout += contents + } + } + } + + group.enter() + stderrPipe.fileHandleForReading.readabilityHandler = { (fh: FileHandle) -> Void in + let data = fh.availableData + if data.count == 0 { + stderrPipe.fileHandleForReading.readabilityHandler = nil + group.leave() + } else { + let contents = data.withUnsafeBytes { [UInt8]($0) } + self.outputRedirection.outputClosures?.stderrClosure(contents) + stderrLock.withLock { + stderr += contents + } + } + } + + process.standardOutput = stdoutPipe + process.standardError = stderrPipe + } + + // first set state then start reading threads + let sync = DispatchGroup() + sync.enter() + self.stateLock.withLock { + self.state = .readingOutput(sync: sync) + } + + group.notify(queue: self.completionQueue) { + self.stateLock.withLock { + self.state = .outputReady(stdout: .success(stdout), stderr: .success(stderr)) + } + sync.leave() + } + + try process.run() + return stdinPipe.fileHandleForWriting + #elseif (!canImport(Darwin) || os(macOS)) + // Initialize the spawn attributes. + #if canImport(Darwin) || os(Android) || os(OpenBSD) + var attributes: posix_spawnattr_t? = nil + #else + var attributes = posix_spawnattr_t() + #endif + posix_spawnattr_init(&attributes) + defer { posix_spawnattr_destroy(&attributes) } + + // Unmask all signals. + var noSignals = sigset_t() + sigemptyset(&noSignals) + posix_spawnattr_setsigmask(&attributes, &noSignals) + + // Reset all signals to default behavior. + #if canImport(Darwin) + var mostSignals = sigset_t() + sigfillset(&mostSignals) + sigdelset(&mostSignals, SIGKILL) + sigdelset(&mostSignals, SIGSTOP) + posix_spawnattr_setsigdefault(&attributes, &mostSignals) + #else + // On Linux, this can only be used to reset signals that are legal to + // modify, so we have to take care about the set we use. + var mostSignals = sigset_t() + sigemptyset(&mostSignals) + for i in 1..? + let pendingLock = NSLock() + + let outputClosures = outputRedirection.outputClosures + + // Close the local write end of the output pipe. + try close(fd: outputPipe[1]) + + // Create a thread and start reading the output on it. + group.enter() + let stdoutThread = Thread { [weak self] in + if let readResult = self?.readOutput( + onFD: outputPipe[0], outputClosure: outputClosures?.stdoutClosure) + { + pendingLock.withLock { + if let stderrResult = pending { + self?.stateLock.withLock { + self?.state = .outputReady(stdout: readResult, stderr: stderrResult) + } + } else { + pending = readResult + } + } + group.leave() + } else if let stderrResult = (pendingLock.withLock { pending }) { + // TODO: this is more of an error + self?.stateLock.withLock { + self?.state = .outputReady(stdout: .success([]), stderr: stderrResult) + } + group.leave() + } + } + + // Only schedule a thread for stderr if no redirect was requested. + var stderrThread: Thread? = nil + if !outputRedirection.redirectStderr { + // Close the local write end of the stderr pipe. + try close(fd: stderrPipe[1]) + + // Create a thread and start reading the stderr output on it. + group.enter() + stderrThread = Thread { [weak self] in + if let readResult = self?.readOutput( + onFD: stderrPipe[0], outputClosure: outputClosures?.stderrClosure) + { + pendingLock.withLock { + if let stdoutResult = pending { + self?.stateLock.withLock { + self?.state = .outputReady(stdout: stdoutResult, stderr: readResult) + } + } else { + pending = readResult + } + } + group.leave() + } else if let stdoutResult = (pendingLock.withLock { pending }) { + // TODO: this is more of an error + self?.stateLock.withLock { + self?.state = .outputReady(stdout: stdoutResult, stderr: .success([])) + } + group.leave() + } + } + } else { + pendingLock.withLock { + pending = .success([]) // no stderr in this case + } + } + + // first set state then start reading threads + self.stateLock.withLock { + self.state = .readingOutput(sync: group) + } + + stdoutThread.start() + stderrThread?.start() + } + + return stdinStream + } catch { + throw ProcessResult.Error.systemError(arguments: arguments, underlyingError: error) + } + #else + preconditionFailure("Process spawning is not available") + #endif // POSIX implementation + } + + /// Executes the process I/O state machine, returning the result when finished. + @available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) + @discardableResult + public func waitUntilExit() async throws -> ProcessResult { + try await withCheckedThrowingContinuation { continuation in + DispatchQueue.processConcurrent.async { + self.waitUntilExit(continuation.resume(with:)) + } + } + } + + /// Blocks the calling process until the subprocess finishes execution. + @available(*, noasync) + @discardableResult + public func waitUntilExit() throws -> ProcessResult { + let group = DispatchGroup() + group.enter() + var processResult: Result? + self.waitUntilExit { result in + processResult = result + group.leave() + } + group.wait() + return try processResult.unsafelyUnwrapped.get() + } + + /// Executes the process I/O state machine, calling completion block when finished. + private func waitUntilExit(_ completion: @escaping (Result) -> Void) { + self.stateLock.lock() + switch self.state { + case .idle: + defer { self.stateLock.unlock() } + preconditionFailure("The process is not yet launched.") + case .complete(let result): + self.stateLock.unlock() + completion(.success(result)) + case .failed(let error): + self.stateLock.unlock() + completion(.failure(error)) + case .readingOutput(let sync): + self.stateLock.unlock() + sync.notify(queue: self.completionQueue) { + self.waitUntilExit(completion) + } + case .outputReady(let stdoutResult, let stderrResult): + defer { self.stateLock.unlock() } + // Wait until process finishes execution. + #if os(Windows) + precondition(_process != nil, "The process is not yet launched.") + let p = _process! + p.waitUntilExit() + let exitStatusCode = p.terminationStatus + let normalExit = p.terminationReason == .exit + #else + var exitStatusCode: Int32 = 0 + var result = waitpid(processID, &exitStatusCode, 0) + while result == -1 && errno == EINTR { + result = waitpid(processID, &exitStatusCode, 0) + } + if result == -1 { + self.state = .failed(SystemError.waitpid(errno)) + } + let normalExit = !WIFSIGNALED(result) + #endif + + // Construct the result. + let executionResult = ProcessResult( + arguments: arguments, + environmentBlock: environmentBlock, + exitStatusCode: exitStatusCode, + normal: normalExit, + output: stdoutResult, + stderrOutput: stderrResult + ) + self.state = .complete(executionResult) + self.completionQueue.async { + self.waitUntilExit(completion) + } + } + } + + #if !os(Windows) + /// Reads the given fd and returns its result. + /// + /// Closes the fd before returning. + private func readOutput(onFD fd: Int32, outputClosure: OutputClosure?) -> Result< + [UInt8], Swift.Error + > { + // Read all of the data from the output pipe. + let N = 4096 + var buf = [UInt8](repeating: 0, count: N + 1) + + var out = [UInt8]() + var error: Swift.Error? = nil + loop: while true { + let n = read(fd, &buf, N) + switch n { + case -1: + if errno == EINTR { + continue + } else { + error = SystemError.read(errno) + break loop + } + case 0: + // Close the read end of the output pipe. + // We should avoid closing the read end of the pipe in case + // -1 because the child process may still have content to be + // flushed into the write end of the pipe. If the read end of the + // pipe is closed, then a write will cause a SIGPIPE signal to + // be generated for the calling process. If the calling process is + // ignoring this signal, then write fails with the error EPIPE. + close(fd) + break loop + default: + let data = buf[0.. ProcessResult { + let process = Process( + arguments: arguments, + environmentBlock: environmentBlock, + outputRedirection: .collect, + loggingHandler: loggingHandler + ) + try process.launch() + return try await process.waitUntilExit() + } + + @_disfavoredOverload + @available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) + @available(*, deprecated, renamed: "popen(arguments:environmentBlock:loggingHandler:)") + static public func popen( + arguments: [String], + environment: [String: String] = ProcessEnv.vars, + loggingHandler: LoggingHandler? = .none + ) async throws -> ProcessResult { + try await popen( + arguments: arguments, environmentBlock: .init(environment), loggingHandler: loggingHandler) + } + + /// Execute a subprocess and returns the result when it finishes execution + /// + /// - Parameters: + /// - args: The arguments for the subprocess. + /// - environment: The environment to pass to subprocess. By default the current process environment + /// will be inherited. + /// - loggingHandler: Handler for logging messages + static public func popen( + args: String..., + environmentBlock: ProcessEnvironmentBlock = ProcessEnv.block, + loggingHandler: LoggingHandler? = .none + ) async throws -> ProcessResult { + try await popen( + arguments: args, environmentBlock: environmentBlock, loggingHandler: loggingHandler) + } + + @_disfavoredOverload + @available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) + @available(*, deprecated, renamed: "popen(args:environmentBlock:loggingHandler:)") + static public func popen( + args: String..., + environment: [String: String] = ProcessEnv.vars, + loggingHandler: LoggingHandler? = .none + ) async throws -> ProcessResult { + try await popen( + arguments: args, environmentBlock: .init(environment), loggingHandler: loggingHandler) + } + + /// Execute a subprocess and get its (UTF-8) output if it has a non zero exit. + /// + /// - Parameters: + /// - arguments: The arguments for the subprocess. + /// - environment: The environment to pass to subprocess. By default the current process environment + /// will be inherited. + /// - loggingHandler: Handler for logging messages + /// - Returns: The process output (stdout + stderr). + @discardableResult + static public func checkNonZeroExit( + arguments: [String], + environmentBlock: ProcessEnvironmentBlock = ProcessEnv.block, + loggingHandler: LoggingHandler? = .none + ) async throws -> String { + let result = try await popen( + arguments: arguments, environmentBlock: environmentBlock, loggingHandler: loggingHandler) + // Throw if there was a non zero termination. + guard result.exitStatus == .terminated(code: 0) else { + throw ProcessResult.Error.nonZeroExit(result) + } + return try result.utf8Output() + } + + @_disfavoredOverload + @available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) + @available(*, deprecated, renamed: "checkNonZeroExit(arguments:environmentBlock:loggingHandler:)") + @discardableResult + static public func checkNonZeroExit( + arguments: [String], + environment: [String: String] = ProcessEnv.vars, + loggingHandler: LoggingHandler? = .none + ) async throws -> String { + try await checkNonZeroExit( + arguments: arguments, environmentBlock: .init(environment), loggingHandler: loggingHandler) + } + + /// Execute a subprocess and get its (UTF-8) output if it has a non zero exit. + /// + /// - Parameters: + /// - args: The arguments for the subprocess. + /// - environment: The environment to pass to subprocess. By default the current process environment + /// will be inherited. + /// - loggingHandler: Handler for logging messages + /// - Returns: The process output (stdout + stderr). + @discardableResult + static public func checkNonZeroExit( + args: String..., + environmentBlock: ProcessEnvironmentBlock = ProcessEnv.block, + loggingHandler: LoggingHandler? = .none + ) async throws -> String { + try await checkNonZeroExit( + arguments: args, environmentBlock: environmentBlock, loggingHandler: loggingHandler) + } + + @_disfavoredOverload + @available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) + @available(*, deprecated, renamed: "checkNonZeroExit(args:environmentBlock:loggingHandler:)") + @discardableResult + static public func checkNonZeroExit( + args: String..., + environment: [String: String] = ProcessEnv.vars, + loggingHandler: LoggingHandler? = .none + ) async throws -> String { + try await checkNonZeroExit( + arguments: args, environmentBlock: .init(environment), loggingHandler: loggingHandler) + } +} + +extension Process { + /// Execute a subprocess and calls completion block when it finishes execution + /// + /// - Parameters: + /// - arguments: The arguments for the subprocess. + /// - environment: The environment to pass to subprocess. By default the current process environment + /// will be inherited. + /// - loggingHandler: Handler for logging messages + /// - queue: Queue to use for callbacks + /// - completion: A completion handler to return the process result + // #if compiler(>=5.8) + // @available(*, noasync) + // #endif + static public func popen( + arguments: [String], + environmentBlock: ProcessEnvironmentBlock = ProcessEnv.block, + loggingHandler: LoggingHandler? = .none, + queue: DispatchQueue? = nil, + completion: @escaping (Result) -> Void + ) { + let completionQueue = queue ?? Self.sharedCompletionQueue + + do { + let process = Process( + arguments: arguments, + environmentBlock: environmentBlock, + outputRedirection: .collect, + loggingHandler: loggingHandler + ) + process.completionQueue = completionQueue + try process.launch() + process.waitUntilExit(completion) + } catch { + completionQueue.async { + completion(.failure(error)) + } + } + } + + @_disfavoredOverload + @available( + *, deprecated, renamed: "popen(arguments:environmentBlock:loggingHandler:queue:completion:)" + ) + static public func popen( + arguments: [String], + environment: [String: String] = ProcessEnv.vars, + loggingHandler: LoggingHandler? = .none, + queue: DispatchQueue? = nil, + completion: @escaping (Result) -> Void + ) { + popen( + arguments: arguments, + environmentBlock: .init(environment), + loggingHandler: loggingHandler, + queue: queue, + completion: completion + ) + } + + /// Execute a subprocess and block until it finishes execution + /// + /// - Parameters: + /// - arguments: The arguments for the subprocess. + /// - environment: The environment to pass to subprocess. By default the current process environment + /// will be inherited. + /// - loggingHandler: Handler for logging messages + /// - Returns: The process result. + // #if compiler(>=5.8) + // @available(*, noasync) + // #endif + @discardableResult + static public func popen( + arguments: [String], + environmentBlock: ProcessEnvironmentBlock = ProcessEnv.block, + loggingHandler: LoggingHandler? = .none + ) throws -> ProcessResult { + let process = Process( + arguments: arguments, + environmentBlock: environmentBlock, + outputRedirection: .collect, + loggingHandler: loggingHandler + ) + try process.launch() + return try process.waitUntilExit() + } + + @_disfavoredOverload + @available(*, deprecated, renamed: "popen(arguments:environmentBlock:loggingHandler:)") + @discardableResult + static public func popen( + arguments: [String], + environment: [String: String] = ProcessEnv.vars, + loggingHandler: LoggingHandler? = .none + ) throws -> ProcessResult { + try popen( + arguments: arguments, environmentBlock: .init(environment), loggingHandler: loggingHandler) + } + + /// Execute a subprocess and block until it finishes execution + /// + /// - Parameters: + /// - args: The arguments for the subprocess. + /// - environment: The environment to pass to subprocess. By default the current process environment + /// will be inherited. + /// - loggingHandler: Handler for logging messages + /// - Returns: The process result. + // #if compiler(>=5.8) + // @available(*, noasync) + // #endif + @discardableResult + static public func popen( + args: String..., + environmentBlock: ProcessEnvironmentBlock = ProcessEnv.block, + loggingHandler: LoggingHandler? = .none + ) throws -> ProcessResult { + return try Process.popen( + arguments: args, environmentBlock: environmentBlock, loggingHandler: loggingHandler) + } + + @_disfavoredOverload + @available(*, deprecated, renamed: "popen(args:environmentBlock:loggingHandler:)") + @discardableResult + static public func popen( + args: String..., + environment: [String: String] = ProcessEnv.vars, + loggingHandler: LoggingHandler? = .none + ) throws -> ProcessResult { + return try Process.popen( + arguments: args, environmentBlock: .init(environment), loggingHandler: loggingHandler) + } + + /// Execute a subprocess and get its (UTF-8) output if it has a non zero exit. + /// + /// - Parameters: + /// - arguments: The arguments for the subprocess. + /// - environment: The environment to pass to subprocess. By default the current process environment + /// will be inherited. + /// - loggingHandler: Handler for logging messages + /// - Returns: The process output (stdout + stderr). + // #if compiler(>=5.8) + // @available(*, noasync) + // #endif + @discardableResult + static public func checkNonZeroExit( + arguments: [String], + environmentBlock: ProcessEnvironmentBlock = ProcessEnv.block, + loggingHandler: LoggingHandler? = .none + ) throws -> String { + let process = Process( + arguments: arguments, + environmentBlock: environmentBlock, + outputRedirection: .collect, + loggingHandler: loggingHandler + ) + try process.launch() + let result = try process.waitUntilExit() + // Throw if there was a non zero termination. + guard result.exitStatus == .terminated(code: 0) else { + throw ProcessResult.Error.nonZeroExit(result) + } + return try result.utf8Output() + } + + @_disfavoredOverload + @available(*, deprecated, renamed: "checkNonZeroExit(arguments:environmentBlock:loggingHandler:)") + @discardableResult + static public func checkNonZeroExit( + arguments: [String], + environment: [String: String] = ProcessEnv.vars, + loggingHandler: LoggingHandler? = .none + ) throws -> String { + try checkNonZeroExit( + arguments: arguments, environmentBlock: .init(environment), loggingHandler: loggingHandler) + } + + /// Execute a subprocess and get its (UTF-8) output if it has a non zero exit. + /// + /// - Parameters: + /// - arguments: The arguments for the subprocess. + /// - environment: The environment to pass to subprocess. By default the current process environment + /// will be inherited. + /// - loggingHandler: Handler for logging messages + /// - Returns: The process output (stdout + stderr). + // #if compiler(>=5.8) + // @available(*, noasync) + // #endif + @discardableResult + static public func checkNonZeroExit( + args: String..., + environmentBlock: ProcessEnvironmentBlock = ProcessEnv.block, + loggingHandler: LoggingHandler? = .none + ) throws -> String { + return try checkNonZeroExit( + arguments: args, environmentBlock: environmentBlock, loggingHandler: loggingHandler) + } + + @_disfavoredOverload + @available(*, deprecated, renamed: "checkNonZeroExit(args:environmentBlock:loggingHandler:)") + @discardableResult + static public func checkNonZeroExit( + args: String..., + environment: [String: String] = ProcessEnv.vars, + loggingHandler: LoggingHandler? = .none + ) throws -> String { + try checkNonZeroExit( + arguments: args, environmentBlock: .init(environment), loggingHandler: loggingHandler) + } +} + +extension Process: Hashable { + public func hash(into hasher: inout Hasher) { + hasher.combine(ObjectIdentifier(self)) + } + + public static func == (lhs: Process, rhs: Process) -> Bool { + ObjectIdentifier(lhs) == ObjectIdentifier(rhs) + } +} + +// MARK: - Private helpers + +#if !os(Windows) + #if canImport(Darwin) + private typealias swiftpm_posix_spawn_file_actions_t = posix_spawn_file_actions_t? + #else + private typealias swiftpm_posix_spawn_file_actions_t = posix_spawn_file_actions_t + #endif + + private func WIFEXITED(_ status: Int32) -> Bool { + return _WSTATUS(status) == 0 + } + + private func _WSTATUS(_ status: Int32) -> Int32 { + return status & 0x7f + } + + private func WIFSIGNALED(_ status: Int32) -> Bool { + return (_WSTATUS(status) != 0) && (_WSTATUS(status) != 0x7f) + } + + private func WEXITSTATUS(_ status: Int32) -> Int32 { + return (status >> 8) & 0xff + } + + private func WTERMSIG(_ status: Int32) -> Int32 { + return status & 0x7f + } + + /// Open the given pipe. + private func open(pipe _pipe: inout [Int32]) throws { + let rv = pipe(&_pipe) + guard rv == 0 else { + throw SystemError.pipe(rv) + } + } + + /// Close the given fd. + private func close(fd: Int32) throws { + func innerClose(_ fd: inout Int32) throws { + let rv = close(fd) + guard rv == 0 else { + throw SystemError.close(rv) + } + } + var innerFd = fd + try innerClose(&innerFd) + } + + extension Process.Error: CustomStringConvertible { + public var description: String { + switch self { + case .missingExecutableProgram(let program): + return "could not find executable for '\(program)'" + case .workingDirectoryNotSupported: + return "workingDirectory is not supported in this platform" + case .stdinUnavailable: + return "could not open stdin on this platform" + } + } + } + + extension Process.Error: CustomNSError { + public var errorUserInfo: [String: Any] { + return [NSLocalizedDescriptionKey: self.description] + } + } + +#endif + +extension ProcessResult.Error: CustomStringConvertible { + public var description: String { + switch self { + case .systemError(let arguments, let underlyingError): + return "error while executing `\(arguments.joined(separator: " "))`: \(underlyingError)" + case .illegalUTF8Sequence: + return "illegal UTF8 sequence output" + case .nonZeroExit(let result): + let stream = BufferedOutputByteStream() + switch result.exitStatus { + case .terminated(let code): + stream.send("terminated(\(code)): ") + #if os(Windows) + case .abnormal(let exception): + stream.send("abnormal(\(exception)): ") + #else + case .signalled(let signal): + stream.send("signalled(\(signal)): ") + #endif + } + + // Strip sandbox information from arguments to keep things pretty. + var args = result.arguments + // This seems a little fragile. + if args.first == "sandbox-exec", args.count > 3 { + args = args.suffix(from: 3).map({ $0 }) + } + stream.send(args.map({ $0.spm_shellEscaped() }).joined(separator: " ")) + + // Include the output, if present. + if let output = try? result.utf8Output() + result.utf8stderrOutput() { + // We indent the output to keep it visually separated from everything else. + let indentation = " " + stream.send(" output:\n").send(indentation).send( + output.replacingOccurrences(of: "\n", with: "\n" + indentation)) + if !output.hasSuffix("\n") { + stream.send("\n") + } + } + + return stream.bytes.description + } + } +} + +#if os(Windows) + extension FileHandle: WritableByteStream { + public var position: Int { + return Int(offsetInFile) + } + + public func write(_ byte: UInt8) { + write(Data([byte])) + } + + public func write(_ bytes: C) where C.Element == UInt8 { + write(Data(bytes)) + } + + public func flush() { + synchronizeFile() + } + } +#endif + +extension Process { + @available(*, deprecated) + fileprivate static func logToStdout(_ message: String) { + stdoutStream.send(message).send("\n") + stdoutStream.flush() + } +} diff --git a/Sources/CartonHelpers/Basics/Process/ProcessEnv.swift b/Sources/CartonHelpers/Basics/Process/ProcessEnv.swift new file mode 100644 index 00000000..17ca15e7 --- /dev/null +++ b/Sources/CartonHelpers/Basics/Process/ProcessEnv.swift @@ -0,0 +1,107 @@ +/* + This source file is part of the Swift.org open source project + + Copyright (c) 2019 Apple Inc. and the Swift project authors + Licensed under Apache License v2.0 with Runtime Library Exception + + See http://swift.org/LICENSE.txt for license information + See http://swift.org/CONTRIBUTORS.txt for Swift project authors +*/ + +import Foundation + +public struct ProcessEnvironmentKey { + public let value: String + public init(_ value: String) { + self.value = value + } +} + +extension ProcessEnvironmentKey: Encodable { + public func encode(to encoder: any Encoder) throws { + var container = encoder.singleValueContainer() + try container.encode(self.value) + } +} + +extension ProcessEnvironmentKey: Decodable { + public init(from decoder: any Decoder) throws { + let container = try decoder.singleValueContainer() + self.value = try container.decode(String.self) + } +} + +extension ProcessEnvironmentKey: Equatable { + public static func == (_ lhs: Self, _ rhs: Self) -> Bool { + #if os(Windows) + // TODO: is this any faster than just doing a lowercased conversion and compare? + return lhs.value.caseInsensitiveCompare(rhs.value) == .orderedSame + #else + return lhs.value == rhs.value + #endif + } +} + +extension ProcessEnvironmentKey: ExpressibleByStringLiteral { + public init(stringLiteral value: String) { + self.init(value) + } +} + +extension ProcessEnvironmentKey: Hashable { + public func hash(into hasher: inout Hasher) { + #if os(Windows) + self.value.lowercased().hash(into: &hasher) + #else + self.value.hash(into: &hasher) + #endif + } +} + +extension ProcessEnvironmentKey: Sendable {} + +public typealias ProcessEnvironmentBlock = [ProcessEnvironmentKey: String] +extension ProcessEnvironmentBlock { + public init(_ dictionary: [String: String]) { + self.init(uniqueKeysWithValues: dictionary.map { (ProcessEnvironmentKey($0.key), $0.value) }) + } +} + +extension ProcessEnvironmentBlock: Sendable {} + +/// Provides functionality related a process's environment. +public enum ProcessEnv { + + @available(*, deprecated, message: "Use `block` instead") + public static var vars: [String: String] { + [String: String](uniqueKeysWithValues: _vars.map { ($0.key.value, $0.value) }) + } + + /// Returns a dictionary containing the current environment. + public static var block: ProcessEnvironmentBlock { _vars } + + private static var _vars = ProcessEnvironmentBlock( + uniqueKeysWithValues: ProcessInfo.processInfo.environment.map { + (ProcessEnvironmentBlock.Key($0.key), $0.value) + } + ) + + /// Invalidate the cached env. + public static func invalidateEnv() { + _vars = ProcessEnvironmentBlock( + uniqueKeysWithValues: ProcessInfo.processInfo.environment.map { + (ProcessEnvironmentKey($0.key), $0.value) + } + ) + } + + /// `PATH` variable in the process's environment (`Path` under Windows). + public static var path: String? { + return block["PATH"] + } + + /// The current working directory of the process. + public static var cwd: AbsolutePath? { + return localFileSystem.currentWorkingDirectory + } +} diff --git a/Sources/CartonHelpers/Basics/README.md b/Sources/CartonHelpers/Basics/README.md new file mode 100644 index 00000000..688194a9 --- /dev/null +++ b/Sources/CartonHelpers/Basics/README.md @@ -0,0 +1,3 @@ +Source files under this directory are derived from the [swift-tools-support-core](https://github.com/apple/swift-tools-support-core) package. The original source files are located in the `Sources/TSCBasic` directory of the swift-tools-support-core repository and are used under the terms of the [Apache License, Version 2.0 with LLVM Exceptions](https://github.com/apple/swift-tools-support-core/blob/main/LICENSE.txt). + +We vend the source files in this directory to avoid bringing in the entire swift-tools-support-core package as a dependency. diff --git a/Sources/CartonHelpers/Basics/StringConversions.swift b/Sources/CartonHelpers/Basics/StringConversions.swift new file mode 100644 index 00000000..5478fed7 --- /dev/null +++ b/Sources/CartonHelpers/Basics/StringConversions.swift @@ -0,0 +1,126 @@ +/* + This source file is part of the Swift.org open source project + + Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors + Licensed under Apache License v2.0 with Runtime Library Exception + + See http://swift.org/LICENSE.txt for license information + See http://swift.org/CONTRIBUTORS.txt for Swift project authors +*/ + +/// Check if the given code unit needs shell escaping. +// +/// - Parameters: +/// - codeUnit: The code unit to be checked. +/// +/// - Returns: True if shell escaping is not needed. +private func inShellAllowlist(_ codeUnit: UInt8) -> Bool { + #if os(Windows) + if codeUnit == UInt8(ascii: "\\") { + return true + } + #endif + switch codeUnit { + case UInt8(ascii: "a")...UInt8(ascii: "z"), + UInt8(ascii: "A")...UInt8(ascii: "Z"), + UInt8(ascii: "0")...UInt8(ascii: "9"), + UInt8(ascii: "-"), + UInt8(ascii: "_"), + UInt8(ascii: "/"), + UInt8(ascii: ":"), + UInt8(ascii: "@"), + UInt8(ascii: "%"), + UInt8(ascii: "+"), + UInt8(ascii: "="), + UInt8(ascii: "."), + UInt8(ascii: ","): + return true + default: + return false + } +} + +extension String { + + /// Creates a shell escaped string. If the string does not need escaping, returns the original string. + /// Otherwise escapes using single quotes on Unix and double quotes on Windows. For example: + /// hello -> hello, hello$world -> 'hello$world', input A -> 'input A' + /// + /// - Returns: Shell escaped string. + public func spm_shellEscaped() -> String { + + // If all the characters in the string are in the allow list then no need to escape. + guard let pos = utf8.firstIndex(where: { !inShellAllowlist($0) }) else { + return self + } + + #if os(Windows) + let quoteCharacter: Character = "\"" + let escapedQuoteCharacter = "\"\"" + #else + let quoteCharacter: Character = "'" + let escapedQuoteCharacter = "'\\''" + #endif + // If there are no quote characters then we can just wrap the string within the quotes. + guard let quotePos = utf8[pos...].firstIndex(of: quoteCharacter.asciiValue!) else { + return String(quoteCharacter) + self + String(quoteCharacter) + } + + // Otherwise iterate and escape all the single quotes. + var newString = String(quoteCharacter) + String(self[.. String { + var result = "" + + for (i, item) in enumerated() { + // Add the separator, if necessary. + if i == count - 1 { + switch count { + case 1: + break + case 2: + result += " \(type.rawValue) " + default: + result += ", \(type.rawValue) " + } + } else if i != 0 { + result += ", " + } + + result += item + } + + return result + } +} diff --git a/Sources/CartonHelpers/Basics/TerminalController.swift b/Sources/CartonHelpers/Basics/TerminalController.swift new file mode 100644 index 00000000..1b3368fb --- /dev/null +++ b/Sources/CartonHelpers/Basics/TerminalController.swift @@ -0,0 +1,211 @@ +/* + This source file is part of the Swift.org open source project + + Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors + Licensed under Apache License v2.0 with Runtime Library Exception + + See http://swift.org/LICENSE.txt for license information + See http://swift.org/CONTRIBUTORS.txt for Swift project authors +*/ + +import Foundation + +#if os(Windows) + import CRT +#endif + +/// A class to have better control on tty output streams: standard output and standard error. +/// Allows operations like cursor movement and colored text output on tty. +public final class TerminalController { + + /// The type of terminal. + public enum TerminalType { + /// The terminal is a TTY. + case tty + + /// TERM environment variable is set to "dumb". + case dumb + + /// The terminal is a file stream. + case file + } + + /// Terminal color choices. + public enum Color { + case noColor + + case red + case green + case yellow + case cyan + + case white + case black + case gray + + /// Returns the color code which can be prefixed on a string to display it in that color. + fileprivate var string: String { + switch self { + case .noColor: return "" + case .red: return "\u{001B}[31m" + case .green: return "\u{001B}[32m" + case .yellow: return "\u{001B}[33m" + case .cyan: return "\u{001B}[36m" + case .white: return "\u{001B}[37m" + case .black: return "\u{001B}[30m" + case .gray: return "\u{001B}[30;1m" + } + } + + @available(*, deprecated, renamed: "gray") + public static var grey: Self { .gray } + } + + /// Pointer to output stream to operate on. + private var stream: WritableByteStream + + /// Width of the terminal. + public var width: Int { + // Determine the terminal width otherwise assume a default. + if let terminalWidth = TerminalController.terminalWidth(), terminalWidth > 0 { + return terminalWidth + } else { + return 80 + } + } + + /// Code to clear the line on a tty. + private let clearLineString = "\u{001B}[2K" + + /// Code to end any currently active wrapping. + private let resetString = "\u{001B}[0m" + + /// Code to make string bold. + private let boldString = "\u{001B}[1m" + + /// Constructs the instance if the stream is a tty. + public init?(stream: WritableByteStream) { + let realStream = (stream as? ThreadSafeOutputByteStream)?.stream ?? stream + + // Make sure it is a file stream and it is tty. + guard let fileStream = realStream as? LocalFileOutputByteStream, + TerminalController.isTTY(fileStream) + else { + return nil + } + + #if os(Windows) + // Enable VT100 interpretation + let hOut = GetStdHandle(STD_OUTPUT_HANDLE) + var dwMode: DWORD = 0 + + guard hOut != INVALID_HANDLE_VALUE else { return nil } + guard GetConsoleMode(hOut, &dwMode) else { return nil } + + dwMode |= DWORD(ENABLE_VIRTUAL_TERMINAL_PROCESSING) + guard SetConsoleMode(hOut, dwMode) else { return nil } + #endif + self.stream = stream + } + + /// Checks if passed file stream is tty. + public static func isTTY(_ stream: LocalFileOutputByteStream) -> Bool { + return terminalType(stream) == .tty + } + + /// Computes the terminal type of the stream. + public static func terminalType(_ stream: LocalFileOutputByteStream) -> TerminalType { + #if !os(Windows) + if ProcessEnv.block["TERM"] == "dumb" { + return .dumb + } + #endif + let isTTY = isatty(fileno(stream.filePointer)) != 0 + return isTTY ? .tty : .file + } + + /// Tries to get the terminal width first using COLUMNS env variable and + /// if that fails ioctl method testing on stdout stream. + /// + /// - Returns: Current width of terminal if it was determinable. + public static func terminalWidth() -> Int? { + #if os(Windows) + var csbi: CONSOLE_SCREEN_BUFFER_INFO = CONSOLE_SCREEN_BUFFER_INFO() + if !GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi) { + // GetLastError() + return nil + } + return Int(csbi.srWindow.Right - csbi.srWindow.Left) + 1 + #else + // Try to get from environment. + if let columns = ProcessEnv.block["COLUMNS"], let width = Int(columns) { + return width + } + + // Try determining using ioctl. + // Following code does not compile on ppc64le well. TIOCGWINSZ is + // defined in system ioctl.h file which needs to be used. This is + // a temporary arrangement and needs to be fixed. + #if !arch(powerpc64le) + var ws = winsize() + #if os(OpenBSD) + let tiocgwinsz = 0x4008_7468 + let err = ioctl(1, UInt(tiocgwinsz), &ws) + #else + let err = ioctl(1, UInt(TIOCGWINSZ), &ws) + #endif + if err == 0 { + return Int(ws.ws_col) + } + #endif + return nil + #endif + } + + /// Flushes the stream. + public func flush() { + stream.flush() + } + + /// Clears the current line and moves the cursor to beginning of the line.. + public func clearLine() { + stream.send(clearLineString).send("\r") + flush() + } + + /// Moves the cursor y columns up. + public func moveCursor(up: Int) { + stream.send("\u{001B}[\(up)A") + flush() + } + + /// Writes a string to the stream. + public func write(_ string: String, inColor color: Color = .noColor, bold: Bool = false) { + writeWrapped(string, inColor: color, bold: bold, stream: stream) + flush() + } + + /// Inserts a new line character into the stream. + public func endLine() { + stream.send("\n") + flush() + } + + /// Wraps the string into the color mentioned. + public func wrap(_ string: String, inColor color: Color, bold: Bool = false) -> String { + let stream = BufferedOutputByteStream() + writeWrapped(string, inColor: color, bold: bold, stream: stream) + return stream.bytes.description + } + + private func writeWrapped( + _ string: String, inColor color: Color, bold: Bool = false, stream: WritableByteStream + ) { + // Don't wrap if string is empty or color is no color. + guard !string.isEmpty && color != .noColor else { + stream.send(string) + return + } + stream.send(color.string).send(bold ? boldString : "").send(string).send(resetString) + } +} diff --git a/Sources/CartonHelpers/Basics/WritableByteStream.swift b/Sources/CartonHelpers/Basics/WritableByteStream.swift new file mode 100644 index 00000000..f6d07d9a --- /dev/null +++ b/Sources/CartonHelpers/Basics/WritableByteStream.swift @@ -0,0 +1,837 @@ +/* + This source file is part of the Swift.org open source project + + Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors + Licensed under Apache License v2.0 with Runtime Library Exception + + See http://swift.org/LICENSE.txt for license information + See http://swift.org/CONTRIBUTORS.txt for Swift project authors +*/ + +import Dispatch + +/// Convert an integer in 0..<16 to its hexadecimal ASCII character. +private func hexdigit(_ value: UInt8) -> UInt8 { + return value < 10 ? (0x30 + value) : (0x41 + value - 10) +} + +/// Describes a type which can be written to a byte stream. +public protocol ByteStreamable { + func write(to stream: WritableByteStream) +} + +/// An output byte stream. +/// +/// This protocol is designed to be able to support efficient streaming to +/// different output destinations, e.g., a file or an in memory buffer. This is +/// loosely modeled on LLVM's llvm::raw_ostream class. +/// +/// The stream is generally used in conjunction with the `appending` function. +/// For example: +/// +/// let stream = BufferedOutputByteStream() +/// stream.appending("Hello, world!") +/// +/// would write the UTF8 encoding of "Hello, world!" to the stream. +/// +/// The stream accepts a number of custom formatting operators which are defined +/// in the `Format` struct (used for namespacing purposes). For example: +/// +/// let items = ["hello", "world"] +/// stream.appending(Format.asSeparatedList(items, separator: " ")) +/// +/// would write each item in the list to the stream, separating them with a +/// space. +public protocol WritableByteStream: AnyObject, TextOutputStream, Closable { + /// The current offset within the output stream. + var position: Int { get } + + /// Write an individual byte to the buffer. + func write(_ byte: UInt8) + + /// Write a collection of bytes to the buffer. + func write(_ bytes: C) where C.Element == UInt8 + + /// Flush the stream's buffer. + func flush() +} + +// Default noop implementation of close to avoid source-breaking downstream dependents with the addition of the close +// API. +extension WritableByteStream { + public func close() throws {} +} + +// Public alias to the old name to not introduce API compatibility. +public typealias OutputByteStream = WritableByteStream + +#if os(Android) || canImport(Musl) + public typealias FILEPointer = OpaquePointer +#else + public typealias FILEPointer = UnsafeMutablePointer +#endif + +extension WritableByteStream { + /// Write a sequence of bytes to the buffer. + public func write(sequence: S) where S.Iterator.Element == UInt8 { + // Iterate the sequence and append byte by byte since sequence's append + // is not performant anyway. + for byte in sequence { + write(byte) + } + } + + /// Write a string to the buffer (as UTF8). + public func write(_ string: String) { + // FIXME(performance): Use `string.utf8._copyContents(initializing:)`. + write(string.utf8) + } + + /// Write a string (as UTF8) to the buffer, with escaping appropriate for + /// embedding within a JSON document. + /// + /// - Note: This writes the literal data applying JSON string escaping, but + /// does not write any other characters (like the quotes that would surround + /// a JSON string). + public func writeJSONEscaped(_ string: String) { + // See RFC7159 for reference: https://tools.ietf.org/html/rfc7159 + for character in string.utf8 { + // Handle string escapes; we use constants here to directly match the RFC. + switch character { + // Literal characters. + case 0x20...0x21, 0x23...0x5B, 0x5D...0xFF: + write(character) + + // Single-character escaped characters. + case 0x22: // '"' + write(0x5C) // '\' + write(0x22) // '"' + case 0x5C: // '\\' + write(0x5C) // '\' + write(0x5C) // '\' + case 0x08: // '\b' + write(0x5C) // '\' + write(0x62) // 'b' + case 0x0C: // '\f' + write(0x5C) // '\' + write(0x66) // 'b' + case 0x0A: // '\n' + write(0x5C) // '\' + write(0x6E) // 'n' + case 0x0D: // '\r' + write(0x5C) // '\' + write(0x72) // 'r' + case 0x09: // '\t' + write(0x5C) // '\' + write(0x74) // 't' + + // Multi-character escaped characters. + default: + write(0x5C) // '\' + write(0x75) // 'u' + write(hexdigit(0)) + write(hexdigit(0)) + write(hexdigit(character >> 4)) + write(hexdigit(character & 0xF)) + } + } + } + + // MARK: helpers that return `self` + + // FIXME: This override shouldn't be necesary but removing it causes a 30% performance regression. This problem is + // tracked by the following bug: https://bugs.swift.org/browse/SR-8535 + @discardableResult + public func send(_ value: ArraySlice) -> WritableByteStream { + value.write(to: self) + return self + } + + @discardableResult + public func send(_ value: ByteStreamable) -> WritableByteStream { + value.write(to: self) + return self + } + + @discardableResult + public func send(_ value: CustomStringConvertible) -> WritableByteStream { + value.description.write(to: self) + return self + } + + @discardableResult + public func send(_ value: ByteStreamable & CustomStringConvertible) -> WritableByteStream { + value.write(to: self) + return self + } +} + +/// The `WritableByteStream` base class. +/// +/// This class provides a base and efficient implementation of the `WritableByteStream` +/// protocol. It can not be used as is-as subclasses as several functions need to be +/// implemented in subclasses. +public class _WritableByteStreamBase: WritableByteStream { + /// If buffering is enabled + @usableFromInline let _buffered: Bool + + /// The data buffer. + /// - Note: Minimum Buffer size should be one. + @usableFromInline var _buffer: [UInt8] + + /// Default buffer size of the data buffer. + private static let bufferSize = 1024 + + /// Queue to protect mutating operation. + fileprivate let queue = DispatchQueue(label: "org.swift.swiftpm.basic.stream") + + init(buffered: Bool) { + self._buffered = buffered + self._buffer = [] + + // When not buffered we still reserve 1 byte, as it is used by the + // by the single byte write() variant. + self._buffer.reserveCapacity(buffered ? _WritableByteStreamBase.bufferSize : 1) + } + + // MARK: Data Access API + + /// The current offset within the output stream. + public var position: Int { + return _buffer.count + } + + /// Currently available buffer size. + @usableFromInline var _availableBufferSize: Int { + return _buffer.capacity - _buffer.count + } + + /// Clears the buffer maintaining current capacity. + @usableFromInline func _clearBuffer() { + _buffer.removeAll(keepingCapacity: true) + } + + // MARK: Data Output API + + public final func flush() { + writeImpl(ArraySlice(_buffer)) + _clearBuffer() + flushImpl() + } + + @usableFromInline func flushImpl() { + // Do nothing. + } + + public final func close() throws { + try closeImpl() + } + + @usableFromInline func closeImpl() throws { + fatalError("Subclasses must implement this") + } + + @usableFromInline func writeImpl(_ bytes: C) where C.Iterator.Element == UInt8 { + fatalError("Subclasses must implement this") + } + + @usableFromInline func writeImpl(_ bytes: ArraySlice) { + fatalError("Subclasses must implement this") + } + + /// Write an individual byte to the buffer. + public final func write(_ byte: UInt8) { + guard _buffered else { + _buffer.append(byte) + writeImpl(ArraySlice(_buffer)) + flushImpl() + _clearBuffer() + return + } + + // If buffer is full, write and clear it. + if _availableBufferSize == 0 { + writeImpl(ArraySlice(_buffer)) + _clearBuffer() + } + + // This will need to change change if we ever have unbuffered stream. + precondition(_availableBufferSize > 0) + _buffer.append(byte) + } + + /// Write a collection of bytes to the buffer. + @inlinable public final func write(_ bytes: C) where C.Element == UInt8 { + guard _buffered else { + if let b = bytes as? ArraySlice { + // Fast path for unbuffered ArraySlice + writeImpl(b) + } else if let b = bytes as? [UInt8] { + // Fast path for unbuffered Array + writeImpl(ArraySlice(b)) + } else { + // generic collection unfortunately must be temporarily buffered + writeImpl(bytes) + } + flushImpl() + return + } + + // This is based on LLVM's raw_ostream. + let availableBufferSize = self._availableBufferSize + let byteCount = Int(bytes.count) + + // If we have to insert more than the available space in buffer. + if byteCount > availableBufferSize { + // If buffer is empty, start writing and keep the last chunk in buffer. + if _buffer.isEmpty { + let bytesToWrite = byteCount - (byteCount % availableBufferSize) + let writeUptoIndex = bytes.index(bytes.startIndex, offsetBy: numericCast(bytesToWrite)) + writeImpl(bytes.prefix(upTo: writeUptoIndex)) + + // If remaining bytes is more than buffer size write everything. + let bytesRemaining = byteCount - bytesToWrite + if bytesRemaining > availableBufferSize { + writeImpl(bytes.suffix(from: writeUptoIndex)) + return + } + // Otherwise keep remaining in buffer. + _buffer += bytes.suffix(from: writeUptoIndex) + return + } + + let writeUptoIndex = bytes.index(bytes.startIndex, offsetBy: numericCast(availableBufferSize)) + // Append whatever we can accommodate. + _buffer += bytes.prefix(upTo: writeUptoIndex) + + writeImpl(ArraySlice(_buffer)) + _clearBuffer() + + // FIXME: We should start again with remaining chunk but this doesn't work. Write everything for now. + //write(collection: bytes.suffix(from: writeUptoIndex)) + writeImpl(bytes.suffix(from: writeUptoIndex)) + return + } + _buffer += bytes + } +} + +/// The thread-safe wrapper around output byte streams. +/// +/// This class wraps any `WritableByteStream` conforming type to provide a type-safe +/// access to its operations. If the provided stream inherits from `_WritableByteStreamBase`, +/// it will also ensure it is type-safe will all other `ThreadSafeOutputByteStream` instances +/// around the same stream. +public final class ThreadSafeOutputByteStream: WritableByteStream { + private static let defaultQueue = DispatchQueue( + label: "org.swift.swiftpm.basic.thread-safe-output-byte-stream") + public let stream: WritableByteStream + private let queue: DispatchQueue + + public var position: Int { + return queue.sync { + stream.position + } + } + + public init(_ stream: WritableByteStream) { + self.stream = stream + self.queue = + (stream as? _WritableByteStreamBase)?.queue ?? ThreadSafeOutputByteStream.defaultQueue + } + + public func write(_ byte: UInt8) { + queue.sync { + stream.write(byte) + } + } + + public func write(_ bytes: C) where C.Element == UInt8 { + queue.sync { + stream.write(bytes) + } + } + + public func flush() { + queue.sync { + stream.flush() + } + } + + public func write(sequence: S) where S.Iterator.Element == UInt8 { + queue.sync { + stream.write(sequence: sequence) + } + } + + public func writeJSONEscaped(_ string: String) { + queue.sync { + stream.writeJSONEscaped(string) + } + } + + public func close() throws { + try queue.sync { + try stream.close() + } + } +} + +#if swift(<5.6) + extension ThreadSafeOutputByteStream: UnsafeSendable {} +#else + extension ThreadSafeOutputByteStream: @unchecked Sendable {} +#endif + +/// Define an output stream operator. We need it to be left associative, so we +/// use `<<<`. +infix operator <<< : StreamingPrecedence +precedencegroup StreamingPrecedence { + associativity: left +} + +// MARK: Output Operator Implementations + +// FIXME: This override shouldn't be necesary but removing it causes a 30% performance regression. This problem is +// tracked by the following bug: https://bugs.swift.org/browse/SR-8535 + +@available(*, deprecated, message: "use send(_:) function on WritableByteStream instead") +@discardableResult +public func <<< (stream: WritableByteStream, value: ArraySlice) -> WritableByteStream { + value.write(to: stream) + return stream +} + +@available(*, deprecated, message: "use send(_:) function on WritableByteStream instead") +@discardableResult +public func <<< (stream: WritableByteStream, value: ByteStreamable) -> WritableByteStream { + value.write(to: stream) + return stream +} + +@available(*, deprecated, message: "use send(_:) function on WritableByteStream instead") +@discardableResult +public func <<< (stream: WritableByteStream, value: CustomStringConvertible) -> WritableByteStream { + value.description.write(to: stream) + return stream +} + +@available(*, deprecated, message: "use send(_:) function on WritableByteStream instead") +@discardableResult +public func <<< (stream: WritableByteStream, value: ByteStreamable & CustomStringConvertible) + -> WritableByteStream +{ + value.write(to: stream) + return stream +} + +extension UInt8: ByteStreamable { + public func write(to stream: WritableByteStream) { + stream.write(self) + } +} + +extension Character: ByteStreamable { + public func write(to stream: WritableByteStream) { + stream.write(String(self)) + } +} + +extension String: ByteStreamable { + public func write(to stream: WritableByteStream) { + stream.write(self.utf8) + } +} + +extension Substring: ByteStreamable { + public func write(to stream: WritableByteStream) { + stream.write(self.utf8) + } +} + +extension StaticString: ByteStreamable { + public func write(to stream: WritableByteStream) { + withUTF8Buffer { stream.write($0) } + } +} + +extension Array: ByteStreamable where Element == UInt8 { + public func write(to stream: WritableByteStream) { + stream.write(self) + } +} + +extension ArraySlice: ByteStreamable where Element == UInt8 { + public func write(to stream: WritableByteStream) { + stream.write(self) + } +} + +extension ContiguousArray: ByteStreamable where Element == UInt8 { + public func write(to stream: WritableByteStream) { + stream.write(self) + } +} + +// MARK: Formatted Streaming Output + +/// Provides operations for returning derived streamable objects to implement various forms of formatted output. +public struct Format { + /// Write the input boolean encoded as a JSON object. + static public func asJSON(_ value: Bool) -> ByteStreamable { + return JSONEscapedBoolStreamable(value: value) + } + private struct JSONEscapedBoolStreamable: ByteStreamable { + let value: Bool + + func write(to stream: WritableByteStream) { + stream.send(value ? "true" : "false") + } + } + + /// Write the input integer encoded as a JSON object. + static public func asJSON(_ value: Int) -> ByteStreamable { + return JSONEscapedIntStreamable(value: value) + } + private struct JSONEscapedIntStreamable: ByteStreamable { + let value: Int + + func write(to stream: WritableByteStream) { + // FIXME: Diagnose integers which cannot be represented in JSON. + stream.send(value.description) + } + } + + /// Write the input double encoded as a JSON object. + static public func asJSON(_ value: Double) -> ByteStreamable { + return JSONEscapedDoubleStreamable(value: value) + } + private struct JSONEscapedDoubleStreamable: ByteStreamable { + let value: Double + + func write(to stream: WritableByteStream) { + // FIXME: What should we do about NaN, etc.? + // + // FIXME: Is Double.debugDescription the best representation? + stream.send(value.debugDescription) + } + } + + /// Write the input CustomStringConvertible encoded as a JSON object. + static public func asJSON(_ value: T) -> ByteStreamable { + return JSONEscapedStringStreamable(value: value.description) + } + /// Write the input string encoded as a JSON object. + static public func asJSON(_ string: String) -> ByteStreamable { + return JSONEscapedStringStreamable(value: string) + } + private struct JSONEscapedStringStreamable: ByteStreamable { + let value: String + + func write(to stream: WritableByteStream) { + stream.send(UInt8(ascii: "\"")) + stream.writeJSONEscaped(value) + stream.send(UInt8(ascii: "\"")) + } + } + + /// Write the input string list encoded as a JSON object. + static public func asJSON(_ items: [T]) -> ByteStreamable { + return JSONEscapedStringListStreamable(items: items.map({ $0.description })) + } + /// Write the input string list encoded as a JSON object. + // + // FIXME: We might be able to make this more generic through the use of a "JSONEncodable" protocol. + static public func asJSON(_ items: [String]) -> ByteStreamable { + return JSONEscapedStringListStreamable(items: items) + } + private struct JSONEscapedStringListStreamable: ByteStreamable { + let items: [String] + + func write(to stream: WritableByteStream) { + stream.send(UInt8(ascii: "[")) + for (i, item) in items.enumerated() { + if i != 0 { stream.send(",") } + stream.send(Format.asJSON(item)) + } + stream.send(UInt8(ascii: "]")) + } + } + + /// Write the input dictionary encoded as a JSON object. + static public func asJSON(_ items: [String: String]) -> ByteStreamable { + return JSONEscapedDictionaryStreamable(items: items) + } + private struct JSONEscapedDictionaryStreamable: ByteStreamable { + let items: [String: String] + + func write(to stream: WritableByteStream) { + stream.send(UInt8(ascii: "{")) + for (offset:i, element:(key:key, value:value)) in items.enumerated() { + if i != 0 { stream.send(",") } + stream.send(Format.asJSON(key)).send(":").send(Format.asJSON(value)) + } + stream.send(UInt8(ascii: "}")) + } + } + + /// Write the input list (after applying a transform to each item) encoded as a JSON object. + // + // FIXME: We might be able to make this more generic through the use of a "JSONEncodable" protocol. + static public func asJSON(_ items: [T], transform: @escaping (T) -> String) -> ByteStreamable { + return JSONEscapedTransformedStringListStreamable(items: items, transform: transform) + } + private struct JSONEscapedTransformedStringListStreamable: ByteStreamable { + let items: [T] + let transform: (T) -> String + + func write(to stream: WritableByteStream) { + stream.send(UInt8(ascii: "[")) + for (i, item) in items.enumerated() { + if i != 0 { stream.send(",") } + stream.send(Format.asJSON(transform(item))) + } + stream.send(UInt8(ascii: "]")) + } + } + + /// Write the input list to the stream with the given separator between items. + static public func asSeparatedList(_ items: [T], separator: String) + -> ByteStreamable + { + return SeparatedListStreamable(items: items, separator: separator) + } + private struct SeparatedListStreamable: ByteStreamable { + let items: [T] + let separator: String + + func write(to stream: WritableByteStream) { + for (i, item) in items.enumerated() { + // Add the separator, if necessary. + if i != 0 { + stream.send(separator) + } + + stream.send(item) + } + } + } + + /// Write the input list to the stream (after applying a transform to each item) with the given separator between + /// items. + static public func asSeparatedList( + _ items: [T], + transform: @escaping (T) -> ByteStreamable, + separator: String + ) -> ByteStreamable { + return TransformedSeparatedListStreamable( + items: items, transform: transform, separator: separator) + } + private struct TransformedSeparatedListStreamable: ByteStreamable { + let items: [T] + let transform: (T) -> ByteStreamable + let separator: String + + func write(to stream: WritableByteStream) { + for (i, item) in items.enumerated() { + if i != 0 { stream.send(separator) } + stream.send(transform(item)) + } + } + } + + static public func asRepeating(string: String, count: Int) -> ByteStreamable { + return RepeatingStringStreamable(string: string, count: count) + } + private struct RepeatingStringStreamable: ByteStreamable { + let string: String + let count: Int + + init(string: String, count: Int) { + precondition(count >= 0, "Count should be >= zero") + self.string = string + self.count = count + } + + func write(to stream: WritableByteStream) { + for _ in 0..(_ bytes: C) where C.Iterator.Element == UInt8 { + contents += bytes + } + override final func writeImpl(_ bytes: ArraySlice) { + contents += bytes + } + + override final func closeImpl() throws { + // Do nothing. The protocol does not require to stop receiving writes, close only signals that resources could + // be released at this point should we need to. + } +} + +/// Represents a stream which is backed to a file. Not for instantiating. +public class FileOutputByteStream: _WritableByteStreamBase { + + public override final func closeImpl() throws { + flush() + try fileCloseImpl() + } + + /// Closes the file flushing any buffered data. + func fileCloseImpl() throws { + fatalError("fileCloseImpl() should be implemented by a subclass") + } +} + +/// Implements file output stream for local file system. +public final class LocalFileOutputByteStream: FileOutputByteStream { + + /// The pointer to the file. + let filePointer: FILEPointer + + /// Set to an error value if there were any IO error during writing. + private var error: FileSystemError? + + /// Closes the file on deinit if true. + private var closeOnDeinit: Bool + + /// Path to the file this stream should operate on. + private let path: AbsolutePath? + + /// Instantiate using the file pointer. + public init(filePointer: FILEPointer, closeOnDeinit: Bool = true, buffered: Bool = true) throws { + self.filePointer = filePointer + self.closeOnDeinit = closeOnDeinit + self.path = nil + super.init(buffered: buffered) + } + + /// Opens the file for writing at the provided path. + /// + /// - Parameters: + /// - path: Path to the file this stream should operate on. + /// - closeOnDeinit: If true closes the file on deinit. clients can use + /// close() if they want to close themselves or catch + /// errors encountered during writing to the file. + /// Default value is true. + /// - buffered: If true buffers writes in memory until full or flush(). + /// Otherwise, writes are processed and flushed immediately. + /// Default value is true. + /// + /// - Throws: FileSystemError + public init(_ path: AbsolutePath, closeOnDeinit: Bool = true, buffered: Bool = true) throws { + guard let filePointer = fopen(path.pathString, "wb") else { + throw FileSystemError(errno: errno, path) + } + self.path = path + self.filePointer = filePointer + self.closeOnDeinit = closeOnDeinit + super.init(buffered: buffered) + } + + deinit { + if closeOnDeinit { + fclose(filePointer) + } + } + + func errorDetected(code: Int32?) { + if let code = code { + error = .init(.ioError(code: code), path) + } else { + error = .init(.unknownOSError, path) + } + } + + override final func writeImpl(_ bytes: C) where C.Iterator.Element == UInt8 { + // FIXME: This will be copying bytes but we don't have option currently. + var contents = [UInt8](bytes) + while true { + let n = fwrite(&contents, 1, contents.count, filePointer) + if n < 0 { + if errno == EINTR { continue } + errorDetected(code: errno) + } else if n != contents.count { + errorDetected(code: nil) + } + break + } + } + + override final func writeImpl(_ bytes: ArraySlice) { + bytes.withUnsafeBytes { bytesPtr in + while true { + let n = fwrite(bytesPtr.baseAddress!, 1, bytesPtr.count, filePointer) + if n < 0 { + if errno == EINTR { continue } + errorDetected(code: errno) + } else if n != bytesPtr.count { + errorDetected(code: nil) + } + break + } + } + } + + override final func flushImpl() { + fflush(filePointer) + } + + override final func fileCloseImpl() throws { + defer { + fclose(filePointer) + // If clients called close we shouldn't call fclose again in deinit. + closeOnDeinit = false + } + // Throw if errors were found during writing. + if let error = error { + throw error + } + } +} + +/// Public stdout stream instance. +public var stdoutStream: ThreadSafeOutputByteStream = try! ThreadSafeOutputByteStream( + LocalFileOutputByteStream( + filePointer: stdout, + closeOnDeinit: false)) + +/// Public stderr stream instance. +public var stderrStream: ThreadSafeOutputByteStream = try! ThreadSafeOutputByteStream( + LocalFileOutputByteStream( + filePointer: stderr, + closeOnDeinit: false)) diff --git a/Sources/CartonHelpers/Basics/misc.swift b/Sources/CartonHelpers/Basics/misc.swift new file mode 100644 index 00000000..39dd88c5 --- /dev/null +++ b/Sources/CartonHelpers/Basics/misc.swift @@ -0,0 +1,328 @@ +/* + This source file is part of the Swift.org open source project + + Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors + Licensed under Apache License v2.0 with Runtime Library Exception + + See http://swift.org/LICENSE.txt for license information + See http://swift.org/CONTRIBUTORS.txt for Swift project authors +*/ + +import Foundation + +#if os(Windows) + import WinSDK +#endif + +#if os(Windows) + public let executableFileSuffix = ".exe" +#else + public let executableFileSuffix = "" +#endif + +#if os(Windows) + private func quote(_ arguments: [String]) -> String { + func quote(argument: String) -> String { + if !argument.contains(where: { " \t\n\"".contains($0) }) { + return argument + } + + // To escape the command line, we surround the argument with quotes. + // However, the complication comes due to how the Windows command line + // parser treats backslashes (\) and quotes ("). + // + // - \ is normally treated as a literal backslash + // e.g. alpha\beta\gamma => alpha\beta\gamma + // - The sequence \" is treated as a literal " + // e.g. alpha\"beta => alpha"beta + // + // But then what if we are given a path that ends with a \? + // + // Surrounding alpha\beta\ with " would be "alpha\beta\" which would be + // an unterminated string since it ends on a literal quote. To allow + // this case the parser treats: + // + // - \\" as \ followed by the " metacharacter + // - \\\" as \ followed by a literal " + // + // In general: + // - 2n \ followed by " => n \ followed by the " metacharacter + // - 2n + 1 \ followed by " => n \ followed by a literal " + + var quoted = "\"" + var unquoted = argument.unicodeScalars + + while !unquoted.isEmpty { + guard let firstNonBS = unquoted.firstIndex(where: { $0 != "\\" }) else { + // String ends with a backslash (e.g. first\second\), escape all + // the backslashes then add the metacharacter ". + let count = unquoted.count + quoted.append(String(repeating: "\\", count: 2 * count)) + break + } + + let count = unquoted.distance(from: unquoted.startIndex, to: firstNonBS) + if unquoted[firstNonBS] == "\"" { + // This is a string of \ followed by a " (e.g. first\"second). + // Escape the backslashes and the quote. + quoted.append(String(repeating: "\\", count: 2 * count + 1)) + } else { + // These are just literal backslashes + quoted.append(String(repeating: "\\", count: count)) + } + + quoted.append(String(unquoted[firstNonBS])) + + // Drop the backslashes and the following character + unquoted.removeFirst(count + 1) + } + quoted.append("\"") + + return quoted + } + return arguments.map(quote(argument:)).joined(separator: " ") + } +#endif + +/// Replace the current process image with a new process image. +/// +/// - Parameters: +/// - path: Absolute path to the executable. +/// - args: The executable arguments. +public func exec(path: String, args: [String]) throws -> Never { + let cArgs = CStringArray(args) + #if os(Windows) + var hJob: HANDLE + + hJob = CreateJobObjectA(nil, nil) + if hJob == HANDLE(bitPattern: 0) { + throw SystemError.exec(Int32(GetLastError()), path: path, args: args) + } + defer { CloseHandle(hJob) } + + let hPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, nil, 0, 1) + if hPort == HANDLE(bitPattern: 0) { + throw SystemError.exec(Int32(GetLastError()), path: path, args: args) + } + + var acpAssociation: JOBOBJECT_ASSOCIATE_COMPLETION_PORT = JOBOBJECT_ASSOCIATE_COMPLETION_PORT() + acpAssociation.CompletionKey = hJob + acpAssociation.CompletionPort = hPort + if !SetInformationJobObject( + hJob, JobObjectAssociateCompletionPortInformation, + &acpAssociation, DWORD(MemoryLayout.size)) + { + throw SystemError.exec(Int32(GetLastError()), path: path, args: args) + } + + var eliLimits: JOBOBJECT_EXTENDED_LIMIT_INFORMATION = JOBOBJECT_EXTENDED_LIMIT_INFORMATION() + eliLimits.BasicLimitInformation.LimitFlags = + DWORD(JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE) | DWORD(JOB_OBJECT_LIMIT_SILENT_BREAKAWAY_OK) + if !SetInformationJobObject( + hJob, JobObjectExtendedLimitInformation, &eliLimits, + DWORD(MemoryLayout.size)) + { + throw SystemError.exec(Int32(GetLastError()), path: path, args: args) + } + + var siInfo: STARTUPINFOW = STARTUPINFOW() + siInfo.cb = DWORD(MemoryLayout.size) + + var piInfo: PROCESS_INFORMATION = PROCESS_INFORMATION() + + try quote(args).withCString(encodedAs: UTF16.self) { pwszCommandLine in + if !CreateProcessW( + nil, + UnsafeMutablePointer(mutating: pwszCommandLine), + nil, nil, false, + DWORD(CREATE_SUSPENDED) | DWORD(CREATE_NEW_PROCESS_GROUP), + nil, nil, &siInfo, &piInfo) + { + throw SystemError.exec(Int32(GetLastError()), path: path, args: args) + } + } + + defer { CloseHandle(piInfo.hThread) } + defer { CloseHandle(piInfo.hProcess) } + + if !AssignProcessToJobObject(hJob, piInfo.hProcess) { + throw SystemError.exec(Int32(GetLastError()), path: path, args: args) + } + + _ = ResumeThread(piInfo.hThread) + + var dwCompletionCode: DWORD = 0 + var ulCompletionKey: ULONG_PTR = 0 + var lpOverlapped: LPOVERLAPPED? + repeat { + } while GetQueuedCompletionStatus( + hPort, &dwCompletionCode, &ulCompletionKey, + &lpOverlapped, INFINITE) + && !(ulCompletionKey == ULONG_PTR(UInt(bitPattern: hJob)) + && dwCompletionCode == JOB_OBJECT_MSG_ACTIVE_PROCESS_ZERO) + + var dwExitCode: DWORD = DWORD(bitPattern: -1) + _ = GetExitCodeProcess(piInfo.hProcess, &dwExitCode) + _exit(Int32(bitPattern: dwExitCode)) + #elseif (!canImport(Darwin) || os(macOS)) + guard execv(path, cArgs.cArray) != -1 else { + throw SystemError.exec(errno, path: path, args: args) + } + fatalError("unreachable") + #else + fatalError("not implemented") + #endif +} + +@_disfavoredOverload +@available(*, deprecated, message: "Use the overload which returns Never") +public func exec(path: String, args: [String]) throws { + try exec(path: path, args: args) +} + +// MARK: TSCUtility function for searching for executables + +/// Create a list of AbsolutePath search paths from a string, such as the PATH environment variable. +/// +/// - Parameters: +/// - pathString: The path string to parse. +/// - currentWorkingDirectory: The current working directory, the relative paths will be converted to absolute paths +/// based on this path. +/// - Returns: List of search paths. +public func getEnvSearchPaths( + pathString: String?, + currentWorkingDirectory: AbsolutePath? +) -> [AbsolutePath] { + // Compute search paths from PATH variable. + #if os(Windows) + let pathSeparator: Character = ";" + #else + let pathSeparator: Character = ":" + #endif + return (pathString ?? "").split(separator: pathSeparator).map(String.init).compactMap({ + pathString in + if let cwd = currentWorkingDirectory { + return try? AbsolutePath(validating: pathString, relativeTo: cwd) + } + return try? AbsolutePath(validating: pathString) + }) +} + +/// Lookup an executable path from an environment variable value, current working +/// directory or search paths. Only return a value that is both found and executable. +/// +/// This method searches in the following order: +/// * If env value is a valid absolute path, return it. +/// * If env value is relative path, first try to locate it in current working directory. +/// * Otherwise, in provided search paths. +/// +/// - Parameters: +/// - filename: The name of the file to find. +/// - currentWorkingDirectory: The current working directory to look in. +/// - searchPaths: The additional search paths to look in if not found in cwd. +/// - Returns: Valid path to executable if present, otherwise nil. +public func lookupExecutablePath( + filename value: String?, + currentWorkingDirectory: AbsolutePath? = localFileSystem.currentWorkingDirectory, + searchPaths: [AbsolutePath] = [] +) -> AbsolutePath? { + + // We should have a value to continue. + guard let value = value, !value.isEmpty else { + return nil + } + + var paths: [AbsolutePath] = [] + + if let cwd = currentWorkingDirectory, + let path = try? AbsolutePath(validating: value, relativeTo: cwd) + { + // We have a value, but it could be an absolute or a relative path. + paths.append(path) + } else if let absPath = try? AbsolutePath(validating: value) { + // Current directory not being available is not a problem + // for the absolute-specified paths. + paths.append(absPath) + } + + // Ensure the value is not a path. + if !value.contains("/") { + // Try to locate in search paths. + paths.append(contentsOf: searchPaths.map({ $0.appending(component: value) })) + } + + return paths.first(where: { localFileSystem.isExecutableFile($0) }) +} + +/// A wrapper for Range to make it Codable. +/// +/// Technically, we can use conditional conformance and make +/// stdlib's Range Codable but since extensions leak out, it +/// is not a good idea to extend types that you don't own. +/// +/// Range conformance will be added soon to stdlib so we can remove +/// this type in the future. +public struct CodableRange where Bound: Comparable & Codable { + + /// The underlying range. + public let range: Range + + /// Create a CodableRange instance. + public init(_ range: Range) { + self.range = range + } +} + +extension CodableRange: Sendable where Bound: Sendable {} + +extension CodableRange: Codable { + private enum CodingKeys: String, CodingKey { + case lowerBound, upperBound + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + try container.encode(range.lowerBound, forKey: .lowerBound) + try container.encode(range.upperBound, forKey: .upperBound) + } + + public init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: CodingKeys.self) + let lowerBound = try container.decode(Bound.self, forKey: .lowerBound) + let upperBound = try container.decode(Bound.self, forKey: .upperBound) + self.init(Range(uncheckedBounds: (lowerBound, upperBound))) + } +} + +extension AbsolutePath { + /// File URL created from the normalized string representation of the path. + public var asURL: Foundation.URL { + return URL(fileURLWithPath: pathString) + } +} + +// FIXME: Eliminate or find a proper place for this. +public enum SystemError: Error { + case chdir(Int32, String) + case close(Int32) + case exec(Int32, path: String, args: [String]) + case pipe(Int32) + case posix_spawn(Int32, [String]) + case read(Int32) + case setenv(Int32, String) + case stat(Int32, String) + case symlink(Int32, String, dest: String) + case unsetenv(Int32, String) + case waitpid(Int32) +} + +/// Memoizes a costly computation to a cache variable. +public func memoize(to cache: inout T?, build: () throws -> T) rethrows -> T { + if let value = cache { + return value + } else { + let value = try build() + cache = value + return value + } +} diff --git a/Sources/CartonHelpers/DefaultToolchain.swift b/Sources/CartonHelpers/DefaultToolchain.swift index e105ab8d..8bc55202 100644 --- a/Sources/CartonHelpers/DefaultToolchain.swift +++ b/Sources/CartonHelpers/DefaultToolchain.swift @@ -12,4 +12,4 @@ // See the License for the specific language governing permissions and // limitations under the License. -public let defaultToolchainVersion = "wasm-5.9.1-RELEASE" +public let defaultToolchainVersion = "wasm-5.9-SNAPSHOT-2024-02-15-a" diff --git a/Sources/CartonHelpers/FileSystem.swift b/Sources/CartonHelpers/FileSystem+traverseRecursively.swift similarity index 56% rename from Sources/CartonHelpers/FileSystem.swift rename to Sources/CartonHelpers/FileSystem+traverseRecursively.swift index dab187f8..b3ac9f80 100644 --- a/Sources/CartonHelpers/FileSystem.swift +++ b/Sources/CartonHelpers/FileSystem+traverseRecursively.swift @@ -13,7 +13,6 @@ // limitations under the License. import Foundation -import TSCBasic extension String { public var isAbsolutePath: Bool { first == "/" } @@ -21,37 +20,31 @@ extension String { extension FileSystem { public func traverseRecursively(_ traversalRoot: AbsolutePath) throws -> [AbsolutePath] { - guard exists(traversalRoot, followSymlink: true) else { + var isDirectory: ObjCBool = false + guard + FileManager.default.fileExists(atPath: traversalRoot.pathString, isDirectory: &isDirectory) + else { return [] } var result = [traversalRoot] - guard isDirectory(traversalRoot) else { + guard isDirectory.boolValue else { return result } - var pathsToTraverse = result - while let currentDirectory = pathsToTraverse.popLast() { - let directoryContents = try getDirectoryContents(currentDirectory) - .map(currentDirectory.appending) + let enumerator = FileManager.default.enumerator(atPath: traversalRoot.pathString) - result.append(contentsOf: directoryContents) - pathsToTraverse.append(contentsOf: directoryContents.filter(isDirectory)) + while let element = enumerator?.nextObject() as? String { + let path = try traversalRoot.appending(RelativePath(validating: element)) + result.append(path) } return result } - public func humanReadableFileSize(_ path: AbsolutePath) throws -> String { - precondition(isFile(path)) - - // FIXME: should use `UnitInformationStorage`, but it's unavailable in open-source Foundation - return try String(format: "%.2f MB", Double(getFileInfo(path).size) / 1024 / 1024) - } - public func resourcesDirectoryNames(relativeTo buildDirectory: AbsolutePath) throws -> [String] { - try getDirectoryContents(buildDirectory).filter { + try FileManager.default.contentsOfDirectory(atPath: buildDirectory.pathString).filter { $0.hasSuffix(".resources") } } diff --git a/Sources/CartonHelpers/HTTPClient.swift b/Sources/CartonHelpers/HTTPClient.swift deleted file mode 100644 index 961245d8..00000000 --- a/Sources/CartonHelpers/HTTPClient.swift +++ /dev/null @@ -1,33 +0,0 @@ -// Copyright 2020 Carton contributors -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -import AsyncHTTPClient -import Foundation - -extension HTTPClient.Request { - public static func get(url: URL) throws -> Self { - try get(url: url.absoluteString) - } - - public static func get(url: String) throws -> Self { - var request = try HTTPClient.Request(url: url) - request.headers.add(name: "User-Agent", value: "carton \(cartonVersion)") - if url.starts(with: "https://api.github.com/"), - let token = ProcessInfo.processInfo.environment["GITHUB_TOKEN"] - { - request.headers.add(name: "Authorization", value: "Bearer \(token)") - } - return request - } -} diff --git a/Sources/CartonHelpers/InteractiveWriter.swift b/Sources/CartonHelpers/InteractiveWriter.swift index 6e130be5..b1a7d2c1 100644 --- a/Sources/CartonHelpers/InteractiveWriter.swift +++ b/Sources/CartonHelpers/InteractiveWriter.swift @@ -6,8 +6,6 @@ See http://swift.org/CONTRIBUTORS.txt for Swift project authors */ -import TSCBasic - /// This class is used to write on the underlying stream. /// /// If underlying stream is a not tty, the string will be written in without any @@ -40,7 +38,7 @@ public final class InteractiveWriter { if let term = term { term.write(string, inColor: color, bold: bold) } else { - stream <<< string + stream.send(string) stream.flush() } } @@ -49,7 +47,7 @@ public final class InteractiveWriter { if let term = term { term.clearLine() } else { - stream <<< "\n" + stream.send("\n") stream.flush() } } diff --git a/Sources/CartonHelpers/Parsers/DiagnosticsParser.swift b/Sources/CartonHelpers/Parsers/DiagnosticsParser.swift deleted file mode 100644 index 97d1a608..00000000 --- a/Sources/CartonHelpers/Parsers/DiagnosticsParser.swift +++ /dev/null @@ -1,240 +0,0 @@ -// Copyright 2020 Carton contributors -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -import Foundation -import Splash -import TSCBasic - -extension TokenType { - fileprivate var color: String { - // Reference on escape codes: https://en.wikipedia.org/wiki/ANSI_escape_code#Colors - switch self { - case .keyword: return "[35;1m" // magenta;bold - case .comment: return "[90m" // bright black - case .call, .dotAccess, .property, .type: return "[94m" // bright blue - case .number, .preprocessing: return "[33m" // yellow - case .string: return "[91;1m" // bright red;bold - default: return "[0m" // reset - } - } -} - -struct TerminalOutputFormat: OutputFormat { - func makeBuilder() -> TerminalOutputBuilder { - .init() - } - - struct TerminalOutputBuilder: OutputBuilder { - var output: String = "" - - mutating func addToken(_ token: String, ofType type: TokenType) { - output.append("\(token, color: type.color)") - } - - mutating func addPlainText(_ text: String) { - output.append(text) - } - - mutating func addWhitespace(_ whitespace: String) { - output.append(whitespace) - } - - mutating func build() -> String { - output - } - } -} - -/// Parses and re-formats diagnostics output by the Swift compiler. -/// -/// The compiler output often repeats iteself, and the diagnostics can sometimes be -/// difficult to read. -/// This reformats them to a more readable output. -public struct DiagnosticsParser: ProcessOutputParser { - public let parsingConditions: ParsingCondition = [.failure] - // swiftlint:disable force_try - enum Regex { - /// The output has moved to a new file - static let enterFile = try! NSRegularExpression(pattern: #"\[\d+\/\d+\] Compiling \w+ "#) - /// A message is beginning with the line # following the `:` - static let line = try! NSRegularExpression(pattern: #"(\/\w+)+\.\w+:"#) - } - - // swiftlint:enable force_try - - struct CustomDiagnostic { - let kind: Kind - let file: String - let line: String.SubSequence - let char: String.SubSequence - let code: String - let message: String - - enum Kind: String { - case error, warning, note - var color: String { - switch self { - case .error: return "[41;1m" // bright red background - case .warning: return "[43;1m" // bright yellow background - case .note: return "[7m" // reversed - } - } - } - } - - fileprivate static let highlighter = SyntaxHighlighter(format: TerminalOutputFormat()) - - public init() {} - - public func parse(_ output: String, _ terminal: InteractiveWriter) { - let lines = output.split(separator: "\n") - var lineIdx = 0 - - var diagnostics = [String.SubSequence: [CustomDiagnostic]]() - - var currFile: String.SubSequence? - var fileMessages = [CustomDiagnostic]() - - while lineIdx < lines.count { - let line = lines[lineIdx] - if let file = line.matches(regex: Regex.enterFile) { - if let currFile = currFile { - diagnostics[currFile] = fileMessages - } - currFile = file - fileMessages = [] - } else if let currFile = currFile { - if let message = line.matches(regex: Regex.line) { - let components = message.split(separator: ":") - if components.count > 3 { - lineIdx += 1 - let file = line.replacingOccurrences(of: message, with: "") - guard - file.split(separator: "/").last? - .replacingOccurrences(of: ":", with: "") == String(currFile) - else { continue } - fileMessages.append( - .init( - kind: - CustomDiagnostic - .Kind( - rawValue: String( - components[2] - .trimmingCharacters(in: .whitespaces))) ?? .note, - file: file, - line: components[0], - char: components[1], - code: String(lines[lineIdx]), - message: components.dropFirst(3).joined(separator: ":") - ) - ) - } - } - } else { - terminal.write(String(line) + "\n", inColor: .cyan) - } - lineIdx += 1 - } - if let currFile = currFile { - diagnostics[currFile] = fileMessages - } - - outputDiagnostics(diagnostics, terminal) - } - - func outputDiagnostics( - _ diagnostics: [String.SubSequence: [CustomDiagnostic]], - _ terminal: InteractiveWriter - ) { - for (file, messages) in diagnostics.sorted(by: { $0.key < $1.key }) { - guard messages.count > 0 else { continue } - terminal.write("\(" \(file) ", color: "[1m", "[7m")") // bold, reversed - terminal.write(" \(messages.first!.file)\(messages.first!.line)\n\n", inColor: .gray) - // Group messages that occur on sequential lines to provie a more readable output - var groupedMessages = [[CustomDiagnostic]]() - for message in messages { - if let lastLineStr = groupedMessages.last?.last?.line, - let lastLine = Int(lastLineStr), - let line = Int(message.line), - lastLine == line - 1 || lastLine == line - { - groupedMessages[groupedMessages.count - 1].append(message) - } else { - groupedMessages.append([message]) - } - } - for messages in groupedMessages { - // Output the diagnostic message - for message in messages { - let kind = message.kind.rawValue.uppercased() - terminal - .write( - " \(" \(kind) ", color: message.kind.color, "[37;1m") \(message.message)\n" - ) // 37;1: bright white - } - let maxLine = messages.map(\.line.count).max() ?? 0 - for (offset, message) in messages.enumerated() { - if offset > 0 { - // Make sure we don't log the same line twice - if messages[offset - 1].line != message.line { - flush(messages: messages, message: message, maxLine: maxLine, terminal) - } - } else { - flush(messages: messages, message: message, maxLine: maxLine, terminal) - } - } - terminal.write("\n") - } - terminal.write("\n") - } - } - - func flush( - messages: [CustomDiagnostic], - message: CustomDiagnostic, - maxLine: Int, - _ terminal: InteractiveWriter - ) { - // Get all diagnostics for a particular line. - let allChars = messages.filter { $0.line == message.line }.map(\.char) - // Output the code for this line, syntax highlighted - let paddedLine = message.line.padding(toLength: maxLine, withPad: " ", startingAt: 0) - let highlightedCode = Self.highlighter.highlight(message.code) - terminal - .write( - " \("\(paddedLine) | ", color: "[36m")\(highlightedCode)\n" - ) // 36: cyan - terminal.write( - " " + "".padding(toLength: maxLine, withPad: " ", startingAt: 0) + " | ", - inColor: .cyan - ) - - // Aggregate the indicators (^ point to the error) onto a single line - var charIndicators = String(repeating: " ", count: Int(message.char)!) + "^" - if allChars.count > 0 { - for char in allChars.dropFirst() { - let idx = Int(char)! - if idx >= charIndicators.count { - charIndicators - .append(String(repeating: " ", count: idx - charIndicators.count) + "^") - } else { - var arr = Array(charIndicators) - arr[idx] = "^" - charIndicators = String(arr) - } - } - } - terminal.write("\(charIndicators)\n", inColor: .red, bold: true) - } -} diff --git a/Sources/CartonHelpers/Process.swift b/Sources/CartonHelpers/Process+run.swift similarity index 81% rename from Sources/CartonHelpers/Process.swift rename to Sources/CartonHelpers/Process+run.swift index f9751059..a5b84d63 100644 --- a/Sources/CartonHelpers/Process.swift +++ b/Sources/CartonHelpers/Process+run.swift @@ -14,33 +14,6 @@ import Dispatch import Foundation -import TSCBasic - -public func processDataOutput(_ arguments: [String]) throws -> [UInt8] { - let process = TSCBasic.Process(arguments: arguments, startNewProcessGroup: false) - try process.launch() - let result = try process.waitUntilExit() - - guard case .terminated(code: EXIT_SUCCESS) = result.exitStatus else { - let stdout: String? - if let output = try ByteString(result.output.get()).validDescription, !output.isEmpty { - stdout = output - } else { - stdout = nil - } - - var stderr: String? - if let output = try ByteString(result.stderrOutput.get()).validDescription { - stderr = output - } else { - stderr = nil - } - - throw ProcessError(stderr: stderr, stdout: stdout) - } - - return try result.output.get() -} struct ProcessError: Error { let stderr: String? @@ -61,7 +34,7 @@ extension ProcessError: CustomStringConvertible { } } -extension TSCBasic.Process { +extension Process { // swiftlint:disable:next function_body_length public static func run( _ arguments: [String], @@ -86,7 +59,7 @@ extension TSCBasic.Process { DispatchQueue.global().async { var stdoutBuffer = "" - let stdout: TSCBasic.Process.OutputClosure = { + let stdout: Process.OutputClosure = { guard let string = String(data: Data($0), encoding: .utf8) else { return } if parser != nil { // Aggregate this for formatting later @@ -98,13 +71,15 @@ extension TSCBasic.Process { var stderrBuffer = [UInt8]() - let stderr: TSCBasic.Process.OutputClosure = { + let stderr: Process.OutputClosure = { stderrBuffer.append(contentsOf: $0) } let process = Process( arguments: arguments, - environment: ProcessEnv.vars.merging(environment) { _, new in new }, + environmentBlock: ProcessEnvironmentBlock( + ProcessInfo.processInfo.environment.merging(environment) { _, new in new } + ), outputRedirection: .stream(stdout: stdout, stderr: stderr), startNewProcessGroup: true, loggingHandler: { diff --git a/Sources/CartonHelpers/TerminalController.swift b/Sources/CartonHelpers/TerminalController+logLookup.swift similarity index 87% rename from Sources/CartonHelpers/TerminalController.swift rename to Sources/CartonHelpers/TerminalController+logLookup.swift index 16703406..a7c344fd 100644 --- a/Sources/CartonHelpers/TerminalController.swift +++ b/Sources/CartonHelpers/TerminalController+logLookup.swift @@ -12,8 +12,6 @@ // See the License for the specific language governing permissions and // limitations under the License. -import TSCBasic - extension String { fileprivate static var home = "\u{001B}[H" fileprivate static var clearScreen = "\u{001B}[2J\u{001B}[H\u{001B}[3J" @@ -29,13 +27,4 @@ extension InteractiveWriter { write("\n") } } - - public func clearWindow() { - write(.clearScreen) - } - - public func homeAndClear() { - write(.home) - write(.clear) - } } diff --git a/Sources/CartonKit/Helpers/Expectation.swift b/Sources/CartonKit/Helpers/Expectation.swift deleted file mode 100644 index 2419f001..00000000 --- a/Sources/CartonKit/Helpers/Expectation.swift +++ /dev/null @@ -1,29 +0,0 @@ -// Copyright 2020 Carton contributors -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -import Foundation - -public struct ExpectationError: Error, CustomStringConvertible { - public let description: String -} - -/// Implements throwing equality assertions, as compared to standard assertions that trap -/// in debug mode. -struct Equality { - let description: (_ x: T, _ y: T, _ context: C) -> String - - func callAsFunction(_ x: T, _ y: T, context: C) throws { - guard x == y else { throw ExpectationError(description: description(x, y, context)) } - } -} diff --git a/Sources/CartonKit/Helpers/URL.swift b/Sources/CartonKit/Helpers/URL.swift deleted file mode 100644 index b38c962e..00000000 --- a/Sources/CartonKit/Helpers/URL.swift +++ /dev/null @@ -1,26 +0,0 @@ -// Copyright 2020 Carton contributors -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -import Foundation - -extension URL { - func appending(_ components: String...) -> URL { - var result = self - for c in components { - result = result.appendingPathComponent(c) - } - - return result - } -} diff --git a/Sources/CartonKit/Model/Entrypoint.swift b/Sources/CartonKit/Model/Entrypoint.swift index 2b916aff..59a70c31 100644 --- a/Sources/CartonKit/Model/Entrypoint.swift +++ b/Sources/CartonKit/Model/Entrypoint.swift @@ -12,13 +12,20 @@ // See the License for the specific language governing permissions and // limitations under the License. -import AsyncHTTPClient -import Basics import CartonHelpers import Foundation -import TSCBasic -public enum EntrypointError: Error { +private struct StringError: Equatable, Codable, CustomStringConvertible, Error { + let description: String + init(_ description: String) { + self.description = description + } +} + +extension StringError: CustomNSError { + var errorUserInfo: [String: Any] { + return [NSLocalizedDescriptionKey: self.description] + } } public struct Entrypoint { @@ -43,7 +50,7 @@ public struct Entrypoint { let (cartonDir, staticDir, filePath) = try paths(on: fileSystem) // If hash check fails, download the `static.zip` archive and unpack it - if try !fileSystem.exists(filePath) + if try !fileSystem.exists(filePath, followSymlink: true) || SHA256().hash( fileSystem.readFileContents(filePath) ) != sha256 @@ -58,10 +65,11 @@ public struct Entrypoint { try fileSystem.writeFileContents(archiveFile, bytes: ByteString(staticArchiveBytes)) terminal.logLookup("Unpacking the archive: ", archiveFile) - try fileSystem.createDirectory(staticDir) - try tsc_await { - ZipArchiver(fileSystem: fileSystem).extract( - from: archiveFile, to: staticDir, completion: $0) + try fileSystem.createDirectory(staticDir, recursive: false) + let result = try Process.popen( + args: "unzip", archiveFile.pathString, "-d", staticDir.pathString) + guard result.exitStatus == .terminated(code: 0) else { + throw try StringError(result.utf8stderrOutput()) } } } diff --git a/Sources/CartonKit/Model/Project.swift b/Sources/CartonKit/Model/Project.swift deleted file mode 100644 index 19eea9b5..00000000 --- a/Sources/CartonKit/Model/Project.swift +++ /dev/null @@ -1,27 +0,0 @@ -// Copyright 2020 Carton contributors -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -import TSCBasic - -public struct Project { - let name: String - let path: AbsolutePath - let inPlace: Bool - - public init(name: String, path: AbsolutePath, inPlace: Bool) { - self.name = name - self.path = path - self.inPlace = inPlace - } -} diff --git a/Sources/CartonKit/Model/Template.swift b/Sources/CartonKit/Model/Template.swift deleted file mode 100644 index f56f27ed..00000000 --- a/Sources/CartonKit/Model/Template.swift +++ /dev/null @@ -1,238 +0,0 @@ -// Copyright 2020 Carton contributors -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -import CartonHelpers -import SwiftToolchain -import TSCBasic - -public enum Templates: String, CaseIterable { - case basic - case tokamak - - public var template: Template.Type { - switch self { - case .basic: return Basic.self - case .tokamak: return Tokamak.self - } - } -} - -public protocol Template { - static var description: String { get } - static func create( - on fileSystem: FileSystem, - project: Project, - _ terminal: InteractiveWriter - ) async throws -} - -enum TemplateError: Error { - case notImplemented -} - -struct PackageDependency: CustomStringConvertible { - let url: String - let version: Version - - enum Version: CustomStringConvertible { - case from(String) - case branch(String) - var description: String { - switch self { - case let .from(min): - return #"from: "\#(min)""# - case let .branch(branch): - return #".branch("\#(branch)")"# - } - } - } - - var description: String { - #".package(url: "\#(url)", \#(version))"# - } -} - -struct TargetDependency: CustomStringConvertible { - let name: String - let package: String - var description: String { - #".product(name: "\#(name)", package: "\#(package)")"# - } -} - -extension Template { - static func createPackage( - type: PackageType, - fileSystem: FileSystem, - project: Project, - _ terminal: InteractiveWriter - ) async throws { - try await Toolchain(fileSystem, terminal) - .runPackageInit(name: project.name, type: type, inPlace: project.inPlace) - } - - static func createManifest( - fileSystem: FileSystem, - project: Project, - platforms: [String] = [], - dependencies: [PackageDependency] = [], - targetDepencencies: [TargetDependency] = [], - _ terminal: InteractiveWriter - ) throws { - try fileSystem.writeFileContents(project.path.appending(component: "Package.swift")) { - var content = """ - // swift-tools-version:5.8 - import PackageDescription - let package = Package( - name: "\(project.name)",\n - """ - if !platforms.isEmpty { - content += " platforms: [\(platforms.joined(separator: ", "))],\n" - } - content += """ - products: [ - .executable(name: "\(project.name)", targets: ["\(project.name)"]) - ], - dependencies: [ - \(dependencies.map(\.description).joined(separator: ",\n")) - ], - targets: [ - .executableTarget( - name: "\(project.name)", - dependencies: [ - "\(project.name)Library", - \(targetDepencencies.map(\.description).joined(separator: ",\n")) - ]), - .target( - name: "\(project.name)Library", - dependencies: []), - .testTarget( - name: "\(project.name)LibraryTests", - dependencies: ["\(project.name)Library"]), - ] - ) - """ - content.write(to: $0) - } - } -} - -// MARK: Templates - -extension Templates { - struct Basic: Template { - static let description: String = "A simple SwiftWasm project." - - static func create( - on fileSystem: FileSystem, - project: Project, - _ terminal: InteractiveWriter - ) async throws { - // FIXME: We now create an intermediate library target to work around - // an issue that prevents us from testing executable targets on Wasm. - // See https://github.com/swiftwasm/swift/issues/5375 - try fileSystem.changeCurrentWorkingDirectory(to: project.path) - try await createPackage( - type: .library, fileSystem: fileSystem, - project: Project(name: project.name + "Library", path: project.path, inPlace: true), - terminal - ) - try createManifest( - fileSystem: fileSystem, - project: project, - dependencies: [ - .init( - url: "https://github.com/swiftwasm/JavaScriptKit", - version: .from(compatibleJSKitVersion.description) - ) - ], - targetDepencencies: [ - .init(name: "JavaScriptKit", package: "JavaScriptKit") - ], - terminal - ) - let sources = project.path.appending(component: "Sources") - let executableTarget = sources.appending(component: project.name) - // Create the executable target - try fileSystem.createDirectory(executableTarget) - try fileSystem.writeFileContents(executableTarget.appending(component: "main.swift")) { - """ - import \(project.name.spm_mangledToC99ExtendedIdentifier())Library - print("Hello, world!") - """ - .write(to: $0) - } - } - } -} - -extension Templates { - struct Tokamak: Template { - static let description: String = "A simple Tokamak project." - - static func create( - on fileSystem: FileSystem, - project: Project, - _ terminal: InteractiveWriter - ) async throws { - try fileSystem.changeCurrentWorkingDirectory(to: project.path) - try await createPackage( - type: .library, - fileSystem: fileSystem, - project: Project(name: project.name + "Library", path: project.path, inPlace: true), - terminal) - try createManifest( - fileSystem: fileSystem, - project: project, - platforms: [".macOS(.v11)", ".iOS(.v13)"], - dependencies: [ - .init( - url: "https://github.com/TokamakUI/Tokamak", - version: .from("0.11.0") - ) - ], - targetDepencencies: [ - .init(name: "TokamakShim", package: "Tokamak") - ], - terminal - ) - - let sources = project.path.appending(component: "Sources") - let executableTarget = sources.appending(component: project.name) - - try fileSystem.writeFileContents(executableTarget.appending(components: "App.swift")) { - """ - import TokamakDOM - import \(project.name.spm_mangledToC99ExtendedIdentifier())Library - - @main - struct TokamakApp: App { - var body: some Scene { - WindowGroup("Tokamak App") { - ContentView() - } - } - } - - struct ContentView: View { - var body: some View { - Text("Hello, world!") - } - } - """ - .write(to: $0) - } - } - } -} diff --git a/Sources/CartonHelpers/Parsers/ChromeStackTrace.swift b/Sources/CartonKit/Parsers/ChromeStackTrace.swift similarity index 61% rename from Sources/CartonHelpers/Parsers/ChromeStackTrace.swift rename to Sources/CartonKit/Parsers/ChromeStackTrace.swift index 2fbd965c..f6d03b61 100644 --- a/Sources/CartonHelpers/Parsers/ChromeStackTrace.swift +++ b/Sources/CartonKit/Parsers/ChromeStackTrace.swift @@ -15,25 +15,19 @@ // Created by Jed Fox on 12/6/20. // -import TSCBasic - -// swiftlint:disable force_try -private let webpackRegex = try! RegEx(pattern: "at (.+) \\(webpack:///(.+?)\\)") -private let wasmRegex = try! RegEx(pattern: "at (.+) \\(:(.+?)\\)") -// swiftlint:enable force_try +private let webpackRegex = #/"at (.+) \\(webpack:///(.+?)\\)/# +private let wasmRegex = #/at (.+) \\(:(.+?)\\)/# extension StringProtocol { - public var chromeStackTrace: [StackTraceItem] { + var chromeStackTrace: [StackTraceItem] { split(separator: "\n").dropFirst().compactMap { - if let webpackMatch = webpackRegex.matchGroups(in: String($0)).first, - let symbol = webpackMatch.first, - let location = webpackMatch.last - { + if let webpackMatch = try? webpackRegex.firstMatch(in: String($0)) { + let symbol = String(webpackMatch.output.0) + let location = String(webpackMatch.output.3) return StackTraceItem(symbol: symbol, location: location, kind: .javaScript) - } else if let wasmMatch = wasmRegex.matchGroups(in: String($0)).first, - let symbol = wasmMatch.first, - let location = wasmMatch.last - { + } else if let wasmMatch = try? wasmRegex.firstMatch(in: String($0)) { + let symbol = String(wasmMatch.output.0) + let location = String(wasmMatch.output.3) return StackTraceItem( symbol: demangle(symbol), location: location, diff --git a/Sources/CartonKit/Parsers/DiagnosticsParser.swift b/Sources/CartonKit/Parsers/DiagnosticsParser.swift new file mode 100644 index 00000000..9025f7b5 --- /dev/null +++ b/Sources/CartonKit/Parsers/DiagnosticsParser.swift @@ -0,0 +1,42 @@ +// Copyright 2020 Carton contributors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +import Foundation + +/// Parses and re-formats diagnostics output by the Swift compiler. +/// +/// The compiler output often repeats iteself, and the diagnostics can sometimes be +/// difficult to read. +/// This reformats them to a more readable output. +struct DiagnosticsParser { + struct CustomDiagnostic { + let kind: Kind + let file: String + let line: String.SubSequence + let char: String.SubSequence + let code: String + let message: String + + enum Kind: String { + case error, warning, note + var color: String { + switch self { + case .error: return "[41;1m" // bright red background + case .warning: return "[43;1m" // bright yellow background + case .note: return "[7m" // reversed + } + } + } + } +} diff --git a/Sources/CartonHelpers/Parsers/FirefoxStackTrace.swift b/Sources/CartonKit/Parsers/FirefoxStackTrace.swift similarity index 60% rename from Sources/CartonHelpers/Parsers/FirefoxStackTrace.swift rename to Sources/CartonKit/Parsers/FirefoxStackTrace.swift index 73232bd7..9fa5a4c3 100644 --- a/Sources/CartonHelpers/Parsers/FirefoxStackTrace.swift +++ b/Sources/CartonKit/Parsers/FirefoxStackTrace.swift @@ -15,25 +15,19 @@ // Created by Max Desiatov on 08/11/2020. // -import TSCBasic - -// swiftlint:disable force_try -private let webpackRegex = try! RegEx(pattern: "(.+)@webpack:///(.+)") -private let wasmRegex = try! RegEx(pattern: "(.+)@http://127.0.0.1.+WebAssembly.instantiate:(.+)") -// swiftlint:enable force_try +private let webpackRegex = #/(.+)@webpack:///(.+)/# +private let wasmRegex = #/(.+)@http://127.0.0.1.+WebAssembly.instantiate:(.+)/# extension StringProtocol { - public var firefoxStackTrace: [StackTraceItem] { + var firefoxStackTrace: [StackTraceItem] { split(separator: "\n").compactMap { - if let webpackMatch = webpackRegex.matchGroups(in: String($0)).first, - let symbol = webpackMatch.first, - let location = webpackMatch.last - { + if let webpackMatch = try? webpackRegex.firstMatch(in: String($0)) { + let symbol = String(webpackMatch.output.0) + let location = String(webpackMatch.output.2) return StackTraceItem(symbol: symbol, location: location, kind: .javaScript) - } else if let wasmMatch = wasmRegex.matchGroups(in: String($0)).first, - let symbol = wasmMatch.first, - let location = wasmMatch.last - { + } else if let wasmMatch = try? wasmRegex.firstMatch(in: String($0)) { + let symbol = String(wasmMatch.output.0) + let location = String(wasmMatch.output.2) return StackTraceItem( symbol: demangle(symbol), location: location, diff --git a/Sources/CartonHelpers/Parsers/SafariStackTrace.swift b/Sources/CartonKit/Parsers/SafariStackTrace.swift similarity index 61% rename from Sources/CartonHelpers/Parsers/SafariStackTrace.swift rename to Sources/CartonKit/Parsers/SafariStackTrace.swift index 278572c1..b3ab495f 100644 --- a/Sources/CartonHelpers/Parsers/SafariStackTrace.swift +++ b/Sources/CartonKit/Parsers/SafariStackTrace.swift @@ -15,30 +15,24 @@ // Created by Jed Fox on 12/6/20. // -import TSCBasic - -// swiftlint:disable force_try -private let jsRegex = try! RegEx(pattern: "(.+?)(?:@(?:\\[(?:native|wasm) code\\]|(.+)))?$") -private let wasmRegex = try! RegEx(pattern: "<\\?>\\.wasm-function\\[(.+)\\]@\\[wasm code\\]") -// swiftlint:enable force_try +private let jsRegex = #/(.+?)(?:@(?:\\[(?:native|wasm) code\\]|(.+)))?$/# +private let wasmRegex = #/"<\\?>\\.wasm-function\\[(.+)\\]@\\[wasm code\\]/# extension StringProtocol { - public var safariStackTrace: [StackTraceItem] { + var safariStackTrace: [StackTraceItem] { split(separator: "\n").compactMap { - if let wasmMatch = wasmRegex.matchGroups(in: String($0)).first, - let symbol = wasmMatch.first - { + if let wasmMatch = try? wasmRegex.firstMatch(in: String($0)) { + let symbol = String(wasmMatch.output) return StackTraceItem( symbol: demangle(symbol), location: nil, kind: .webAssembly ) - } else if let jsMatch = jsRegex.matchGroups(in: String($0)).first, - let symbol = jsMatch.first - { + } else if let jsMatch = try? jsRegex.firstMatch(in: String($0)) { + let symbol = String(jsMatch.output.0) let loc: String? - if jsMatch.count == 2 && !jsMatch[1].isEmpty { - loc = jsMatch[1] + if jsMatch.output.2 == nil && !jsMatch.output.1.isEmpty { + loc = String(jsMatch.1) } else { loc = nil } diff --git a/Sources/CartonHelpers/StackTrace.swift b/Sources/CartonKit/Parsers/StackTrace.swift similarity index 90% rename from Sources/CartonHelpers/StackTrace.swift rename to Sources/CartonKit/Parsers/StackTrace.swift index 92b741ad..184d1501 100644 --- a/Sources/CartonHelpers/StackTrace.swift +++ b/Sources/CartonKit/Parsers/StackTrace.swift @@ -19,7 +19,7 @@ #endif @_silgen_name("swift_demangle") -public func _stdlib_demangleImpl( +func _stdlib_demangleImpl( mangledName: UnsafePointer?, mangledNameLength: UInt, outputBuffer: UnsafeMutablePointer?, @@ -50,13 +50,13 @@ func demangle(_ mangledName: String) -> String { } } -public struct StackTraceItem: Equatable { - public enum Kind { +struct StackTraceItem: Equatable { + enum Kind { case javaScript case webAssembly } - public let symbol: String - public let location: String? - public let kind: Kind + let symbol: String + let location: String? + let kind: Kind } diff --git a/Sources/CartonHelpers/Parsers/String+Regex.swift b/Sources/CartonKit/Parsers/String+Regex.swift similarity index 100% rename from Sources/CartonHelpers/Parsers/String+Regex.swift rename to Sources/CartonKit/Parsers/String+Regex.swift diff --git a/Sources/CartonHelpers/Parsers/String+color.swift b/Sources/CartonKit/Parsers/String+color.swift similarity index 100% rename from Sources/CartonHelpers/Parsers/String+color.swift rename to Sources/CartonKit/Parsers/String+color.swift diff --git a/Sources/CartonHelpers/Parsers/TestsParser.swift b/Sources/CartonKit/Parsers/TestsParser.swift similarity index 97% rename from Sources/CartonHelpers/Parsers/TestsParser.swift rename to Sources/CartonKit/Parsers/TestsParser.swift index a2344c7e..26f5eac9 100644 --- a/Sources/CartonHelpers/Parsers/TestsParser.swift +++ b/Sources/CartonKit/Parsers/TestsParser.swift @@ -12,9 +12,8 @@ // See the License for the specific language governing permissions and // limitations under the License. +import CartonHelpers import Foundation -import Splash -import TSCBasic extension String.StringInterpolation { fileprivate mutating func appendInterpolation(_ regexLabel: TestsParser.Regex.Label) { @@ -172,8 +171,6 @@ public struct TestsParser: ProcessOutputParser { } } - fileprivate static let highlighter = SyntaxHighlighter(format: TerminalOutputFormat()) - public func parse(_ output: String, _ terminal: InteractiveWriter) { let lines = output.split(separator: "\n") @@ -296,8 +293,8 @@ public struct TestsParser: ProcessOutputParser { if let fileContents = fileContents { let fileLines = fileContents.components(separatedBy: .newlines) guard fileLines.count >= lineNum else { break } - let highlightedCode = Self.highlighter.highlight(String(fileLines[lineNum - 1])) - terminal.write(" \("\(problem.line) | ", color: "[36m")\(highlightedCode)\n") + let codeLine = String(fileLines[lineNum - 1]) + terminal.write(" \("\(problem.line) | ", color: "[36m")\(codeLine)\n") } } } diff --git a/Sources/CartonKit/Server/Application.swift b/Sources/CartonKit/Server/Application.swift index 05ea78af..e86bcb56 100644 --- a/Sources/CartonKit/Server/Application.swift +++ b/Sources/CartonKit/Server/Application.swift @@ -14,93 +14,282 @@ import CartonHelpers import Foundation -import PackageModel -import SwiftToolchain -import TSCBasic -import Vapor - -extension Application { - struct Configuration { - let port: Int - let host: String - let mainWasmPath: AbsolutePath - let customIndexPath: AbsolutePath? - let manifest: Manifest - let product: ProductDescription? - let entrypoint: Entrypoint - let onWebSocketOpen: (WebSocket, DestinationEnvironment) async -> Void - let onWebSocketClose: (WebSocket) async -> Void - } +import Logging +import NIO +import NIOHTTP1 +import NIOWebSocket - func configure(_ configuration: Configuration) throws { - http.server.configuration.port = configuration.port - http.server.configuration.hostname = configuration.host +extension Server { + final class HTTPHandler: ChannelInboundHandler, RemovableChannelHandler { + typealias InboundIn = HTTPServerRequestPart + typealias OutboundOut = HTTPServerResponsePart - let directory = FileManager.default.homeDirectoryForCurrentUser - .appendingPathComponent(".carton") - .appendingPathComponent("static") - .path - middleware.use(FileMiddleware(publicDirectory: directory)) + struct Configuration { + let logger: Logger + let mainWasmPath: AbsolutePath + let customIndexPath: AbsolutePath? + let resourcesPaths: [String] + let entrypoint: Entrypoint + } - // register routes - get { (request: Request) -> EventLoopFuture in - let customIndexContent: EventLoopFuture - if let path = configuration.customIndexPath?.pathString { - customIndexContent = request.fileio.collectFile(at: path).map { String(buffer: $0) } - } else { - customIndexContent = request.eventLoop.makeSucceededFuture(nil) + let configuration: Configuration + private var responseBody: ByteBuffer! + + init(configuration: Configuration) { + self.configuration = configuration + } + + func handlerAdded(context: ChannelHandlerContext) { + } + + func handlerRemoved(context: ChannelHandlerContext) { + self.responseBody = nil + } + + func channelRead(context: ChannelHandlerContext, data: NIOAny) { + let reqPart = self.unwrapInboundIn(data) + + // We're not interested in request bodies here + guard case .head(let head) = reqPart else { + return } - return customIndexContent.map { - HTML( - value: HTML.indexPage( - customContent: $0, - entrypointName: configuration.entrypoint.fileName - )) + // GETs only. + guard case .GET = head.method else { + self.respond405(context: context) + return } - } + configuration.logger.info("\(head.method) \(head.uri)") - // Don't limit the size of frame to accept large test outputs - webSocket("watcher", maxFrameSize: .init(integerLiteral: Int(UInt32.max))) { request, ws in - let environment = - request.headers["User-Agent"].compactMap(DestinationEnvironment.init).first - ?? .other + let response: StaticResponse + do { + switch head.uri { + case "/": + response = try respondIndexPage(context: context) + case "/main.wasm": + response = StaticResponse( + contentType: "application/wasm", + body: try context.channel.allocator.buffer( + bytes: localFileSystem.readFileContents(configuration.mainWasmPath).contents + ) + ) + default: + guard let staticResponse = try self.respond(context: context, head: head) else { + self.respond404(context: context) + return + } + response = staticResponse + } + } catch { + configuration.logger.error("Failed to respond to \(head.uri): \(error)") + response = StaticResponse( + contentType: "text/plain", + body: context.channel.allocator.buffer(string: "Internal server error") + ) + } + self.responseBody = response.body - Task { await configuration.onWebSocketOpen(ws, environment) } - ws.onClose.whenComplete { _ in Task { await configuration.onWebSocketClose(ws) } } + var headers = HTTPHeaders() + headers.add(name: "Content-Type", value: response.contentType) + headers.add(name: "Content-Length", value: String(response.body.readableBytes)) + headers.add(name: "Connection", value: "close") + let responseHead = HTTPResponseHead( + version: .init(major: 1, minor: 1), + status: .ok, + headers: headers) + context.write(self.wrapOutboundOut(.head(responseHead)), promise: nil) + context.write(self.wrapOutboundOut(.body(.byteBuffer(response.body))), promise: nil) + context.write(self.wrapOutboundOut(.end(nil))).whenComplete { (_: Result) in + context.close(promise: nil) + } + context.flush() } - get("main.wasm") { - // stream the file - $0.fileio.streamFile(at: configuration.mainWasmPath.pathString) + struct StaticResponse { + let contentType: String + let body: ByteBuffer } - // Serve resources for all targets at their respective paths. - let buildDirectory = configuration.mainWasmPath.parentDirectory + private func respond(context: ChannelHandlerContext, head: HTTPRequestHead) throws + -> StaticResponse? + { + var responders = [ + self.makeStaticResourcesResponder( + baseDirectory: FileManager.default.homeDirectoryForCurrentUser + .appendingPathComponent(".carton") + .appendingPathComponent("static") + ) + ] + + let buildDirectory = configuration.mainWasmPath.parentDirectory + for directoryName in try localFileSystem.resourcesDirectoryNames(relativeTo: buildDirectory) { + responders.append { context, uri in + let parts = uri.split(separator: "/") + guard let firstPart = parts.first, + firstPart == directoryName + else { return nil } + let baseDir = URL(fileURLWithPath: buildDirectory.pathString).appendingPathComponent( + directoryName + ) + let inner = self.makeStaticResourcesResponder(baseDirectory: baseDir) + return try inner(context, "/" + parts.dropFirst().joined(separator: "/")) + } + } + + // Serve resources for the main target at the root path. + for mainResourcesPath in configuration.resourcesPaths { + responders.append( + self.makeStaticResourcesResponder(baseDirectory: URL(fileURLWithPath: mainResourcesPath))) + } - func requestHandler(_ directoryName: String) -> ((Request) -> Response) { - { (request: Request) -> Response in - request.fileio.streamFile( - at: AbsolutePath( - buildDirectory.appending(component: directoryName), - request.parameters.getCatchall().joined(separator: "/") - ).pathString + for responder in responders { + if let response = try responder(context, head.uri) { + return response + } + } + return nil + } + + private func makeStaticResourcesResponder( + baseDirectory: URL + ) -> (_ context: ChannelHandlerContext, _ uri: String) throws -> StaticResponse? { + return { context, uri in + assert(uri.first == "/") + let fileURL = baseDirectory.appendingPathComponent(String(uri.dropFirst())) + var isDir: ObjCBool = false + guard FileManager.default.fileExists(atPath: fileURL.path, isDirectory: &isDir), + !isDir.boolValue + else { + return nil + } + let contentType = self.contentType(of: fileURL) ?? "application/octet-stream" + + return StaticResponse( + contentType: contentType, + body: try context.channel.allocator.buffer(bytes: Data(contentsOf: fileURL)) ) } } - for directoryName in try localFileSystem.resourcesDirectoryNames(relativeTo: buildDirectory) { - get(.constant(directoryName), "**", use: requestHandler(directoryName)) + private func contentType(of filePath: URL) -> String? { + let typeByExtension = [ + "js": "application/javascript", + "mjs": "application/javascript", + "wasm": "application/wasm", + ] + return typeByExtension[filePath.pathExtension] + } + + private func respondIndexPage(context: ChannelHandlerContext) throws -> StaticResponse { + var customIndexContent: String? + if let path = configuration.customIndexPath?.pathString { + customIndexContent = try String(contentsOfFile: path) + } + let htmlContent = HTML.indexPage( + customContent: customIndexContent, + entrypointName: configuration.entrypoint.fileName + ) + return StaticResponse( + contentType: "text/html", + body: context.channel.allocator.buffer(string: htmlContent) + ) + } + + private func respond405(context: ChannelHandlerContext) { + var headers = HTTPHeaders() + headers.add(name: "Connection", value: "close") + headers.add(name: "Content-Length", value: "0") + let head = HTTPResponseHead( + version: .http1_1, + status: .methodNotAllowed, + headers: headers) + context.write(self.wrapOutboundOut(.head(head)), promise: nil) + context.write(self.wrapOutboundOut(.end(nil))).whenComplete { (_: Result) in + context.close(promise: nil) + } + context.flush() + } + + private func respond404(context: ChannelHandlerContext) { + var headers = HTTPHeaders() + headers.add(name: "Connection", value: "close") + headers.add(name: "Content-Length", value: "0") + let head = HTTPResponseHead( + version: .http1_1, + status: .notFound, + headers: headers) + context.write(self.wrapOutboundOut(.head(head)), promise: nil) + context.write(self.wrapOutboundOut(.end(nil))).whenComplete { (_: Result) in + context.close(promise: nil) + } + context.flush() } + } - let inferredMainTarget = configuration.manifest.targets.first { - configuration.product?.targets.contains($0.name) == true + final class WebSocketHandler: ChannelInboundHandler { + typealias InboundIn = WebSocketFrame + typealias OutboundOut = WebSocketFrame + + struct Configuration { + let onText: @Sendable (String) -> Void } - // Serve resources for the main target at the root path. - guard let mainTarget = inferredMainTarget else { return } + private var awaitingClose: Bool = false + let configuration: Configuration + + init(configuration: Configuration) { + self.configuration = configuration + } + + public func handlerAdded(context: ChannelHandlerContext) { + } - let resourcesPath = configuration.manifest.resourcesPath(for: mainTarget) - get("**", use: requestHandler(resourcesPath)) + public func channelRead(context: ChannelHandlerContext, data: NIOAny) { + let frame = self.unwrapInboundIn(data) + + switch frame.opcode { + case .connectionClose: + self.receivedClose(context: context, frame: frame) + case .text: + var data = frame.unmaskedData + let text = data.readString(length: data.readableBytes) ?? "" + self.configuration.onText(text) + case .binary, .continuation, .pong: + // We ignore these frames. + break + default: + // Unknown frames are errors. + self.closeOnError(context: context) + } + } + + public func channelReadComplete(context: ChannelHandlerContext) { + context.flush() + } + + private func receivedClose(context: ChannelHandlerContext, frame: WebSocketFrame) { + if awaitingClose { + context.close(promise: nil) + } else { + var data = frame.unmaskedData + let closeDataCode = data.readSlice(length: 2) ?? ByteBuffer() + let closeFrame = WebSocketFrame(fin: true, opcode: .connectionClose, data: closeDataCode) + _ = context.write(self.wrapOutboundOut(closeFrame)).map { () in + context.close(promise: nil) + } + } + } + + private func closeOnError(context: ChannelHandlerContext) { + var data = context.channel.allocator.buffer(capacity: 2) + data.write(webSocketErrorCode: .protocolError) + let frame = WebSocketFrame(fin: true, opcode: .connectionClose, data: data) + context.write(self.wrapOutboundOut(frame)).whenComplete { (_: Result) in + context.close(mode: .output, promise: nil) + } + awaitingClose = true + } } } + +extension ChannelHandlerContext: @unchecked Sendable {} diff --git a/Sources/CartonKit/Server/Environment+UserAgent.swift b/Sources/CartonKit/Server/Environment+UserAgent.swift index f7792525..9d77d125 100644 --- a/Sources/CartonKit/Server/Environment+UserAgent.swift +++ b/Sources/CartonKit/Server/Environment+UserAgent.swift @@ -12,7 +12,27 @@ // See the License for the specific language governing permissions and // limitations under the License. -import SwiftToolchain +import CartonHelpers + +enum DestinationEnvironment { + case other + case safari + case firefox + case chrome + case edge +} + +extension String { + func parsedStackTrace(in environment: DestinationEnvironment) -> [StackTraceItem]? { + switch environment { + case .safari: return safariStackTrace + case .firefox: return firefoxStackTrace + case .chrome: return chromeStackTrace + case .edge: return chromeStackTrace // TODO: return nil if on old Edge + default: return nil + } + } +} extension DestinationEnvironment { init?(userAgent: String) { diff --git a/Sources/CartonKit/Server/HTML.swift b/Sources/CartonKit/Server/HTML.swift index d3f37c84..e0d4eeed 100644 --- a/Sources/CartonKit/Server/HTML.swift +++ b/Sources/CartonKit/Server/HTML.swift @@ -12,8 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -import TSCBasic -import Vapor +import CartonHelpers enum HTMLError: String, Error { case customIndexPageWithoutHead = """ @@ -25,16 +24,7 @@ public struct HTML { let value: String } -extension HTML: ResponseEncodable { - public func encodeResponse(for request: Request) -> EventLoopFuture { - var headers = HTTPHeaders() - headers.add(name: .contentType, value: "text/html") - return request.eventLoop.makeSucceededFuture( - .init( - status: .ok, headers: headers, body: .init(string: value) - )) - } - +extension HTML { public static func readCustomIndexPage(at path: String?, on fileSystem: FileSystem) throws -> String? { @@ -42,7 +32,8 @@ extension HTML: ResponseEncodable { let content = try localFileSystem.readFileContents( customIndexPage.isAbsolutePath ? AbsolutePath(validating: customIndexPage) - : AbsolutePath(localFileSystem.currentWorkingDirectory!, customIndexPage) + : AbsolutePath( + validating: customIndexPage, relativeTo: localFileSystem.currentWorkingDirectory!) ).description guard content.contains("") else { diff --git a/Sources/CartonKit/Server/Server.swift b/Sources/CartonKit/Server/Server.swift index 82647b9b..5901c20d 100644 --- a/Sources/CartonKit/Server/Server.swift +++ b/Sources/CartonKit/Server/Server.swift @@ -13,11 +13,11 @@ // limitations under the License. import CartonHelpers -import PackageModel -import SwiftToolchain -import TSCBasic -import TSCUtility -import Vapor +import Foundation +import Logging +import NIO +import NIOHTTP1 +import NIOWebSocket private enum Event { enum CodingKeys: String, CodingKey { @@ -62,29 +62,48 @@ extension Event: Decodable { } } -/// This `Hashable` conformance is required to handle simultaneous connections with `Set` -extension WebSocket: Hashable { - public static func == (lhs: WebSocket, rhs: WebSocket) -> Bool { - lhs === rhs - } - - public func hash(into hasher: inout Hasher) { - hasher.combine(ObjectIdentifier(self)) - } +/// A protocol for a builder that can be used to build the app. +public protocol BuilderProtocol { + var pathsToWatch: [AbsolutePath] { get } + func run() async throws } public actor Server { + final class Connection: Hashable { + let channel: Channel + + init(channel: Channel) { + self.channel = channel + } + + func close() -> EventLoopFuture { + channel.eventLoop.makeSucceededVoidFuture() + } + + func reload(_ text: String = "reload") { + let buffer = channel.allocator.buffer(string: text) + let frame = WebSocketFrame(fin: true, opcode: .text, data: buffer) + self.channel.writeAndFlush(frame, promise: nil) + } + + static func == (lhs: Connection, rhs: Connection) -> Bool { + lhs === rhs + } + + func hash(into hasher: inout Hasher) { + hasher.combine(ObjectIdentifier(self)) + } + } /// Used for decoding `Event` values sent from the WebSocket client. private let decoder = JSONDecoder() /// A set of connected WebSocket clients currently connected to this server. - private var connections = Set() + private var connections = Set() /// Filesystem watcher monitoring relevant source files for changes. private var watcher: FSWatch? - /// An instance of Vapor server application. - private let app: Application + private var serverChannel: (any Channel)! /// Local URL of this server, `https://128.0.0.1:8080/` by default. private let localURL: String @@ -98,27 +117,27 @@ public actor Server { /// Continuation for waitUntilTestFinished, passing `hadError: Bool` private var onTestFinishedContinuation: CheckedContinuation? + private let configuration: Configuration + public struct Configuration { - let builder: Builder? + let builder: BuilderProtocol? let mainWasmPath: AbsolutePath let verbose: Bool let port: Int let host: String let customIndexPath: AbsolutePath? - let manifest: Manifest - let product: ProductDescription? + let resourcesPaths: [String] let entrypoint: Entrypoint let terminal: InteractiveWriter public init( - builder: Builder?, + builder: BuilderProtocol?, mainWasmPath: AbsolutePath, verbose: Bool, port: Int, host: String, customIndexPath: AbsolutePath?, - manifest: Manifest, - product: ProductDescription?, + resourcesPaths: [String], entrypoint: Entrypoint, terminal: InteractiveWriter ) { @@ -128,52 +147,18 @@ public actor Server { self.port = port self.host = host self.customIndexPath = customIndexPath - self.manifest = manifest - self.product = product + self.resourcesPaths = resourcesPaths self.entrypoint = entrypoint self.terminal = terminal } } public init( - _ configuration: Configuration, - _ eventLoopGroupProvider: Application.EventLoopGroupProvider = .createNew + _ configuration: Configuration ) async throws { - var env = Environment( - name: configuration.verbose ? "development" : "production", - arguments: ["vapor"] - ) localURL = "http://\(configuration.host):\(configuration.port)/" - - try LoggingSystem.bootstrap(from: &env) - app = Application(env, eventLoopGroupProvider) watcher = nil - - try app.configure( - .init( - port: configuration.port, - host: configuration.host, - mainWasmPath: configuration.mainWasmPath, - customIndexPath: configuration.customIndexPath, - manifest: configuration.manifest, - product: configuration.product, - entrypoint: configuration.entrypoint, - onWebSocketOpen: { [weak self] ws, environment in - if let handler = await self?.createWSHandler( - configuration, - in: environment, - terminal: configuration.terminal - ) { - ws.eventLoop.execute { - ws.onText(handler) - } - } - - await self?.add(connection: ws) - }, - onWebSocketClose: { [weak self] in await self?.remove(connection: $0) } - ) - ) + self.configuration = configuration guard let builder = configuration.builder else { return @@ -196,9 +181,6 @@ public actor Server { return } - if !configuration.verbose { - configuration.terminal.clearWindow() - } configuration.terminal.write( "\nThese paths have changed, rebuilding...\n", inColor: .yellow @@ -226,34 +208,88 @@ public actor Server { private func add(pendingChanges: [AbsolutePath]) {} - private func add(connection: WebSocket) { + private func add(connection: Connection) { connections.insert(connection) } - private func remove(connection: WebSocket) { + private func remove(connection: Connection) { connections.remove(connection) } - public func start() throws -> String { - try app.start() + public func start() async throws -> String { + let group = MultiThreadedEventLoopGroup.singleton + let upgrader = NIOWebSocketServerUpgrader( + shouldUpgrade: { + (channel: Channel, head: HTTPRequestHead) in + channel.eventLoop.makeSucceededFuture(HTTPHeaders()) + }, + upgradePipelineHandler: { (channel: Channel, head: HTTPRequestHead) in + return channel.eventLoop.makeFutureWithTask { () -> WebSocketHandler? in + guard head.uri == "/watcher" else { + return nil + } + let environment = + head.headers["User-Agent"].compactMap(DestinationEnvironment.init).first + ?? .other + let handler = await WebSocketHandler( + configuration: Server.WebSocketHandler.Configuration( + onText: self.createWSHandler(in: environment, terminal: self.configuration.terminal) + ) + ) + await self.add(connection: Connection(channel: channel)) + return handler + }.flatMap { maybeHandler in + guard let handler = maybeHandler else { + return channel.eventLoop.makeSucceededVoidFuture() + } + return channel.pipeline.addHandler(handler) + } + } + ) + let handlerConfiguration = HTTPHandler.Configuration( + logger: Logger(label: "org.swiftwasm.carton.dev-server"), + mainWasmPath: configuration.mainWasmPath, + customIndexPath: configuration.customIndexPath, + resourcesPaths: configuration.resourcesPaths, + entrypoint: configuration.entrypoint + ) + let channel = try await ServerBootstrap(group: group) + // Specify backlog and enable SO_REUSEADDR for the server itself + .serverChannelOption(ChannelOptions.backlog, value: 256) + .serverChannelOption(ChannelOptions.socketOption(.so_reuseaddr), value: 1) + .childChannelInitializer { channel in + let httpHandler = HTTPHandler(configuration: handlerConfiguration) + let config: NIOHTTPServerUpgradeConfiguration = ( + upgraders: [upgrader], + completionHandler: { _ in + channel.pipeline.removeHandler(httpHandler, promise: nil) + } + ) + return channel.pipeline.configureHTTPServerPipeline(withServerUpgrade: config).flatMap { + channel.pipeline.addHandler(httpHandler) + } + } + // Enable SO_REUSEADDR for the accepted Channels + .childChannelOption(ChannelOptions.socketOption(.so_reuseaddr), value: 1) + .bind(host: configuration.host, port: configuration.port) + .get() + + self.serverChannel = channel return localURL } /// Wait and handle the shutdown public func waitUntilStop() async throws { - defer { self.app.shutdown() } - try await app.running?.onStop.get() + try await self.serverChannel.closeFuture.get() try closeSockets() } /// Wait and handle the shutdown public func waitUntilTestFinished() async throws -> Bool { - defer { self.app.shutdown() } let hadError = await withCheckedContinuation { cont in self.onTestFinishedContinuation = cont } self.onTestFinishedContinuation = nil - app.running?.stop() try closeSockets() return hadError } @@ -265,14 +301,14 @@ public actor Server { } private func run( - _ builder: Builder, + _ builder: any BuilderProtocol, _ terminal: InteractiveWriter ) async throws { try await builder.run() terminal.write("\nBuild completed successfully\n", inColor: .green, bold: false) terminal.logLookup("The app is currently hosted at ", localURL) - connections.forEach { $0.send("reload") } + connections.forEach { $0.reload() } } private func stopTest(hadError: Bool) { @@ -283,11 +319,10 @@ public actor Server { extension Server { /// Returns a handler that responds to WebSocket messages coming from the browser. func createWSHandler( - _ configuration: Configuration, in environment: DestinationEnvironment, terminal: InteractiveWriter - ) -> @Sendable (WebSocket, String) -> Void { - { [weak self] _, text in + ) -> @Sendable (String) -> Void { + { [weak self] text in guard let self = self else { return } guard let data = text.data(using: .utf8), diff --git a/Sources/CartonKit/Server/StaticArchive.swift b/Sources/CartonKit/Server/StaticArchive.swift index 33e7c7d7..53194c1c 100644 --- a/Sources/CartonKit/Server/StaticArchive.swift +++ b/Sources/CartonKit/Server/StaticArchive.swift @@ -1,23 +1,24 @@ -import TSCBasic +import CartonHelpers public let devEntrypointSHA256 = ByteString([ 0x07, 0x6D, 0x94, 0xC8, 0x40, 0x67, 0xEF, 0xE5, 0xAE, 0x50, 0x32, 0xAC, 0x17, 0x10, 0xFA, 0x51, - 0x35, 0x9F, 0xEE, 0x89, 0x5E, 0xFC, 0xA9, 0x32, 0xA4, 0xFA, 0x9A, 0xB4, 0x0B, 0xF8, 0x56, 0x73 + 0x35, 0x9F, 0xEE, 0x89, 0x5E, 0xFC, 0xA9, 0x32, 0xA4, 0xFA, 0x9A, 0xB4, 0x0B, 0xF8, 0x56, 0x73, ]) public let bundleEntrypointSHA256 = ByteString([ 0x05, 0xBA, 0xF0, 0xD9, 0x9F, 0x48, 0xF8, 0x0B, 0xA1, 0x57, 0x27, 0x9E, 0xB0, 0xFD, 0xAC, 0xEE, - 0x42, 0x50, 0x9F, 0x41, 0x86, 0xED, 0xA9, 0x5E, 0x05, 0x19, 0x33, 0x5D, 0x04, 0x8F, 0x4F, 0x33 + 0x42, 0x50, 0x9F, 0x41, 0x86, 0xED, 0xA9, 0x5E, 0x05, 0x19, 0x33, 0x5D, 0x04, 0x8F, 0x4F, 0x33, ]) public let testEntrypointSHA256 = ByteString([ 0x9C, 0x69, 0xC3, 0x94, 0x6B, 0x20, 0xD1, 0x9B, 0xEE, 0x16, 0x87, 0x4D, 0xA0, 0x99, 0x73, 0x6B, - 0xC1, 0x12, 0x6D, 0xC7, 0xE8, 0x9C, 0xF0, 0x16, 0x31, 0x5F, 0xD0, 0x6B, 0x3E, 0x48, 0x4E, 0x33 + 0xC1, 0x12, 0x6D, 0xC7, 0xE8, 0x9C, 0xF0, 0x16, 0x31, 0x5F, 0xD0, 0x6B, 0x3E, 0x48, 0x4E, 0x33, ]) public let testNodeEntrypointSHA256 = ByteString([ 0x2E, 0x13, 0x05, 0xE6, 0x24, 0x07, 0x1A, 0x07, 0x2C, 0xE5, 0xAE, 0xFA, 0x28, 0x50, 0xD6, 0xA2, - 0xC1, 0xBB, 0x11, 0x7A, 0x04, 0x84, 0xB7, 0x21, 0xF5, 0x33, 0x28, 0xEC, 0xCA, 0xF8, 0x1F, 0x09 + 0xC1, 0xBB, 0x11, 0x7A, 0x04, 0x84, 0xB7, 0x21, 0xF5, 0x33, 0x28, 0xEC, 0xCA, 0xF8, 0x1F, 0x09, ]) -public let staticArchiveContents = "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" \ No newline at end of file +public let staticArchiveContents = + "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" diff --git a/Sources/CartonKit/Utilities/FSWatch.swift b/Sources/CartonKit/Utilities/FSWatch.swift new file mode 100644 index 00000000..cf142448 --- /dev/null +++ b/Sources/CartonKit/Utilities/FSWatch.swift @@ -0,0 +1,871 @@ +/* + This source file is part of the Swift.org open source project + + Copyright (c) 2014 - 2018 Apple Inc. and the Swift project authors + Licensed under Apache License v2.0 with Runtime Library Exception + + See http://swift.org/LICENSE.txt for license information + See http://swift.org/CONTRIBUTORS.txt for Swift project authors +*/ + +import CartonHelpers +import Dispatch +import Foundation + +#if os(Windows) + import WinSDK +#endif + +/// FSWatch is a cross-platform filesystem watching utility. +public class FSWatch { + + public typealias EventReceivedBlock = (_ paths: [AbsolutePath]) -> Void + + /// Delegate for handling events from the underling watcher. + fileprivate struct _WatcherDelegate { + let block: EventReceivedBlock + + func pathsDidReceiveEvent(_ paths: [AbsolutePath]) { + block(paths) + } + } + + /// The paths being watched. + public let paths: [AbsolutePath] + + /// The underlying file watching utility. + /// + /// This is FSEventStream on macOS and inotify on linux. + private var _watcher: _FileWatcher! + + /// The number of seconds the watcher should wait before passing the + /// collected events to the clients. + let latency: Double + + /// Create an instance with given paths. + /// + /// Paths can be files or directories. Directories are watched recursively. + public init(paths: [AbsolutePath], latency: Double = 1, block: @escaping EventReceivedBlock) { + precondition(!paths.isEmpty) + self.paths = paths + self.latency = latency + + #if os(OpenBSD) + self._watcher = NoOpWatcher( + paths: paths, latency: latency, delegate: _WatcherDelegate(block: block)) + #elseif os(Windows) + self._watcher = RDCWatcher( + paths: paths, latency: latency, delegate: _WatcherDelegate(block: block)) + #elseif canImport(Glibc) || canImport(Musl) + var ipaths: [AbsolutePath: Inotify.WatchOptions] = [:] + + // FIXME: We need to recurse here. + for path in paths { + if localFileSystem.isDirectory(path) { + ipaths[path] = .defaultDirectoryWatchOptions + } else if localFileSystem.isFile(path) { + ipaths[path] = .defaultFileWatchOptions + // Watch files. + } else { + // FIXME: Report errors + } + } + + self._watcher = Inotify( + paths: ipaths, latency: latency, delegate: _WatcherDelegate(block: block)) + #elseif os(macOS) + self._watcher = FSEventStream( + paths: paths, latency: latency, delegate: _WatcherDelegate(block: block)) + #else + fatalError("Unsupported platform") + #endif + } + + /// Start watching the filesystem for events. + /// + /// This method should be called only once. + public func start() throws { + // FIXME: Write precondition to ensure its called only once. + try _watcher.start() + } + + /// Stop watching the filesystem. + /// + /// This method should be called after start() and the object should be thrown away. + public func stop() { + // FIXME: Write precondition to ensure its called after start() and once only. + _watcher.stop() + } +} + +/// Protocol to which the different file watcher implementations should conform. +private protocol _FileWatcher { + func start() throws + func stop() +} + +#if os(OpenBSD) || (!os(macOS) && canImport(Darwin)) + extension FSWatch._WatcherDelegate: NoOpWatcherDelegate {} + extension NoOpWatcher: _FileWatcher {} +#elseif os(Windows) + extension FSWatch._WatcherDelegate: RDCWatcherDelegate {} + extension RDCWatcher: _FileWatcher {} +#elseif canImport(Glibc) || canImport(Musl) + extension FSWatch._WatcherDelegate: InotifyDelegate {} + extension Inotify: _FileWatcher {} +#elseif os(macOS) + extension FSWatch._WatcherDelegate: FSEventStreamDelegate {} + extension FSEventStream: _FileWatcher {} +#else + #error("Implementation required") +#endif + +// MARK:- inotify + +#if os(OpenBSD) || (!os(macOS) && canImport(Darwin)) + + public protocol NoOpWatcherDelegate { + func pathsDidReceiveEvent(_ paths: [AbsolutePath]) + } + + public final class NoOpWatcher { + public init(paths: [AbsolutePath], latency: Double, delegate: NoOpWatcherDelegate? = nil) { + } + + public func start() throws {} + + public func stop() {} + } + +#elseif os(Windows) + + public protocol RDCWatcherDelegate { + func pathsDidReceiveEvent(_ paths: [AbsolutePath]) + } + + /// Bindings for `ReadDirectoryChangesW` C APIs. + public final class RDCWatcher { + class Watch { + var hDirectory: HANDLE + let path: String + var overlapped: OVERLAPPED + var terminate: HANDLE + var buffer: UnsafeMutableBufferPointer // buffer must be DWORD-aligned + var thread: TSCBasic.Thread? + + public init(directory handle: HANDLE, _ path: String) { + self.hDirectory = handle + self.path = path + self.overlapped = OVERLAPPED() + self.overlapped.hEvent = CreateEventW(nil, false, false, nil) + self.terminate = CreateEventW(nil, true, false, nil) + + let EntrySize: Int = + MemoryLayout.stride + + (Int(MAX_PATH) * MemoryLayout.stride) + self.buffer = + UnsafeMutableBufferPointer.allocate( + capacity: EntrySize * 4 / MemoryLayout.stride) + } + + deinit { + SetEvent(self.terminate) + CloseHandle(self.terminate) + CloseHandle(self.overlapped.hEvent) + CloseHandle(hDirectory) + self.buffer.deallocate() + } + } + + /// The paths being watched. + private let paths: [AbsolutePath] + + /// The settle period (in seconds). + private let settle: Double + + /// The watcher delegate. + private let delegate: RDCWatcherDelegate? + + private let watches: [Watch] + private let queue: DispatchQueue = + DispatchQueue(label: "org.swift.swiftpm.\(RDCWatcher.self).callback") + + public init(paths: [AbsolutePath], latency: Double, delegate: RDCWatcherDelegate? = nil) { + self.paths = paths + self.settle = latency + self.delegate = delegate + + self.watches = paths.map { + $0.pathString.withCString(encodedAs: UTF16.self) { + let dwDesiredAccess: DWORD = DWORD(FILE_LIST_DIRECTORY) + let dwShareMode: DWORD = DWORD(FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE) + let dwCreationDisposition: DWORD = DWORD(OPEN_EXISTING) + let dwFlags: DWORD = DWORD(FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED) + + let handle: HANDLE = + CreateFileW( + $0, dwDesiredAccess, dwShareMode, nil, + dwCreationDisposition, dwFlags, nil) + assert(!(handle == INVALID_HANDLE_VALUE)) + + let dwSize: DWORD = GetFinalPathNameByHandleW(handle, nil, 0, 0) + let path: String = String( + decodingCString: [WCHAR](unsafeUninitializedCapacity: Int(dwSize) + 1) { + let dwSize: DWORD = GetFinalPathNameByHandleW( + handle, $0.baseAddress, DWORD($0.count), 0) + assert(dwSize == $0.count) + $1 = Int(dwSize) + }, as: UTF16.self) + + return Watch(directory: handle, path) + } + } + } + + public func start() throws { + // TODO(compnerd) can we compress the threads to a single worker thread + self.watches.forEach { watch in + watch.thread = Thread { [delegate = self.delegate, queue = self.queue, weak watch] in + guard let watch = watch else { return } + + while true { + let dwNotifyFilter: DWORD = + DWORD(FILE_NOTIFY_CHANGE_FILE_NAME) + | DWORD(FILE_NOTIFY_CHANGE_DIR_NAME) + | DWORD(FILE_NOTIFY_CHANGE_SIZE) + | DWORD(FILE_NOTIFY_CHANGE_LAST_WRITE) + | DWORD(FILE_NOTIFY_CHANGE_CREATION) + var dwBytesReturned: DWORD = 0 + if !ReadDirectoryChangesW( + watch.hDirectory, &watch.buffer, + DWORD(watch.buffer.count * MemoryLayout.stride), + true, dwNotifyFilter, &dwBytesReturned, + &watch.overlapped, nil) + { + return + } + + var handles: (HANDLE?, HANDLE?) = (watch.terminate, watch.overlapped.hEvent) + switch WaitForMultipleObjects(2, &handles.0, false, INFINITE) { + case WAIT_OBJECT_0 + 1: + break + case DWORD(WAIT_TIMEOUT): // Spurious Wakeup? + continue + case WAIT_FAILED, WAIT_OBJECT_0: // Terminate Request + fallthrough + default: + CloseHandle(watch.hDirectory) + watch.hDirectory = INVALID_HANDLE_VALUE + return + } + + if !GetOverlappedResult(watch.hDirectory, &watch.overlapped, &dwBytesReturned, false) { + queue.async { + delegate?.pathsDidReceiveEvent([AbsolutePath(watch.path)]) + } + return + } + + // There was a buffer underrun on the kernel side. We may + // have lost events, please re-synchronize. + if dwBytesReturned == 0 { + return + } + + var paths: [AbsolutePath] = [] + watch.buffer.withMemoryRebound(to: FILE_NOTIFY_INFORMATION.self) { + let pNotify: UnsafeMutablePointer? = + $0.baseAddress + while var pNotify = pNotify { + // FIXME(compnerd) do we care what type of event was received? + let file: String = + String( + utf16CodeUnitsNoCopy: &pNotify.pointee.FileName, + count: Int(pNotify.pointee.FileNameLength) / MemoryLayout.stride, + freeWhenDone: false) + paths.append(AbsolutePath(file)) + + pNotify = (UnsafeMutableRawPointer(pNotify) + Int(pNotify.pointee.NextEntryOffset)) + .assumingMemoryBound(to: FILE_NOTIFY_INFORMATION.self) + } + } + + queue.async { + delegate?.pathsDidReceiveEvent(paths) + } + } + } + watch.thread?.start() + } + } + + public func stop() { + self.watches.forEach { + SetEvent($0.terminate) + $0.thread?.join() + } + } + } + +#elseif canImport(Glibc) || canImport(Musl) + + /// The delegate for receiving inotify events. + public protocol InotifyDelegate { + func pathsDidReceiveEvent(_ paths: [AbsolutePath]) + } + + /// Bindings for inotify C APIs. + public final class Inotify { + + /// The errors encountered during inotify operations. + public enum Error: Swift.Error { + case invalidFD + case failedToWatch(AbsolutePath) + } + + /// The available options for a particular path. + public struct WatchOptions: OptionSet { + public let rawValue: Int32 + + public init(rawValue: Int32) { + self.rawValue = rawValue + } + + // File/directory created in watched directory (e.g., open(2) + // O_CREAT, mkdir(2), link(2), symlink(2), bind(2) on a UNIX + // domain socket). + public static let create = WatchOptions(rawValue: IN_CREATE) + + // File/directory deleted from watched directory. + public static let delete = WatchOptions(rawValue: IN_DELETE) + + // Watched file/directory was itself deleted. (This event + // also occurs if an object is moved to another filesystem, + // since mv(1) in effect copies the file to the other + // filesystem and then deletes it from the original filesys‐ + // tem.) In addition, an IN_IGNORED event will subsequently + // be generated for the watch descriptor. + public static let deleteSelf = WatchOptions(rawValue: IN_DELETE_SELF) + + public static let move = WatchOptions(rawValue: IN_MOVE) + + /// Watched file/directory was itself moved. + public static let moveSelf = WatchOptions(rawValue: IN_MOVE_SELF) + + /// File was modified (e.g., write(2), truncate(2)). + public static let modify = WatchOptions(rawValue: IN_MODIFY) + + // File or directory was opened. + public static let open = WatchOptions(rawValue: IN_OPEN) + + // Metadata changed—for example, permissions (e.g., + // chmod(2)), timestamps (e.g., utimensat(2)), extended + // attributes (setxattr(2)), link count (since Linux 2.6.25; + // e.g., for the target of link(2) and for unlink(2)), and + // user/group ID (e.g., chown(2)). + public static let attrib = WatchOptions(rawValue: IN_ATTRIB) + + // File opened for writing was closed. + public static let closeWrite = WatchOptions(rawValue: IN_CLOSE_WRITE) + + // File or directory not opened for writing was closed. + public static let closeNoWrite = WatchOptions(rawValue: IN_CLOSE_NOWRITE) + + // File was accessed (e.g., read(2), execve(2)). + public static let access = WatchOptions(rawValue: IN_ACCESS) + + /// The list of default options that can be used for watching files. + public static let defaultFileWatchOptions: WatchOptions = [.deleteSelf, .moveSelf, .modify] + + /// The list of default options that can be used for watching directories. + public static let defaultDirectoryWatchOptions: WatchOptions = [ + .create, .delete, .deleteSelf, .move, .moveSelf, + ] + + /// List of all available events. + public static let all: [WatchOptions] = [ + .create, + .delete, + .deleteSelf, + .move, + .moveSelf, + .modify, + .open, + .attrib, + .closeWrite, + .closeNoWrite, + .access, + ] + } + + // Sizeof inotify_event + max len of filepath + 1 (for null char). + private static let eventSize = MemoryLayout.size + Int(NAME_MAX) + 1 + + /// The paths being watched. + public let paths: [AbsolutePath: WatchOptions] + + /// The delegate. + private let delegate: InotifyDelegate? + + /// The settle period (in seconds). + public let settle: Double + + /// Internal properties. + private var fd: Int32? + + /// The list of watched directories/files. + private var wds: [Int32: AbsolutePath] = [:] + + /// The queue on which we read the events. + private let readQueue = DispatchQueue(label: "org.swift.swiftpm.\(Inotify.self).read") + + /// Callback queue for the delegate. + private let callbacksQueue = DispatchQueue(label: "org.swift.swiftpm.\(Inotify.self).callback") + + /// Condition for handling event reporting. + private var reportCondition = Condition() + + // Should be read or written to using the report condition only. + private var collectedEvents: [AbsolutePath] = [] + + // Should be read or written to using the report condition only. + private var lastEventTime: Date? = nil + + // Should be read or written to using the report condition only. + private var cancelled = false + + /// Pipe for waking up the read loop. + private var cancellationPipe: [Int32] = [0, 0] + + /// Create a inotify instance. + /// + /// The paths are not watched recursively. + public init( + paths: [AbsolutePath: WatchOptions], latency: Double, delegate: InotifyDelegate? = nil + ) { + self.paths = paths + self.delegate = delegate + self.settle = latency + } + + /// Start the watch operation. + public func start() throws { + + // All paths need to exist. + for (path, _) in paths { + guard localFileSystem.exists(path) else { + throw Error.failedToWatch(path) + } + } + + // Create the file descriptor. + let fd = inotify_init1(Int32(IN_NONBLOCK)) + + guard fd != -1 else { + throw Error.invalidFD + } + self.fd = fd + + /// Add watch for each path. + for (path, options) in paths { + + let wd = inotify_add_watch(fd, path.description, UInt32(options.rawValue)) + guard wd != -1 else { + throw Error.failedToWatch(path) + } + + self.wds[wd] = path + } + + // Start the report thread. + startReportThread() + + readQueue.async { + self.startRead() + } + } + + /// End the watch operation. + public func stop() { + // FIXME: Write precondition to ensure this is called only once. + guard let fd = fd else { + assertionFailure("end called without a fd") + return + } + + // Shutdown the report thread. + reportCondition.whileLocked { + cancelled = true + reportCondition.signal() + } + + // Wakeup the read loop by writing on the cancellation pipe. + let writtenData = write(cancellationPipe[1], "", 1) + assert(writtenData == 1) + + // FIXME: We need to remove the watches. + close(fd) + } + + private func startRead() { + guard let fd = fd else { + fatalError("unexpected call to startRead without fd") + } + + // Create a pipe that we can use to get notified when we're cancelled. + let pipeRv = pipe(&cancellationPipe) + // FIXME: We don't see pipe2 for some reason. + let f = fcntl(cancellationPipe[0], F_SETFL, O_NONBLOCK) + assert(f != -1) + assert(pipeRv == 0) + + while true { + // The read fd set. Contains the inotify and cancellation fd. + var rfds = fd_set() + FD_ZERO(&rfds) + + FD_SET(fd, &rfds) + FD_SET(cancellationPipe[0], &rfds) + + let nfds = [fd, cancellationPipe[0]].reduce(0, max) + 1 + // num fds, read fds, write fds, except fds, timeout + let selectRet = select(nfds, &rfds, nil, nil, nil) + // FIXME: Check for int signal. + assert(selectRet != -1) + + // Return if we're cancelled. + if FD_ISSET(cancellationPipe[0], &rfds) { + return + } + assert(FD_ISSET(fd, &rfds)) + + let buf = UnsafeMutablePointer.allocate(capacity: Inotify.eventSize) + // FIXME: We need to free the buffer. + + let readLength = read(fd, buf, Inotify.eventSize) + // FIXME: Check for int signal. + + // Consume events. + var idx = 0 + while idx < readLength { + let event = withUnsafePointer(to: &buf[idx]) { + $0.withMemoryRebound(to: inotify_event.self, capacity: 1) { + $0.pointee + } + } + + // Get the associated with the event. + var path = wds[event.wd]! + + // FIXME: We need extract information from the event mask and + // create a data structure. + // FIXME: Do we need to detect and remove watch for directories + // that are deleted? + + // Get the relative base name from the event if present. + if event.len > 0 { + // Get the basename of the file that had the event. + let basename = String(cString: buf + idx + MemoryLayout.size) + + // Construct the full path. + // FIXME: We should report this path separately. + path = path.appending(component: basename) + } + + // Signal the reporter. + reportCondition.whileLocked { + lastEventTime = Date() + collectedEvents.append(path) + reportCondition.signal() + } + + idx += MemoryLayout.size + Int(event.len) + } + } + } + + /// Spawns a thread that collects events and reports them after the settle period. + private func startReportThread() { + let thread = TSCBasic.Thread { + var endLoop = false + while !endLoop { + + // Block until we timeout or get signalled. + self.reportCondition.whileLocked { + var performReport = false + + // Block until timeout expires or wait forever until we get some event. + if let lastEventTime = self.lastEventTime { + let timeout = lastEventTime + Double(self.settle) + let timeLimitReached = !self.reportCondition.wait(until: timeout) + + if timeLimitReached { + self.lastEventTime = nil + performReport = true + } + } else { + self.reportCondition.wait() + } + + // If we're cancelled, just return. + if self.cancelled { + endLoop = true + return + } + + // Report the events if we're asked to. + if performReport && !self.collectedEvents.isEmpty { + let events = self.collectedEvents + self.collectedEvents = [] + self.callbacksQueue.async { + self.report(events) + } + } + } + } + } + + thread.start() + } + + private func report(_ paths: [AbsolutePath]) { + delegate?.pathsDidReceiveEvent(paths) + } + } + + // FIXME: Swift should provide shims for FD_ macros + + private func FD_ZERO(_ set: inout fd_set) { + #if os(Android) || canImport(Musl) + #if arch(arm) + set.fds_bits = ( + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + ) + #else + set.fds_bits = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) + #endif + #else + #if arch(arm) + set.__fds_bits = ( + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + ) + #else + set.__fds_bits = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) + #endif + #endif + } + + private func FD_SET(_ fd: Int32, _ set: inout fd_set) { + let intOffset = Int(fd / 16) + let bitOffset = Int(fd % 16) + #if os(Android) || canImport(Musl) + var fd_bits = set.fds_bits + let mask: UInt = 1 << bitOffset + #else + var fd_bits = set.__fds_bits + let mask = 1 << bitOffset + #endif + switch intOffset { + case 0: fd_bits.0 = fd_bits.0 | mask + case 1: fd_bits.1 = fd_bits.1 | mask + case 2: fd_bits.2 = fd_bits.2 | mask + case 3: fd_bits.3 = fd_bits.3 | mask + case 4: fd_bits.4 = fd_bits.4 | mask + case 5: fd_bits.5 = fd_bits.5 | mask + case 6: fd_bits.6 = fd_bits.6 | mask + case 7: fd_bits.7 = fd_bits.7 | mask + case 8: fd_bits.8 = fd_bits.8 | mask + case 9: fd_bits.9 = fd_bits.9 | mask + case 10: fd_bits.10 = fd_bits.10 | mask + case 11: fd_bits.11 = fd_bits.11 | mask + case 12: fd_bits.12 = fd_bits.12 | mask + case 13: fd_bits.13 = fd_bits.13 | mask + case 14: fd_bits.14 = fd_bits.14 | mask + case 15: fd_bits.15 = fd_bits.15 | mask + #if arch(arm) + case 16: fd_bits.16 = fd_bits.16 | mask + case 17: fd_bits.17 = fd_bits.17 | mask + case 18: fd_bits.18 = fd_bits.18 | mask + case 19: fd_bits.19 = fd_bits.19 | mask + case 20: fd_bits.20 = fd_bits.20 | mask + case 21: fd_bits.21 = fd_bits.21 | mask + case 22: fd_bits.22 = fd_bits.22 | mask + case 23: fd_bits.23 = fd_bits.23 | mask + case 24: fd_bits.24 = fd_bits.24 | mask + case 25: fd_bits.25 = fd_bits.25 | mask + case 26: fd_bits.26 = fd_bits.26 | mask + case 27: fd_bits.27 = fd_bits.27 | mask + case 28: fd_bits.28 = fd_bits.28 | mask + case 29: fd_bits.29 = fd_bits.29 | mask + case 30: fd_bits.30 = fd_bits.30 | mask + case 31: fd_bits.31 = fd_bits.31 | mask + #endif + default: break + } + #if os(Android) || canImport(Musl) + set.fds_bits = fd_bits + #else + set.__fds_bits = fd_bits + #endif + } + + private func FD_ISSET(_ fd: Int32, _ set: inout fd_set) -> Bool { + let intOffset = Int(fd / 32) + let bitOffset = Int(fd % 32) + #if os(Android) || canImport(Musl) + let fd_bits = set.fds_bits + let mask: UInt = 1 << bitOffset + #else + let fd_bits = set.__fds_bits + let mask = 1 << bitOffset + #endif + switch intOffset { + case 0: return fd_bits.0 & mask != 0 + case 1: return fd_bits.1 & mask != 0 + case 2: return fd_bits.2 & mask != 0 + case 3: return fd_bits.3 & mask != 0 + case 4: return fd_bits.4 & mask != 0 + case 5: return fd_bits.5 & mask != 0 + case 6: return fd_bits.6 & mask != 0 + case 7: return fd_bits.7 & mask != 0 + case 8: return fd_bits.8 & mask != 0 + case 9: return fd_bits.9 & mask != 0 + case 10: return fd_bits.10 & mask != 0 + case 11: return fd_bits.11 & mask != 0 + case 12: return fd_bits.12 & mask != 0 + case 13: return fd_bits.13 & mask != 0 + case 14: return fd_bits.14 & mask != 0 + case 15: return fd_bits.15 & mask != 0 + #if arch(arm) + case 16: return fd_bits.16 & mask != 0 + case 17: return fd_bits.17 & mask != 0 + case 18: return fd_bits.18 & mask != 0 + case 19: return fd_bits.19 & mask != 0 + case 20: return fd_bits.20 & mask != 0 + case 21: return fd_bits.21 & mask != 0 + case 22: return fd_bits.22 & mask != 0 + case 23: return fd_bits.23 & mask != 0 + case 24: return fd_bits.24 & mask != 0 + case 25: return fd_bits.25 & mask != 0 + case 26: return fd_bits.26 & mask != 0 + case 27: return fd_bits.27 & mask != 0 + case 28: return fd_bits.28 & mask != 0 + case 29: return fd_bits.29 & mask != 0 + case 30: return fd_bits.30 & mask != 0 + case 31: return fd_bits.31 & mask != 0 + #endif + default: return false + } + } + +#endif + +// MARK:- FSEventStream + +#if os(macOS) + + private func callback( + streamRef: ConstFSEventStreamRef, + clientCallBackInfo: UnsafeMutableRawPointer?, + numEvents: Int, + eventPaths: UnsafeMutableRawPointer, + eventFlags: UnsafePointer, + eventIds: UnsafePointer + ) { + let eventStream = unsafeBitCast(clientCallBackInfo, to: FSEventStream.self) + + // We expect the paths to be reported in an NSArray because we requested CFTypes. + let eventPaths = unsafeBitCast(eventPaths, to: NSArray.self) as? [String] ?? [] + + // Compute the set of paths that were changed. + let paths = eventPaths.compactMap({ try? AbsolutePath(validating: $0) }) + + eventStream.callbacksQueue.async { + eventStream.delegate.pathsDidReceiveEvent(paths) + } + } + + public protocol FSEventStreamDelegate { + func pathsDidReceiveEvent(_ paths: [AbsolutePath]) + } + + /// Wrapper for Darwin's FSEventStream API. + public final class FSEventStream { + + /// The errors encountered during fs event watching. + public enum Error: Swift.Error { + case unknownError + } + + /// Reference to the underlying event stream. + /// + /// This is var and implicitly unwrapped optional because + /// we need to capture self for the context. + private var stream: FSEventStreamRef! + + /// Reference to the handler that should be called. + let delegate: FSEventStreamDelegate + + /// The thread on which the stream is running. + private var thread: Thread? + + /// The run loop attached to the stream. + private var runLoop: CFRunLoop? + + /// Callback queue for the delegate. + fileprivate let callbacksQueue = DispatchQueue( + label: "org.swift.swiftpm.\(FSEventStream.self).callback") + + public init( + paths: [AbsolutePath], + latency: Double, + delegate: FSEventStreamDelegate, + flags: FSEventStreamCreateFlags = FSEventStreamCreateFlags(kFSEventStreamCreateFlagUseCFTypes) + ) { + self.delegate = delegate + + // Create the context that needs to be passed to the callback. + var callbackContext = FSEventStreamContext() + callbackContext.info = unsafeBitCast(self, to: UnsafeMutableRawPointer.self) + + // Create the stream. + self.stream = FSEventStreamCreate( + nil, + callback, + &callbackContext, + paths.map({ $0.pathString }) as CFArray, + FSEventStreamEventId(kFSEventStreamEventIdSinceNow), + latency, + flags + ) + } + + // Start the runloop. + public func start() throws { + let thread = Thread { [weak self] in + guard let `self` = self else { return } + self.runLoop = CFRunLoopGetCurrent() + let queue = DispatchQueue(label: "org.swiftwasm.carton.FSWatch") + queue.sync { + // Schedule the run loop. + FSEventStreamSetDispatchQueue(self.stream, queue) + // Start the stream. + FSEventStreamSetDispatchQueue(self.stream, queue) + FSEventStreamStart(self.stream) + } + } + thread.start() + self.thread = thread + } + + /// Stop watching the events. + public func stop() { + // FIXME: This is probably not thread safe? + if let runLoop = self.runLoop { + CFRunLoopStop(runLoop) + } + } + } +#endif diff --git a/Sources/CartonKit/Utilities/README.md b/Sources/CartonKit/Utilities/README.md new file mode 100644 index 00000000..76e803f0 --- /dev/null +++ b/Sources/CartonKit/Utilities/README.md @@ -0,0 +1,3 @@ +Source files under this directory are derived from the [swift-tools-support-core](https://github.com/apple/swift-tools-support-core) package. The original source files are located in the `Sources/TSCUtility` directory of the swift-tools-support-core repository and are used under the terms of the [Apache License, Version 2.0 with LLVM Exceptions](https://github.com/apple/swift-tools-support-core/blob/main/LICENSE.txt). + +We vend the source files in this directory to avoid bringing in the entire swift-tools-support-core package as a dependency. diff --git a/Sources/SwiftToolchain/BuildDescription.swift b/Sources/SwiftToolchain/BuildDescription.swift deleted file mode 100644 index 2e47b4e7..00000000 --- a/Sources/SwiftToolchain/BuildDescription.swift +++ /dev/null @@ -1,22 +0,0 @@ -// Copyright 2021 Carton contributors -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -import PackageModel -import TSCBasic - -public struct BuildDescription { - public let arguments: [String] - public let mainWasmPath: AbsolutePath - public let product: ProductDescription -} diff --git a/Sources/SwiftToolchain/BuildFlavor.swift b/Sources/SwiftToolchain/BuildFlavor.swift deleted file mode 100644 index 8ff994b0..00000000 --- a/Sources/SwiftToolchain/BuildFlavor.swift +++ /dev/null @@ -1,48 +0,0 @@ -// Copyright 2020 Carton contributors -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -public enum SanitizeVariant: String, CaseIterable { - case stackOverflow -} - -/// The target environment to build for. -/// `Environment` doesn't specify the concrete environment, but the type of environments enough for build planning. -public enum Environment: String, CaseIterable { - public static var allCasesNames: [String] { Environment.allCases.map { $0.rawValue } } - - // TODO: Rename to `commandLine` to avoid confusion - case wasmer - case node - case defaultBrowser - -} - -public struct BuildFlavor { - public var isRelease: Bool - public var environment: Environment - public var sanitize: SanitizeVariant? - public var swiftCompilerFlags: [String] - - public init( - isRelease: Bool, - environment: Environment, - sanitize: SanitizeVariant?, - swiftCompilerFlags: [String] - ) { - self.isRelease = isRelease - self.environment = environment - self.sanitize = sanitize - self.swiftCompilerFlags = swiftCompilerFlags - } -} diff --git a/Sources/SwiftToolchain/Builder.swift b/Sources/SwiftToolchain/Builder.swift deleted file mode 100644 index b52d9cc2..00000000 --- a/Sources/SwiftToolchain/Builder.swift +++ /dev/null @@ -1,124 +0,0 @@ -// Copyright 2020 Carton contributors -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -import CartonHelpers -import Foundation -import TSCBasic -import WasmTransformer - -public final class Builder { - public let mainWasmPath: AbsolutePath - public let pathsToWatch: [AbsolutePath] - private let arguments: [String] - private let flavor: BuildFlavor - private let terminal: InteractiveWriter - private let fileSystem: FileSystem - - public init( - arguments: [String], - mainWasmPath: AbsolutePath, - pathsToWatch: [AbsolutePath] = [], - _ flavor: BuildFlavor, - _ fileSystem: FileSystem, - _ terminal: InteractiveWriter - ) { - self.arguments = arguments - self.mainWasmPath = mainWasmPath - self.pathsToWatch = pathsToWatch - self.flavor = flavor - self.terminal = terminal - self.fileSystem = fileSystem - } - - private func buildWithoutSanitizing(builderArguments: [String]) async throws { - let buildStarted = Date() - try await Process.run( - builderArguments, - loadingMessage: "Compiling...", - parser: nil, - terminal - ) - - terminal.logLookup( - "`swift build` completed in ", - String(format: "%.2f seconds", abs(buildStarted.timeIntervalSinceNow)) - ) - - var transformers: [(inout InputByteStream, inout InMemoryOutputWriter) throws -> Void] = [] - if flavor.environment == .node || flavor.environment == .defaultBrowser { - // If building for JS-host environments, - // - i64 params in imports are not supported without bigint-i64 feature - // - The param types in imports don't have to be strictly same as host expected - // - Users cannot avoid having such imports come from WASI since they are - // mandatory imports. - // - // So lower i64 param types to be i32. It happens *only for WASI imports* - // since users can avoid such imports coming from other user modules. - let transformer = I64ImportTransformer(shouldLower: { - $0.module == "wasi_snapshot_preview1" || $0.module == "wasi_unstable" - }) - transformers.append(transformer.transform) - } - // Strip unnecessary autolink sections, which is only used at link-time - transformers.append( - CustomSectionStripper(stripIf: { - $0 == ".swift1_autolink_entries" - }).transform) - - switch flavor.sanitize { - case .stackOverflow: - transformers.append(StackOverflowSanitizer().transform) - case .none: - break - } - - guard !transformers.isEmpty else { return } - - let binary = try fileSystem.readFileContents(mainWasmPath) - - let transformStarted = Date() - var inputBinary = binary.contents - for transformer in transformers { - var input = InputByteStream(bytes: inputBinary) - var writer = InMemoryOutputWriter(reservingCapacity: inputBinary.count) - try transformer(&input, &writer) - inputBinary = writer.bytes() - } - - terminal.logLookup( - "Binary transformation for Safari compatibility completed in ", - String(format: "%.2f seconds", abs(transformStarted.timeIntervalSinceNow)) - ) - - try fileSystem.writeFileContents(mainWasmPath, bytes: .init(inputBinary)) - } - - public func run() async throws { - switch flavor.sanitize { - case .none: - return try await buildWithoutSanitizing(builderArguments: arguments) - case .stackOverflow: - let sanitizerFile = - try fileSystem.homeDirectory.appending(components: ".carton", "static", "so_sanitizer.wasm") - - var modifiedArguments = arguments - modifiedArguments.append(contentsOf: [ - "-Xlinker", sanitizerFile.pathString, - // stack-overflow-sanitizer depends on "--stack-first" - "-Xlinker", "--stack-first", - ]) - return try await buildWithoutSanitizing(builderArguments: modifiedArguments) - } - } -} diff --git a/Sources/SwiftToolchain/DestinationEnvironment.swift b/Sources/SwiftToolchain/DestinationEnvironment.swift deleted file mode 100644 index df6f5044..00000000 --- a/Sources/SwiftToolchain/DestinationEnvironment.swift +++ /dev/null @@ -1,35 +0,0 @@ -// Copyright 2020 Carton contributors -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -import CartonHelpers - -public enum DestinationEnvironment { - case other - case safari - case firefox - case chrome - case edge -} - -extension String { - public func parsedStackTrace(in environment: DestinationEnvironment) -> [StackTraceItem]? { - switch environment { - case .safari: return safariStackTrace - case .firefox: return firefoxStackTrace - case .chrome: return chromeStackTrace - case .edge: return chromeStackTrace // TODO: return nil if on old Edge - default: return nil - } - } -} diff --git a/Sources/SwiftToolchain/Manifest.swift b/Sources/SwiftToolchain/Manifest.swift deleted file mode 100644 index 5eea3ba9..00000000 --- a/Sources/SwiftToolchain/Manifest.swift +++ /dev/null @@ -1,66 +0,0 @@ -// Copyright 2020 Carton contributors -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -import Basics -import CartonHelpers -import PackageLoading -import PackageModel -import TSCBasic -import Workspace - -extension Manifest { - static func from( - path: AbsolutePath, swiftc: AbsolutePath, fileSystem: FileSystem, terminal: InteractiveWriter - ) async throws -> Manifest { - terminal.write("\nParsing package manifest: ", inColor: .yellow) - let destination = try Destination.hostDestination(swiftc.parentDirectory) - let toolchain = try UserToolchain(destination: destination) - let loader = ManifestLoader(toolchain: toolchain) - let observability = ObservabilitySystem { _, diagnostic in - terminal.write("\n\(diagnostic)") - } - let workspace = try Workspace( - fileSystem: fileSystem, forRootPackage: path, customManifestLoader: loader) - let manifest = try await workspace.loadRootManifest( - at: path, - observabilityScope: observability.topScope - ) - return manifest - } - - public func resourcesPath(for target: TargetDescription) -> String { - "\(displayName)_\(target.name).resources" - } -} - -extension Workspace { - func loadRootManifest( - at path: AbsolutePath, - observabilityScope: ObservabilityScope - ) async throws -> Manifest { - try await withCheckedThrowingContinuation { continuation in - loadRootManifest(at: path, observabilityScope: observabilityScope) { result in - continuation.resume(with: result) - } - } - } -} - -public enum PackageType: String { - case empty - case library - case executable - case systemModule = "system-module" - case manifest -} diff --git a/Sources/SwiftToolchain/Toolchain.swift b/Sources/SwiftToolchain/Toolchain.swift index d79510d4..ed3b9401 100644 --- a/Sources/SwiftToolchain/Toolchain.swift +++ b/Sources/SwiftToolchain/Toolchain.swift @@ -1,25 +1,20 @@ -// Copyright 2020 Carton contributors -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. +//// Copyright 2020 Carton contributors +//// +//// Licensed under the Apache License, Version 2.0 (the "License"); +//// you may not use this file except in compliance with the License. +//// You may obtain a copy of the License at +//// +//// http://www.apache.org/licenses/LICENSE-2.0 +//// +//// Unless required by applicable law or agreed to in writing, software +//// distributed under the License is distributed on an "AS IS" BASIS, +//// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +//// See the License for the specific language governing permissions and +//// limitations under the License. import CartonHelpers -import Foundation -import PackageModel -import TSCBasic -import TSCUtility -import WasmTransformer -public let compatibleJSKitVersion = Version(0, 18, 0) +public let compatibleJSKitVersion = "0.18.0" enum ToolchainError: Error, CustomStringConvertible { case directoryDoesNotExist(AbsolutePath) @@ -29,7 +24,7 @@ enum ToolchainError: Error, CustomStringConvertible { case failedToBuildTestBundle case missingPackageManifest case invalidVersion(version: String) - case invalidResponse(url: String, status: UInt) + case invalidResponse(url: String, status: Int) case unsupportedOperatingSystem case noInstallationDirectory(path: String) case noWorkingDirectory @@ -66,370 +61,3 @@ enum ToolchainError: Error, CustomStringConvertible { } } } - -extension PackageDependency { - var isJavaScriptKitCompatible: Bool { - var exactVersion: Version? - var versionRange: Range? - switch self { - case let .sourceControl(sourceControl): - switch sourceControl.requirement { - case let .exact(version): exactVersion = version - case let .range(range): versionRange = range - default: break - } - case let .registry(registry): - switch registry.requirement { - case let .exact(version): exactVersion = version - case let .range(range): versionRange = range - } - default: break - } - if let exactVersion = exactVersion { - return exactVersion >= compatibleJSKitVersion - } - if let versionRange = versionRange { - return versionRange.lowerBound >= compatibleJSKitVersion - } - return false - } - - var requirementDescription: String { - switch self { - case let .sourceControl(sourceControl): - return sourceControl.requirement.description - case let .registry(registry): - return registry.requirement.description - default: - return "(Unknown)" - } - } -} - -public final class Toolchain { - private let fileSystem: FileSystem - private let terminal: InteractiveWriter - - private let version: String - private let swiftPath: AbsolutePath - public let manifest: Result - - public init( - for versionSpec: String? = nil, - _ fileSystem: FileSystem, - _ terminal: InteractiveWriter - ) async throws { - let toolchainSystem = try ToolchainSystem(fileSystem: fileSystem) - let (swiftPath, version) = try await toolchainSystem.inferSwiftPath(from: versionSpec, terminal) - self.swiftPath = swiftPath - self.version = version - self.fileSystem = fileSystem - self.terminal = terminal - if let workingDirectory = fileSystem.currentWorkingDirectory { - let swiftc = swiftPath.parentDirectory.appending(component: "swiftc") - manifest = await Result { - try await Manifest.from( - path: workingDirectory, swiftc: swiftc, fileSystem: fileSystem, terminal: terminal) - } - } else { - manifest = .failure(ToolchainError.noWorkingDirectory) - } - } - - private func inferBinPath(isRelease: Bool) throws -> AbsolutePath { - guard - let output = try processStringOutput([ - swiftPath.pathString, "build", "-c", isRelease ? "release" : "debug", - "--triple", "wasm32-unknown-wasi", "--show-bin-path", - ])?.components(separatedBy: CharacterSet.newlines), - let binPath = output.first - else { fatalError("failed to decode UTF8 output of the `swift build` invocation") } - - return try AbsolutePath(validating: binPath) - } - - private func inferDevProduct(hint: String?) throws -> ProductDescription? { - let manifest = try manifest.get() - - var candidateProducts = manifest.products - .filter { $0.type == .executable } - - if let productName = hint { - candidateProducts = candidateProducts.filter { $0.name == productName } - - guard candidateProducts.count == 1 else { - terminal.write( - """ - Failed to disambiguate the executable product, \ - make sure `\(productName)` product is present in Package.swift - """, inColor: .red) - return nil - } - - terminal.logLookup("- development product: ", productName) - return candidateProducts[0] - } else if candidateProducts.count == 1 { - return candidateProducts[0] - } else { - terminal.write("Failed to disambiguate the development product\n", inColor: .red) - - if candidateProducts.count > 1 { - terminal.write("Pass one of \(candidateProducts) to the --product option\n", inColor: .red) - } else { - terminal.write( - "Make sure there's at least one executable product in your Package.swift\n", - inColor: .red - ) - } - - return nil - } - } - - private func inferManifestDirectory() throws -> AbsolutePath { - guard (try? manifest.get()) != nil, var cwd = fileSystem.currentWorkingDirectory else { - throw ToolchainError.missingPackageManifest - } - - repeat { - guard !fileSystem.isFile(cwd.appending(component: "Package.swift")) else { - return cwd - } - - // `parentDirectory` just returns `self` if it's `root` - cwd = cwd.parentDirectory - } while !cwd.isRoot - - throw ToolchainError.missingPackageManifest - } - - public func inferSourcesPaths() throws -> [AbsolutePath] { - let manifest = try manifest.get() - - let targetPaths = manifest.targets.compactMap { target -> String? in - - guard let path = target.path else { - switch target.type { - case .regular, .executable: - return RelativePath("Sources").appending(component: target.name).pathString - case .test, .system, .binary, .macro, .plugin: - return nil - } - } - return path - } - - let manifestDirectory = try inferManifestDirectory() - - return try targetPaths.compactMap { - try manifestDirectory.appending(RelativePath(validating: $0)) - } - } - - private func emitJSKitWarningIfNeeded() throws { - let manifest = try manifest.get() - guard - let jsKit = manifest.dependencies.first(where: { - $0.nameForTargetDependencyResolutionOnly == "JavaScriptKit" - }) - else { - return - } - - switch jsKit { - case .fileSystem: - terminal.write( - """ - - The local version of JavaScriptKit found in your dependency tree is not known to be \ - compatible with carton \(cartonVersion). Please specify a JavaScriptKit dependency of \ - version \(compatibleJSKitVersion) in your `Package.swift`.\n - - """, - inColor: .red - ) - - default: - guard !jsKit.isJavaScriptKitCompatible else { return } - terminal.write( - """ - - JavaScriptKit requirement \(jsKit - .requirementDescription), which is present in your dependency tree is not \ - known to be compatible with carton \(cartonVersion). Please specify a JavaScriptKit \ - dependency of version \(compatibleJSKitVersion) in your `Package.swift`.\n - - """, - inColor: .red - ) - } - } - - public func buildCurrentProject( - product: String?, - flavor: BuildFlavor - ) async throws -> BuildDescription { - guard let product = try inferDevProduct(hint: product) - else { throw ToolchainError.noExecutableProduct } - - try emitJSKitWarningIfNeeded() - - let binPath = try inferBinPath(isRelease: flavor.isRelease) - let mainWasmPath = binPath.appending(component: "\(product.name).wasm") - terminal.logLookup("- development binary to serve: ", mainWasmPath.pathString) - - terminal.write("\nBuilding the project before spinning up a server...\n", inColor: .yellow) - - var builderArguments = [ - swiftPath.pathString, "build", "-c", flavor.isRelease ? "release" : "debug", - "--product", product.name, - ] - - builderArguments.append(contentsOf: basicBuildArguments(flavor: flavor)) - - try await Builder( - arguments: builderArguments, - mainWasmPath: mainWasmPath, - flavor, - fileSystem, - terminal - ).run() - - guard fileSystem.exists(mainWasmPath) else { - terminal.write( - "Failed to build the main executable binary, fix the build errors and restart\n", - inColor: .red - ) - throw ToolchainError.failedToBuild(product: product.name) - } - - return .init(arguments: builderArguments, mainWasmPath: mainWasmPath, product: product) - } - - public func getTestProduct(flavor: BuildFlavor) throws -> ( - name: String, artifactPath: AbsolutePath - ) { - let manifest = try manifest.get() - let binPath = try inferBinPath(isRelease: flavor.isRelease) - let testProductName = "\(manifest.displayName)PackageTests" - let testBundlePath = binPath.appending(component: "\(testProductName).wasm") - return (testProductName, testBundlePath) - } - - /// Returns an absolute path to the resulting test bundle - public func buildTestBundle( - flavor: BuildFlavor - ) async throws -> AbsolutePath { - let (testProductName, testBundlePath) = try getTestProduct(flavor: flavor) - terminal.logLookup("- test bundle to run: ", testBundlePath.pathString) - - terminal.write( - "\nBuilding the test bundle before running the test suite...\n", - inColor: .yellow - ) - - var builderArguments = [ - swiftPath.pathString, "build", "-c", flavor.isRelease ? "release" : "debug", - "--product", testProductName, - "-Xswiftc", "-color-diagnostics", - ] - builderArguments.append(contentsOf: basicBuildArguments(flavor: flavor)) - - try await Builder( - arguments: builderArguments, - mainWasmPath: testBundlePath, - flavor, - fileSystem, - terminal - ).run() - - guard fileSystem.exists(testBundlePath) else { - terminal.write( - "Failed to build the test bundle, fix the build errors and restart\n", - inColor: .red - ) - throw ToolchainError.failedToBuildTestBundle - } - - return testBundlePath - } - - private func basicBuildArguments(flavor: BuildFlavor) -> [String] { - var builderArguments = ["--triple", "wasm32-unknown-wasi"] - - if let wasmVersion = try? Version(swiftWasmVersion: version) { - - // Versions later than 5.3.x have test discovery enabled by default and the explicit flag - // deprecated. - if wasmVersion.major == 5, wasmVersion.minor == 3 { - builderArguments.append("--enable-test-discovery") - } - - // SwiftWasm 5.5 requires explicit linking arguments in certain configurations, - // see https://github.com/swiftwasm/swift/issues/3891 - if wasmVersion.major == 5, wasmVersion.minor == 5 { - builderArguments.append(contentsOf: ["-Xlinker", "-licuuc", "-Xlinker", "-licui18n"]) - } - - // SwiftWasm 5.6 and up requires reactor model from updated wasi-libc when not building as a command - // see https://github.com/WebAssembly/WASI/issues/13 - if wasmVersion >= Version(5, 6, 0) && flavor.environment != .wasmer { - builderArguments.append(contentsOf: [ - "-Xswiftc", "-Xclang-linker", "-Xswiftc", "-mexec-model=reactor", - "-Xlinker", "--export=main", - ]) - } - } - - builderArguments.append( - contentsOf: flavor.swiftCompilerFlags.flatMap { - ["-Xswiftc", $0] - }) - - return builderArguments - } - - public func runPackageInit(name: String, type: PackageType, inPlace: Bool) async throws { - let initArgs = [ - swiftPath.pathString, "package", "init", - "--type", type.rawValue, - "--name", name - ] - try await TSCBasic.Process.run(initArgs, terminal) - } - - public func runPackage(_ arguments: [String]) async throws { - let args = [swiftPath.pathString, "package"] + arguments - try await TSCBasic.Process.run(args, terminal) - } -} - -extension Result where Failure == Error { - init(catching body: () async throws -> Success) async { - do { - let value = try await body() - self = .success(value) - } catch { - self = .failure(error) - } - } -} - -extension Version { - /// Initialize a numeric version from a SwiftWasm Toolchain version string, e.g.: - /// "wasm-5.3.1-RELEASE", "wasm-5.7-SNAPSHOT-2022-07-14-a", - /// **discarding all identifiers**. - /// Note: input toolchain name already has "swift-" prefix stripped. - init(swiftWasmVersion: String) throws { - let prefix = "wasm-" - guard swiftWasmVersion.hasPrefix(prefix) else { - throw ToolchainError.invalidVersion(version: swiftWasmVersion) - } - var swiftWasmVersion = swiftWasmVersion - swiftWasmVersion.removeFirst(prefix.count) - - let version = try Version(versionString: swiftWasmVersion, usesLenientParsing: true) - // Strip prereleaseIdentifiers - self.init(version.major, version.minor, version.patch) - } -} diff --git a/Sources/SwiftToolchain/ToolchainInstallation.swift b/Sources/SwiftToolchain/ToolchainInstallation.swift index d3f7571d..4adf1edf 100644 --- a/Sources/SwiftToolchain/ToolchainInstallation.swift +++ b/Sources/SwiftToolchain/ToolchainInstallation.swift @@ -12,15 +12,12 @@ // See the License for the specific language governing permissions and // limitations under the License. -import AsyncHTTPClient import CartonHelpers import Foundation -import TSCBasic -import TSCUtility private let expectedArchiveSize = 891_856_371 -extension FileDownloadDelegate.Progress { +extension AsyncFileDownload.Progress { fileprivate var totalOrEstimatedBytes: Int { totalBytes ?? expectedArchiveSize } @@ -31,7 +28,6 @@ extension ToolchainSystem { version: String, from url: Foundation.URL, to sdkPath: AbsolutePath, - _ client: HTTPClient, _ terminal: InteractiveWriter ) async throws -> AbsolutePath { if !fileSystem.exists(sdkPath, followSymlink: true) { @@ -60,7 +56,6 @@ extension ToolchainSystem { let fileDownload = AsyncFileDownload( path: archivePath.pathString, url, - client, onTotalBytes: { terminal.write("Archive size is \($0 / 1_000_000) MB\n", inColor: .yellow) } @@ -112,7 +107,11 @@ extension ToolchainSystem { ] } terminal.logLookup("Unpacking the archive: ", arguments.joined(separator: " ")) - _ = try processDataOutput(arguments) + try Foundation.Process.run( + URL(fileURLWithPath: arguments[0]), + arguments: Array(arguments.dropFirst()) + ) + .waitUntilExit() return installationPath } diff --git a/Sources/SwiftToolchain/ToolchainManagement.swift b/Sources/SwiftToolchain/ToolchainManagement.swift index 89986cf9..e128d40c 100644 --- a/Sources/SwiftToolchain/ToolchainManagement.swift +++ b/Sources/SwiftToolchain/ToolchainManagement.swift @@ -12,19 +12,22 @@ // See the License for the specific language governing permissions and // limitations under the License. -import AsyncHTTPClient import CartonHelpers import Foundation -import NIOFoundationCompat -import TSCBasic -import TSCUtility -public func processStringOutput(_ arguments: [String]) throws -> String? { - try ByteString(processDataOutput(arguments)).validDescription +internal func processStringOutput(_ arguments: [String]) throws -> String? { + let process = Process() + process.executableURL = URL(fileURLWithPath: arguments[0]) + process.arguments = Array(arguments.dropFirst()) + let pipe = Pipe() + process.standardOutput = pipe + try process.run() + process.waitUntilExit() + let data = pipe.fileHandleForReading.readDataToEndOfFile() + return String(data: data, encoding: .utf8) } -// swiftlint:disable:next force_try -private let versionRegEx = try! RegEx(pattern: "(?:swift-)?(.+-.)-.+\\.tar.gz") +private let versionRegEx = #/(?:swift-)?(.+-.)-.+\\.tar.gz/# private struct Release: Decodable { struct Asset: Decodable { @@ -109,10 +112,10 @@ public class ToolchainSystem { if let versionSpec = versionSpec { if let url = URL(string: versionSpec), let filename = url.pathComponents.last, - let match = versionRegEx.matchGroups(in: filename).first?.first + let match = try versionRegEx.firstMatch(in: filename)?.0 { terminal.logLookup("Inferred swift version: ", match) - return match + return String(match) } else { return versionSpec } @@ -132,7 +135,7 @@ public class ToolchainSystem { let swiftPath = installationPath.appending(components: "usr", "bin", "swift") terminal.logLookup("- checking Swift compiler path: ", swiftPath) - guard fileSystem.isFile(swiftPath) else { return nil } + guard fileSystem.exists(swiftPath, followSymlink: true) else { return nil } terminal.write("Inferring basic settings...\n", inColor: .yellow) terminal.logLookup("- swift executable: ", swiftPath) @@ -145,9 +148,9 @@ public class ToolchainSystem { private func inferDownloadURL( from version: String, - _ client: HTTPClient, + _ client: URLSession, _ terminal: InteractiveWriter - ) throws -> Foundation.URL? { + ) async throws -> Foundation.URL? { let releaseURL = """ https://api.github.com/repos/swiftwasm/swift/releases/tags/\ swift-\(version) @@ -155,21 +158,17 @@ public class ToolchainSystem { terminal.logLookup("Fetching release assets from ", releaseURL) let decoder = JSONDecoder() - let request = try HTTPClient.Request.get(url: releaseURL) - let release = try tsc_await { - client.execute(request: request).flatMapResult { response -> Result in - guard (200..<300).contains(response.status.code), let body = response.body else { - return .failure( - ToolchainError.invalidResponse( - url: releaseURL, - status: response.status.code - )) - } - terminal.write("Response contained body, parsing it now...\n", inColor: .green) - - return Result { try decoder.decode(Release.self, from: body) } - }.whenComplete($0) + let request = URLRequest(url: URL(string: releaseURL)!) + let (data, response) = try await URLSession.shared.data(for: request) + guard let httpResponse = response as? HTTPURLResponse else { + throw ToolchainError.invalidResponse(url: releaseURL, status: -1) } + guard 200..<300 ~= httpResponse.statusCode else { + throw ToolchainError.invalidResponse(url: releaseURL, status: httpResponse.statusCode) + } + terminal.write("Response contained body, parsing it now...\n", inColor: .green) + + let release = try decoder.decode(Release.self, from: data) #if arch(x86_64) let archSuffix = "x86_64" @@ -194,14 +193,17 @@ public class ToolchainSystem { let nameSuffixes = platformSuffixes.map { "\($0)_\(archSuffix)" } return release.assets.map(\.url).filter { url in nameSuffixes.contains { url.absoluteString.contains($0) } + && !url.absoluteString.contains(".artifactbundle.") }.first } private func inferLinuxDistributionSuffix() throws -> String { - guard let releaseFile = [ - AbsolutePath.root.appending(components: "etc", "lsb-release"), - AbsolutePath.root.appending(components: "etc", "os-release"), - ].first(where: fileSystem.isFile) else { + guard + let releaseFile = [ + AbsolutePath.root.appending(components: "etc", "lsb-release"), + AbsolutePath.root.appending(components: "etc", "os-release"), + ].first(where: fileSystem.isFile) + else { throw ToolchainError.unsupportedOperatingSystem } @@ -222,7 +224,7 @@ public class ToolchainSystem { /** Infer `swift` binary path matching a given version if any is present, or infer the version from the `.swift-version` file. If neither version is installed, download it. */ - func inferSwiftPath( + public func inferSwiftPath( from versionSpec: String? = nil, _ terminal: InteractiveWriter ) async throws -> (AbsolutePath, String) { @@ -246,15 +248,13 @@ public class ToolchainSystem { } } - let client = HTTPClient(eventLoopGroupProvider: .createNew) - // swiftlint:disable:next force_try - defer { try! client.syncShutdown() } + let client = URLSession.shared let downloadURL: Foundation.URL if let specURL = specURL { downloadURL = specURL - } else if let inferredURL = try inferDownloadURL(from: swiftVersion, client, terminal) { + } else if let inferredURL = try await inferDownloadURL(from: swiftVersion, client, terminal) { downloadURL = inferredURL } else { terminal.write("The Swift version \(swiftVersion) was not found\n", inColor: .red) @@ -270,7 +270,6 @@ public class ToolchainSystem { version: swiftVersion, from: downloadURL, to: cartonToolchainResolver.cartonSDKPath, - client, terminal ) @@ -298,8 +297,4 @@ public class ToolchainSystem { return version } - - public func setLocalSwiftVersion(_ version: String) throws { - try fileSystem.writeFileContents(swiftVersionPath, bytes: ByteString([UInt8](version.utf8))) - } } diff --git a/Sources/SwiftToolchain/ToolchainResolver.swift b/Sources/SwiftToolchain/ToolchainResolver.swift index b099db63..6f171264 100644 --- a/Sources/SwiftToolchain/ToolchainResolver.swift +++ b/Sources/SwiftToolchain/ToolchainResolver.swift @@ -1,4 +1,4 @@ -import TSCBasic +import CartonHelpers protocol ToolchainResolver { func fetchVersions() throws -> [(version: String, path: AbsolutePath)] diff --git a/Sources/SwiftToolchain/Utilities/ProgressAnimation.swift b/Sources/SwiftToolchain/Utilities/ProgressAnimation.swift new file mode 100644 index 00000000..7a84ca18 --- /dev/null +++ b/Sources/SwiftToolchain/Utilities/ProgressAnimation.swift @@ -0,0 +1,311 @@ +/* + This source file is part of the Swift.org open source project + + Copyright (c) 2014 - 2018 Apple Inc. and the Swift project authors + Licensed under Apache License v2.0 with Runtime Library Exception + + See http://swift.org/LICENSE.txt for license information + See http://swift.org/CONTRIBUTORS.txt for Swift project authors +*/ + +import CartonHelpers + +/// A protocol to operate on terminal based progress animations. +public protocol ProgressAnimationProtocol { + /// Update the animation with a new step. + /// - Parameters: + /// - step: The index of the operation's current step. + /// - total: The total number of steps before the operation is complete. + /// - text: The description of the current step. + func update(step: Int, total: Int, text: String) + + /// Complete the animation. + /// - Parameters: + /// - success: Defines if the operation the animation represents was succesful. + func complete(success: Bool) + + /// Clear the animation. + func clear() +} + +/// A single line percent-based progress animation. +public final class SingleLinePercentProgressAnimation: ProgressAnimationProtocol { + private let stream: WritableByteStream + private let header: String? + private var displayedPercentages: Set = [] + private var hasDisplayedHeader = false + + init(stream: WritableByteStream, header: String?) { + self.stream = stream + self.header = header + } + + public func update(step: Int, total: Int, text: String) { + if let header = header, !hasDisplayedHeader { + stream.send(header) + stream.send("\n") + stream.flush() + hasDisplayedHeader = true + } + + let percentage = step * 100 / total + let roundedPercentage = Int(Double(percentage / 10).rounded(.down)) * 10 + if percentage != 100, !displayedPercentages.contains(roundedPercentage) { + stream.send(String(roundedPercentage)).send(".. ") + displayedPercentages.insert(roundedPercentage) + } + + stream.flush() + } + + public func complete(success: Bool) { + if success { + stream.send("OK") + stream.flush() + } + } + + public func clear() { + } +} + +/// A multi-line ninja-like progress animation. +public final class MultiLineNinjaProgressAnimation: ProgressAnimationProtocol { + private struct Info: Equatable { + let step: Int + let total: Int + let text: String + } + + private let stream: WritableByteStream + private var lastDisplayedText: String? = nil + + public init(stream: WritableByteStream) { + self.stream = stream + } + + public func update(step: Int, total: Int, text: String) { + assert(step <= total) + + guard text != lastDisplayedText else { return } + + stream.send("[\(step)/\(total)] ").send(text) + stream.send("\n") + stream.flush() + lastDisplayedText = text + } + + public func complete(success: Bool) { + } + + public func clear() { + } +} + +/// A redrawing ninja-like progress animation. +public final class RedrawingNinjaProgressAnimation: ProgressAnimationProtocol { + private let terminal: TerminalController + private var hasDisplayedProgress = false + + init(terminal: TerminalController) { + self.terminal = terminal + } + + public func update(step: Int, total: Int, text: String) { + assert(step <= total) + + terminal.clearLine() + + let progressText = "[\(step)/\(total)] \(text)" + let width = terminal.width + if progressText.utf8.count > width { + let suffix = "…" + terminal.write(String(progressText.prefix(width - suffix.utf8.count))) + terminal.write(suffix) + } else { + terminal.write(progressText) + } + + hasDisplayedProgress = true + } + + public func complete(success: Bool) { + if hasDisplayedProgress { + terminal.endLine() + } + } + + public func clear() { + terminal.clearLine() + } +} + +/// A ninja-like progress animation that adapts to the provided output stream. +public final class NinjaProgressAnimation: DynamicProgressAnimation { + public init(stream: WritableByteStream) { + super.init( + stream: stream, + ttyTerminalAnimationFactory: { RedrawingNinjaProgressAnimation(terminal: $0) }, + dumbTerminalAnimationFactory: { + SingleLinePercentProgressAnimation(stream: stream, header: nil) + }, + defaultAnimationFactory: { MultiLineNinjaProgressAnimation(stream: stream) }) + } +} + +/// A multi-line percent-based progress animation. +public final class MultiLinePercentProgressAnimation: ProgressAnimationProtocol { + private struct Info: Equatable { + let percentage: Int + let text: String + } + + private let stream: WritableByteStream + private let header: String + private var hasDisplayedHeader = false + private var lastDisplayedText: String? = nil + + public init(stream: WritableByteStream, header: String) { + self.stream = stream + self.header = header + } + + public func update(step: Int, total: Int, text: String) { + assert(step <= total) + + if !hasDisplayedHeader, !header.isEmpty { + stream.send(header) + stream.send("\n") + stream.flush() + hasDisplayedHeader = true + } + + let percentage = step * 100 / total + stream.send("\(percentage)%: ").send(text) + stream.send("\n") + stream.flush() + lastDisplayedText = text + } + + public func complete(success: Bool) { + } + + public func clear() { + } +} + +/// A redrawing lit-like progress animation. +public final class RedrawingLitProgressAnimation: ProgressAnimationProtocol { + private let terminal: TerminalController + private let header: String + private var hasDisplayedHeader = false + + init(terminal: TerminalController, header: String) { + self.terminal = terminal + self.header = header + } + + /// Creates repeating string for count times. + /// If count is negative, returns empty string. + private func repeating(string: String, count: Int) -> String { + return String(repeating: string, count: max(count, 0)) + } + + public func update(step: Int, total: Int, text: String) { + assert(step <= total) + + let width = terminal.width + if !hasDisplayedHeader { + let spaceCount = width / 2 - header.utf8.count / 2 + terminal.write(repeating(string: " ", count: spaceCount)) + terminal.write(header, inColor: .cyan, bold: true) + terminal.endLine() + hasDisplayedHeader = true + } else { + terminal.moveCursor(up: 1) + } + + terminal.clearLine() + let percentage = step * 100 / total + let paddedPercentage = percentage < 10 ? " \(percentage)" : "\(percentage)" + let prefix = "\(paddedPercentage)% " + terminal.wrap("[", inColor: .green, bold: true) + terminal.write(prefix) + + let barWidth = width - prefix.utf8.count + let n = Int(Double(barWidth) * Double(percentage) / 100.0) + + terminal.write( + repeating(string: "=", count: n) + repeating(string: "-", count: barWidth - n), + inColor: .green) + terminal.write("]", inColor: .green, bold: true) + terminal.endLine() + + terminal.clearLine() + if text.utf8.count > width { + let prefix = "…" + terminal.write(prefix) + terminal.write(String(text.suffix(width - prefix.utf8.count))) + } else { + terminal.write(text) + } + } + + public func complete(success: Bool) { + terminal.endLine() + terminal.endLine() + } + + public func clear() { + terminal.clearLine() + terminal.moveCursor(up: 1) + terminal.clearLine() + } +} + +/// A percent-based progress animation that adapts to the provided output stream. +public final class PercentProgressAnimation: DynamicProgressAnimation { + public init(stream: WritableByteStream, header: String) { + super.init( + stream: stream, + ttyTerminalAnimationFactory: { RedrawingLitProgressAnimation(terminal: $0, header: header) }, + dumbTerminalAnimationFactory: { + SingleLinePercentProgressAnimation(stream: stream, header: header) + }, + defaultAnimationFactory: { MultiLinePercentProgressAnimation(stream: stream, header: header) } + ) + } +} + +/// A progress animation that adapts to the provided output stream. +public class DynamicProgressAnimation: ProgressAnimationProtocol { + private let animation: ProgressAnimationProtocol + + public init( + stream: WritableByteStream, + ttyTerminalAnimationFactory: (TerminalController) -> ProgressAnimationProtocol, + dumbTerminalAnimationFactory: () -> ProgressAnimationProtocol, + defaultAnimationFactory: () -> ProgressAnimationProtocol + ) { + if let terminal = TerminalController(stream: stream) { + animation = ttyTerminalAnimationFactory(terminal) + } else if let fileStream = stream as? LocalFileOutputByteStream, + TerminalController.terminalType(fileStream) == .dumb + { + animation = dumbTerminalAnimationFactory() + } else { + animation = defaultAnimationFactory() + } + } + + public func update(step: Int, total: Int, text: String) { + animation.update(step: step, total: total, text: text) + } + + public func complete(success: Bool) { + animation.complete(success: success) + } + + public func clear() { + animation.clear() + } +} diff --git a/Sources/SwiftToolchain/Utilities/README.md b/Sources/SwiftToolchain/Utilities/README.md new file mode 100644 index 00000000..76e803f0 --- /dev/null +++ b/Sources/SwiftToolchain/Utilities/README.md @@ -0,0 +1,3 @@ +Source files under this directory are derived from the [swift-tools-support-core](https://github.com/apple/swift-tools-support-core) package. The original source files are located in the `Sources/TSCUtility` directory of the swift-tools-support-core repository and are used under the terms of the [Apache License, Version 2.0 with LLVM Exceptions](https://github.com/apple/swift-tools-support-core/blob/main/LICENSE.txt). + +We vend the source files in this directory to avoid bringing in the entire swift-tools-support-core package as a dependency. diff --git a/Sources/WebDriverClient/WebDriverClient.swift b/Sources/WebDriverClient/WebDriverClient.swift index d75c50fa..f5157fad 100644 --- a/Sources/WebDriverClient/WebDriverClient.swift +++ b/Sources/WebDriverClient/WebDriverClient.swift @@ -12,16 +12,14 @@ // See the License for the specific language governing permissions and // limitations under the License. -import AsyncHTTPClient import Foundation -import NIOFoundationCompat public enum WebDriverError: Error { - case newSessionFailed(HTTPClient.Response) + case newSessionFailed } public struct WebDriverClient { - let client: HTTPClient + let client: URLSession let driverEndpoint: URL let sessionId: String @@ -54,7 +52,7 @@ public struct WebDriverClient { public static func newSession( endpoint: URL, body: String = defaultSessionRequestBody, - httpClient: HTTPClient + httpClient: URLSession ) async throws -> WebDriverClient { struct Response: Decodable { let sessionId: String @@ -63,15 +61,16 @@ public struct WebDriverClient { let capabilities: [String: String] = [:] let desiredCapabilities: [String: String] = [:] } - let httpResponse = try await httpClient.post( - url: endpoint.appendingPathComponent("session").absoluteString, - body: HTTPClient.Body.string(body) - ).get() - guard let responseBody = httpResponse.body else { - throw WebDriverError.newSessionFailed(httpResponse) + var request = URLRequest(url: endpoint.appendingPathComponent("session")) + request.httpMethod = "POST" + request.httpBody = body.data(using: .utf8) + let (body, httpResponse) = try await httpClient.data(for: request) + guard let httpResponse = httpResponse as? HTTPURLResponse, 200..<300 ~= httpResponse.statusCode + else { + throw WebDriverError.newSessionFailed } let decoder = JSONDecoder() - let response = try decoder.decode(ValueResponse.self, from: responseBody) + let response = try decoder.decode(ValueResponse.self, from: body) return WebDriverClient( client: httpClient, driverEndpoint: endpoint, @@ -89,23 +88,24 @@ public struct WebDriverClient { return url.absoluteString } - private static func makeRequestBody(_ body: R) throws -> HTTPClient.Body { + private static func makeRequestBody(_ body: R) throws -> Data { let encoder = JSONEncoder() - return try HTTPClient.Body.data(encoder.encode(body)) + return try encoder.encode(body) } public func goto(url: String) async throws { struct Request: Encodable { let url: String } - _ = try await client.post( - url: makeSessionURL("url"), - body: Self.makeRequestBody(Request(url: url)) - ) - .get() + var request = URLRequest(url: URL(string: makeSessionURL("url"))!) + request.httpMethod = "POST" + request.httpBody = try Self.makeRequestBody(Request(url: url)) + _ = try await client.data(for: request) } public func closeSession() async throws { - _ = try await client.delete(url: makeSessionURL()).get() + var request = URLRequest(url: URL(string: makeSessionURL())!) + request.httpMethod = "DELETE" + _ = try await client.data(for: request) } } diff --git a/Sources/CartonKit/Helpers/ByteString.swift b/Sources/carton-plugin-helper/main.swift similarity index 72% rename from Sources/CartonKit/Helpers/ByteString.swift rename to Sources/carton-plugin-helper/main.swift index df39dec5..90df6924 100644 --- a/Sources/CartonKit/Helpers/ByteString.swift +++ b/Sources/carton-plugin-helper/main.swift @@ -1,4 +1,4 @@ -// Copyright 2020 Carton contributors +// Copyright 2024 Carton contributors // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -12,11 +12,6 @@ // See the License for the specific language governing permissions and // limitations under the License. -import Crypto -import TSCBasic - -extension ByteString { - public var hexSHA256: String { - ByteString(SHA256.hash(data: contents)).hexadecimalRepresentation - } -} +// NOTE: This executable product is used to guess the build directory of the +// current SwiftPM invocation from SwiftPM Plugin process. Do not use this +// product directly. diff --git a/Sources/carton-release/Formula.swift b/Sources/carton-release/Formula.swift deleted file mode 100644 index 634d5488..00000000 --- a/Sources/carton-release/Formula.swift +++ /dev/null @@ -1,70 +0,0 @@ -// Copyright 2020 Carton contributors -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -import ArgumentParser -import AsyncHTTPClient -import TSCBasic - -struct Formula: ParsableCommand { - @Argument() var version: String - - func run() throws { - let archiveURL = "https://github.com/swiftwasm/carton/archive/\(version).tar.gz" - - let client = HTTPClient(eventLoopGroupProvider: .createNew) - let response: HTTPClient.Response = try tsc_await { - client.get(url: archiveURL).whenComplete($0) - } - try client.syncShutdown() - - guard - var body = response.body, - let bytes = body.readBytes(length: body.readableBytes) - else { fatalError("download failed for URL \(archiveURL)") } - - let downloadedArchive = ByteString(bytes) - - let sha256 = SHA256().hash(downloadedArchive).hexadecimalRepresentation - - let formula = #""" - class Carton < Formula - desc "📦 Watcher, bundler, and test runner for your SwiftWasm apps" - homepage "https://carton.dev" - head "https://github.com/swiftwasm/carton.git" - - depends_on :xcode => "11.4" - depends_on "wasmer" - depends_on "binaryen" - - stable do - version "\#(version)" - url "https://github.com/swiftwasm/carton/archive/#{version}.tar.gz" - sha256 "\#(sha256)" - end - - def install - system "swift", "build", "--disable-sandbox", "-c", "release" - system "mv", ".build/release/carton", "carton" - bin.install "carton" - end - - test do - system "carton -h" - end - end - """# - - print(formula) - } -} diff --git a/Sources/carton-release/HashArchive.swift b/Sources/carton-release/HashArchive.swift index 1b21a5c8..1eaf3aa6 100644 --- a/Sources/carton-release/HashArchive.swift +++ b/Sources/carton-release/HashArchive.swift @@ -14,7 +14,6 @@ import ArgumentParser import CartonHelpers -import TSCBasic import WasmTransformer struct HashArchive: AsyncParsableCommand { @@ -38,44 +37,45 @@ struct HashArchive: AsyncParsableCommand { func run() async throws { let terminal = InteractiveWriter.stdout let cwd = localFileSystem.currentWorkingDirectory! - let staticPath = AbsolutePath(cwd, "static") + let staticPath = try AbsolutePath(validating: "static", relativeTo: cwd) let dotFilesStaticPath = try localFileSystem.homeDirectory.appending( components: ".carton", "static" ) try localFileSystem.createDirectory(dotFilesStaticPath, recursive: true) - let hashes = try await (["dev", "bundle", "test", "testNode"]) - .asyncMap { entrypoint -> (String, String) in - let filename = "\(entrypoint).js" - var arguments = [ - "npx", "esbuild", "--bundle", "entrypoint/\(filename)", "--outfile=static/\(filename)", - ] - - if entrypoint == "testNode" { - arguments.append(contentsOf: [ - "--format=cjs", "--platform=node", - "--external:./JavaScriptKit_JavaScriptKit.resources/Runtime/index.js", - ]) - } else { - arguments.append(contentsOf: [ - "--format=esm", - "--external:./JavaScriptKit_JavaScriptKit.resources/Runtime/index.mjs", - ]) - } - - try await Process.run(arguments, terminal) - let entrypointPath = AbsolutePath(staticPath, filename) - let dotFilesEntrypointPath = dotFilesStaticPath.appending(component: filename) - try localFileSystem.removeFileTree(dotFilesEntrypointPath) - try localFileSystem.copy(from: entrypointPath, to: dotFilesEntrypointPath) - - return ( + var hashes: [(String, String)] = [] + for entrypoint in ["dev", "bundle", "test", "testNode"] { + let filename = "\(entrypoint).js" + var arguments = [ + "npx", "esbuild", "--bundle", "entrypoint/\(filename)", "--outfile=static/\(filename)", + ] + + if entrypoint == "testNode" { + arguments.append(contentsOf: [ + "--format=cjs", "--platform=node", + "--external:./JavaScriptKit_JavaScriptKit.resources/Runtime/index.js", + ]) + } else { + arguments.append(contentsOf: [ + "--format=esm", + "--external:./JavaScriptKit_JavaScriptKit.resources/Runtime/index.mjs", + ]) + } + + try await Process.run(arguments, terminal) + let entrypointPath = try AbsolutePath(validating: filename, relativeTo: staticPath) + let dotFilesEntrypointPath = dotFilesStaticPath.appending(component: filename) + try localFileSystem.removeFileTree(dotFilesEntrypointPath) + try localFileSystem.copy(from: entrypointPath, to: dotFilesEntrypointPath) + + hashes.append( + ( entrypoint, try SHA256().hash(localFileSystem.readFileContents(entrypointPath)) .hexadecimalRepresentation.uppercased() - ) - } + )) + } try localFileSystem.writeFileContents( staticPath.appending(component: "so_sanitizer.wasm"), @@ -83,22 +83,21 @@ struct HashArchive: AsyncParsableCommand { ) print("file written to \(staticPath.appending(component: "so_sanitizer.wasm"))") - let archiveSources = try localFileSystem.traverseRecursively(staticPath) - // `traverseRecursively` also returns the `staticPath` directory itself, dropping it here - .dropFirst() + let archiveSources = try localFileSystem.getDirectoryContents(staticPath) + .map { try AbsolutePath(validating: $0, relativeTo: staticPath) } .map(\.pathString) try await Process.run(["zip", "-j", "static.zip"] + archiveSources, terminal) let staticArchiveContents = try localFileSystem.readFileContents( AbsolutePath( - localFileSystem.currentWorkingDirectory!, - RelativePath("static.zip") + validating: "static.zip", + relativeTo: localFileSystem.currentWorkingDirectory! )) // Base64 is not an efficient way, but too long byte array literal breaks type-checker let hashesFileContent = """ - import TSCBasic + import CartonHelpers \(hashes.map { """ @@ -114,7 +113,8 @@ struct HashArchive: AsyncParsableCommand { try localFileSystem.writeFileContents( AbsolutePath( cwd, - RelativePath("Sources").appending(components: "CartonKit", "Server", "StaticArchive.swift") + RelativePath(validating: "Sources").appending( + components: "CartonKit", "Server", "StaticArchive.swift") ), bytes: ByteString(encodingAsUTF8: hashesFileContent) ) diff --git a/Sources/carton-release/Main.swift b/Sources/carton-release/Main.swift index efda46a3..5e8db7ba 100644 --- a/Sources/carton-release/Main.swift +++ b/Sources/carton-release/Main.swift @@ -15,14 +15,10 @@ import ArgumentParser import CartonHelpers -struct CartonRelease: ParsableCommand { +@main +struct CartonRelease: AsyncParsableCommand { static let configuration = CommandConfiguration( abstract: "Carton release automation utility", - subcommands: [Formula.self, HashArchive.self] + subcommands: [HashArchive.self] ) } - -@main -struct Main: AsyncMain { - typealias Command = CartonRelease -} diff --git a/Sources/carton/main.swift b/Sources/carton/main.swift new file mode 100644 index 00000000..23e0de5d --- /dev/null +++ b/Sources/carton/main.swift @@ -0,0 +1,198 @@ +// Copyright 2024 Carton contributors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// This executable is a thin wrapper around the Swift Package Manager and the Carton's SwiftPM Plugins. +// The responsibilities of this executable are: +// - to install appropriate SwiftWasm toolchain if it's not installed and to use it for the later invocations +// * This step will be eventually removed once SwiftPM provides a good way to manage Swift SDKs declaratively +// and Xcode toolchain provides WebAssembly target. (OSS toolchain already provides it) +// - to grant the SwiftPM Plugin process appropriate permissions to write to the file system +// * "dev" and "test" subcommands require listening TCP sockets but SwiftPM doesn't provide a way to +// express this requirement in the package manifest +// * "bundle" subcommand requires writing to the file system to "./Bundle" directory. This is to keep +// soft compatibility with the default behavior of the previous version of Carton +// - to give the SwiftPM build system the target triple by default +// * SwiftPM doesn't provide a way to control the target triple from plugin process +// - to pre-build "{package-name}PackageTests" product before running plugin process +// * SwiftPM doesn't support building only "all tests" product from plugin process, so we have to +// build it before running the CartonTest plugin process +// +// This executable should be eventually removed once SwiftPM provides a way to express those requirements. + +import CartonHelpers +import Foundation +import SwiftToolchain + +extension Foundation.Process { + internal static func checkRun( + _ executableURL: URL, arguments: [String], forwardExit: Bool = false + ) throws { + fputs( + "Running \(([executableURL.path] + arguments).map { "\"\($0)\"" }.joined(separator: " "))\n", + stderr) + fflush(stderr) + + let process = Foundation.Process() + process.executableURL = executableURL + process.arguments = arguments + + // Monitor termination/interrruption signals to forward them to child process + func setSignalForwarding(_ signalNo: Int32) { + signal(signalNo, SIG_IGN) + let signalSource = DispatchSource.makeSignalSource(signal: signalNo) + signalSource.setEventHandler { + signalSource.cancel() + process.interrupt() + } + signalSource.resume() + } + setSignalForwarding(SIGINT) + setSignalForwarding(SIGTERM) + + if forwardExit { + process.terminationHandler = { + // Exit plugin process itself when child process exited + exit($0.terminationStatus) + } + } + try process.run() + process.waitUntilExit() + + if process.terminationStatus != 0 { + exit(process.terminationStatus) + } + } +} + +func derivePackageCommandArguments( + swiftExec: URL, + subcommand: String, + scratchPath: String, + extraArguments: [String] +) throws -> [String] { + var packageArguments: [String] = [ + "package", "--triple", "wasm32-unknown-wasi", "--scratch-path", scratchPath, + ] + var pluginArguments: [String] = ["plugin"] + var cartonPluginArguments: [String] = extraArguments + + switch subcommand { + case "bundle": + pluginArguments += ["--allow-writing-to-directory", "Bundle"] + // Place before user-given extra arguments to allow overriding default options + cartonPluginArguments = ["--output", "Bundle"] + cartonPluginArguments + case "dev": + packageArguments += ["--disable-sandbox"] + case "test": + // 1. Ask the plugin process to generate the build command based on the given options + let commandFile = makeTemporaryFile( + prefix: "test-build", suffix: "args", in: URL(fileURLWithPath: NSTemporaryDirectory())) + try Foundation.Process.checkRun( + swiftExec, + arguments: packageArguments + pluginArguments + [ + "carton-test", + "internal-get-build-command", + ] + cartonPluginArguments + ["--output", commandFile.path] + ) + + // 2. Build the test product + let buildCommand = + try String(contentsOf: commandFile).split(separator: "\n").map(String.init) + [ + "--triple", "wasm32-unknown-wasi", "--scratch-path", scratchPath, + ] + try Foundation.Process.checkRun( + swiftExec, + arguments: buildCommand + ) + + // "--environment browser" launches a http server + packageArguments += ["--disable-sandbox"] + default: break + } + + return packageArguments + pluginArguments + ["carton-\(subcommand)"] + cartonPluginArguments +} + +func makeTemporaryFile(prefix: String, suffix: String, in directory: URL) -> URL { + var template = directory.appendingPathComponent("carton-XXXXXX").path + let result = template.withUTF8 { template in + let copy = UnsafeMutableBufferPointer.allocate(capacity: template.count + 1) + defer { copy.deallocate() } + template.copyBytes(to: copy) + copy[template.count] = 0 + guard mkstemp(copy.baseAddress) != -1 else { + fatalError("Failed to create a temporary directory") + } + return String(cString: copy.baseAddress!) + } + return URL(fileURLWithPath: result) +} + +func pluginSubcommand(subcommand: String, argv0: String, arguments: [String]) async throws { + let scratchPath = URL(fileURLWithPath: ".build/carton") + if FileManager.default.fileExists(atPath: scratchPath.path) { + try FileManager.default.createDirectory(at: scratchPath, withIntermediateDirectories: true) + } + + let terminal = InteractiveWriter.stdout + let toolchainSystem = try ToolchainSystem(fileSystem: localFileSystem) + let (swiftPath, _) = try await toolchainSystem.inferSwiftPath(terminal) + let extraArguments = arguments + + let swiftExec = URL(fileURLWithPath: swiftPath.pathString) + let pluginArguments = try derivePackageCommandArguments( + swiftExec: swiftExec, + subcommand: subcommand, + scratchPath: scratchPath.path, + extraArguments: extraArguments + ) + + try Foundation.Process.checkRun(swiftExec, arguments: pluginArguments, forwardExit: true) +} + +func main(arguments: [String]) async throws { + let argv0 = arguments[0] + let arguments = arguments.dropFirst() + let pluginSubcommands = ["bundle", "dev", "test"] + let subcommands = pluginSubcommands + ["package", "--version"] + guard let subcommand = arguments.first, subcommands.contains(subcommand) else { + if arguments.first == "init" { + print( + "Warning: 'init' subcommand has been removed, use 'swift package init' and add 'carton' as a dependency in Package.swift instead." + ) + } + print("Usage: swift run carton [options]") + print("Available subcommands: \(subcommands.joined(separator: ", "))") + exit(1) + } + + switch subcommand { + case _ where pluginSubcommands.contains(subcommand): + try await pluginSubcommand( + subcommand: subcommand, argv0: argv0, arguments: Array(arguments.dropFirst())) + case "package": + let terminal = InteractiveWriter.stdout + let toolchainSystem = try ToolchainSystem(fileSystem: localFileSystem) + let (swiftPath, _) = try await toolchainSystem.inferSwiftPath(terminal) + try Foundation.Process.checkRun( + URL(fileURLWithPath: swiftPath.pathString), + arguments: ["package"] + arguments.dropFirst(), forwardExit: true + ) + case "--version": + print(cartonVersion) + default: fatalError("Unimplemented subcommand!?") + } +} + +try await main(arguments: CommandLine.arguments) diff --git a/Tests/CartonCommandTests/BundleCommandTests.swift b/Tests/CartonCommandTests/BundleCommandTests.swift index 2563d7d5..041cc855 100644 --- a/Tests/CartonCommandTests/BundleCommandTests.swift +++ b/Tests/CartonCommandTests/BundleCommandTests.swift @@ -15,7 +15,7 @@ // Created by Cavelle Benjamin on Dec/25/20. // -import TSCBasic +import CartonHelpers import XCTest @testable import CartonCLI @@ -25,7 +25,7 @@ final class BundleCommandTests: XCTestCase { try withFixture("EchoExecutable") { packageDirectory in let bundleDirectory = packageDirectory.appending(component: "Bundle") - AssertExecuteCommand(command: "carton bundle", cwd: packageDirectory.url) + try swiftRun(["carton", "bundle"], packageDirectory: packageDirectory.url) // Confirm that the files are actually in the folder XCTAssertTrue(bundleDirectory.exists, "The Bundle directory should exist") @@ -43,22 +43,24 @@ final class BundleCommandTests: XCTestCase { func testWithXswiftc() throws { try withFixture("EchoExecutable") { packageDirectory in - AssertExecuteCommand( - command: "carton bundle -Xswiftc --fake-swiftc-options", - cwd: packageDirectory.url, - expected: "error: unknown argument: '--fake-swiftc-options'", - expectedContains: true + let result = try swiftRun( + ["carton", "bundle", "-Xswiftc", "--fake-swiftc-options"], + packageDirectory: packageDirectory.url ) + + XCTAssertTrue(result.stdout.contains("error: unknown argument: '--fake-swiftc-options'")) + XCTAssertNotEqual(result.exitCode, 0) } } func testWithDebugInfo() throws { - try withTemporaryDirectory { tmpDirPath in - try ProcessEnv.chdir(tmpDirPath) - try Process.checkNonZeroExit(arguments: [cartonPath, "init", "--template", "basic"]) - try Process.checkNonZeroExit(arguments: [cartonPath, "bundle", "--debug-info"]) + try withFixture("EchoExecutable") { packageDirectory in + let result = try swiftRun( + ["carton", "bundle", "--debug-info"], packageDirectory: packageDirectory.url + ) + result.assertZeroExit() - let bundleDirectory = tmpDirPath.appending(component: "Bundle") + let bundleDirectory = packageDirectory.appending(component: "Bundle") guard let wasmBinary = (bundleDirectory.ls().filter { $0.contains("wasm") }).first else { XCTFail("No wasm binary found") return @@ -71,16 +73,15 @@ final class BundleCommandTests: XCTestCase { } func testWasmOptimizationOptions() throws { - try withTemporaryDirectory { tmpDirPath in - try ProcessEnv.chdir(tmpDirPath) - try Process.checkNonZeroExit(arguments: [cartonPath, "init", "--template", "basic"]) - + try withFixture("EchoExecutable") { packageDirectory in func getFileSizeOfWasmBinary(wasmOptimizations: WasmOptimizations) throws -> UInt64 { - let bundleDirectory = tmpDirPath.appending(component: "Bundle") + let bundleDirectory = packageDirectory.appending(component: "Bundle") - try Process.checkNonZeroExit(arguments: [ - cartonPath, "bundle", "--wasm-optimizations", wasmOptimizations.rawValue, - ]) + let result = try swiftRun( + ["carton", "bundle", "--wasm-optimizations", wasmOptimizations.rawValue], + packageDirectory: packageDirectory.url + ) + result.assertZeroExit() guard let wasmFile = (bundleDirectory.ls().filter { $0.contains("wasm") }).first else { XCTFail("No wasm binary found") diff --git a/Tests/CartonCommandTests/CommandTestHelper.swift b/Tests/CartonCommandTests/CommandTestHelper.swift index e1d6065a..f0d1cfbf 100644 --- a/Tests/CartonCommandTests/CommandTestHelper.swift +++ b/Tests/CartonCommandTests/CommandTestHelper.swift @@ -1,343 +1,89 @@ -// ===----------------------------------------------------------*- swift -*-===// +// Copyright 2024 Carton contributors // -// This source file is part of the Swift Argument Parser open source project +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at // -// Copyright (c) 2020 Apple Inc. and the Swift project authors -// Licensed under Apache License v2.0 with Runtime Library Exception +// http://www.apache.org/licenses/LICENSE-2.0 // -// See https://swift.org/LICENSE.txt for license information -// -// ===----------------------------------------------------------------------===// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. import ArgumentParser import XCTest -extension ExitCode { - public static var quit = ExitCode(SIGQUIT) -} - -public func stop(process id: Int32, exitCode: ExitCode = .success) { - print("sending stop command") - kill(id, exitCode.rawValue) -} - -// extensions to the ParsableArguments protocol to facilitate XCTestExpectation support -public protocol TestableParsableArguments: ParsableArguments { - var didValidateExpectation: XCTestExpectation { get } -} - -extension TestableParsableArguments { - public mutating func validate() throws { - didValidateExpectation.fulfill() - } -} - -// extensions to the ParsableCommand protocol to facilitate XCTestExpectation support -public protocol TestableParsableCommand: ParsableCommand, TestableParsableArguments { - var didRunExpectation: XCTestExpectation { get } -} - -extension TestableParsableCommand { - public mutating func run() throws { - didRunExpectation.fulfill() - } -} - -extension XCTestExpectation { - public convenience init(singleExpectation description: String) { - self.init(description: description) - expectedFulfillmentCount = 1 - assertForOverFulfill = true - } -} - -public func AssertResultFailure( - _ expression: @autoclosure () -> Result, - _ message: @autoclosure () -> String = "", - file: StaticString = #file, - line: UInt = #line -) { - switch expression() { - case .success: - let msg = message() - XCTFail(msg.isEmpty ? "Incorrectly succeeded" : msg, file: file, line: line) - case .failure: - break - } -} - -public func AssertErrorMessage( - _ type: A.Type, - _ arguments: [String], - _ errorMessage: String, - file: StaticString = #file, - line: UInt = #line -) where A: ParsableArguments { - do { - _ = try A.parse(arguments) - XCTFail("Parsing should have failed.", file: file, line: line) - } catch { - // We expect to hit this path, i.e. getting an error: - XCTAssertEqual(A.message(for: error), errorMessage, file: file, line: line) - } -} - -public func AssertFullErrorMessage( - _ type: A.Type, - _ arguments: [String], - _ errorMessage: String, - file: StaticString = #file, - line: UInt = #line -) where A: ParsableArguments { - do { - _ = try A.parse(arguments) - XCTFail("Parsing should have failed.", file: file, line: line) - } catch { - // We expect to hit this path, i.e. getting an error: - XCTAssertEqual(A.fullMessage(for: error), errorMessage, file: file, line: line) - } -} - -public func AssertParse( - _ type: A.Type, - _ arguments: [String], - file: StaticString = #file, - line: UInt = #line, - closure: (A) throws -> Void -) where A: ParsableArguments { - do { - let parsed = try type.parse(arguments) - try closure(parsed) - } catch { - let message = type.message(for: error) - XCTFail("\"\(message)\" — \(error)", file: file, line: line) - } -} - -public func AssertParseCommand( - _ rootCommand: ParsableCommand.Type, - _ type: A.Type, - _ arguments: [String], - file: StaticString = #file, - line: UInt = #line, - closure: (A) throws -> Void -) { - do { - let command = try rootCommand.parseAsRoot(arguments) - guard let aCommand = command as? A else { - XCTFail("Command is of unexpected type: \(command)", file: file, line: line) - return - } - try closure(aCommand) - } catch { - let message = rootCommand.message(for: error) - XCTFail("\"\(message)\" — \(error)", file: file, line: line) - } -} - -public func AssertEqualStringsIgnoringTrailingWhitespace( - _ string1: String, - _ string2: String, - file: StaticString = #file, - line: UInt = #line -) { - let lines1 = string1.split(separator: "\n", omittingEmptySubsequences: false) - let lines2 = string2.split(separator: "\n", omittingEmptySubsequences: false) - - XCTAssertEqual( - lines1.count, - lines2.count, - "Strings have different numbers of lines.", - file: file, - line: line - ) - for (line1, line2) in zip(lines1, lines2) { - XCTAssertEqual(line1.trimmed(), line2.trimmed(), file: file, line: line) - } -} - -public func AssertHelp( - for _: T.Type, equals expected: String, - file: StaticString = #file, line: UInt = #line -) { - do { - _ = try T.parse(["-h"]) - XCTFail(file: file, line: line) - } catch { - let helpString = T.fullMessage(for: error) - AssertEqualStringsIgnoringTrailingWhitespace( - helpString, expected, file: file, line: line - ) - } - - let helpString = T.helpMessage() - AssertEqualStringsIgnoringTrailingWhitespace( - helpString, expected, file: file, line: line - ) -} - -public func AssertHelp( - for _: T.Type, root _: U.Type, equals expected: String, - file: StaticString = #file, line: UInt = #line -) { - let helpString = U.helpMessage(for: T.self) - AssertEqualStringsIgnoringTrailingWhitespace( - helpString, expected, file: file, line: line - ) -} - extension XCTest { - public var debugURL: URL { - let bundleURL = Bundle(for: type(of: self)).bundleURL - return bundleURL.lastPathComponent.hasSuffix("xctest") - ? bundleURL.deletingLastPathComponent() - : bundleURL - } - - public var cartonPath: String { - debugURL.appendingPathComponent("carton").path - } - - /// Execute shell command and return the process the command is running in - /// - /// - parameter command: The command to execute. - /// - paramater shouldPrintOutput: whether the command output should be printed to stdout/stderr. - /// - parameter cwd: The current working directory for executing the command. - /// - parameter file: The file the assertion is coming from. - /// - parameter line: The line the assertion is coming from. - public func executeCommand( - command: String, - shouldPrintOutput: Bool = false, - cwd: URL? = nil, // To allow for testing of file-based output - file: StaticString = #file, line: UInt = #line - ) -> Process? { - let splitCommand = command.split(separator: " ") - let arguments = splitCommand.dropFirst().map(String.init) - - let commandName = String(splitCommand.first!) - let commandURL = debugURL.appendingPathComponent(commandName) - guard (try? commandURL.checkResourceIsReachable()) ?? false else { - XCTFail( - "No executable at '\(commandURL.standardizedFileURL.path)'.", - file: file, line: line) - return nil - } - + func findSwiftExecutable() throws -> String { let process = Process() - if #available(macOS 10.13, *) { - process.executableURL = commandURL - } else { - process.launchPath = commandURL.path - } - process.arguments = arguments - - if let workingDirectory = cwd { - process.currentDirectoryURL = workingDirectory - } - + process.executableURL = URL(fileURLWithPath: "/usr/bin/which") + process.arguments = ["swift"] let output = Pipe() - process.standardOutput = shouldPrintOutput ? FileHandle.standardOutput : output - let error = Pipe() - process.standardError = shouldPrintOutput ? FileHandle.standardError : error - - if #available(macOS 10.13, *) { - guard (try? process.run()) != nil else { - XCTFail("Couldn't run command process.", file: file, line: line) - return nil - } - } else { - process.launch() - } - - return process + process.standardOutput = output + try process.run() + process.waitUntilExit() + let outputData = output.fileHandleForReading.readDataToEndOfFile() + return String(data: outputData, encoding: .utf8)!.trimmingCharacters( + in: .whitespacesAndNewlines) } - /// Execute shell command and assert output is what is expected - /// - /// - parameter command: The command to execute. - /// - parameter cwd: The current working directory for executing the command. - /// - parameter expected: The expect string output of the command. - /// - parameter expectedContains: A flag for whether or not it's exact or 'contains' should be used. - /// - parameter exitCode: The exit code of the command. Default is 'success' - /// - parameter debug: Debug the assertion by printing out the command string. - /// - parameter file: The file the assertion is coming from. - /// - parameter line: The line the assertion is coming from. - public func AssertExecuteCommand( - command: String, - cwd: URL? = nil, // To allow for testing of file based output - expected: String? = nil, - expectedContains: Bool = false, - exitCode: ExitCode = .success, - debug: Bool = false, - file: StaticString = #file, line: UInt = #line - ) { - let splitCommand = command.split(separator: " ") - let arguments = splitCommand.dropFirst().map(String.init) + struct SwiftRunResult { + var exitCode: Int32 + var stdout: String + var stderr: String - let commandName = String(splitCommand.first!) - let commandURL = debugURL.appendingPathComponent(commandName) - guard (try? commandURL.checkResourceIsReachable()) ?? false else { - XCTFail( - "No executable at '\(commandURL.standardizedFileURL.path)'.", - file: file, line: line) - return + func assertZeroExit(_ file: StaticString = #file, line: UInt = #line) { + XCTAssertEqual(exitCode, 0, file: file, line: line) } + } + func swiftRunProcess( + _ arguments: [CustomStringConvertible], + packageDirectory: URL + ) throws -> (Process, stdout: Pipe, stderr: Pipe) { let process = Process() - if #available(macOS 10.13, *) { - process.executableURL = commandURL - } else { - process.launchPath = commandURL.path - } - process.arguments = arguments - - if let workingDirectory = cwd { - process.currentDirectoryURL = workingDirectory + process.executableURL = URL(fileURLWithPath: try findSwiftExecutable()) + process.arguments = ["run"] + arguments.map(\.description) + process.currentDirectoryURL = packageDirectory + let stdoutPipe = Pipe() + process.standardOutput = stdoutPipe + let stderrPipe = Pipe() + process.standardError = stderrPipe + + func setSignalForwarding(_ signalNo: Int32) { + signal(signalNo, SIG_IGN) + let signalSource = DispatchSource.makeSignalSource(signal: signalNo) + signalSource.setEventHandler { + signalSource.cancel() + process.interrupt() + } + signalSource.resume() } + setSignalForwarding(SIGINT) + setSignalForwarding(SIGTERM) - let output = Pipe() - process.standardOutput = output - let error = Pipe() - process.standardError = error + try process.run() - if #available(macOS 10.13, *) { - guard (try? process.run()) != nil else { - XCTFail("Couldn't run command process.", file: file, line: line) - return - } - } else { - process.launch() - } + return (process, stdoutPipe, stderrPipe) + } + @discardableResult + func swiftRun(_ arguments: [CustomStringConvertible], packageDirectory: URL) throws + -> SwiftRunResult + { + let (process, stdoutPipe, stderrPipe) = try swiftRunProcess( + arguments, packageDirectory: packageDirectory) process.waitUntilExit() - let outputData = output.fileHandleForReading.readDataToEndOfFile() - let outputActual = String(data: outputData, encoding: .utf8)! + let stdout = String( + data: stdoutPipe.fileHandleForReading.readDataToEndOfFile(), encoding: .utf8)! .trimmingCharacters(in: .whitespacesAndNewlines) - if debug { print(outputActual) } - - let errorData = error.fileHandleForReading.readDataToEndOfFile() - let errorActual = String(data: errorData, encoding: .utf8)! + let stderr = String( + data: stderrPipe.fileHandleForReading.readDataToEndOfFile(), encoding: .utf8)! .trimmingCharacters(in: .whitespacesAndNewlines) - - let finalString = errorActual + outputActual - - if let expected = expected { - if expectedContains { - XCTAssertTrue( - finalString.contains(expected), - "The final string \(finalString) does not contain \(expected)", - file: file, line: line - ) - } else { - AssertEqualStringsIgnoringTrailingWhitespace( - expected, - errorActual + outputActual, - file: file, - line: line - ) - } - } + return SwiftRunResult(exitCode: process.terminationStatus, stdout: stdout, stderr: stderr) } } diff --git a/Tests/CartonCommandTests/DevCommandTests.swift b/Tests/CartonCommandTests/DevCommandTests.swift index d8af4277..786444ca 100644 --- a/Tests/CartonCommandTests/DevCommandTests.swift +++ b/Tests/CartonCommandTests/DevCommandTests.swift @@ -15,58 +15,45 @@ // Created by Cavelle Benjamin on Dec/20/20. // -import AsyncHTTPClient +import Foundation import XCTest @testable import CartonCLI -final class DevCommandTests: XCTestCase { - private var client: HTTPClient? +#if canImport(FoundationNetworking) + import FoundationNetworking +#endif - override func tearDown() { - try? client?.syncShutdown() - client = nil - } +final class DevCommandTests: XCTestCase { + private var client: URLSession? #if os(macOS) - func testWithNoArguments() throws { + func testWithNoArguments() async throws { // FIXME: Don't assume a specific port is available since it can be used by others or tests - try withFixture("EchoExecutable") { packageDirectory in - guard - let process = executeCommand( - command: "carton dev --verbose", - shouldPrintOutput: true, - cwd: packageDirectory.url - ) - else { - XCTFail("Could not create process") - return - } + try await withFixture("EchoExecutable") { packageDirectory in + let (process, _, _) = try swiftRunProcess( + ["carton", "dev", "--verbose", "--skip-auto-open"], + packageDirectory: packageDirectory.url + ) - checkForExpectedContent(process: process, at: "http://127.0.0.1:8080") + await checkForExpectedContent(process: process, at: "http://127.0.0.1:8080") } } - func testWithArguments() throws { + func testWithArguments() async throws { // FIXME: Don't assume a specific port is available since it can be used by others or tests - try withFixture("EchoExecutable") { packageDirectory in - guard - let process = executeCommand( - command: "carton dev --verbose --port 8081", - shouldPrintOutput: true, - cwd: packageDirectory.url - ) - else { - XCTFail("Could not create process") - return - } + try await withFixture("EchoExecutable") { packageDirectory in + let (process, _, _) = try swiftRunProcess( + ["carton", "dev", "--verbose", "--port", "8081", "--skip-auto-open"], + packageDirectory: packageDirectory.url + ) - checkForExpectedContent(process: process, at: "http://127.0.0.1:8081") + await checkForExpectedContent(process: process, at: "http://127.0.0.1:8081") } } #endif - func checkForExpectedContent(process: Process, at url: String) { + func checkForExpectedContent(process: Process, at url: String) async { // client time out for connecting and responding let timeOut: Int64 = 60 @@ -90,16 +77,10 @@ final class DevCommandTests: XCTestCase { """ - let timeout = HTTPClient.Configuration.Timeout( - connect: .seconds(timeOut), - read: .seconds(timeOut) - ) - - client = HTTPClient( - eventLoopGroupProvider: .createNew, - configuration: HTTPClient.Configuration(timeout: timeout)) + client = .shared - var response: HTTPClient.Response? + var response: HTTPURLResponse? + var responseBody: Data? var count = 0 // give the server some time to start @@ -110,18 +91,30 @@ final class DevCommandTests: XCTestCase { } sleep(delay) - response = try? client?.get(url: url).wait() count += 1 + + guard + let (body, urlResponse) = try? await client?.data( + for: URLRequest( + url: URL(string: url)!, + cachePolicy: .reloadIgnoringCacheData, + timeoutInterval: TimeInterval(timeOut) + ) + ) + else { + continue + } + response = urlResponse as? HTTPURLResponse + responseBody = body } while count < polls && response == nil // end the process regardless of success process.terminate() if let response = response { - XCTAssertTrue(response.status == .ok, "Response was not ok") + XCTAssertTrue(response.statusCode == 200, "Response was not ok") - guard let data = (response.body.flatMap { $0.getData(at: 0, length: $0.readableBytes) }) - else { + guard let data = responseBody else { XCTFail("Could not map data") return } diff --git a/Tests/CartonCommandTests/InitCommandTests.swift b/Tests/CartonCommandTests/InitCommandTests.swift deleted file mode 100644 index 8feea7ef..00000000 --- a/Tests/CartonCommandTests/InitCommandTests.swift +++ /dev/null @@ -1,90 +0,0 @@ -// Copyright 2020 Carton contributors -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -// Created by Cavelle Benjamin on Dec/20/20. -// - -import TSCBasic -import XCTest - -@testable import CartonCLI - -final class InitCommandTests: XCTestCase { - func testWithNoArguments() throws { - try withTemporaryDirectory { tmpDirPath in - let package = "wasp" - let packageDirectory = tmpDirPath.appending(component: package) - - try packageDirectory.mkdir() - try ProcessEnv.chdir(packageDirectory) - try Process.checkNonZeroExit(arguments: [cartonPath, "init"]) - - // Confirm that the files are actually in the folder - XCTAssertTrue(packageDirectory.ls().contains("Package.swift"), "Package.swift does not exist") - XCTAssertTrue(packageDirectory.ls().contains(".gitignore"), ".gitignore does not exist") - XCTAssertTrue(packageDirectory.ls().contains("Sources"), "Sources does not exist") - XCTAssertTrue( - packageDirectory.ls().contains("Sources/\(package)"), - "Sources/\(package) does not exist" - ) - XCTAssertTrue( - packageDirectory.ls().contains("Sources/\(package)/main.swift"), - "Sources/\(package)/main.swift does not exist" - ) - XCTAssertTrue(packageDirectory.ls().contains("Tests"), "Tests does not exist") - XCTAssertTrue( - packageDirectory.ls().contains("Tests/\(package)LibraryTests"), - "Tests/\(package)LibraryTests does not exist" - ) - XCTAssertTrue( - packageDirectory.ls().contains("Tests/\(package)LibraryTests/\(package)LibraryTests.swift"), - "Tests/\(package)LibraryTests/\(package)LibraryTests.swift does not exist" - ) - } - } - - func testInitWithTokamakTemplate() throws { - try withTemporaryDirectory { tmpDirPath in - - let package = "fusion" - let packageDirectory = tmpDirPath.appending(component: package) - - try packageDirectory.mkdir() - try ProcessEnv.chdir(packageDirectory) - try Process.checkNonZeroExit(arguments: [cartonPath, "init", "--template", "tokamak"]) - - // Confirm that the files are actually in the folder - XCTAssertTrue(packageDirectory.ls().contains("Package.swift"), "Package.swift does not exist") - XCTAssertTrue(packageDirectory.ls().contains(".gitignore"), ".gitignore does not exist") - XCTAssertTrue(packageDirectory.ls().contains("Sources"), "Sources does not exist") - XCTAssertTrue( - packageDirectory.ls().contains("Sources/\(package)"), - "Sources/\(package) does not exist" - ) - XCTAssertTrue( - packageDirectory.ls().contains("Sources/\(package)/App.swift"), - "Sources/\(package)/App.swift does not exist" - ) - XCTAssertTrue(packageDirectory.ls().contains("Tests"), "Tests does not exist") - XCTAssertTrue( - packageDirectory.ls().contains("Tests/\(package)LibraryTests"), - "Tests/\(package)LibraryTests does not exist" - ) - XCTAssertTrue( - packageDirectory.ls().contains("Tests/\(package)LibraryTests/\(package)LibraryTests.swift"), - "Tests/\(package)LibraryTests/\(package)LibraryTests.swift does not exist" - ) - } - } -} diff --git a/Tests/CartonCommandTests/IntegrationTests.swift b/Tests/CartonCommandTests/IntegrationTests.swift deleted file mode 100644 index ca4c60ef..00000000 --- a/Tests/CartonCommandTests/IntegrationTests.swift +++ /dev/null @@ -1,28 +0,0 @@ -// Copyright 2022 Carton contributors -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -import TSCBasic -import XCTest - -@testable import CartonCLI - -final class IntegrationTests: XCTestCase { - func testTokamakBundle() throws { - try withTemporaryDirectory { tmpDirPath in - try ProcessEnv.chdir(tmpDirPath) - try Process.checkNonZeroExit(arguments: [cartonPath, "init", "--template", "tokamak"]) - try Process.checkNonZeroExit(arguments: [cartonPath, "bundle"]) - } - } -} diff --git a/Tests/CartonCommandTests/SDKCommandTests.swift b/Tests/CartonCommandTests/SDKCommandTests.swift deleted file mode 100644 index a242a844..00000000 --- a/Tests/CartonCommandTests/SDKCommandTests.swift +++ /dev/null @@ -1,67 +0,0 @@ -// Copyright 2020 Carton contributors -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -// Created by Cavelle Benjamin on Dec/25/20. -// - -import TSCBasic -import XCTest - -@testable import CartonCLI - -final class SDKCommandTests: XCTestCase { - func testInstall() throws { - try AssertExecuteCommand( - command: "carton sdk install", - cwd: packageDirectory.url, - expected: "SDK successfully installed!", - expectedContains: true - ) - } - - func testVersions() throws { - try AssertExecuteCommand( - command: "carton sdk versions", - cwd: packageDirectory.url, - expected: "wasm-", - expectedContains: true - ) - } - - func testLocalNoFile() throws { - try withTemporaryDirectory { tmpDir in - AssertExecuteCommand( - command: "carton sdk local", - cwd: tmpDir.url, - expected: "Version file is not present: ", - expectedContains: true - ) - } - } - - func testLocalWithFile() throws { - try withTemporaryDirectory { tmpDir in - let swiftVersion = tmpDir.appending(component: ".swift-version") - let alternateLocal = "wasm-5.4.0" - try alternateLocal.write(to: swiftVersion.url, atomically: true, encoding: .utf8) - - AssertExecuteCommand( - command: "carton sdk local", - cwd: tmpDir.url, - expected: "wasm-5.4.0", - expectedContains: true - ) - } - } -} diff --git a/Tests/CartonCommandTests/StringHelpers.swift b/Tests/CartonCommandTests/StringHelpers.swift deleted file mode 100644 index c48dddeb..00000000 --- a/Tests/CartonCommandTests/StringHelpers.swift +++ /dev/null @@ -1,27 +0,0 @@ -// ===----------------------------------------------------------*- swift -*-===// -// -// This source file is part of the Swift Argument Parser open source project -// -// Copyright (c) 2020 Apple Inc. and the Swift project authors -// Licensed under Apache License v2.0 with Runtime Library Exception -// -// See https://swift.org/LICENSE.txt for license information -// -// ===----------------------------------------------------------------------===// - -extension Substring { - func trimmed() -> Substring { - guard let i = lastIndex(where: { $0 != " " }) else { - return "" - } - return self[...i] - } -} - -extension String { - public func trimmingLines() -> String { - split(separator: "\n", omittingEmptySubsequences: false) - .map { $0.trimmed() } - .joined(separator: "\n") - } -} diff --git a/Tests/CartonCommandTests/TestCommandTests.swift b/Tests/CartonCommandTests/TestCommandTests.swift index b99f25ab..dd7e7535 100644 --- a/Tests/CartonCommandTests/TestCommandTests.swift +++ b/Tests/CartonCommandTests/TestCommandTests.swift @@ -15,8 +15,7 @@ // Created by Cavelle Benjamin on Dec/28/20. // -import AsyncHTTPClient -import TSCBasic +import CartonHelpers import XCTest @testable import CartonCLI @@ -31,45 +30,47 @@ private enum Constants { final class TestCommandTests: XCTestCase { func testWithNoArguments() throws { try withFixture(Constants.testAppPackageName) { packageDirectory in - AssertExecuteCommand( - command: "carton test", - cwd: packageDirectory.url, - debug: true + let result = try swiftRun( + ["carton", "test"], packageDirectory: packageDirectory.url ) + result.assertZeroExit() } } func testEnvironmentNodeNoJSKit() throws { try withFixture(Constants.testAppPackageName) { packageDirectory in - AssertExecuteCommand( - command: "carton test --environment node", - cwd: packageDirectory.url, - debug: true + let result = try swiftRun( + ["carton", "test", "--environment", "node"], packageDirectory: packageDirectory.url ) + result.assertZeroExit() } } func testEnvironmentNodeJSKit() throws { try withFixture(Constants.nodeJSKitPackageName) { packageDirectory in - AssertExecuteCommand( - command: "carton test --environment node", - cwd: packageDirectory.url, - debug: true + let result = try swiftRun( + ["carton", "test", "--environment", "node"], packageDirectory: packageDirectory.url ) + result.assertZeroExit() } } func testSkipBuild() throws { try withFixture(Constants.nodeJSKitPackageName) { packageDirectory in - AssertExecuteCommand( - command: "carton test --environment node", - cwd: packageDirectory.url + var result = try swiftRun( + ["carton", "test", "--environment", "node"], packageDirectory: packageDirectory.url ) - AssertExecuteCommand( - command: - "carton test --environment node --prebuilt-test-bundle-path ./.build/wasm32-unknown-wasi/debug/NodeJSKitTestPackageTests.wasm", - cwd: packageDirectory.url + result.assertZeroExit() + + result = try swiftRun( + [ + "carton", "test", "--environment", "node", + "--prebuilt-test-bundle-path", + "./.build/carton/wasm32-unknown-wasi/debug/NodeJSKitTestPackageTests.wasm", + ], + packageDirectory: packageDirectory.url ) + result.assertZeroExit() } } @@ -78,10 +79,11 @@ final class TestCommandTests: XCTestCase { throw XCTSkip("WebDriver is required") } try withFixture(Constants.testAppPackageName) { packageDirectory in - AssertExecuteCommand( - command: "carton test --environment defaultBrowser --headless", - cwd: packageDirectory.url + let result = try swiftRun( + ["carton", "test", "--environment", "browser", "--headless"], + packageDirectory: packageDirectory.url ) + result.assertZeroExit() } } @@ -98,13 +100,11 @@ final class TestCommandTests: XCTestCase { throw XCTSkip("WebDriver is required") } try withFixture(fixture) { packageDirectory in - try ProcessEnv.chdir(packageDirectory) - let process = Process(arguments: [ - cartonPath, "test", "--environment", "defaultBrowser", "--headless", - ]) - try process.launch() - let result = try process.waitUntilExit() - XCTAssertNotEqual(result.exitStatus, .terminated(code: 0)) + let result = try swiftRun( + ["carton", "test", "--environment", "browser", "--headless"], + packageDirectory: packageDirectory.url + ) + XCTAssertNotEqual(result.exitCode, 0) } } @@ -124,12 +124,11 @@ final class TestCommandTests: XCTestCase { """ // FIXME: Don't assume a specific port is available since it can be used by others or tests - AssertExecuteCommand( - command: "carton test --environment defaultBrowser --port 8082", - cwd: packageDirectory.url, - expected: expectedContent, - expectedContains: true + let result = try swiftRun( + ["carton", "test", "--environment", "browser", "--port", "8082"], + packageDirectory: packageDirectory.url ) + XCTAssertTrue(result.stdout.contains(expectedContent)) } } #endif diff --git a/Tests/CartonCommandTests/Testable.swift b/Tests/CartonCommandTests/Testable.swift index 22052c20..6bb630da 100644 --- a/Tests/CartonCommandTests/Testable.swift +++ b/Tests/CartonCommandTests/Testable.swift @@ -15,9 +15,8 @@ // Created by Cavelle Benjamin on Dec/20/20. // +import CartonHelpers import Foundation -import TSCBasic -import TSCTestSupport /// Returns path to the built products directory. public var productsDirectory: AbsolutePath { @@ -50,25 +49,15 @@ public var packageDirectory: AbsolutePath { func withFixture(_ name: String, _ body: (AbsolutePath) throws -> Void) throws { let fixtureDir = try testFixturesDirectory.appending(component: name) - try withTemporaryDirectory(prefix: name) { tmpDirPath in - let dstDir = tmpDirPath.appending(component: name) - try systemQuietly("cp", "-R", "-H", fixtureDir.pathString, dstDir.pathString) - try body(dstDir) - } + try body(fixtureDir) } -extension AbsolutePath { - func mkdir() throws { - _ = try FileManager.default.createDirectory( - atPath: pathString, - withIntermediateDirectories: true - ) - } - - func delete() throws { - _ = try FileManager.default.removeItem(atPath: pathString) - } +func withFixture(_ name: String, _ body: (AbsolutePath) async throws -> Void) async throws { + let fixtureDir = try testFixturesDirectory.appending(component: name) + try await body(fixtureDir) +} +extension AbsolutePath { var url: URL { URL(fileURLWithPath: pathString) } diff --git a/Tests/CartonTests/CartonTests.swift b/Tests/CartonTests/CartonTests.swift index d31f6a1c..10d3271f 100644 --- a/Tests/CartonTests/CartonTests.swift +++ b/Tests/CartonTests/CartonTests.swift @@ -13,8 +13,6 @@ // limitations under the License. import CartonHelpers -import TSCBasic -import TSCUtility import XCTest import class Foundation.Bundle @@ -84,38 +82,6 @@ final class CartonTests: XCTestCase { } } - func testDiagnosticsParser() { - // swiftlint:disable line_length - let testDiagnostics = """ - [1/1] Compiling TokamakCore Font.swift - /Users/username/Project/Sources/TokamakCore/Tokens/Font.swift:58:15: error: invalid redeclaration of 'resolve(in:)' - public func resolve(in environment: EnvironmentValues) -> _Font { - ^ - /Users/username/Project/Sources/TokamakCore/Tokens/Font.swift:55:15: note: 'resolve(in:)' previously declared here - public func resolve(in environment: EnvironmentValues) -> _Font { - ^ - """ - let expectedOutput = """ - \u{001B}[1m\u{001B}[7m Font.swift \u{001B}[0m /Users/username/Project/Sources/TokamakCore/Tokens/Font.swift:58 - - \u{001B}[41;1m\u{001B}[37;1m ERROR \u{001B}[0m invalid redeclaration of 'resolve(in:)' - \u{001B}[36m58 | \u{001B}[0m \u{001B}[35;1mpublic\u{001B}[0m \u{001B}[35;1mfunc\u{001B}[0m resolve(in environment: \u{001B}[94mEnvironmentValues\u{001B}[0m) -> \u{001B}[94m_Font\u{001B}[0m { - | ^ - - \u{001B}[7m\u{001B}[37;1m NOTE \u{001B}[0m 'resolve(in:)' previously declared here - \u{001B}[36m55 | \u{001B}[0m \u{001B}[35;1mpublic\u{001B}[0m \u{001B}[35;1mfunc\u{001B}[0m resolve(in environment: \u{001B}[94mEnvironmentValues\u{001B}[0m) -> \u{001B}[94m_Font\u{001B}[0m { - | ^ - - - - """ - // swiftlint:enable line_length - let stream = TestOutputStream() - let writer = InteractiveWriter(stream: stream) - DiagnosticsParser().parse(testDiagnostics, writer) - XCTAssertEqual(stream.currentOutput, expectedOutput) - } - func testDestinationEnvironment() { XCTAssertEqual( DestinationEnvironment( @@ -150,20 +116,4 @@ final class CartonTests: XCTestCase { nil ) } - - func testSwiftWasmVersionParsing() throws { - let v5_6 = try Version(swiftWasmVersion: "wasm-5.6.0-RELEASE") - XCTAssertEqual(v5_6.major, 5) - XCTAssertEqual(v5_6.minor, 6) - XCTAssertEqual(v5_6.patch, 0) - XCTAssert(v5_6.prereleaseIdentifiers.isEmpty) - XCTAssert(v5_6 >= Version(5, 6, 0)) - - let v5_7_snapshot = try Version(swiftWasmVersion: "wasm-5.7-SNAPSHOT-2022-07-14-a") - XCTAssertEqual(v5_7_snapshot.major, 5) - XCTAssertEqual(v5_7_snapshot.minor, 7) - XCTAssertEqual(v5_7_snapshot.patch, 0) - XCTAssert(v5_7_snapshot.prereleaseIdentifiers.isEmpty) - XCTAssert(v5_7_snapshot >= Version(5, 6, 0)) - } } diff --git a/Tests/CartonTests/StackTraceTests.swift b/Tests/CartonTests/StackTraceTests.swift index cf37c05e..d3918174 100644 --- a/Tests/CartonTests/StackTraceTests.swift +++ b/Tests/CartonTests/StackTraceTests.swift @@ -18,6 +18,7 @@ import XCTest @testable import CartonHelpers +@testable import CartonKit final class StackTraceTests: XCTestCase {} extension StackTraceTests { diff --git a/Tests/Fixtures/CrashTest/Package.swift b/Tests/Fixtures/CrashTest/Package.swift index 2a010077..2e53f7d9 100644 --- a/Tests/Fixtures/CrashTest/Package.swift +++ b/Tests/Fixtures/CrashTest/Package.swift @@ -3,5 +3,6 @@ import PackageDescription let package = Package( name: "Test", + dependencies: [.package(path: "../../..")], targets: [.testTarget(name: "CrashTest", path: "Tests")] ) diff --git a/Tests/Fixtures/EchoExecutable/Package.swift b/Tests/Fixtures/EchoExecutable/Package.swift index 2db72047..f97fa8cf 100644 --- a/Tests/Fixtures/EchoExecutable/Package.swift +++ b/Tests/Fixtures/EchoExecutable/Package.swift @@ -4,5 +4,6 @@ import PackageDescription let package = Package( name: "Foo", products: [.executable(name: "my-echo", targets: ["my-echo"])], + dependencies: [.package(path: "../../..")], targets: [.target(name: "my-echo")] ) diff --git a/Tests/Fixtures/FailTest/Package.swift b/Tests/Fixtures/FailTest/Package.swift index 6e6f4ffd..264ef927 100644 --- a/Tests/Fixtures/FailTest/Package.swift +++ b/Tests/Fixtures/FailTest/Package.swift @@ -3,5 +3,6 @@ import PackageDescription let package = Package( name: "Test", + dependencies: [.package(path: "../../..")], targets: [.testTarget(name: "FailTest", path: "Tests")] ) diff --git a/Tests/Fixtures/NodeJSKitTest/Package.resolved b/Tests/Fixtures/NodeJSKitTest/Package.resolved index 18d83d7f..3f74e530 100644 --- a/Tests/Fixtures/NodeJSKitTest/Package.resolved +++ b/Tests/Fixtures/NodeJSKitTest/Package.resolved @@ -8,6 +8,78 @@ "revision" : "2d7bc960eed438dce7355710ece43fa004bbb3ac", "version" : "0.15.0" } + }, + { + "identity" : "swift-argument-parser", + "kind" : "remoteSourceControl", + "location" : "https://github.com/apple/swift-argument-parser.git", + "state" : { + "revision" : "c8ed701b513cf5177118a175d85fbbbcd707ab41", + "version" : "1.3.0" + } + }, + { + "identity" : "swift-atomics", + "kind" : "remoteSourceControl", + "location" : "https://github.com/apple/swift-atomics.git", + "state" : { + "revision" : "cd142fd2f64be2100422d658e7411e39489da985", + "version" : "1.2.0" + } + }, + { + "identity" : "swift-collections", + "kind" : "remoteSourceControl", + "location" : "https://github.com/apple/swift-collections.git", + "state" : { + "revision" : "94cf62b3ba8d4bed62680a282d4c25f9c63c2efb", + "version" : "1.1.0" + } + }, + { + "identity" : "swift-log", + "kind" : "remoteSourceControl", + "location" : "https://github.com/apple/swift-log.git", + "state" : { + "revision" : "e97a6fcb1ab07462881ac165fdbb37f067e205d5", + "version" : "1.5.4" + } + }, + { + "identity" : "swift-nio", + "kind" : "remoteSourceControl", + "location" : "https://github.com/apple/swift-nio.git", + "state" : { + "revision" : "635b2589494c97e48c62514bc8b37ced762e0a62", + "version" : "2.63.0" + } + }, + { + "identity" : "swift-system", + "kind" : "remoteSourceControl", + "location" : "https://github.com/apple/swift-system.git", + "state" : { + "revision" : "025bcb1165deab2e20d4eaba79967ce73013f496", + "version" : "1.2.1" + } + }, + { + "identity" : "swift-tools-support-core", + "kind" : "remoteSourceControl", + "location" : "https://github.com/apple/swift-tools-support-core.git", + "state" : { + "branch" : "main", + "revision" : "930e82e5ae2432c71fe05f440b5d778285270bdb" + } + }, + { + "identity" : "wasmtransformer", + "kind" : "remoteSourceControl", + "location" : "https://github.com/swiftwasm/WasmTransformer", + "state" : { + "revision" : "d04b31f61b6f528a9a96ebfe4fa4275e333eba82", + "version" : "0.5.0" + } } ], "version" : 2 diff --git a/Tests/Fixtures/NodeJSKitTest/Package.swift b/Tests/Fixtures/NodeJSKitTest/Package.swift index 7fb2ecea..991d31d7 100644 --- a/Tests/Fixtures/NodeJSKitTest/Package.swift +++ b/Tests/Fixtures/NodeJSKitTest/Package.swift @@ -6,7 +6,8 @@ import PackageDescription let package = Package( name: "NodeJSKitTest", dependencies: [ - .package(url: "https://github.com/swiftwasm/JavaScriptKit", from: "0.15.0") + .package(path: "../../../"), + .package(url: "https://github.com/swiftwasm/JavaScriptKit", from: "0.15.0"), ], targets: [ // Targets are the basic building blocks of a package. A target can define a module or a test suite. diff --git a/Tests/Fixtures/PluginTest/.gitignore b/Tests/Fixtures/PluginTest/.gitignore new file mode 100644 index 00000000..0023a534 --- /dev/null +++ b/Tests/Fixtures/PluginTest/.gitignore @@ -0,0 +1,8 @@ +.DS_Store +/.build +/Packages +xcuserdata/ +DerivedData/ +.swiftpm/configuration/registries.json +.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata +.netrc diff --git a/Tests/Fixtures/PluginTest/Package.swift b/Tests/Fixtures/PluginTest/Package.swift new file mode 100644 index 00000000..1cea453c --- /dev/null +++ b/Tests/Fixtures/PluginTest/Package.swift @@ -0,0 +1,17 @@ +// swift-tools-version: 5.9 +// The swift-tools-version declares the minimum version of Swift required to build this package. + +import PackageDescription + +let package = Package( + name: "PluginTest", + dependencies: [ + .package(path: "../../../"), + .package(url: "https://github.com/swiftwasm/JavaScriptKit", from: "0.19.0"), + ], + targets: [ + .executableTarget(name: "PluginTestExe", dependencies: ["JavaScriptKit"]), + .target(name: "PluginTest"), + .testTarget(name: "PluginTestTests", dependencies: ["PluginTest"]), + ] +) diff --git a/Tests/Fixtures/PluginTest/Sources/PluginTest/PluginTest.swift b/Tests/Fixtures/PluginTest/Sources/PluginTest/PluginTest.swift new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/Tests/Fixtures/PluginTest/Sources/PluginTest/PluginTest.swift @@ -0,0 +1 @@ + diff --git a/Tests/Fixtures/PluginTest/Sources/PluginTestExe/main.swift b/Tests/Fixtures/PluginTest/Sources/PluginTestExe/main.swift new file mode 100644 index 00000000..f8fc4d68 --- /dev/null +++ b/Tests/Fixtures/PluginTest/Sources/PluginTestExe/main.swift @@ -0,0 +1,7 @@ +// The Swift Programming Language +// https://docs.swift.org/swift-book + +import JavaScriptKit + +JSObject.global.alert!("Hello, wa") +print("Hello, wa") diff --git a/Tests/Fixtures/PluginTest/Tests/PluginTestTests/PluginTestTests.swift b/Tests/Fixtures/PluginTest/Tests/PluginTestTests/PluginTestTests.swift new file mode 100644 index 00000000..12c158d9 --- /dev/null +++ b/Tests/Fixtures/PluginTest/Tests/PluginTestTests/PluginTestTests.swift @@ -0,0 +1,7 @@ +import XCTest + +class PluginTestTests: XCTestCase { + func testExample() { + XCTAssertTrue(true) + } +} diff --git a/Tests/Fixtures/TestApp/Package.resolved b/Tests/Fixtures/TestApp/Package.resolved index cf53b91f..7d0ac516 100644 --- a/Tests/Fixtures/TestApp/Package.resolved +++ b/Tests/Fixtures/TestApp/Package.resolved @@ -9,6 +9,69 @@ "revision": "2d7bc960eed438dce7355710ece43fa004bbb3ac", "version": "0.15.0" } + }, + { + "package": "swift-argument-parser", + "repositoryURL": "https://github.com/apple/swift-argument-parser.git", + "state": { + "branch": null, + "revision": "c8ed701b513cf5177118a175d85fbbbcd707ab41", + "version": "1.3.0" + } + }, + { + "package": "swift-atomics", + "repositoryURL": "https://github.com/apple/swift-atomics.git", + "state": { + "branch": null, + "revision": "cd142fd2f64be2100422d658e7411e39489da985", + "version": "1.2.0" + } + }, + { + "package": "swift-collections", + "repositoryURL": "https://github.com/apple/swift-collections.git", + "state": { + "branch": null, + "revision": "94cf62b3ba8d4bed62680a282d4c25f9c63c2efb", + "version": "1.1.0" + } + }, + { + "package": "swift-log", + "repositoryURL": "https://github.com/apple/swift-log.git", + "state": { + "branch": null, + "revision": "e97a6fcb1ab07462881ac165fdbb37f067e205d5", + "version": "1.5.4" + } + }, + { + "package": "swift-nio", + "repositoryURL": "https://github.com/apple/swift-nio.git", + "state": { + "branch": null, + "revision": "635b2589494c97e48c62514bc8b37ced762e0a62", + "version": "2.63.0" + } + }, + { + "package": "swift-system", + "repositoryURL": "https://github.com/apple/swift-system.git", + "state": { + "branch": null, + "revision": "025bcb1165deab2e20d4eaba79967ce73013f496", + "version": "1.2.1" + } + }, + { + "package": "WasmTransformer", + "repositoryURL": "https://github.com/swiftwasm/WasmTransformer", + "state": { + "branch": null, + "revision": "d04b31f61b6f528a9a96ebfe4fa4275e333eba82", + "version": "0.5.0" + } } ] }, diff --git a/Tests/Fixtures/TestApp/Package.swift b/Tests/Fixtures/TestApp/Package.swift index aa94aa66..05199bb8 100644 --- a/Tests/Fixtures/TestApp/Package.swift +++ b/Tests/Fixtures/TestApp/Package.swift @@ -9,7 +9,8 @@ let package = Package( .executable(name: "TestApp", targets: ["TestApp"]) ], dependencies: [ - .package(url: "https://github.com/swiftwasm/JavaScriptKit", from: "0.15.0") + .package(path: "../../../"), + .package(url: "https://github.com/swiftwasm/JavaScriptKit", from: "0.15.0"), ], targets: [ // Targets are the basic building blocks of a package. A target can define a module or a test diff --git a/Tests/WebDriverClientTests/WebDriverClientTests.swift b/Tests/WebDriverClientTests/WebDriverClientTests.swift index f2124439..3ab9593f 100644 --- a/Tests/WebDriverClientTests/WebDriverClientTests.swift +++ b/Tests/WebDriverClientTests/WebDriverClientTests.swift @@ -12,17 +12,10 @@ // See the License for the specific language governing permissions and // limitations under the License. -import AsyncHTTPClient import WebDriverClient import XCTest final class WebDriverClientTests: XCTestCase { - let httpClient = HTTPClient(eventLoopGroupProvider: .createNew) - - override func tearDown() async throws { - try httpClient.syncShutdown() - } - func checkRemoteURL() throws -> URL { guard let value = ProcessInfo.processInfo.environment["WEBDRIVER_REMOTE_URL"] else { throw XCTSkip("Skip WebDriver tests due to no WEBDRIVER_REMOTE_URL env var") @@ -32,7 +25,7 @@ final class WebDriverClientTests: XCTestCase { func testGoto() async throws { let client = try await WebDriverClient.newSession( - endpoint: checkRemoteURL(), httpClient: httpClient + endpoint: checkRemoteURL(), httpClient: .shared ) try await client.goto(url: "https://example.com") try await client.closeSession() From aace14890efff74b2ea84ac145a725e2cff3f2d5 Mon Sep 17 00:00:00 2001 From: Yuta Saito Date: Sun, 25 Feb 2024 08:02:43 +0000 Subject: [PATCH 02/13] Repair Linux build --- Plugins/CartonDev/Plugin.swift | 2 +- .../TestRunners/BrowserTestRunner.swift | 3 + Sources/CartonHelpers/AsyncFileDownload.swift | 3 + Sources/CartonHelpers/Basics/Condition.swift | 59 ++++ Sources/CartonHelpers/Basics/FileInfo.swift | 4 + Sources/CartonHelpers/Basics/FileSystem.swift | 10 +- Sources/CartonHelpers/Basics/Lock.swift | 257 ++++++++++++++++++ .../Basics/Process/Process.swift | 72 ----- .../Basics/WritableByteStream.swift | 1 + Sources/CartonHelpers/URLSession.swift | 34 +++ Sources/CartonKit/Utilities/FSWatch.swift | 4 +- .../SwiftToolchain/ToolchainManagement.swift | 3 + Sources/WebDriverClient/WebDriverClient.swift | 19 ++ Sources/carton/main.swift | 2 +- 14 files changed, 393 insertions(+), 80 deletions(-) create mode 100644 Sources/CartonHelpers/Basics/Condition.swift create mode 100644 Sources/CartonHelpers/Basics/Lock.swift create mode 100644 Sources/CartonHelpers/URLSession.swift diff --git a/Plugins/CartonDev/Plugin.swift b/Plugins/CartonDev/Plugin.swift index bd3a437f..b8e79adf 100644 --- a/Plugins/CartonDev/Plugin.swift +++ b/Plugins/CartonDev/Plugin.swift @@ -133,7 +133,7 @@ private func createTemporaryDirectory(under directory: Path) throws -> Path { defer { copy.deallocate() } template.copyBytes(to: copy) copy[template.count] = 0 - guard let result = mkdtemp(copy.baseAddress) else { + guard let result = mkdtemp(copy.baseAddress!) else { throw CartonPluginError("Failed to create a temporary directory") } return String(cString: result) diff --git a/Sources/CartonCLI/Commands/TestRunners/BrowserTestRunner.swift b/Sources/CartonCLI/Commands/TestRunners/BrowserTestRunner.swift index dd79b907..de30540e 100644 --- a/Sources/CartonCLI/Commands/TestRunners/BrowserTestRunner.swift +++ b/Sources/CartonCLI/Commands/TestRunners/BrowserTestRunner.swift @@ -18,6 +18,9 @@ import Foundation import NIOCore import NIOPosix import WebDriverClient +#if canImport(FoundationNetworking) +import FoundationNetworking +#endif private enum Constants { static let entrypoint = Entrypoint(fileName: "test.js", sha256: testEntrypointSHA256) diff --git a/Sources/CartonHelpers/AsyncFileDownload.swift b/Sources/CartonHelpers/AsyncFileDownload.swift index 38722ddf..0185e3d9 100644 --- a/Sources/CartonHelpers/AsyncFileDownload.swift +++ b/Sources/CartonHelpers/AsyncFileDownload.swift @@ -13,6 +13,9 @@ // limitations under the License. import Foundation +#if canImport(FoundationNetworking) +import FoundationNetworking +#endif public struct InvalidResponseCode: Error { let code: UInt diff --git a/Sources/CartonHelpers/Basics/Condition.swift b/Sources/CartonHelpers/Basics/Condition.swift new file mode 100644 index 00000000..566c1a02 --- /dev/null +++ b/Sources/CartonHelpers/Basics/Condition.swift @@ -0,0 +1,59 @@ +/* + This source file is part of the Swift.org open source project + + Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors + Licensed under Apache License v2.0 with Runtime Library Exception + + See http://swift.org/LICENSE.txt for license information + See http://swift.org/CONTRIBUTORS.txt for Swift project authors +*/ +#if !_runtime(_ObjC) +@preconcurrency import Foundation +#else +import Foundation +#endif + +/// Simple wrapper around NSCondition. +/// - SeeAlso: NSCondition +public struct Condition { + private let _condition = NSCondition() + + /// Create a new condition. + public init() {} + + /// Wait for the condition to become available. + public func wait() { + _condition.wait() + } + + /// Blocks the current thread until the condition is signaled or the specified time limit is reached. + /// + /// - Returns: true if the condition was signaled; otherwise, false if the time limit was reached. + public func wait(until limit: Date) -> Bool { + return _condition.wait(until: limit) + } + + /// Signal the availability of the condition (awake one thread waiting on + /// the condition). + public func signal() { + _condition.signal() + } + + /// Broadcast the availability of the condition (awake all threads waiting + /// on the condition). + public func broadcast() { + _condition.broadcast() + } + + /// A helper method to execute the given body while condition is locked. + /// - Note: Will ensure condition unlocks even if `body` throws. + public func whileLocked(_ body: () throws -> T) rethrows -> T { + _condition.lock() + defer { _condition.unlock() } + return try body() + } +} + +#if compiler(>=5.7) +extension Condition: Sendable {} +#endif diff --git a/Sources/CartonHelpers/Basics/FileInfo.swift b/Sources/CartonHelpers/Basics/FileInfo.swift index 38f4a315..90499b35 100644 --- a/Sources/CartonHelpers/Basics/FileInfo.swift +++ b/Sources/CartonHelpers/Basics/FileInfo.swift @@ -8,7 +8,11 @@ See http://swift.org/CONTRIBUTORS.txt for Swift project authors */ +#if !_runtime(_ObjC) +@preconcurrency import Foundation +#else import Foundation +#endif #if swift(<5.6) extension FileAttributeType: UnsafeSendable {} diff --git a/Sources/CartonHelpers/Basics/FileSystem.swift b/Sources/CartonHelpers/Basics/FileSystem.swift index bd19bfd6..f693e22f 100644 --- a/Sources/CartonHelpers/Basics/FileSystem.swift +++ b/Sources/CartonHelpers/Basics/FileSystem.swift @@ -336,7 +336,11 @@ extension FileSystem { public func hasQuarantineAttribute(_ path: AbsolutePath) -> Bool { false } - public func hasAttribute(_ name: FileSystemAttribute, _ path: AbsolutePath) -> Bool { false } + public func hasAttribute(_ name: FileSystemAttribute, _ path: AbsolutePath) -> Bool { + #if canImport(Darwin) + false + #endif + } public func itemReplacementDirectories(for path: AbsolutePath) throws -> [AbsolutePath] { [] } } @@ -396,8 +400,6 @@ private struct LocalFileSystem: FileSystem { let bufLength = getxattr(path.pathString, name.rawValue, nil, 0, 0, 0) return bufLength > 0 - #else - return false #endif } @@ -414,7 +416,7 @@ private struct LocalFileSystem: FileSystem { let fsr: UnsafePointer = cwdStr.fileSystemRepresentation defer { fsr.deallocate() } - return try? AbsolutePath(String(cString: fsr)) + return try? AbsolutePath(validating: String(cString: fsr)) #endif } diff --git a/Sources/CartonHelpers/Basics/Lock.swift b/Sources/CartonHelpers/Basics/Lock.swift new file mode 100644 index 00000000..64216123 --- /dev/null +++ b/Sources/CartonHelpers/Basics/Lock.swift @@ -0,0 +1,257 @@ +/* + This source file is part of the Swift.org open source project + + Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors + Licensed under Apache License v2.0 with Runtime Library Exception + + See http://swift.org/LICENSE.txt for license information + See http://swift.org/CONTRIBUTORS.txt for Swift project authors +*/ + +import Foundation + +@available(*, deprecated, message: "Use NSLock directly instead. SPM has a withLock extension function" ) +/// A simple lock wrapper. +public struct Lock { + private let _lock = NSLock() + + /// Create a new lock. + public init() { + } + + func lock() { + _lock.lock() + } + + func unlock() { + _lock.unlock() + } + + /// Execute the given block while holding the lock. + public func withLock (_ body: () throws -> T) rethrows -> T { + lock() + defer { unlock() } + return try body() + } +} + +// for internal usage +extension NSLock { + internal func withLock (_ body: () throws -> T) rethrows -> T { + self.lock() + defer { self.unlock() } + return try body() + } +} + +public enum ProcessLockError: Error { + case unableToAquireLock(errno: Int32) +} + +extension ProcessLockError: CustomNSError { + public var errorUserInfo: [String : Any] { + return [NSLocalizedDescriptionKey: "\(self)"] + } +} +/// Provides functionality to acquire a lock on a file via POSIX's flock() method. +/// It can be used for things like serializing concurrent mutations on a shared resource +/// by multiple instances of a process. The `FileLock` is not thread-safe. +public final class FileLock { + + public enum LockType { + case exclusive + case shared + } + + /// File descriptor to the lock file. + #if os(Windows) + private var handle: HANDLE? + #else + private var fileDescriptor: CInt? + #endif + + /// Path to the lock file. + private let lockFile: AbsolutePath + + /// Create an instance of FileLock at the path specified + /// + /// Note: The parent directory path should be a valid directory. + internal init(at lockFile: AbsolutePath) { + self.lockFile = lockFile + } + + @available(*, deprecated, message: "use init(at:) instead") + public convenience init(name: String, cachePath: AbsolutePath) { + self.init(at: cachePath.appending(component: name + ".lock")) + } + + /// Try to acquire a lock. This method will block until lock the already aquired by other process. + /// + /// Note: This method can throw if underlying POSIX methods fail. + public func lock(type: LockType = .exclusive, blocking: Bool = true) throws { + #if os(Windows) + if handle == nil { + let h: HANDLE = lockFile.pathString.withCString(encodedAs: UTF16.self, { + CreateFileW( + $0, + UInt32(GENERIC_READ) | UInt32(GENERIC_WRITE), + UInt32(FILE_SHARE_READ) | UInt32(FILE_SHARE_WRITE), + nil, + DWORD(OPEN_ALWAYS), + DWORD(FILE_ATTRIBUTE_NORMAL), + nil + ) + }) + if h == INVALID_HANDLE_VALUE { + throw FileSystemError(errno: Int32(GetLastError()), lockFile) + } + self.handle = h + } + var overlapped = OVERLAPPED() + overlapped.Offset = 0 + overlapped.OffsetHigh = 0 + overlapped.hEvent = nil + var dwFlags = Int32(0) + switch type { + case .exclusive: dwFlags |= LOCKFILE_EXCLUSIVE_LOCK + case .shared: break + } + if !blocking { + dwFlags |= LOCKFILE_FAIL_IMMEDIATELY + } + if !LockFileEx(handle, DWORD(dwFlags), 0, + UInt32.max, UInt32.max, &overlapped) { + throw ProcessLockError.unableToAquireLock(errno: Int32(GetLastError())) + } + #else + // Open the lock file. + if fileDescriptor == nil { + let fd = open(lockFile.pathString, O_WRONLY | O_CREAT | O_CLOEXEC, 0o666) + if fd == -1 { + throw FileSystemError(errno: errno, lockFile) + } + self.fileDescriptor = fd + } + var flags = Int32(0) + switch type { + case .exclusive: flags = LOCK_EX + case .shared: flags = LOCK_SH + } + if !blocking { + flags |= LOCK_NB + } + // Aquire lock on the file. + while true { + if flock(fileDescriptor!, flags) == 0 { + break + } + // Retry if interrupted. + if errno == EINTR { continue } + throw ProcessLockError.unableToAquireLock(errno: errno) + } + #endif + } + + /// Unlock the held lock. + public func unlock() { + #if os(Windows) + var overlapped = OVERLAPPED() + overlapped.Offset = 0 + overlapped.OffsetHigh = 0 + overlapped.hEvent = nil + UnlockFileEx(handle, 0, UInt32.max, UInt32.max, &overlapped) + #else + guard let fd = fileDescriptor else { return } + flock(fd, LOCK_UN) + #endif + } + + deinit { + #if os(Windows) + guard let handle = handle else { return } + CloseHandle(handle) + #else + guard let fd = fileDescriptor else { return } + close(fd) + #endif + } + + /// Execute the given block while holding the lock. + public func withLock(type: LockType = .exclusive, blocking: Bool = true, _ body: () throws -> T) throws -> T { + try lock(type: type, blocking: blocking) + defer { unlock() } + return try body() + } + + /// Execute the given block while holding the lock. + public func withLock(type: LockType = .exclusive, blocking: Bool = true, _ body: () async throws -> T) async throws -> T { + try lock(type: type, blocking: blocking) + defer { unlock() } + return try await body() + } + + public static func prepareLock( + fileToLock: AbsolutePath, + at lockFilesDirectory: AbsolutePath? = nil + ) throws -> FileLock { + // unless specified, we use the tempDirectory to store lock files + let lockFilesDirectory = try lockFilesDirectory ?? localFileSystem.tempDirectory + if !localFileSystem.exists(lockFilesDirectory) { + throw FileSystemError(.noEntry, lockFilesDirectory) + } + if !localFileSystem.isDirectory(lockFilesDirectory) { + throw FileSystemError(.notDirectory, lockFilesDirectory) + } + // use the parent path to generate unique filename in temp + var lockFileName = try (resolveSymlinks(fileToLock.parentDirectory) + .appending(component: fileToLock.basename)) + .components.joined(separator: "_") + .replacingOccurrences(of: ":", with: "_") + ".lock" +#if os(Windows) + // NTFS has an ARC limit of 255 codepoints + var lockFileUTF16 = lockFileName.utf16.suffix(255) + while String(lockFileUTF16) == nil { + lockFileUTF16 = lockFileUTF16.dropFirst() + } + lockFileName = String(lockFileUTF16) ?? lockFileName +#else + if lockFileName.hasPrefix(AbsolutePath.root.pathString) { + lockFileName = String(lockFileName.dropFirst(AbsolutePath.root.pathString.count)) + } + // back off until it occupies at most `NAME_MAX` UTF-8 bytes but without splitting scalars + // (we might split clusters but it's not worth the effort to keep them together as long as we get a valid file name) + var lockFileUTF8 = lockFileName.utf8.suffix(Int(NAME_MAX)) + while String(lockFileUTF8) == nil { + // in practice this will only be a few iterations + lockFileUTF8 = lockFileUTF8.dropFirst() + } + // we will never end up with nil since we have ASCII characters at the end + lockFileName = String(lockFileUTF8) ?? lockFileName +#endif + let lockFilePath = lockFilesDirectory.appending(component: lockFileName) + + return FileLock(at: lockFilePath) + } + + public static func withLock( + fileToLock: AbsolutePath, + lockFilesDirectory: AbsolutePath? = nil, + type: LockType = .exclusive, + blocking: Bool = true, + body: () throws -> T + ) throws -> T { + let lock = try Self.prepareLock(fileToLock: fileToLock, at: lockFilesDirectory) + return try lock.withLock(type: type, blocking: blocking, body) + } + + public static func withLock( + fileToLock: AbsolutePath, + lockFilesDirectory: AbsolutePath? = nil, + type: LockType = .exclusive, + blocking: Bool = true, + body: () async throws -> T + ) async throws -> T { + let lock = try Self.prepareLock(fileToLock: fileToLock, at: lockFilesDirectory) + return try await lock.withLock(type: type, blocking: blocking, body) + } +} diff --git a/Sources/CartonHelpers/Basics/Process/Process.swift b/Sources/CartonHelpers/Basics/Process/Process.swift index a7f23545..9105ae05 100644 --- a/Sources/CartonHelpers/Basics/Process/Process.swift +++ b/Sources/CartonHelpers/Basics/Process/Process.swift @@ -369,59 +369,6 @@ public final class Process { private static var validatedExecutablesMap = [String: AbsolutePath?]() private static let validatedExecutablesMapLock = NSLock() - /// Create a new process instance. - /// - /// - Parameters: - /// - arguments: The arguments for the subprocess. - /// - environment: The environment to pass to subprocess. By default the current process environment - /// will be inherited. - /// - workingDirectory: The path to the directory under which to run the process. - /// - outputRedirection: How process redirects its output. Default value is .collect. - /// - startNewProcessGroup: If true, a new progress group is created for the child making it - /// continue running even if the parent is killed or interrupted. Default value is true. - /// - loggingHandler: Handler for logging messages - /// - public init( - arguments: [String], - environmentBlock: ProcessEnvironmentBlock = ProcessEnv.block, - workingDirectory: AbsolutePath, - outputRedirection: OutputRedirection = .collect, - startNewProcessGroup: Bool = true, - loggingHandler: LoggingHandler? = .none - ) { - self.arguments = arguments - self.environmentBlock = environmentBlock - self.workingDirectory = workingDirectory - self.outputRedirection = outputRedirection - self.startNewProcessGroup = startNewProcessGroup - self.loggingHandler = loggingHandler - } - - @_disfavoredOverload - @available(macOS 10.15, *) - @available( - *, deprecated, - renamed: - "init(arguments:environmentBlock:workingDirectory:outputRedirection:startNewProcessGroup:loggingHandler:)" - ) - public convenience init( - arguments: [String], - environment: [String: String] = ProcessEnv.vars, - workingDirectory: AbsolutePath, - outputRedirection: OutputRedirection = .collect, - startNewProcessGroup: Bool = true, - loggingHandler: LoggingHandler? = .none - ) { - self.init( - arguments: arguments, - environmentBlock: .init(environment), - workingDirectory: workingDirectory, - outputRedirection: outputRedirection, - startNewProcessGroup: startNewProcessGroup, - loggingHandler: loggingHandler - ) - } - /// Create a new process instance. /// /// - Parameters: @@ -707,25 +654,6 @@ public final class Process { posix_spawn_file_actions_init(&fileActions) defer { posix_spawn_file_actions_destroy(&fileActions) } - if let workingDirectory = workingDirectory?.pathString { - #if canImport(Darwin) - // The only way to set a workingDirectory is using an availability-gated initializer, so we don't need - // to handle the case where the posix_spawn_file_actions_addchdir_np method is unavailable. This check only - // exists here to make the compiler happy. - if #available(macOS 10.15, *) { - posix_spawn_file_actions_addchdir_np(&fileActions, workingDirectory) - } - #elseif os(Linux) - guard SPM_posix_spawn_file_actions_addchdir_np_supported() else { - throw Process.Error.workingDirectoryNotSupported - } - - SPM_posix_spawn_file_actions_addchdir_np(&fileActions, workingDirectory) - #else - throw Process.Error.workingDirectoryNotSupported - #endif - } - var stdinPipe: [Int32] = [-1, -1] try open(pipe: &stdinPipe) diff --git a/Sources/CartonHelpers/Basics/WritableByteStream.swift b/Sources/CartonHelpers/Basics/WritableByteStream.swift index f6d07d9a..11d0b5e5 100644 --- a/Sources/CartonHelpers/Basics/WritableByteStream.swift +++ b/Sources/CartonHelpers/Basics/WritableByteStream.swift @@ -9,6 +9,7 @@ */ import Dispatch +import Foundation /// Convert an integer in 0..<16 to its hexadecimal ASCII character. private func hexdigit(_ value: UInt8) -> UInt8 { diff --git a/Sources/CartonHelpers/URLSession.swift b/Sources/CartonHelpers/URLSession.swift new file mode 100644 index 00000000..7bc3731e --- /dev/null +++ b/Sources/CartonHelpers/URLSession.swift @@ -0,0 +1,34 @@ +// Copyright 2024 Carton contributors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +import Foundation +#if canImport(FoundationNetworking) +import FoundationNetworking + +/// Until we get "async" implementations of URLSession in corelibs-foundation, we use our own polyfill. +extension URLSession { + public func data(for request: URLRequest) async throws -> (Data, URLResponse) { + return try await withCheckedThrowingContinuation { continuation in + let task = self.dataTask(with: request) { (data, response, error) in + guard let data = data, let response = response else { + let error = error ?? URLError(.badServerResponse) + return continuation.resume(throwing: error) + } + continuation.resume(returning: (data, response)) + } + task.resume() + } + } +} +#endif diff --git a/Sources/CartonKit/Utilities/FSWatch.swift b/Sources/CartonKit/Utilities/FSWatch.swift index cf142448..1cfbf389 100644 --- a/Sources/CartonKit/Utilities/FSWatch.swift +++ b/Sources/CartonKit/Utilities/FSWatch.swift @@ -151,7 +151,7 @@ private protocol _FileWatcher { var overlapped: OVERLAPPED var terminate: HANDLE var buffer: UnsafeMutableBufferPointer // buffer must be DWORD-aligned - var thread: TSCBasic.Thread? + var thread: Thread? public init(directory handle: HANDLE, _ path: String) { self.hDirectory = handle @@ -586,7 +586,7 @@ private protocol _FileWatcher { /// Spawns a thread that collects events and reports them after the settle period. private func startReportThread() { - let thread = TSCBasic.Thread { + let thread = Thread { var endLoop = false while !endLoop { diff --git a/Sources/SwiftToolchain/ToolchainManagement.swift b/Sources/SwiftToolchain/ToolchainManagement.swift index e128d40c..27771fe6 100644 --- a/Sources/SwiftToolchain/ToolchainManagement.swift +++ b/Sources/SwiftToolchain/ToolchainManagement.swift @@ -14,6 +14,9 @@ import CartonHelpers import Foundation +#if canImport(FoundationNetworking) +import FoundationNetworking +#endif internal func processStringOutput(_ arguments: [String]) throws -> String? { let process = Process() diff --git a/Sources/WebDriverClient/WebDriverClient.swift b/Sources/WebDriverClient/WebDriverClient.swift index f5157fad..677d5917 100644 --- a/Sources/WebDriverClient/WebDriverClient.swift +++ b/Sources/WebDriverClient/WebDriverClient.swift @@ -13,6 +13,25 @@ // limitations under the License. import Foundation +#if canImport(FoundationNetworking) +import FoundationNetworking + +/// Until we get "async" implementations of URLSession in corelibs-foundation, we use our own polyfill. +extension URLSession { + public func data(for request: URLRequest) async throws -> (Data, URLResponse) { + return try await withCheckedThrowingContinuation { continuation in + let task = self.dataTask(with: request) { (data, response, error) in + guard let data = data, let response = response else { + let error = error ?? URLError(.badServerResponse) + return continuation.resume(throwing: error) + } + continuation.resume(returning: (data, response)) + } + task.resume() + } + } +} +#endif public enum WebDriverError: Error { case newSessionFailed diff --git a/Sources/carton/main.swift b/Sources/carton/main.swift index 23e0de5d..a1519405 100644 --- a/Sources/carton/main.swift +++ b/Sources/carton/main.swift @@ -131,7 +131,7 @@ func makeTemporaryFile(prefix: String, suffix: String, in directory: URL) -> URL defer { copy.deallocate() } template.copyBytes(to: copy) copy[template.count] = 0 - guard mkstemp(copy.baseAddress) != -1 else { + guard mkstemp(copy.baseAddress!) != -1 else { fatalError("Failed to create a temporary directory") } return String(cString: copy.baseAddress!) From 7c652376c41907f36c721cfcf7a93333e535b8b0 Mon Sep 17 00:00:00 2001 From: Yuta Saito Date: Sun, 25 Feb 2024 17:04:01 +0900 Subject: [PATCH 03/13] Remove unmaintained SwiftLint GitHub Action --- .github/workflows/swiftlint.yml | 18 ------------------ 1 file changed, 18 deletions(-) delete mode 100644 .github/workflows/swiftlint.yml diff --git a/.github/workflows/swiftlint.yml b/.github/workflows/swiftlint.yml deleted file mode 100644 index 56c784a4..00000000 --- a/.github/workflows/swiftlint.yml +++ /dev/null @@ -1,18 +0,0 @@ -name: SwiftLint - -on: - pull_request: - paths: - - ".github/workflows/swiftlint.yml" - - ".swiftlint.yml" - - "**/*.swift" - -jobs: - SwiftLint: - runs-on: ubuntu-20.04 - steps: - - uses: actions/checkout@v1 - - name: GitHub Action for SwiftLint with --strict - uses: norio-nomura/action-swiftlint@3.1.0 - env: - DIFF_BASE: ${{ github.base_ref }} From b5d349dcd77d6b433f8db991c509a6a5a9b342b6 Mon Sep 17 00:00:00 2001 From: Yuta Saito Date: Sun, 25 Feb 2024 17:25:44 +0900 Subject: [PATCH 04/13] Allow non-wasmer runtime for testing --- Sources/CartonCLI/Commands/Test.swift | 2 +- ...erTestRunner.swift => CommandTestRunner.swift} | 15 ++++++++------- 2 files changed, 9 insertions(+), 8 deletions(-) rename Sources/CartonCLI/Commands/TestRunners/{WasmerTestRunner.swift => CommandTestRunner.swift} (65%) diff --git a/Sources/CartonCLI/Commands/Test.swift b/Sources/CartonCLI/Commands/Test.swift index 893178ab..fa8a77d2 100644 --- a/Sources/CartonCLI/Commands/Test.swift +++ b/Sources/CartonCLI/Commands/Test.swift @@ -108,7 +108,7 @@ struct Test: AsyncParsableCommand { switch environment { case .command: - try await WasmerTestRunner( + try await CommandTestRunner( testFilePath: bundlePath, listTestCases: list, testCases: testCases, diff --git a/Sources/CartonCLI/Commands/TestRunners/WasmerTestRunner.swift b/Sources/CartonCLI/Commands/TestRunners/CommandTestRunner.swift similarity index 65% rename from Sources/CartonCLI/Commands/TestRunners/WasmerTestRunner.swift rename to Sources/CartonCLI/Commands/TestRunners/CommandTestRunner.swift index 24ee157f..0f2d6e6f 100644 --- a/Sources/CartonCLI/Commands/TestRunners/WasmerTestRunner.swift +++ b/Sources/CartonCLI/Commands/TestRunners/CommandTestRunner.swift @@ -16,22 +16,23 @@ import CartonHelpers import CartonKit import Foundation -struct WasmerTestRunner: TestRunner { +struct CommandTestRunner: TestRunner { let testFilePath: AbsolutePath let listTestCases: Bool let testCases: [String] let terminal: InteractiveWriter func run() async throws { - terminal.write("\nRunning the test bundle with wasmer:\n", inColor: .yellow) - var wasmerArguments = ["wasmer", testFilePath.pathString] + let program = ProcessInfo.processInfo.environment["CARTON_TEST_RUNNER"] ?? "wasmer" + terminal.write("\nRunning the test bundle with \"\(program)\":\n", inColor: .yellow) + var arguments = [program, testFilePath.pathString] if listTestCases { - wasmerArguments.append(contentsOf: ["--", "-l"]) + arguments.append(contentsOf: ["--", "-l"]) } else if !testCases.isEmpty { - wasmerArguments.append("--") - wasmerArguments.append(contentsOf: testCases) + arguments.append("--") + arguments.append(contentsOf: testCases) } - try await Process.run(wasmerArguments, parser: TestsParser(), terminal) + try await Process.run(arguments, parser: TestsParser(), terminal) } } From 119d286b75fb9b47566f6b9bfb702ff213d139c3 Mon Sep 17 00:00:00 2001 From: Yuta Saito Date: Sun, 25 Feb 2024 17:26:08 +0900 Subject: [PATCH 05/13] Use Foundation.Process instead of Process.run in hash-archive --- Sources/carton-release/HashArchive.swift | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/Sources/carton-release/HashArchive.swift b/Sources/carton-release/HashArchive.swift index 1eaf3aa6..c14144a6 100644 --- a/Sources/carton-release/HashArchive.swift +++ b/Sources/carton-release/HashArchive.swift @@ -15,6 +15,7 @@ import ArgumentParser import CartonHelpers import WasmTransformer +import Foundation struct HashArchive: AsyncParsableCommand { /** Converts a hexadecimal hash string to Swift code that represents an archive of static assets. @@ -48,7 +49,7 @@ struct HashArchive: AsyncParsableCommand { for entrypoint in ["dev", "bundle", "test", "testNode"] { let filename = "\(entrypoint).js" var arguments = [ - "npx", "esbuild", "--bundle", "entrypoint/\(filename)", "--outfile=static/\(filename)", + "esbuild", "--bundle", "entrypoint/\(filename)", "--outfile=static/\(filename)", ] if entrypoint == "testNode" { @@ -63,7 +64,10 @@ struct HashArchive: AsyncParsableCommand { ]) } - try await Process.run(arguments, terminal) + guard let npx = Process.findExecutable("npx") else { + fatalError("\"npx\" command not found in PATH") + } + try Foundation.Process.run(npx.asURL, arguments: arguments).waitUntilExit() let entrypointPath = try AbsolutePath(validating: filename, relativeTo: staticPath) let dotFilesEntrypointPath = dotFilesStaticPath.appending(component: filename) try localFileSystem.removeFileTree(dotFilesEntrypointPath) From e757c4038c2801afa9b0778013dbc1b62310823b Mon Sep 17 00:00:00 2001 From: Yuta Saito Date: Sun, 25 Feb 2024 17:27:15 +0900 Subject: [PATCH 06/13] swift-format --- .../TestRunners/BrowserTestRunner.swift | 3 +- Sources/CartonHelpers/AsyncFileDownload.swift | 3 +- Sources/CartonHelpers/Basics/Condition.swift | 78 ++-- Sources/CartonHelpers/Basics/FileInfo.swift | 4 +- Sources/CartonHelpers/Basics/FileSystem.swift | 2 +- Sources/CartonHelpers/Basics/Lock.swift | 414 +++++++++--------- Sources/CartonHelpers/URLSession.swift | 25 +- .../SwiftToolchain/ToolchainManagement.swift | 3 +- Sources/WebDriverClient/WebDriverClient.swift | 25 +- Sources/carton-release/HashArchive.swift | 2 +- 10 files changed, 288 insertions(+), 271 deletions(-) diff --git a/Sources/CartonCLI/Commands/TestRunners/BrowserTestRunner.swift b/Sources/CartonCLI/Commands/TestRunners/BrowserTestRunner.swift index de30540e..365f9d2e 100644 --- a/Sources/CartonCLI/Commands/TestRunners/BrowserTestRunner.swift +++ b/Sources/CartonCLI/Commands/TestRunners/BrowserTestRunner.swift @@ -18,8 +18,9 @@ import Foundation import NIOCore import NIOPosix import WebDriverClient + #if canImport(FoundationNetworking) -import FoundationNetworking + import FoundationNetworking #endif private enum Constants { diff --git a/Sources/CartonHelpers/AsyncFileDownload.swift b/Sources/CartonHelpers/AsyncFileDownload.swift index 0185e3d9..26cb292b 100644 --- a/Sources/CartonHelpers/AsyncFileDownload.swift +++ b/Sources/CartonHelpers/AsyncFileDownload.swift @@ -13,8 +13,9 @@ // limitations under the License. import Foundation + #if canImport(FoundationNetworking) -import FoundationNetworking + import FoundationNetworking #endif public struct InvalidResponseCode: Error { diff --git a/Sources/CartonHelpers/Basics/Condition.swift b/Sources/CartonHelpers/Basics/Condition.swift index 566c1a02..f66897c1 100644 --- a/Sources/CartonHelpers/Basics/Condition.swift +++ b/Sources/CartonHelpers/Basics/Condition.swift @@ -8,52 +8,52 @@ See http://swift.org/CONTRIBUTORS.txt for Swift project authors */ #if !_runtime(_ObjC) -@preconcurrency import Foundation + @preconcurrency import Foundation #else -import Foundation + import Foundation #endif /// Simple wrapper around NSCondition. /// - SeeAlso: NSCondition public struct Condition { - private let _condition = NSCondition() - - /// Create a new condition. - public init() {} - - /// Wait for the condition to become available. - public func wait() { - _condition.wait() - } - - /// Blocks the current thread until the condition is signaled or the specified time limit is reached. - /// - /// - Returns: true if the condition was signaled; otherwise, false if the time limit was reached. - public func wait(until limit: Date) -> Bool { - return _condition.wait(until: limit) - } - - /// Signal the availability of the condition (awake one thread waiting on - /// the condition). - public func signal() { - _condition.signal() - } - - /// Broadcast the availability of the condition (awake all threads waiting - /// on the condition). - public func broadcast() { - _condition.broadcast() - } - - /// A helper method to execute the given body while condition is locked. - /// - Note: Will ensure condition unlocks even if `body` throws. - public func whileLocked(_ body: () throws -> T) rethrows -> T { - _condition.lock() - defer { _condition.unlock() } - return try body() - } + private let _condition = NSCondition() + + /// Create a new condition. + public init() {} + + /// Wait for the condition to become available. + public func wait() { + _condition.wait() + } + + /// Blocks the current thread until the condition is signaled or the specified time limit is reached. + /// + /// - Returns: true if the condition was signaled; otherwise, false if the time limit was reached. + public func wait(until limit: Date) -> Bool { + return _condition.wait(until: limit) + } + + /// Signal the availability of the condition (awake one thread waiting on + /// the condition). + public func signal() { + _condition.signal() + } + + /// Broadcast the availability of the condition (awake all threads waiting + /// on the condition). + public func broadcast() { + _condition.broadcast() + } + + /// A helper method to execute the given body while condition is locked. + /// - Note: Will ensure condition unlocks even if `body` throws. + public func whileLocked(_ body: () throws -> T) rethrows -> T { + _condition.lock() + defer { _condition.unlock() } + return try body() + } } #if compiler(>=5.7) -extension Condition: Sendable {} + extension Condition: Sendable {} #endif diff --git a/Sources/CartonHelpers/Basics/FileInfo.swift b/Sources/CartonHelpers/Basics/FileInfo.swift index 90499b35..547cba43 100644 --- a/Sources/CartonHelpers/Basics/FileInfo.swift +++ b/Sources/CartonHelpers/Basics/FileInfo.swift @@ -9,9 +9,9 @@ */ #if !_runtime(_ObjC) -@preconcurrency import Foundation + @preconcurrency import Foundation #else -import Foundation + import Foundation #endif #if swift(<5.6) diff --git a/Sources/CartonHelpers/Basics/FileSystem.swift b/Sources/CartonHelpers/Basics/FileSystem.swift index f693e22f..f09bb490 100644 --- a/Sources/CartonHelpers/Basics/FileSystem.swift +++ b/Sources/CartonHelpers/Basics/FileSystem.swift @@ -338,7 +338,7 @@ extension FileSystem { public func hasAttribute(_ name: FileSystemAttribute, _ path: AbsolutePath) -> Bool { #if canImport(Darwin) - false + false #endif } diff --git a/Sources/CartonHelpers/Basics/Lock.swift b/Sources/CartonHelpers/Basics/Lock.swift index 64216123..3d58d570 100644 --- a/Sources/CartonHelpers/Basics/Lock.swift +++ b/Sources/CartonHelpers/Basics/Lock.swift @@ -10,248 +10,260 @@ import Foundation -@available(*, deprecated, message: "Use NSLock directly instead. SPM has a withLock extension function" ) +@available( + *, deprecated, message: "Use NSLock directly instead. SPM has a withLock extension function" +) /// A simple lock wrapper. public struct Lock { - private let _lock = NSLock() + private let _lock = NSLock() - /// Create a new lock. - public init() { - } + /// Create a new lock. + public init() { + } - func lock() { - _lock.lock() - } + func lock() { + _lock.lock() + } - func unlock() { - _lock.unlock() - } + func unlock() { + _lock.unlock() + } - /// Execute the given block while holding the lock. - public func withLock (_ body: () throws -> T) rethrows -> T { - lock() - defer { unlock() } - return try body() - } + /// Execute the given block while holding the lock. + public func withLock(_ body: () throws -> T) rethrows -> T { + lock() + defer { unlock() } + return try body() + } } // for internal usage extension NSLock { - internal func withLock (_ body: () throws -> T) rethrows -> T { - self.lock() - defer { self.unlock() } - return try body() - } + internal func withLock(_ body: () throws -> T) rethrows -> T { + self.lock() + defer { self.unlock() } + return try body() + } } public enum ProcessLockError: Error { - case unableToAquireLock(errno: Int32) + case unableToAquireLock(errno: Int32) } extension ProcessLockError: CustomNSError { - public var errorUserInfo: [String : Any] { - return [NSLocalizedDescriptionKey: "\(self)"] - } + public var errorUserInfo: [String: Any] { + return [NSLocalizedDescriptionKey: "\(self)"] + } } /// Provides functionality to acquire a lock on a file via POSIX's flock() method. /// It can be used for things like serializing concurrent mutations on a shared resource /// by multiple instances of a process. The `FileLock` is not thread-safe. public final class FileLock { - public enum LockType { - case exclusive - case shared - } + public enum LockType { + case exclusive + case shared + } - /// File descriptor to the lock file. + /// File descriptor to the lock file. #if os(Windows) private var handle: HANDLE? #else private var fileDescriptor: CInt? #endif - /// Path to the lock file. - private let lockFile: AbsolutePath + /// Path to the lock file. + private let lockFile: AbsolutePath - /// Create an instance of FileLock at the path specified - /// - /// Note: The parent directory path should be a valid directory. - internal init(at lockFile: AbsolutePath) { - self.lockFile = lockFile - } + /// Create an instance of FileLock at the path specified + /// + /// Note: The parent directory path should be a valid directory. + internal init(at lockFile: AbsolutePath) { + self.lockFile = lockFile + } - @available(*, deprecated, message: "use init(at:) instead") - public convenience init(name: String, cachePath: AbsolutePath) { - self.init(at: cachePath.appending(component: name + ".lock")) - } + @available(*, deprecated, message: "use init(at:) instead") + public convenience init(name: String, cachePath: AbsolutePath) { + self.init(at: cachePath.appending(component: name + ".lock")) + } - /// Try to acquire a lock. This method will block until lock the already aquired by other process. - /// - /// Note: This method can throw if underlying POSIX methods fail. - public func lock(type: LockType = .exclusive, blocking: Bool = true) throws { - #if os(Windows) - if handle == nil { - let h: HANDLE = lockFile.pathString.withCString(encodedAs: UTF16.self, { - CreateFileW( - $0, - UInt32(GENERIC_READ) | UInt32(GENERIC_WRITE), - UInt32(FILE_SHARE_READ) | UInt32(FILE_SHARE_WRITE), - nil, - DWORD(OPEN_ALWAYS), - DWORD(FILE_ATTRIBUTE_NORMAL), - nil - ) - }) - if h == INVALID_HANDLE_VALUE { - throw FileSystemError(errno: Int32(GetLastError()), lockFile) - } - self.handle = h - } - var overlapped = OVERLAPPED() - overlapped.Offset = 0 - overlapped.OffsetHigh = 0 - overlapped.hEvent = nil - var dwFlags = Int32(0) - switch type { - case .exclusive: dwFlags |= LOCKFILE_EXCLUSIVE_LOCK - case .shared: break - } - if !blocking { - dwFlags |= LOCKFILE_FAIL_IMMEDIATELY - } - if !LockFileEx(handle, DWORD(dwFlags), 0, - UInt32.max, UInt32.max, &overlapped) { - throw ProcessLockError.unableToAquireLock(errno: Int32(GetLastError())) + /// Try to acquire a lock. This method will block until lock the already aquired by other process. + /// + /// Note: This method can throw if underlying POSIX methods fail. + public func lock(type: LockType = .exclusive, blocking: Bool = true) throws { + #if os(Windows) + if handle == nil { + let h: HANDLE = lockFile.pathString.withCString( + encodedAs: UTF16.self, + { + CreateFileW( + $0, + UInt32(GENERIC_READ) | UInt32(GENERIC_WRITE), + UInt32(FILE_SHARE_READ) | UInt32(FILE_SHARE_WRITE), + nil, + DWORD(OPEN_ALWAYS), + DWORD(FILE_ATTRIBUTE_NORMAL), + nil + ) + }) + if h == INVALID_HANDLE_VALUE { + throw FileSystemError(errno: Int32(GetLastError()), lockFile) } - #else - // Open the lock file. - if fileDescriptor == nil { - let fd = open(lockFile.pathString, O_WRONLY | O_CREAT | O_CLOEXEC, 0o666) - if fd == -1 { - throw FileSystemError(errno: errno, lockFile) - } - self.fileDescriptor = fd + self.handle = h + } + var overlapped = OVERLAPPED() + overlapped.Offset = 0 + overlapped.OffsetHigh = 0 + overlapped.hEvent = nil + var dwFlags = Int32(0) + switch type { + case .exclusive: dwFlags |= LOCKFILE_EXCLUSIVE_LOCK + case .shared: break + } + if !blocking { + dwFlags |= LOCKFILE_FAIL_IMMEDIATELY + } + if !LockFileEx( + handle, DWORD(dwFlags), 0, + UInt32.max, UInt32.max, &overlapped) + { + throw ProcessLockError.unableToAquireLock(errno: Int32(GetLastError())) + } + #else + // Open the lock file. + if fileDescriptor == nil { + let fd = open(lockFile.pathString, O_WRONLY | O_CREAT | O_CLOEXEC, 0o666) + if fd == -1 { + throw FileSystemError(errno: errno, lockFile) } - var flags = Int32(0) - switch type { - case .exclusive: flags = LOCK_EX - case .shared: flags = LOCK_SH + self.fileDescriptor = fd + } + var flags = Int32(0) + switch type { + case .exclusive: flags = LOCK_EX + case .shared: flags = LOCK_SH + } + if !blocking { + flags |= LOCK_NB + } + // Aquire lock on the file. + while true { + if flock(fileDescriptor!, flags) == 0 { + break } - if !blocking { - flags |= LOCK_NB - } - // Aquire lock on the file. - while true { - if flock(fileDescriptor!, flags) == 0 { - break - } - // Retry if interrupted. - if errno == EINTR { continue } - throw ProcessLockError.unableToAquireLock(errno: errno) - } - #endif - } + // Retry if interrupted. + if errno == EINTR { continue } + throw ProcessLockError.unableToAquireLock(errno: errno) + } + #endif + } - /// Unlock the held lock. - public func unlock() { - #if os(Windows) - var overlapped = OVERLAPPED() - overlapped.Offset = 0 - overlapped.OffsetHigh = 0 - overlapped.hEvent = nil - UnlockFileEx(handle, 0, UInt32.max, UInt32.max, &overlapped) - #else - guard let fd = fileDescriptor else { return } - flock(fd, LOCK_UN) - #endif - } + /// Unlock the held lock. + public func unlock() { + #if os(Windows) + var overlapped = OVERLAPPED() + overlapped.Offset = 0 + overlapped.OffsetHigh = 0 + overlapped.hEvent = nil + UnlockFileEx(handle, 0, UInt32.max, UInt32.max, &overlapped) + #else + guard let fd = fileDescriptor else { return } + flock(fd, LOCK_UN) + #endif + } - deinit { - #if os(Windows) - guard let handle = handle else { return } - CloseHandle(handle) - #else - guard let fd = fileDescriptor else { return } - close(fd) - #endif - } + deinit { + #if os(Windows) + guard let handle = handle else { return } + CloseHandle(handle) + #else + guard let fd = fileDescriptor else { return } + close(fd) + #endif + } - /// Execute the given block while holding the lock. - public func withLock(type: LockType = .exclusive, blocking: Bool = true, _ body: () throws -> T) throws -> T { - try lock(type: type, blocking: blocking) - defer { unlock() } - return try body() - } + /// Execute the given block while holding the lock. + public func withLock( + type: LockType = .exclusive, blocking: Bool = true, _ body: () throws -> T + ) throws -> T { + try lock(type: type, blocking: blocking) + defer { unlock() } + return try body() + } - /// Execute the given block while holding the lock. - public func withLock(type: LockType = .exclusive, blocking: Bool = true, _ body: () async throws -> T) async throws -> T { - try lock(type: type, blocking: blocking) - defer { unlock() } - return try await body() - } - - public static func prepareLock( - fileToLock: AbsolutePath, - at lockFilesDirectory: AbsolutePath? = nil - ) throws -> FileLock { - // unless specified, we use the tempDirectory to store lock files - let lockFilesDirectory = try lockFilesDirectory ?? localFileSystem.tempDirectory - if !localFileSystem.exists(lockFilesDirectory) { - throw FileSystemError(.noEntry, lockFilesDirectory) - } - if !localFileSystem.isDirectory(lockFilesDirectory) { - throw FileSystemError(.notDirectory, lockFilesDirectory) - } - // use the parent path to generate unique filename in temp - var lockFileName = try (resolveSymlinks(fileToLock.parentDirectory) - .appending(component: fileToLock.basename)) - .components.joined(separator: "_") - .replacingOccurrences(of: ":", with: "_") + ".lock" -#if os(Windows) - // NTFS has an ARC limit of 255 codepoints - var lockFileUTF16 = lockFileName.utf16.suffix(255) - while String(lockFileUTF16) == nil { - lockFileUTF16 = lockFileUTF16.dropFirst() - } - lockFileName = String(lockFileUTF16) ?? lockFileName -#else - if lockFileName.hasPrefix(AbsolutePath.root.pathString) { - lockFileName = String(lockFileName.dropFirst(AbsolutePath.root.pathString.count)) - } - // back off until it occupies at most `NAME_MAX` UTF-8 bytes but without splitting scalars - // (we might split clusters but it's not worth the effort to keep them together as long as we get a valid file name) - var lockFileUTF8 = lockFileName.utf8.suffix(Int(NAME_MAX)) - while String(lockFileUTF8) == nil { - // in practice this will only be a few iterations - lockFileUTF8 = lockFileUTF8.dropFirst() - } - // we will never end up with nil since we have ASCII characters at the end - lockFileName = String(lockFileUTF8) ?? lockFileName -#endif - let lockFilePath = lockFilesDirectory.appending(component: lockFileName) + /// Execute the given block while holding the lock. + public func withLock( + type: LockType = .exclusive, blocking: Bool = true, _ body: () async throws -> T + ) async throws -> T { + try lock(type: type, blocking: blocking) + defer { unlock() } + return try await body() + } - return FileLock(at: lockFilePath) + public static func prepareLock( + fileToLock: AbsolutePath, + at lockFilesDirectory: AbsolutePath? = nil + ) throws -> FileLock { + // unless specified, we use the tempDirectory to store lock files + let lockFilesDirectory = try lockFilesDirectory ?? localFileSystem.tempDirectory + if !localFileSystem.exists(lockFilesDirectory) { + throw FileSystemError(.noEntry, lockFilesDirectory) } - - public static func withLock( - fileToLock: AbsolutePath, - lockFilesDirectory: AbsolutePath? = nil, - type: LockType = .exclusive, - blocking: Bool = true, - body: () throws -> T - ) throws -> T { - let lock = try Self.prepareLock(fileToLock: fileToLock, at: lockFilesDirectory) - return try lock.withLock(type: type, blocking: blocking, body) + if !localFileSystem.isDirectory(lockFilesDirectory) { + throw FileSystemError(.notDirectory, lockFilesDirectory) } + // use the parent path to generate unique filename in temp + var lockFileName = + try + (resolveSymlinks(fileToLock.parentDirectory) + .appending(component: fileToLock.basename)) + .components.joined(separator: "_") + .replacingOccurrences(of: ":", with: "_") + ".lock" + #if os(Windows) + // NTFS has an ARC limit of 255 codepoints + var lockFileUTF16 = lockFileName.utf16.suffix(255) + while String(lockFileUTF16) == nil { + lockFileUTF16 = lockFileUTF16.dropFirst() + } + lockFileName = String(lockFileUTF16) ?? lockFileName + #else + if lockFileName.hasPrefix(AbsolutePath.root.pathString) { + lockFileName = String(lockFileName.dropFirst(AbsolutePath.root.pathString.count)) + } + // back off until it occupies at most `NAME_MAX` UTF-8 bytes but without splitting scalars + // (we might split clusters but it's not worth the effort to keep them together as long as we get a valid file name) + var lockFileUTF8 = lockFileName.utf8.suffix(Int(NAME_MAX)) + while String(lockFileUTF8) == nil { + // in practice this will only be a few iterations + lockFileUTF8 = lockFileUTF8.dropFirst() + } + // we will never end up with nil since we have ASCII characters at the end + lockFileName = String(lockFileUTF8) ?? lockFileName + #endif + let lockFilePath = lockFilesDirectory.appending(component: lockFileName) - public static func withLock( - fileToLock: AbsolutePath, - lockFilesDirectory: AbsolutePath? = nil, - type: LockType = .exclusive, - blocking: Bool = true, - body: () async throws -> T - ) async throws -> T { - let lock = try Self.prepareLock(fileToLock: fileToLock, at: lockFilesDirectory) - return try await lock.withLock(type: type, blocking: blocking, body) - } + return FileLock(at: lockFilePath) + } + + public static func withLock( + fileToLock: AbsolutePath, + lockFilesDirectory: AbsolutePath? = nil, + type: LockType = .exclusive, + blocking: Bool = true, + body: () throws -> T + ) throws -> T { + let lock = try Self.prepareLock(fileToLock: fileToLock, at: lockFilesDirectory) + return try lock.withLock(type: type, blocking: blocking, body) + } + + public static func withLock( + fileToLock: AbsolutePath, + lockFilesDirectory: AbsolutePath? = nil, + type: LockType = .exclusive, + blocking: Bool = true, + body: () async throws -> T + ) async throws -> T { + let lock = try Self.prepareLock(fileToLock: fileToLock, at: lockFilesDirectory) + return try await lock.withLock(type: type, blocking: blocking, body) + } } diff --git a/Sources/CartonHelpers/URLSession.swift b/Sources/CartonHelpers/URLSession.swift index 7bc3731e..071ff2fb 100644 --- a/Sources/CartonHelpers/URLSession.swift +++ b/Sources/CartonHelpers/URLSession.swift @@ -13,22 +13,23 @@ // limitations under the License. import Foundation + #if canImport(FoundationNetworking) -import FoundationNetworking + import FoundationNetworking -/// Until we get "async" implementations of URLSession in corelibs-foundation, we use our own polyfill. -extension URLSession { - public func data(for request: URLRequest) async throws -> (Data, URLResponse) { - return try await withCheckedThrowingContinuation { continuation in - let task = self.dataTask(with: request) { (data, response, error) in - guard let data = data, let response = response else { - let error = error ?? URLError(.badServerResponse) - return continuation.resume(throwing: error) + /// Until we get "async" implementations of URLSession in corelibs-foundation, we use our own polyfill. + extension URLSession { + public func data(for request: URLRequest) async throws -> (Data, URLResponse) { + return try await withCheckedThrowingContinuation { continuation in + let task = self.dataTask(with: request) { (data, response, error) in + guard let data = data, let response = response else { + let error = error ?? URLError(.badServerResponse) + return continuation.resume(throwing: error) + } + continuation.resume(returning: (data, response)) } - continuation.resume(returning: (data, response)) + task.resume() } - task.resume() } } -} #endif diff --git a/Sources/SwiftToolchain/ToolchainManagement.swift b/Sources/SwiftToolchain/ToolchainManagement.swift index 27771fe6..e9bf5aa4 100644 --- a/Sources/SwiftToolchain/ToolchainManagement.swift +++ b/Sources/SwiftToolchain/ToolchainManagement.swift @@ -14,8 +14,9 @@ import CartonHelpers import Foundation + #if canImport(FoundationNetworking) -import FoundationNetworking + import FoundationNetworking #endif internal func processStringOutput(_ arguments: [String]) throws -> String? { diff --git a/Sources/WebDriverClient/WebDriverClient.swift b/Sources/WebDriverClient/WebDriverClient.swift index 677d5917..c773eea6 100644 --- a/Sources/WebDriverClient/WebDriverClient.swift +++ b/Sources/WebDriverClient/WebDriverClient.swift @@ -13,24 +13,25 @@ // limitations under the License. import Foundation + #if canImport(FoundationNetworking) -import FoundationNetworking + import FoundationNetworking -/// Until we get "async" implementations of URLSession in corelibs-foundation, we use our own polyfill. -extension URLSession { - public func data(for request: URLRequest) async throws -> (Data, URLResponse) { - return try await withCheckedThrowingContinuation { continuation in - let task = self.dataTask(with: request) { (data, response, error) in - guard let data = data, let response = response else { - let error = error ?? URLError(.badServerResponse) - return continuation.resume(throwing: error) + /// Until we get "async" implementations of URLSession in corelibs-foundation, we use our own polyfill. + extension URLSession { + public func data(for request: URLRequest) async throws -> (Data, URLResponse) { + return try await withCheckedThrowingContinuation { continuation in + let task = self.dataTask(with: request) { (data, response, error) in + guard let data = data, let response = response else { + let error = error ?? URLError(.badServerResponse) + return continuation.resume(throwing: error) + } + continuation.resume(returning: (data, response)) } - continuation.resume(returning: (data, response)) + task.resume() } - task.resume() } } -} #endif public enum WebDriverError: Error { diff --git a/Sources/carton-release/HashArchive.swift b/Sources/carton-release/HashArchive.swift index c14144a6..fe26dca2 100644 --- a/Sources/carton-release/HashArchive.swift +++ b/Sources/carton-release/HashArchive.swift @@ -14,8 +14,8 @@ import ArgumentParser import CartonHelpers -import WasmTransformer import Foundation +import WasmTransformer struct HashArchive: AsyncParsableCommand { /** Converts a hexadecimal hash string to Swift code that represents an archive of static assets. From 8a5efdf5e6ff1c13d1277cab17a5e1e6d01b217a Mon Sep 17 00:00:00 2001 From: Yuta Saito Date: Sun, 25 Feb 2024 17:32:25 +0900 Subject: [PATCH 07/13] Remove unnecessary -validate-tbd-against-ir=none --- .github/workflows/swift.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/swift.yml b/.github/workflows/swift.yml index 5df7a746..17ab8757 100644 --- a/.github/workflows/swift.yml +++ b/.github/workflows/swift.yml @@ -44,7 +44,7 @@ jobs: - name: Build the project run: | swift -v - swift build -Xswiftc -Xfrontend -Xswiftc -validate-tbd-against-ir=none + swift build - name: Build and install JavaScript and sanitizer resources run: | @@ -60,7 +60,7 @@ jobs: if [ -e /home/runner/.wasmer/wasmer.sh ]; then source /home/runner/.wasmer/wasmer.sh fi - swift test -Xswiftc -Xfrontend -Xswiftc -validate-tbd-against-ir=none + swift test env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} From 89166d715bed6caf5cea6f76b02667f37b32b8b1 Mon Sep 17 00:00:00 2001 From: Yuta Saito Date: Sun, 25 Feb 2024 17:53:07 +0900 Subject: [PATCH 08/13] Fix stack trace parsers --- Sources/CartonKit/Parsers/ChromeStackTrace.swift | 14 +++++++------- Sources/CartonKit/Parsers/FirefoxStackTrace.swift | 4 ++-- Sources/CartonKit/Parsers/SafariStackTrace.swift | 12 ++++++------ 3 files changed, 15 insertions(+), 15 deletions(-) diff --git a/Sources/CartonKit/Parsers/ChromeStackTrace.swift b/Sources/CartonKit/Parsers/ChromeStackTrace.swift index f6d03b61..d5f7b7fd 100644 --- a/Sources/CartonKit/Parsers/ChromeStackTrace.swift +++ b/Sources/CartonKit/Parsers/ChromeStackTrace.swift @@ -15,19 +15,19 @@ // Created by Jed Fox on 12/6/20. // -private let webpackRegex = #/"at (.+) \\(webpack:///(.+?)\\)/# -private let wasmRegex = #/at (.+) \\(:(.+?)\\)/# +private let webpackRegex = #/at (.+) \(webpack:///(.+?)\)/# +private let wasmRegex = #/at (.+) \(:(.+?)\)/# extension StringProtocol { var chromeStackTrace: [StackTraceItem] { split(separator: "\n").dropFirst().compactMap { - if let webpackMatch = try? webpackRegex.firstMatch(in: String($0)) { - let symbol = String(webpackMatch.output.0) - let location = String(webpackMatch.output.3) + if let webpackMatch = try? webpackRegex.firstMatch(in: String($0)) { + let symbol = String(webpackMatch.output.1) + let location = String(webpackMatch.output.2) return StackTraceItem(symbol: symbol, location: location, kind: .javaScript) } else if let wasmMatch = try? wasmRegex.firstMatch(in: String($0)) { - let symbol = String(wasmMatch.output.0) - let location = String(wasmMatch.output.3) + let symbol = String(wasmMatch.output.1) + let location = String(wasmMatch.output.2) return StackTraceItem( symbol: demangle(symbol), location: location, diff --git a/Sources/CartonKit/Parsers/FirefoxStackTrace.swift b/Sources/CartonKit/Parsers/FirefoxStackTrace.swift index 9fa5a4c3..84838ab3 100644 --- a/Sources/CartonKit/Parsers/FirefoxStackTrace.swift +++ b/Sources/CartonKit/Parsers/FirefoxStackTrace.swift @@ -22,11 +22,11 @@ extension StringProtocol { var firefoxStackTrace: [StackTraceItem] { split(separator: "\n").compactMap { if let webpackMatch = try? webpackRegex.firstMatch(in: String($0)) { - let symbol = String(webpackMatch.output.0) + let symbol = String(webpackMatch.output.1) let location = String(webpackMatch.output.2) return StackTraceItem(symbol: symbol, location: location, kind: .javaScript) } else if let wasmMatch = try? wasmRegex.firstMatch(in: String($0)) { - let symbol = String(wasmMatch.output.0) + let symbol = String(wasmMatch.output.1) let location = String(wasmMatch.output.2) return StackTraceItem( symbol: demangle(symbol), diff --git a/Sources/CartonKit/Parsers/SafariStackTrace.swift b/Sources/CartonKit/Parsers/SafariStackTrace.swift index b3ab495f..135ec268 100644 --- a/Sources/CartonKit/Parsers/SafariStackTrace.swift +++ b/Sources/CartonKit/Parsers/SafariStackTrace.swift @@ -15,24 +15,24 @@ // Created by Jed Fox on 12/6/20. // -private let jsRegex = #/(.+?)(?:@(?:\\[(?:native|wasm) code\\]|(.+)))?$/# -private let wasmRegex = #/"<\\?>\\.wasm-function\\[(.+)\\]@\\[wasm code\\]/# +private let jsRegex = #/(.+?)(?:@(?:\[(?:native|wasm) code\]|(.+)))?$/# +private let wasmRegex = #/<\?>\.wasm-function\[(.+)\]@\[wasm code\]/# extension StringProtocol { var safariStackTrace: [StackTraceItem] { split(separator: "\n").compactMap { if let wasmMatch = try? wasmRegex.firstMatch(in: String($0)) { - let symbol = String(wasmMatch.output) + let symbol = String(wasmMatch.output.1) return StackTraceItem( symbol: demangle(symbol), location: nil, kind: .webAssembly ) } else if let jsMatch = try? jsRegex.firstMatch(in: String($0)) { - let symbol = String(jsMatch.output.0) + let symbol = String(jsMatch.output.1) let loc: String? - if jsMatch.output.2 == nil && !jsMatch.output.1.isEmpty { - loc = String(jsMatch.1) + if let foundLoc = jsMatch.output.2, !foundLoc.isEmpty { + loc = String(foundLoc) } else { loc = nil } From 2fb74d9771eba5baed32c9136b733a6ec2847cfd Mon Sep 17 00:00:00 2001 From: Yuta Saito Date: Sun, 25 Feb 2024 18:52:15 +0900 Subject: [PATCH 09/13] Skip test product build if prebuilt test bundle is specified --- Plugins/CartonPluginShared/PluginShared.swift | 13 +++++- Plugins/CartonTest/Plugin.swift | 40 +++++++++++-------- Sources/CartonCLI/Commands/Bundle.swift | 6 ++- Sources/carton/main.swift | 14 ++++--- .../BundleCommandTests.swift | 12 ------ .../CommandTestHelper.swift | 2 +- Tests/Fixtures/NodeJSKitTest/Package.resolved | 9 ----- 7 files changed, 49 insertions(+), 47 deletions(-) diff --git a/Plugins/CartonPluginShared/PluginShared.swift b/Plugins/CartonPluginShared/PluginShared.swift index 73d4fb5f..28739534 100644 --- a/Plugins/CartonPluginShared/PluginShared.swift +++ b/Plugins/CartonPluginShared/PluginShared.swift @@ -44,12 +44,23 @@ internal func deriveResourcesPaths( productArtifactPath: Path, sourceTargets: [any PackagePlugin.Target], package: Package +) -> [Path] { + return deriveResourcesPaths( + buildDirectory: productArtifactPath.removingLastComponent(), + sourceTargets: sourceTargets, package: package + ) +} + +internal func deriveResourcesPaths( + buildDirectory: Path, + sourceTargets: [any PackagePlugin.Target], + package: Package ) -> [Path] { sourceTargets.compactMap { target -> Path? in // NOTE: The resource bundle file name is constructed from `displayName` instead of `id` for some reason // https://github.com/apple/swift-package-manager/blob/swift-5.9.2-RELEASE/Sources/PackageLoading/PackageBuilder.swift#L908 let bundleName = package.displayName + "_" + target.name + ".resources" - let resourcesPath = productArtifactPath.removingLastComponent().appending(subpath: bundleName) + let resourcesPath = buildDirectory.appending(subpath: bundleName) guard FileManager.default.fileExists(atPath: resourcesPath.string) else { return nil } return resourcesPath } diff --git a/Plugins/CartonTest/Plugin.swift b/Plugins/CartonTest/Plugin.swift index e612b6bc..d7a6c685 100644 --- a/Plugins/CartonTest/Plugin.swift +++ b/Plugins/CartonTest/Plugin.swift @@ -19,10 +19,12 @@ import PackagePlugin struct CartonTestPlugin: CommandPlugin { struct Options { var environment: Environment + var prebuiltTestBundlePath: String? static func parse(from extractor: inout ArgumentExtractor) throws -> Options { let environment = try Environment.parse(from: &extractor) - return Options(environment: environment) + let prebuiltTestBundlePath = extractor.extractOption(named: "prebuilt-test-bundle-path").first + return Options(environment: environment, prebuiltTestBundlePath: prebuiltTestBundlePath) } } @@ -33,16 +35,18 @@ struct CartonTestPlugin: CommandPlugin { try checkHelpFlag(arguments, subcommand: "test", context: context) let productName = "\(context.package.displayName)PackageTests" - let wasmFileName = "\(productName).wasm" if arguments.first == "internal-get-build-command" { var extractor = ArgumentExtractor(Array(arguments.dropFirst())) let options = try Options.parse(from: &extractor) - var buildParameters = Environment.Parameters() - options.environment.applyBuildParameters(&buildParameters) - var buildCommand = ["build", "--product", productName] - buildCommand += buildParameters.otherSwiftcFlags.flatMap { ["-Xswiftc", $0] } - buildCommand += buildParameters.otherLinkerFlags.flatMap { ["-Xlinker", $0] } + var buildCommand: [String] = [] + if options.prebuiltTestBundlePath == nil { + var buildParameters = Environment.Parameters() + options.environment.applyBuildParameters(&buildParameters) + buildCommand = ["build", "--product", productName] + buildCommand += buildParameters.otherSwiftcFlags.flatMap { ["-Xswiftc", $0] } + buildCommand += buildParameters.otherLinkerFlags.flatMap { ["-Xlinker", $0] } + } let outputFile = extractor.extractOption(named: "output").last! try buildCommand.joined(separator: "\n").write( @@ -53,21 +57,25 @@ struct CartonTestPlugin: CommandPlugin { var extractor = ArgumentExtractor(arguments) let options = try Options.parse(from: &extractor) let buildDirectory = try self.buildDirectory(context: context) - let testProductArtifactPath = buildDirectory.appending(subpath: wasmFileName) - // TODO: SwiftPM does not allow to build *only tests* from plugin - guard FileManager.default.fileExists(atPath: testProductArtifactPath.string) else { - throw Error( - "Failed to find \"\(wasmFileName)\" in \(buildDirectory). Please build \"\(productName)\" product first" - ) - } + let testProductArtifactPath = try options.prebuiltTestBundlePath ?? { + let wasmFileName = "\(productName).wasm" + let testProductArtifactPath = buildDirectory.appending(subpath: wasmFileName).string + // TODO: SwiftPM does not allow to build *only tests* from plugin + guard FileManager.default.fileExists(atPath: testProductArtifactPath) else { + throw Error( + "Failed to find \"\(wasmFileName)\" in \(buildDirectory). Please build \"\(productName)\" product first" + ) + } + return testProductArtifactPath + }() let testTargets = context.package.targets(ofType: SwiftSourceModuleTarget.self).filter { $0.kind == .test } let resourcesPaths = deriveResourcesPaths( - productArtifactPath: testProductArtifactPath, + buildDirectory: buildDirectory, sourceTargets: testTargets, package: context.package ) @@ -75,7 +83,7 @@ struct CartonTestPlugin: CommandPlugin { let frontendArguments = [ "test", - "--prebuilt-test-bundle-path", testProductArtifactPath.string, + "--prebuilt-test-bundle-path", testProductArtifactPath, "--environment", options.environment.rawValue, ] + resourcesPaths.flatMap { diff --git a/Sources/CartonCLI/Commands/Bundle.swift b/Sources/CartonCLI/Commands/Bundle.swift index 395be6cb..4fc542cc 100644 --- a/Sources/CartonCLI/Commands/Bundle.swift +++ b/Sources/CartonCLI/Commands/Bundle.swift @@ -112,7 +112,9 @@ struct Bundle: AsyncParsableCommand { try localFileSystem.move(from: mainWasmPath, to: wasmOutputFilePath) } } else { - try localFileSystem.move(from: mainWasmPath, to: wasmOutputFilePath) + if mainWasmPath != wasmOutputFilePath { + try localFileSystem.move(from: mainWasmPath, to: wasmOutputFilePath) + } } try copyToBundle( @@ -215,7 +217,7 @@ struct Bundle: AsyncParsableCommand { extension ByteString { fileprivate var hexChecksum: String { - SHA256().hash(self).hexadecimalRepresentation + String(SHA256().hash(self).hexadecimalRepresentation.prefix(16)) } } diff --git a/Sources/carton/main.swift b/Sources/carton/main.swift index a1519405..5ae30bc5 100644 --- a/Sources/carton/main.swift +++ b/Sources/carton/main.swift @@ -107,14 +107,16 @@ func derivePackageCommandArguments( ) // 2. Build the test product - let buildCommand = - try String(contentsOf: commandFile).split(separator: "\n").map(String.init) + [ + let buildArguments = try String(contentsOf: commandFile).split(separator: "\n") + if !buildArguments.isEmpty { + let buildCommand = buildArguments.map(String.init) + [ "--triple", "wasm32-unknown-wasi", "--scratch-path", scratchPath, ] - try Foundation.Process.checkRun( - swiftExec, - arguments: buildCommand - ) + try Foundation.Process.checkRun( + swiftExec, + arguments: buildCommand + ) + } // "--environment browser" launches a http server packageArguments += ["--disable-sandbox"] diff --git a/Tests/CartonCommandTests/BundleCommandTests.swift b/Tests/CartonCommandTests/BundleCommandTests.swift index 041cc855..0c6ac1a8 100644 --- a/Tests/CartonCommandTests/BundleCommandTests.swift +++ b/Tests/CartonCommandTests/BundleCommandTests.swift @@ -41,18 +41,6 @@ final class BundleCommandTests: XCTestCase { } } - func testWithXswiftc() throws { - try withFixture("EchoExecutable") { packageDirectory in - let result = try swiftRun( - ["carton", "bundle", "-Xswiftc", "--fake-swiftc-options"], - packageDirectory: packageDirectory.url - ) - - XCTAssertTrue(result.stdout.contains("error: unknown argument: '--fake-swiftc-options'")) - XCTAssertNotEqual(result.exitCode, 0) - } - } - func testWithDebugInfo() throws { try withFixture("EchoExecutable") { packageDirectory in let result = try swiftRun( diff --git a/Tests/CartonCommandTests/CommandTestHelper.swift b/Tests/CartonCommandTests/CommandTestHelper.swift index f0d1cfbf..ead7121e 100644 --- a/Tests/CartonCommandTests/CommandTestHelper.swift +++ b/Tests/CartonCommandTests/CommandTestHelper.swift @@ -35,7 +35,7 @@ extension XCTest { var stderr: String func assertZeroExit(_ file: StaticString = #file, line: UInt = #line) { - XCTAssertEqual(exitCode, 0, file: file, line: line) + XCTAssertEqual(exitCode, 0, "stdout: " + stdout + "\nstderr: " + stderr, file: file, line: line) } } diff --git a/Tests/Fixtures/NodeJSKitTest/Package.resolved b/Tests/Fixtures/NodeJSKitTest/Package.resolved index 3f74e530..e6b7b812 100644 --- a/Tests/Fixtures/NodeJSKitTest/Package.resolved +++ b/Tests/Fixtures/NodeJSKitTest/Package.resolved @@ -63,15 +63,6 @@ "version" : "1.2.1" } }, - { - "identity" : "swift-tools-support-core", - "kind" : "remoteSourceControl", - "location" : "https://github.com/apple/swift-tools-support-core.git", - "state" : { - "branch" : "main", - "revision" : "930e82e5ae2432c71fe05f440b5d778285270bdb" - } - }, { "identity" : "wasmtransformer", "kind" : "remoteSourceControl", From 0b7354e378c6afb9ad1376d1865c7e9a8835e047 Mon Sep 17 00:00:00 2001 From: Yuta Saito Date: Sun, 25 Feb 2024 21:21:15 +0900 Subject: [PATCH 10/13] Disable manifest caching when building test product by swift-build --- Sources/carton/main.swift | 3 +++ 1 file changed, 3 insertions(+) diff --git a/Sources/carton/main.swift b/Sources/carton/main.swift index 5ae30bc5..885f73f8 100644 --- a/Sources/carton/main.swift +++ b/Sources/carton/main.swift @@ -110,6 +110,9 @@ func derivePackageCommandArguments( let buildArguments = try String(contentsOf: commandFile).split(separator: "\n") if !buildArguments.isEmpty { let buildCommand = buildArguments.map(String.init) + [ + // NOTE: "swift-build" uses llbuild manifest cache by default even though + // target triple changed. + "--disable-build-manifest-caching", "--triple", "wasm32-unknown-wasi", "--scratch-path", scratchPath, ] try Foundation.Process.checkRun( From 0f913e754b9eba276106982d213f91dab4498d14 Mon Sep 17 00:00:00 2001 From: Yuta Saito Date: Sun, 25 Feb 2024 12:57:26 +0000 Subject: [PATCH 11/13] Use `Process.run` instead of `Foundation.Process.run` --- Sources/SwiftToolchain/ToolchainInstallation.swift | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/Sources/SwiftToolchain/ToolchainInstallation.swift b/Sources/SwiftToolchain/ToolchainInstallation.swift index 4adf1edf..2b630ca6 100644 --- a/Sources/SwiftToolchain/ToolchainInstallation.swift +++ b/Sources/SwiftToolchain/ToolchainInstallation.swift @@ -107,11 +107,7 @@ extension ToolchainSystem { ] } terminal.logLookup("Unpacking the archive: ", arguments.joined(separator: " ")) - try Foundation.Process.run( - URL(fileURLWithPath: arguments[0]), - arguments: Array(arguments.dropFirst()) - ) - .waitUntilExit() + try await Process.run(arguments, terminal) return installationPath } From af9e3710d8678c678c8c30f52942a3ba7ca6a0bd Mon Sep 17 00:00:00 2001 From: Yuta Saito Date: Sun, 25 Feb 2024 23:34:31 +0900 Subject: [PATCH 12/13] Remove development files from the repository --- Tests/Fixtures/PluginTest/.gitignore | 8 -------- Tests/Fixtures/PluginTest/Package.swift | 17 ----------------- .../Sources/PluginTest/PluginTest.swift | 1 - .../PluginTest/Sources/PluginTestExe/main.swift | 7 ------- .../Tests/PluginTestTests/PluginTestTests.swift | 7 ------- 5 files changed, 40 deletions(-) delete mode 100644 Tests/Fixtures/PluginTest/.gitignore delete mode 100644 Tests/Fixtures/PluginTest/Package.swift delete mode 100644 Tests/Fixtures/PluginTest/Sources/PluginTest/PluginTest.swift delete mode 100644 Tests/Fixtures/PluginTest/Sources/PluginTestExe/main.swift delete mode 100644 Tests/Fixtures/PluginTest/Tests/PluginTestTests/PluginTestTests.swift diff --git a/Tests/Fixtures/PluginTest/.gitignore b/Tests/Fixtures/PluginTest/.gitignore deleted file mode 100644 index 0023a534..00000000 --- a/Tests/Fixtures/PluginTest/.gitignore +++ /dev/null @@ -1,8 +0,0 @@ -.DS_Store -/.build -/Packages -xcuserdata/ -DerivedData/ -.swiftpm/configuration/registries.json -.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata -.netrc diff --git a/Tests/Fixtures/PluginTest/Package.swift b/Tests/Fixtures/PluginTest/Package.swift deleted file mode 100644 index 1cea453c..00000000 --- a/Tests/Fixtures/PluginTest/Package.swift +++ /dev/null @@ -1,17 +0,0 @@ -// swift-tools-version: 5.9 -// The swift-tools-version declares the minimum version of Swift required to build this package. - -import PackageDescription - -let package = Package( - name: "PluginTest", - dependencies: [ - .package(path: "../../../"), - .package(url: "https://github.com/swiftwasm/JavaScriptKit", from: "0.19.0"), - ], - targets: [ - .executableTarget(name: "PluginTestExe", dependencies: ["JavaScriptKit"]), - .target(name: "PluginTest"), - .testTarget(name: "PluginTestTests", dependencies: ["PluginTest"]), - ] -) diff --git a/Tests/Fixtures/PluginTest/Sources/PluginTest/PluginTest.swift b/Tests/Fixtures/PluginTest/Sources/PluginTest/PluginTest.swift deleted file mode 100644 index 8b137891..00000000 --- a/Tests/Fixtures/PluginTest/Sources/PluginTest/PluginTest.swift +++ /dev/null @@ -1 +0,0 @@ - diff --git a/Tests/Fixtures/PluginTest/Sources/PluginTestExe/main.swift b/Tests/Fixtures/PluginTest/Sources/PluginTestExe/main.swift deleted file mode 100644 index f8fc4d68..00000000 --- a/Tests/Fixtures/PluginTest/Sources/PluginTestExe/main.swift +++ /dev/null @@ -1,7 +0,0 @@ -// The Swift Programming Language -// https://docs.swift.org/swift-book - -import JavaScriptKit - -JSObject.global.alert!("Hello, wa") -print("Hello, wa") diff --git a/Tests/Fixtures/PluginTest/Tests/PluginTestTests/PluginTestTests.swift b/Tests/Fixtures/PluginTest/Tests/PluginTestTests/PluginTestTests.swift deleted file mode 100644 index 12c158d9..00000000 --- a/Tests/Fixtures/PluginTest/Tests/PluginTestTests/PluginTestTests.swift +++ /dev/null @@ -1,7 +0,0 @@ -import XCTest - -class PluginTestTests: XCTestCase { - func testExample() { - XCTAssertTrue(true) - } -} From 29d665de6edc0dfd5251a508f839300d9bc06188 Mon Sep 17 00:00:00 2001 From: Yuta Saito Date: Mon, 26 Feb 2024 01:08:29 +0900 Subject: [PATCH 13/13] Format Toolchain.swift file --- Sources/SwiftToolchain/Toolchain.swift | 63 --------------------- Sources/SwiftToolchain/ToolchainError.swift | 43 ++++++++++++++ 2 files changed, 43 insertions(+), 63 deletions(-) delete mode 100644 Sources/SwiftToolchain/Toolchain.swift create mode 100644 Sources/SwiftToolchain/ToolchainError.swift diff --git a/Sources/SwiftToolchain/Toolchain.swift b/Sources/SwiftToolchain/Toolchain.swift deleted file mode 100644 index ed3b9401..00000000 --- a/Sources/SwiftToolchain/Toolchain.swift +++ /dev/null @@ -1,63 +0,0 @@ -//// Copyright 2020 Carton contributors -//// -//// Licensed under the Apache License, Version 2.0 (the "License"); -//// you may not use this file except in compliance with the License. -//// You may obtain a copy of the License at -//// -//// http://www.apache.org/licenses/LICENSE-2.0 -//// -//// Unless required by applicable law or agreed to in writing, software -//// distributed under the License is distributed on an "AS IS" BASIS, -//// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -//// See the License for the specific language governing permissions and -//// limitations under the License. - -import CartonHelpers - -public let compatibleJSKitVersion = "0.18.0" - -enum ToolchainError: Error, CustomStringConvertible { - case directoryDoesNotExist(AbsolutePath) - case invalidInstallationArchive(AbsolutePath) - case noExecutableProduct - case failedToBuild(product: String) - case failedToBuildTestBundle - case missingPackageManifest - case invalidVersion(version: String) - case invalidResponse(url: String, status: Int) - case unsupportedOperatingSystem - case noInstallationDirectory(path: String) - case noWorkingDirectory - - var description: String { - switch self { - case let .directoryDoesNotExist(path): - return "Directory at path \(path.pathString) does not exist and could not be created" - case let .invalidInstallationArchive(path): - return "Invalid toolchain/SDK archive was installed at path \(path)" - case .noExecutableProduct: - return "No executable product to build could be inferred" - case let .failedToBuild(product): - return "Failed to build executable product \(product)" - case .failedToBuildTestBundle: - return "Failed to build the test bundle" - case .missingPackageManifest: - return """ - The `Package.swift` manifest file could not be found. Please navigate to a directory that \ - contains `Package.swift` and restart. - """ - case let .invalidVersion(version): - return "Invalid version \(version)" - case let .invalidResponse(url: url, status: status): - return "Response from \(url) had invalid status \(status) or didn't contain body" - case .unsupportedOperatingSystem: - return "This version of the operating system is not supported" - case let .noInstallationDirectory(path): - return """ - Failed to infer toolchain installation directory. Please make sure that \(path) exists. - """ - case .noWorkingDirectory: - return "Working directory cannot be inferred from file system" - } - } -} diff --git a/Sources/SwiftToolchain/ToolchainError.swift b/Sources/SwiftToolchain/ToolchainError.swift new file mode 100644 index 00000000..57346ab5 --- /dev/null +++ b/Sources/SwiftToolchain/ToolchainError.swift @@ -0,0 +1,43 @@ +// Copyright 2020 Carton contributors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +import CartonHelpers + +enum ToolchainError: Error, CustomStringConvertible { + case directoryDoesNotExist(AbsolutePath) + case invalidInstallationArchive(AbsolutePath) + case invalidVersion(version: String) + case invalidResponse(url: String, status: Int) + case unsupportedOperatingSystem + case noInstallationDirectory(path: String) + + var description: String { + switch self { + case let .directoryDoesNotExist(path): + return "Directory at path \(path.pathString) does not exist and could not be created" + case let .invalidInstallationArchive(path): + return "Invalid toolchain/SDK archive was installed at path \(path)" + case let .invalidVersion(version): + return "Invalid version \(version)" + case let .invalidResponse(url: url, status: status): + return "Response from \(url) had invalid status \(status) or didn't contain body" + case .unsupportedOperatingSystem: + return "This version of the operating system is not supported" + case let .noInstallationDirectory(path): + return """ + Failed to infer toolchain installation directory. Please make sure that \(path) exists. + """ + } + } +}