feat: bindings for EndpointsRuleEngine

.github/workflows/ci.yml

@@ -20,10 +20,6 @@ jobs:
       - uses: actions/checkout@v1
       - name: GitHub Action for SwiftLint
         uses: norio-nomura/action-swiftlint@3.1.0
-      - name: GitHub Action for SwiftLint with --strict
-        uses: norio-nomura/action-swiftlint@3.1.0
-        with:
-          args: --strict
       - name: GitHub Action for SwiftLint (Only files changed in the PR)
         uses: norio-nomura/action-swiftlint@3.1.0
         env:

Source/AwsCommonRuntimeKit/crt/CRTError.swift

@@ -9,4 +9,6 @@ public enum CRTError: Error {
   case memoryAllocationFailure
   case stringConversionError(UnsafePointer<aws_string>?)
   case crtError(AWSError)
+  // TODO: cleanup error handling https://github.com/awslabs/aws-crt-swift/issues/77
+  case awsError(AWSCommonRuntimeError)
 }

Source/AwsCommonRuntimeKit/sdkutils/CRTAWSEndpointsRequestContext.swift

@@ -0,0 +1,55 @@
+//  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+//  SPDX-License-Identifier: Apache-2.0.
+
+import AwsCSdkUtils
+
+/// Request context used for resolving endpoint
+public class CRTAWSEndpointsRequestContext {
+    let rawValue: OpaquePointer
+
+    /// Initialize a new request context
+    /// - Parameter allocator: Allocator to use for request context creation
+    public init(allocator: Allocator = defaultAllocator) throws {
+        guard let rawValue = aws_endpoints_request_context_new(allocator.rawValue) else {
+            throw CRTError.awsError(AWSCommonRuntimeError())
+        }
+
+        self.rawValue = rawValue
+    }
+
+    /// Add a string endpoint parameter to the request context
+    /// - Parameters:
+    ///   - name: The name of the parameter
+    ///   - value: The value of the parameter
+    ///   - allocator: The allocator to use for the parameter
+    public func add(name: String, value: String?, allocator: Allocator = defaultAllocator) throws {
+        guard let value = value else {
+            return
+        }
+        let namePtr: UnsafeMutablePointer<aws_byte_cursor> = fromPointer(ptr: name.awsByteCursor)
+        let valuePtr: UnsafeMutablePointer<aws_byte_cursor> = fromPointer(ptr: value.awsByteCursor)
+        let success = aws_endpoints_request_context_add_string(allocator.rawValue,
+                                                               rawValue,
+                                                               namePtr.pointee,
+                                                               valuePtr.pointee)
+        if success != 0 {
+            throw CRTError.awsError(AWSCommonRuntimeError())
+        }
+    }
+
+    /// Add a bool endpoint parameter to the request context
+    /// - Parameters:
+    ///   - name: The name of the parameter
+    ///   - value: The value of the parameter
+    ///   - allocator: The allocator to use for the parameter
+    public func add(name: String, value: Bool?, allocator: Allocator = defaultAllocator) throws {
+        guard let value = value else {
+            return
+        }
+        let namePtr: UnsafeMutablePointer<aws_byte_cursor> = fromPointer(ptr: name.awsByteCursor)
+        let success = aws_endpoints_request_context_add_boolean(allocator.rawValue, rawValue, namePtr.pointee, value)
+        if success != 0 {
+            throw CRTError.awsError(AWSCommonRuntimeError())
+        }
+    }
+}

Source/AwsCommonRuntimeKit/sdkutils/CRTAWSEndpointsResolvedEndpoint.swift

