DO NOT MERGE: initial conversion of swift toolchain release to OpenAPI

cmcgee1024 · cmcgee1024 · commit ab87ffd53952 · 2025-03-14T09:33:15.000-04:00
diff --git a/Sources/SwiftlyCore/HTTPClient.swift b/Sources/SwiftlyCore/HTTPClient.swift
@@ -53,6 +53,12 @@ extension Components.Schemas.SwiftlyReleasePlatformArtifacts {
 public protocol HTTPRequestExecutor {
     func execute(_ request: HTTPClientRequest, timeout: TimeAmount) async throws -> HTTPClientResponse
     func getCurrentSwiftlyRelease() async throws -> Components.Schemas.SwiftlyRelease
+    func getReleaseToolchains(
+        platform: PlatformDefinition,
+        arch a: Components.Schemas.Architecture?,
+        limit: Int?,
+        filter: ((ToolchainVersion.StableRelease) -> Bool)?
+    ) async throws -> [ToolchainVersion.StableRelease]
 }
 
 internal struct SwiftlyUserAgentMiddleware: ClientMiddleware {
@@ -128,6 +134,61 @@ internal class HTTPRequestExecutorImpl: HTTPRequestExecutor {
         let response = try await client.getCurrentSwiftlyRelease()
         return try response.ok.body.json
     }
+
+    public func getReleaseToolchains(
+        platform: PlatformDefinition,
+        arch a: Components.Schemas.Architecture? = nil,
+        limit: Int? = nil,
+        filter: ((ToolchainVersion.StableRelease) -> Bool)? = nil
+    ) async throws -> [ToolchainVersion.StableRelease] {
+        let arch = a ?? cpuArch
+
+        let config = AsyncHTTPClientTransport.Configuration(client: self.httpClient, timeout: .seconds(30))
+        let swiftlyUserAgent = SwiftlyUserAgentMiddleware()
+
+        let client = Client(
+            serverURL: try Servers.Server1.url(),
+            transport: AsyncHTTPClientTransport(configuration: config),
+            middlewares: [swiftlyUserAgent]
+        )
+
+        let response = try await client.listReleases()
+
+        var swiftOrgFiltered: [ToolchainVersion.StableRelease] = try response.ok.body.json.compactMap { swiftOrgRelease in
+            if platform.name != PlatformDefinition.macOS.name {
+                // If the platform isn't xcode then verify that there is an offering for this platform name and arch
+                guard let swiftOrgPlatform = swiftOrgRelease.platforms.first(where: { $0.matches(platform) }) else {
+                    return nil
+                }
+
+                guard case let archs = swiftOrgPlatform.archs, archs.contains(arch) else {
+                    return nil
+                }
+            }
+
+            guard let version = try? ToolchainVersion(parsing: swiftOrgRelease.stableName),
+                  case let .stable(release) = version
+            else {
+                throw SwiftlyError(message: "error parsing swift.org release version: \(swiftOrgRelease.stableName)")
+            }
+
+            if let filter {
+                guard filter(release) else {
+                    return nil
+                }
+            }
+
+            return release
+        }
+
+        swiftOrgFiltered.sort(by: >)
+
+        return if let limit = limit {
+            Array(swiftOrgFiltered.prefix(limit))
+        } else {
+            swiftOrgFiltered
+        }
+    }
 }
 
 private func makeRequest(url: String) -> HTTPClientRequest {
@@ -136,13 +197,21 @@ private func makeRequest(url: String) -> HTTPClientRequest {
     return request
 }
 
-struct SwiftOrgPlatform: Codable {
-    var name: String
-    var archs: [String]?
+extension Components.Schemas.Release {
+    var stableName: String {
+        let components = self.name.components(separatedBy: ".")
+        if components.count == 2 {
+            return self.name + ".0"
+        } else {
+            return self.name
+        }
+    }
+}
 
-    /// platform is a mapping from the 'name' field of the swift.org platform object
+extension Components.Schemas.Platform {
+    /// platformDef is a mapping from the 'name' field of the swift.org platform object
     /// to swiftly's PlatformDefinition, if possible.
-    var platform: PlatformDefinition? {
+    var platformDef: PlatformDefinition? {
         // NOTE: some of these platforms are represented on swift.org metadata, but not supported by swiftly and so they don't have constants in PlatformDefinition
         switch self.name {
         case "Ubuntu 14.04":
@@ -181,28 +250,14 @@ struct SwiftOrgPlatform: Codable {
     }
 
     func matches(_ platform: PlatformDefinition) -> Bool {
-        guard let myPlatform = self.platform else {
+        guard let myPlatform = self.platformDef else {
             return false
         }
 
         return myPlatform.name == platform.name
     }
 }
 
-public struct SwiftOrgRelease: Codable {
-    var name: String
-    var platforms: [SwiftOrgPlatform]
-
-    var stableName: String {
-        let components = self.name.components(separatedBy: ".")
-        if components.count == 2 {
-            return self.name + ".0"
-        } else {
-            return self.name
-        }
-    }
-}
-
 public struct SwiftOrgSnapshotList: Codable {
     var aarch64: [SwiftOrgSnapshot]?
     var x86_64: [SwiftOrgSnapshot]?
@@ -291,49 +346,11 @@ public struct SwiftlyHTTPClient {
     /// limit (default unlimited).
     public func getReleaseToolchains(
         platform: PlatformDefinition,
-        arch a: String? = nil,
+        arch a: Components.Schemas.Architecture? = nil,
         limit: Int? = nil,
         filter: ((ToolchainVersion.StableRelease) -> Bool)? = nil
     ) async throws -> [ToolchainVersion.StableRelease] {
-        let arch = a ?? cpuArch
-
-        let url = "https://www.swift.org/api/v1/install/releases.json"
-        let swiftOrgReleases: [SwiftOrgRelease] = try await self.getFromJSON(url: url, type: [SwiftOrgRelease].self)
-
-        var swiftOrgFiltered: [ToolchainVersion.StableRelease] = try swiftOrgReleases.compactMap { swiftOrgRelease in
-            if platform.name != PlatformDefinition.macOS.name {
-                // If the platform isn't xcode then verify that there is an offering for this platform name and arch
-                guard let swiftOrgPlatform = swiftOrgRelease.platforms.first(where: { $0.matches(platform) }) else {
-                    return nil
-                }
-
-                guard let archs = swiftOrgPlatform.archs, archs.contains(arch) else {
-                    return nil
-                }
-            }
-
-            guard let version = try? ToolchainVersion(parsing: swiftOrgRelease.stableName),
-                  case let .stable(release) = version
-            else {
-                throw SwiftlyError(message: "error parsing swift.org release version: \(swiftOrgRelease.stableName)")
-            }
-
-            if let filter {
-                guard filter(release) else {
-                    return nil
-                }
-            }
-
-            return release
-        }
-
-        swiftOrgFiltered.sort(by: >)
-
-        return if let limit = limit {
-            Array(swiftOrgFiltered.prefix(limit))
-        } else {
-            swiftOrgFiltered
-        }
+        try await SwiftlyCore.httpRequestExecutor.getReleaseToolchains(platform: platform, arch: a, limit: limit, filter: filter)
     }
 
     public struct SnapshotBranchNotFoundError: LocalizedError {
@@ -349,7 +366,7 @@ public struct SwiftlyHTTPClient {
         limit: Int? = nil,
         filter: ((ToolchainVersion.Snapshot) -> Bool)? = nil
     ) async throws -> [ToolchainVersion.Snapshot] {
-        let arch = a ?? cpuArch
+        let arch = a ?? String(describing: cpuArch)
 
         let platformName = if platform.name == PlatformDefinition.macOS.name {
             "macos"
diff --git a/Sources/SwiftlyCore/SwiftlyCore.swift b/Sources/SwiftlyCore/SwiftlyCore.swift
@@ -53,9 +53,9 @@ public func readLine(prompt: String) -> String? {
 }
 
 #if arch(x86_64)
-public let cpuArch = "x86_64"
+public let cpuArch = Components.Schemas.Architecture(value1: Components.Schemas.KnownArchitecture.x8664)
 #elseif arch(arm64)
-public let cpuArch = "aarch64"
+public let cpuArch = Components.Schemas.Architecture(value1: Components.Schemas.KnownArchitecture.aarch64)
 #else
 #error("Unsupported processor architecture")
 #endif
diff --git a/Sources/SwiftlyCore/openapi-generator-config.yaml b/Sources/SwiftlyCore/openapi-generator-config.yaml
@@ -4,4 +4,4 @@ generate:
 namingStrategy: idiomatic
 accessModifier: public
 filter:
-  tags: ["Swiftly"]
+  tags: ["Swiftly", "Toolchains"]
diff --git a/Tests/SwiftlyTests/HTTPClientTests.swift b/Tests/SwiftlyTests/HTTPClientTests.swift
@@ -6,9 +6,9 @@ final class HTTPClientTests: SwiftlyTests {
     func testGet() async throws {
         // GIVEN: we have a swiftly http client
         // WHEN: we make get request for a particular type of JSON
-        var releases: [SwiftOrgRelease] = try await SwiftlyCore.httpClient.getFromJSON(
+        var releases: [Components.Schemas.Release] = try await SwiftlyCore.httpClient.getFromJSON(
             url: "https://www.swift.org/api/v1/install/releases.json",
-            type: [SwiftOrgRelease].self,
+            type: [Components.Schemas.Release].self,
             headers: [:]
         )
         // THEN: we get a decoded JSON response
@@ -20,7 +20,7 @@ final class HTTPClientTests: SwiftlyTests {
         do {
             releases = try await SwiftlyCore.httpClient.getFromJSON(
                 url: "https://www.swift.org/api/v1/install/releases-invalid.json",
-                type: [SwiftOrgRelease].self,
+                type: [Components.Schemas.Release].self,
                 headers: [:]
             )
         } catch {
@@ -35,7 +35,7 @@ final class HTTPClientTests: SwiftlyTests {
         do {
             releases = try await SwiftlyCore.httpClient.getFromJSON(
                 url: "https://invalid.swift.org/api/v1/install/releases.json",
-                type: [SwiftOrgRelease].self,
+                type: [Components.Schemas.Release].self,
                 headers: [:]
             )
         } catch {
@@ -74,7 +74,7 @@ final class HTTPClientTests: SwiftlyTests {
             .release(major: 6, minor: 0), // This is available in swift.org API
         ]
 
-        for arch in ["x86_64", "aarch64"] {
+        for arch in [Components.Schemas.Architecture(value1: Components.Schemas.KnownArchitecture.x8664), Components.Schemas.Architecture(value1: Components.Schemas.KnownArchitecture.aarch64)] {
             for platform in supportedPlatforms {
                 // GIVEN: we have a swiftly http client with swift.org metadata capability
                 // WHEN: we ask for the first five releases of a supported platform in a supported arch
@@ -87,7 +87,7 @@ final class HTTPClientTests: SwiftlyTests {
                 for branch in branches {
                     // GIVEN: we have a swiftly http client with swift.org metadata capability
                     // WHEN: we ask for the first five snapshots on a branch for a supported platform and arch
-                    let snapshots = try await SwiftlyCore.httpClient.getSnapshotToolchains(platform: platform, arch: arch, branch: branch, limit: 5)
+                    let snapshots = try await SwiftlyCore.httpClient.getSnapshotToolchains(platform: platform, arch: String(describing: arch), branch: branch, limit: 5)
                     // THEN: we get at least 3 releases
                     XCTAssertTrue(3 <= snapshots.count)
                 }
diff --git a/Tests/SwiftlyTests/SwiftlyTests.swift b/Tests/SwiftlyTests/SwiftlyTests.swift
@@ -467,6 +467,15 @@ private struct MockHTTPRequestExecutor: HTTPRequestExecutor {
     public func getCurrentSwiftlyRelease() async throws -> Components.Schemas.SwiftlyRelease {
         throw SwiftlyTestError(message: "Mocking of fetching the current swiftly release is not implemented in MockHTTPRequestExecutor.")
     }
+
+    public func getReleaseToolchains(
+        platform _: PlatformDefinition,
+        arch _: Components.Schemas.Architecture?,
+        limit _: Int?,
+        filter _: ((ToolchainVersion.StableRelease) -> Bool)?
+    ) async throws -> [ToolchainVersion.StableRelease] {
+        throw SwiftlyTestError(message: "Mocking of fetching the release toolchains is not implemented in MockHTTPRequestExecutor.")
+    }
 }
 
 /// An `HTTPRequestExecutor` which will return a mocked response to any toolchain download requests.
@@ -506,6 +515,15 @@ public class MockToolchainDownloader: HTTPRequestExecutor {
         return release
     }
 
+    public func getReleaseToolchains(
+        platform _: PlatformDefinition,
+        arch _: Components.Schemas.Architecture?,
+        limit _: Int?,
+        filter _: ((ToolchainVersion.StableRelease) -> Bool)?
+    ) async throws -> [ToolchainVersion.StableRelease] {
+        throw SwiftlyTestError(message: "Mocking of the fetching of release toolchains is not implemented by the MockToolchainDownloader")
+    }
+
     public func execute(_ request: HTTPClientRequest, timeout: TimeAmount) async throws -> HTTPClientResponse {
         guard let url = URL(string: request.url) else {
             throw SwiftlyTestError(message: "invalid request URL: \(request.url)")
