Address PR feedback. Use shared configureIosSimulatorTasks

Author: lauzadis

gradle/libs.versions.toml

@@ -2,7 +2,7 @@
 kotlin-version = "2.1.0"
 dokka-version = "1.9.10"
 
-aws-kotlin-repo-tools-version = "0.4.21-kn"
+aws-kotlin-repo-tools-version = "0.4.22-kn"
 
 # libs
 coroutines-version = "1.9.0"

runtime/build.gradle.kts

@@ -7,8 +7,6 @@ import aws.sdk.kotlin.gradle.kmp.*
 import aws.sdk.kotlin.gradle.util.typedProp
 import org.gradle.kotlin.dsl.withType
 import org.jetbrains.kotlin.gradle.dsl.JvmTarget
-import org.jetbrains.kotlin.gradle.targets.native.tasks.KotlinNativeSimulatorTest
-import org.jetbrains.kotlin.konan.target.HostManager
 
 plugins {
     alias(libs.plugins.dokka)
@@ -70,49 +68,6 @@ subprojects {
                 }
             }
         }
-
-        // disable "standalone" mode in simulator tests since it causes TLS issues. this means we need to manage the simulator
-        // ourselves (booting / shutting down). FIXME: https://youtrack.jetbrains.com/issue/KT-38317
-        val simulatorDeviceName = project.findProperty("iosSimulatorDevice") as? String ?: "iPhone 15"
-
-        val xcrun = "/usr/bin/xcrun"
-
-        tasks.register<Exec>("bootIosSimulatorDevice") {
-            isIgnoreExitValue = true
-            commandLine(xcrun, "simctl", "boot", simulatorDeviceName)
-
-            doLast {
-                val result = executionResult.get()
-                val code = result.exitValue
-                if (code != 148 && code != 149) { // ignore "simulator already running" errors
-                    result.assertNormalExitValue()
-                }
-            }
-        }
-
-        tasks.register<Exec>("shutdownIosSimulatorDevice") {
-            mustRunAfter(tasks.withType<KotlinNativeSimulatorTest>())
-            commandLine(xcrun, "simctl", "shutdown", simulatorDeviceName)
-
-            doLast {
-                val result = executionResult.get()
-                if (result.exitValue != 405) {
-                    result.assertNormalExitValue()
-                }
-            }
-        }
-
-        tasks.withType<KotlinNativeSimulatorTest>().configureEach {
-            if (!HostManager.hostIsMac) {
-                return@configureEach
-            }
-
-            dependsOn("bootIosSimulatorDevice")
-            finalizedBy("shutdownIosSimulatorDevice")
-
-            standalone = false
-            device = simulatorDeviceName
-        }
     }
 
     kotlin.sourceSets.all {
@@ -157,4 +112,6 @@ subprojects {
             }
         }
     }
+
+    configureIosSimulatorTasks()
 }

runtime/runtime-core/common/test/aws/smithy/kotlin/runtime/net/HostResolverTest.kt

@@ -15,20 +15,12 @@ class HostResolverTest {
 
         addresses.forEach { addr ->
             assertEquals("localhost", addr.hostname)
-            when (val ip = addr.address) {
-                is IpV4Addr -> {
-                    assertEquals(4, ip.octets.size)
-                    // localhost should resolve to 127.0.0.1
-                    assertContentEquals(byteArrayOf(127, 0, 0, 1), ip.octets)
-                }
-                is IpV6Addr -> {
-                    assertEquals(16, ip.octets.size)
-                    // ::1 in IPv6
-                    val expectedIpv6 = ByteArray(16) { 0 }
-                    expectedIpv6[15] = 1
-                    assertContentEquals(expectedIpv6, ip.octets)
-                }
+
+            val localHostAddr = when (addr.address) {
+                is IpV4Addr -> IpV4Addr.LOCALHOST
+                is IpV6Addr -> IpV6Addr.LOCALHOST
             }
+            assertEquals(addr.address, localHostAddr)
         }
     }
 

runtime/runtime-core/native/src/aws/smithy/kotlin/runtime/net/HostResolverNative.kt

@@ -17,51 +17,39 @@ internal actual object DefaultHostResolver : HostResolver {
 
         val result = allocPointerTo<addrinfo>()
 
-        // Perform the DNS lookup
-        val status = getaddrinfo(hostname, null, hints.ptr, result.ptr)
-        if (status != 0) {
-            throw RuntimeException("Failed to resolve host $hostname: ${gai_strerror(status)?.toKString()}")
+        try {
+            // Perform the DNS lookup
+            val status = getaddrinfo(hostname, null, hints.ptr, result.ptr)
+            check (status == 0) { "Failed to resolve host $hostname: ${gai_strerror(status)?.toKString()}" }
+
+            return generateSequence(result.value) { it.pointed.ai_next }
+                .map { it.pointed.ai_addr!!.pointed.toIpAddr() }
+                .map { HostAddress(hostname, it) }
+                .toList()
+        } finally {
+            freeaddrinfo(result.value)
         }
+    }
 
-        val addresses = mutableListOf<HostAddress>()
-        var current = result.value
-
-        while (current != null) {
-            val sockaddr = current.pointed.ai_addr!!.pointed
-
-            @OptIn(UnsafeNumber::class)
-            when (sockaddr.sa_family.toInt()) {
-                AF_INET -> {
-                    val addr = sockaddr.reinterpret<sockaddr_in>()
-                    val ipBytes = ByteArray(4)
-                    memcpy(ipBytes.refTo(0), addr.sin_addr.ptr, 4uL)
-
-                    addresses.add(
-                        HostAddress(
-                            hostname = hostname,
-                            address = IpV4Addr(ipBytes),
-                        ),
-                    )
-                }
-                AF_INET6 -> {
-                    val addr = sockaddr.reinterpret<sockaddr_in6>()
-                    val ipBytes = ByteArray(16)
-                    memcpy(ipBytes.refTo(0), addr.sin6_addr.ptr, 16.convert())
-                    addresses.add(
-                        HostAddress(
-                            hostname = hostname,
-                            address = IpV6Addr(ipBytes),
-                        ),
-                    )
-                }
-            }
-            current = current.pointed.ai_next
+    @OptIn(UnsafeNumber::class)
+    private fun sockaddr.toIpAddr(): IpAddr {
+        val (size, addrPtr, constructor) = when (sa_family.toInt()) {
+            AF_INET -> Triple(
+                4,
+                reinterpret<sockaddr_in>().sin_addr.ptr,
+                { bytes: ByteArray -> IpV4Addr(bytes) },
+            )
+            AF_INET6 -> Triple(
+                16,
+                reinterpret<sockaddr_in6>().sin6_addr.ptr,
+                { bytes: ByteArray -> IpV6Addr(bytes) },
+            )
+            else -> throw IllegalArgumentException("Unsupported sockaddr family $sa_family")
         }
 
-        // Free the getaddrinfo results
-        freeaddrinfo(result.value)
-
-        addresses
+        val ipBytes = ByteArray(size)
+        memcpy(ipBytes.refTo(0), addrPtr, size.toULong())
+        return constructor(ipBytes)
     }
 
     actual override fun reportFailure(addr: HostAddress) {