@@ -0,0 +1,88 @@
+//  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+//  SPDX-License-Identifier: Apache-2.0.
+
+import Foundation
+import AwsCSdkUtils
+
+/// Resolved endpoint
+public class CRTAWSEndpointResolvedEndpoint {
+    let rawValue: OpaquePointer
+
+    /// Initialize a new resolved endpoint
+    /// - Parameter rawValue: The raw value of the resolved endpoint
+    public init(rawValue: OpaquePointer) {
+        self.rawValue = rawValue
+
+        aws_endpoints_resolved_endpoint_acquire(rawValue)
+    }
+
+    /// Get the type of the resolved endpoint
+    /// - Returns: The type of the resolved endpoint
+    public func getType() -> CRTAWSEndpointsResolvedEndpointType {
+        let type = aws_endpoints_resolved_endpoint_get_type(rawValue)
+        return CRTAWSEndpointsResolvedEndpointType(rawValue: type)
+    }
+
+    /// Get the URL of the resolved endpoint
+    /// - Returns: The URL of the resolved endpoint
+    public func getURL() throws -> String? {
+        let urlOut = UnsafeMutablePointer<aws_byte_cursor>.allocate(capacity: 1)
+        let success = aws_endpoints_resolved_endpoint_get_url(rawValue, urlOut)
+        if success != 0 {
+            throw CRTError.awsError(AWSCommonRuntimeError())
+        }
+        return urlOut.pointee.toString()
+    }
+
+    /// Get the properties of the resolved endpoint
+    /// - Returns: The properties of the resolved endpoint
+    public func getProperties() throws -> [String: AnyHashable]? {
+        let propsOut = UnsafeMutablePointer<aws_byte_cursor>.allocate(capacity: 1)
+        let success = aws_endpoints_resolved_endpoint_get_properties(rawValue, propsOut)
+        if success != 0 {
+            throw CRTError.awsError(AWSCommonRuntimeError())
+        }
+        guard let data = propsOut.pointee.toString()?.data(using: .utf8) else {
+            return nil
+        }
+        return try JSONSerialization.jsonObject(with: data) as? [String: AnyHashable]
+    }
+
+    /// Get the error of the resolved endpoint
+    /// - Parameter allocator: The allocator to use for the error
+    public func getError() throws -> String? {
+        let errorOut = UnsafeMutablePointer<aws_byte_cursor>.allocate(capacity: 1)
+        let success = aws_endpoints_resolved_endpoint_get_error(rawValue, errorOut)
+        if success != 0 {
+            throw CRTError.awsError(AWSCommonRuntimeError())
+        }
+        return errorOut.pointee.toString()
+    }
+
+    /// Get headers of the resolved endpoint
+    /// - Returns: The headers of the resolved endpoint
+    public func getHeaders() throws -> [String: [String]]? {
+        let headersOut: UnsafeMutablePointer<UnsafePointer<aws_hash_table>?>
+            = UnsafeMutablePointer<UnsafePointer<aws_hash_table>?>.allocate(capacity: 1)
+        let success = aws_endpoints_resolved_endpoint_get_headers(rawValue, headersOut)
+        if success != 0 {
+            throw CRTError.awsError(AWSCommonRuntimeError())
+        }
+
+        var headers: [String: [String]] = [:]
+        var iter = aws_hash_iter_begin(headersOut.pointee)
+
+        while !aws_hash_iter_done(&iter) {
+            let key = iter.element.key.bindMemory(to: String.self, capacity: 1).pointee
+            let value = iter.element.value.bindMemory(to: aws_array_list.self, capacity: 1).pointee.toStringArray()
+            headers[key] = value
+            aws_hash_iter_next(&iter)
+        }
+
+        return headers
+    }
+
+    deinit {
+        aws_endpoints_resolved_endpoint_release(rawValue)
+    }
+}

Source/AwsCommonRuntimeKit/sdkutils/CRTAWSEndpointsResolvedEndpointType.swift

@@ -0,0 +1,28 @@
+//  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+//  SPDX-License-Identifier: Apache-2.0.
+
+import AwsCSdkUtils
+
+/// Resolved endpoint type
+public enum CRTAWSEndpointsResolvedEndpointType {
+    /// Used for endpoints that are resolved successfully
+    case endpoint
+    /// Used for endpoints that resolve to an error
+    case error
+}
+
+extension CRTAWSEndpointsResolvedEndpointType: RawRepresentable, CaseIterable {
+    public init(rawValue: aws_endpoints_resolved_endpoint_type) {
+        let value = Self.allCases.first(where: {$0.rawValue == rawValue})
+        self = value ?? .endpoint
+    }
+
+    public var rawValue: aws_endpoints_resolved_endpoint_type {
+        switch self {
+        case .endpoint:
+            return AWS_ENDPOINTS_RESOLVED_ENDPOINT
+        case .error:
+            return AWS_ENDPOINTS_RESOLVED_ERROR
+        }
+    }
+}

Source/AwsCommonRuntimeKit/sdkutils/CRTAWSEndpointsRuleEngine.swift

