Setup a basic run of cmake-smoke-test in CI

owenv · owenv · commit a9ba7c9c1b14 · 2025-05-04T10:30:00.000-07:00
diff --git a/.github/workflows/pull_request.yml b/.github/workflows/pull_request.yml
@@ -45,6 +45,21 @@ jobs:
       linux_swift_versions: '["nightly-main", "nightly-6.2"]'
       windows_swift_versions: '["nightly-main"]'
       windows_build_command: 'swift test --no-parallel'
+  cmake-smoke-test:
+    name: cmake-smoke-test
+    uses: swiftlang/github-workflows/.github/workflows/swift_package_test.yml@main
+    with:
+      linux_os_versions: '["noble"]'
+      linux_pre_build_command: |
+        apt-get update -y
+
+        # Build dependencies
+        apt-get install -y libsqlite3-dev libncurses-dev
+
+        apt-get install -y cmake ninja-build
+      linux_build_command: 'TERM=xterm-256color swift package cmake-smoke-test --disable-sandbox --cmake-path `which cmake` --ninja-path `which ninja`'
+      linux_swift_versions: '["nightly-main"]'
+      windows_swift_versions: '[]'
   soundness:
     name: Soundness
     uses: swiftlang/github-workflows/.github/workflows/soundness.yml@main
diff --git a/Plugins/cmake-smoke-test/cmake-smoke-test.swift b/Plugins/cmake-smoke-test/cmake-smoke-test.swift
@@ -24,21 +24,21 @@ struct CMakeSmokeTest: CommandPlugin {
         }
 
         guard let cmakePath = args.extractOption(named: "cmake-path").last else { throw Errors.missingRequiredOption("--cmake-path") }
-        print("using cmake at \(cmakePath)")
+        Diagnostics.progress("using cmake at \(cmakePath)")
         let cmakeURL = URL(filePath: cmakePath)
         guard let ninjaPath = args.extractOption(named: "ninja-path").last else { throw Errors.missingRequiredOption("--ninja-path") }
-        print("using ninja at \(ninjaPath)")
+        Diagnostics.progress("using ninja at \(ninjaPath)")
         let ninjaURL = URL(filePath: ninjaPath)
         let sysrootPath = args.extractOption(named: "sysroot-path").last
         if let sysrootPath {
-            print("using sysroot at \(sysrootPath)")
+            Diagnostics.progress("using sysroot at \(sysrootPath)")
         }
 
         let moduleCachePath = context.pluginWorkDirectoryURL.appending(component: "module-cache").path()
 
         let swiftBuildURL = context.package.directoryURL
         let swiftBuildBuildURL = context.pluginWorkDirectoryURL.appending(component: "swift-build")
-        print("swift-build: \(swiftBuildURL.path())")
+        Diagnostics.progress("swift-build: \(swiftBuildURL.path())")
 
         let swiftToolsSupportCoreURL = try findDependency("swift-tools-support-core", pluginContext: context)
         let swiftToolsSupportCoreBuildURL = context.pluginWorkDirectoryURL.appending(component: "swift-tools-support-core")
@@ -82,37 +82,37 @@ struct CMakeSmokeTest: CommandPlugin {
             "-DCMAKE_Swift_FLAGS='\(sharedSwiftFlags.joined(separator: " "))'"
         ] + cMakeProjectArgs
 
-        print("Building swift-tools-support-core")
+        Diagnostics.progress("Building swift-tools-support-core")
         try await Process.checkNonZeroExit(url: cmakeURL, arguments: sharedCMakeArgs + [swiftToolsSupportCoreURL.path()], workingDirectory: swiftToolsSupportCoreBuildURL)
         try await Process.checkNonZeroExit(url: ninjaURL, arguments: [], workingDirectory: swiftToolsSupportCoreBuildURL)
-        print("Built swift-tools-support-core")
+        Diagnostics.progress("Built swift-tools-support-core")
 
         if hostOS != .macOS {
-            print("Building swift-system")
+            Diagnostics.progress("Building swift-system")
             try await Process.checkNonZeroExit(url: cmakeURL, arguments: sharedCMakeArgs + [swiftSystemURL.path()], workingDirectory: swiftSystemBuildURL)
             try await Process.checkNonZeroExit(url: ninjaURL, arguments: [], workingDirectory: swiftSystemBuildURL)
-            print("Built swift-system")
+            Diagnostics.progress("Built swift-system")
         }
 
-        print("Building llbuild")
+        Diagnostics.progress("Building llbuild")
         try await Process.checkNonZeroExit(url: cmakeURL, arguments: sharedCMakeArgs + ["-DLLBUILD_SUPPORT_BINDINGS:=Swift", llbuildURL.path()], workingDirectory: llbuildBuildURL)
         try await Process.checkNonZeroExit(url: ninjaURL, arguments: [], workingDirectory: llbuildBuildURL)
-        print("Built llbuild")
+        Diagnostics.progress("Built llbuild")
 