@@ -0,0 +1,43 @@
+//  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+//  SPDX-License-Identifier: Apache-2.0.
+
+import AwsCSdkUtils
+
+/// Rule engine for matching endpoint rules
+public class CRTAWSEndpointsRuleEngine {
+    let rawValue: OpaquePointer
+
+    /// Initialize a new rule engine
+    /// - Parameters:
+    ///   - ruleSetString: The rule set string to use for the rule engine
+    ///   - allocator: The allocator to use for creating rule engine
+    public init(ruleSetString: String, allocator: Allocator = defaultAllocator) throws {
+        guard let ruleSet = aws_endpoints_ruleset_new_from_string(allocator.rawValue, ruleSetString.newByteCursor().rawValue),
+            let rawValue = aws_endpoints_rule_engine_new(allocator.rawValue, ruleSet) else {
+            throw CRTError.awsError(AWSCommonRuntimeError())
+        }
+
+        self.rawValue = rawValue
+    }
+
+    /// Resolve an endpoint from the rule engine using the provided request context
+    /// - Parameter context: The request context to use for endpoint resolution
+    /// - Returns: The resolved endpoint
+    public func resolve(context: CRTAWSEndpointsRequestContext) throws -> CRTAWSEndpointResolvedEndpoint? {
+        let resolvedEndpoint: UnsafeMutablePointer<OpaquePointer?>? = UnsafeMutablePointer.allocate(capacity: 1)
+        let success = aws_endpoints_rule_engine_resolve(rawValue, context.rawValue, resolvedEndpoint)
+        if success != 0 {
+            throw CRTError.awsError(AWSCommonRuntimeError())
+        }
+
+        guard let pointee = resolvedEndpoint?.pointee else {
+            return nil
+        }
+
+        return CRTAWSEndpointResolvedEndpoint(rawValue: pointee)
+    }
+
+    deinit {
+        aws_endpoints_rule_engine_release(rawValue)
+    }
+}

Test/AwsCommonRuntimeKitTests/sdkutils/CRTAWSEndpointsRuleEngineTests.swift

@@ -0,0 +1,106 @@
+//  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+//  SPDX-License-Identifier: Apache-2.0.
+
+import XCTest
+import Foundation
+@testable import AwsCommonRuntimeKit
+
+class CRTAWSEndpointsRuleEngineTests: CrtXCBaseTestCase {
+    let ruleSetString =
+        """
+        {
+          "version": "1.0",
+          "serviceId": "example",
+          "parameters": {
+            "Region": {
+              "type": "string",
+              "builtIn": "AWS::Region",
+              "documentation": "The region to dispatch the request to"
+            }
+          },
+          "rules": [
+            {
+              "documentation": "rules for when region isSet",
+              "type": "tree",
+              "conditions": [
+                {
+                  "fn": "isSet",
+                  "argv": [
+                    {
+                      "ref": "Region"
+                    }
+                  ]
+                }
+              ],
+              "rules": [
+                {
+                  "type": "endpoint",
+                  "conditions": [
+                    {
+                      "fn": "aws.partition",
+                      "argv": [
+                        {
+                          "ref": "Region"
+                        }
+                      ],
+                      "assign": "partitionResult"
+                    }
+                  ],
+                  "endpoint": {
+                    "url": "https://example.{Region}.{partitionResult#dnsSuffix}"
+                  }
+                },
+                {
+                  "type": "error",
+                  "documentation": "invalid region value",
+                  "conditions": [],
+                  "error": "unable to determine endpoint for region: {Region}"
+                }
+              ]
+            },
+            {
+              "type": "endpoint",
+              "documentation": "the single service global endpoint",
+              "conditions": [],
+              "endpoint": {
+                "url": "https://example.amazonaws.com"
+              }
+            }
+          ]
+        }
+        """
+
+    func testResolve() throws {
+        let engine = try CRTAWSEndpointsRuleEngine(ruleSetString: ruleSetString)
+        let context = try CRTAWSEndpointsRequestContext()
+        try context.add(name: "Region", value: "us-west-2")
+        let endpoint = try engine.resolve(context: context)
+        let url = try endpoint?.getURL()
+        XCTAssertNotNil(url)
+        XCTAssertEqual("https://example.us-west-2.amazonaws.com", url!)
+    }
+
+    func testRuleSetParsingPerformance() {
+        measure {
+            _ = try! CRTAWSEndpointsRuleEngine(ruleSetString: ruleSetString)
+        }
+    }
+
+    func testRuleSetEvaluationPerformance() {
+        let engine = try! CRTAWSEndpointsRuleEngine(ruleSetString: ruleSetString)
+        let context = try! CRTAWSEndpointsRequestContext()
+        try! context.add(name: "Region", value: "us-west-2")
+        measure {
+            let _ = try! engine.resolve(context: context)
+        }
+    }
+
+    func testResolvePerformance() {
+        measure {
+            let engine = try! CRTAWSEndpointsRuleEngine(ruleSetString: ruleSetString)
+            let context = try! CRTAWSEndpointsRequestContext()
+            try! context.add(name: "Region", value: "us-west-2")
+            let _ = try! engine.resolve(context: context)
+        }
+    }
+}