-        print("Building swift-argument-parser")
+        Diagnostics.progress("Building swift-argument-parser")
         try await Process.checkNonZeroExit(url: cmakeURL, arguments: sharedCMakeArgs + ["-DBUILD_TESTING=NO", "-DBUILD_EXAMPLES=NO", swiftArgumentParserURL.path()], workingDirectory: swiftArgumentParserBuildURL)
         try await Process.checkNonZeroExit(url: ninjaURL, arguments: [], workingDirectory: swiftArgumentParserBuildURL)
-        print("Built swift-argument-parser")
+        Diagnostics.progress("Built swift-argument-parser")
 
-        print("Building swift-driver")
+        Diagnostics.progress("Building swift-driver")
         try await Process.checkNonZeroExit(url: cmakeURL, arguments: sharedCMakeArgs + [swiftDriverURL.path()], workingDirectory: swiftDriverBuildURL)
         try await Process.checkNonZeroExit(url: ninjaURL, arguments: [], workingDirectory: swiftDriverBuildURL)
-        print("Built swift-driver")
+        Diagnostics.progress("Built swift-driver")
 
-        print("Building swift-build in \(swiftBuildBuildURL)")
+        Diagnostics.progress("Building swift-build in \(swiftBuildBuildURL)")
         try await Process.checkNonZeroExit(url: cmakeURL, arguments: sharedCMakeArgs + [swiftBuildURL.path()], workingDirectory: swiftBuildBuildURL)
         try await Process.checkNonZeroExit(url: ninjaURL, arguments: [], workingDirectory: swiftBuildBuildURL)
-        print("Built swift-build")
+        Diagnostics.progress("Built swift-build")
     }
 
     func findDependency(_ name: String, pluginContext: PluginContext) throws -> URL {
@@ -132,7 +132,7 @@ struct CMakeSmokeTest: CommandPlugin {
             throw Errors.missingRepository(name)
         }
         let dependencyURL = dependency.directoryURL
-        print("\(name): \(dependencyURL.path())")
+        Diagnostics.progress("\(name): \(dependencyURL.path())")
         guard FileManager.default.fileExists(atPath: dependencyURL.path()) else {
             throw Errors.missingRepository(dependencyURL.path())
         }
@@ -167,13 +167,19 @@ enum OS {
 
 extension Process {
     func run() async throws {
+        Diagnostics.progress("entered run")
         try await withCheckedThrowingContinuation { continuation in
+            Diagnostics.progress("continuation")
             terminationHandler = { _ in
+                Diagnostics.progress("termination handler")
                 continuation.resume()
+                Diagnostics.progress("resumed continuation")
             }
 
             do {
+                Diagnostics.progress("pre-run")
                 try run()
+                Diagnostics.progress("post-run")
             } catch {
                 terminationHandler = nil
                 continuation.resume(throwing: error)
@@ -182,12 +188,30 @@ extension Process {
     }
 
     static func checkNonZeroExit(url: URL, arguments: [String], workingDirectory: URL, environment: [String: String]? = nil) async throws {
-        print("\(url.path()) \(arguments.joined(separator: " "))")
+        Diagnostics.progress("\(url.path()) \(arguments.joined(separator: " "))")
         let process = Process()
         process.executableURL = url
         process.arguments = arguments
         process.currentDirectoryURL = workingDirectory
         process.environment = environment
+        let outputPipe = Pipe()
+        let errorPipe = Pipe()
+        outputPipe.fileHandleForReading.readabilityHandler = { (fh : FileHandle) -> Void in
+            Diagnostics.progress("output")
+            let data = (try? fh.read(upToCount: Int.max)) ?? Data()
+            if !data.isEmpty {
+                Diagnostics.progress(String(decoding: data, as: UTF8.self))
+            }
+        }
+        errorPipe.fileHandleForReading.readabilityHandler = { (fh : FileHandle) -> Void in
+            Diagnostics.progress("error")
+            let data = (try? fh.read(upToCount: Int.max)) ?? Data()
+            if !data.isEmpty {
+                Diagnostics.progress(String(decoding: data, as: UTF8.self))
+            }
+        }
+        process.standardOutput = nil
+        process.standardError = nil
         try await process.run()
         if process.terminationStatus != 0 {
             throw Errors.processError(terminationReason: process.terminationReason, terminationStatus: process.terminationStatus)
diff --git a/Plugins/launch-xcode/launch-xcode.swift b/Plugins/launch-xcode/launch-xcode.swift
@@ -42,8 +42,8 @@ struct LaunchXcode: CommandPlugin {
         let process = Process()
         process.executableURL = URL(fileURLWithPath: "/usr/bin/open")
         process.arguments = ["-n", "-F", "-W", "--env", "XCBBUILDSERVICE_PATH=\(buildServiceURL.path())", "-b", "com.apple.dt.Xcode"]
-        process.standardOutput = nil
-        process.standardError = nil
+        process.standardOutput = Pipe()
+        process.standardError = Pipe()
         try await process.run()
         if process.terminationStatus != 0 {
             throw LaunchXcodeError.launchFailed
