kn: prepare for release (#1421)

Author: aws-sdk-kotlin-ci

gradle/libs.versions.toml

@@ -2,7 +2,7 @@
 kotlin-version = "2.2.0"
 dokka-version = "2.0.0"
 
-aws-kotlin-repo-tools-version = "0.4.51"
+aws-kotlin-repo-tools-version = "0.4.56"
 
 # libs
 coroutines-version = "1.10.2"
@@ -13,7 +13,7 @@ okio-version = "3.16.0"
 otel-version = "1.52.0"
 slf4j-version = "2.0.17"
 slf4j-v1x-version = "1.7.36"
-crt-kotlin-version = "0.10.3"
+crt-kotlin-version = "0.11.5"
 micrometer-version = "1.15.2"
 binary-compatibility-validator-version = "0.18.1"
 kotlin-multiplatform-bignum-version = "0.3.10"

runtime/runtime-core/build.gradle.kts

@@ -4,11 +4,8 @@
  */
 
 import aws.sdk.kotlin.gradle.kmp.NATIVE_ENABLED
-import aws.sdk.kotlin.gradle.util.typedProp
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
 import org.jetbrains.kotlin.konan.target.HostManager
-import java.nio.file.Files
-import java.nio.file.Paths
 
 plugins {
     alias(libs.plugins.kotlinx.serialization)
@@ -69,64 +66,4 @@ kotlin {
             }
         }
     }
-
-    if (NATIVE_ENABLED && HostManager.hostIsMingw) {
-        mingwX64 {
-            val mingwHome = findMingwHome()
-            val defPath = layout.buildDirectory.file("cinterop/winver.def")
-
-            // Dynamically construct def file because of dynamic mingw paths
-            val defFileTask by tasks.registering {
-                outputs.file(defPath)
-
-                val mingwLibs = Paths.get(mingwHome, "lib").toString().replace("\\", "\\\\") // Windows path shenanigans
-
-                doLast {
-                    Files.writeString(
-                        defPath.get().asFile.toPath(),
-                        """
-                            package = aws.smithy.kotlin.native.winver
-                            headers = windows.h
-                            compilerOpts = \
-                                -DUNICODE \
-                                -DWINVER=0x0601 \
-                                -D_WIN32_WINNT=0x0601 \
-                                -DWINAPI_FAMILY=3 \
-                                -DOEMRESOURCE \
-                                -Wno-incompatible-pointer-types \
-                                -Wno-deprecated-declarations
-                            libraryPaths = $mingwLibs
-                            staticLibraries = libversion.a
-                        """.trimIndent(),
-                    )
-                }
-            }
-            compilations["main"].cinterops {
-                create("winver") {
-                    val mingwIncludes = Paths.get(mingwHome, "include").toString()
-                    includeDirs(mingwIncludes)
-                    definitionFile.set(defPath)
-
-                    // Ensure that the def file is written first
-                    tasks[interopProcessingTaskName].dependsOn(defFileTask)
-                }
-            }
-
-            // TODO clean up
-            val compilerArgs = listOf(
-                "-Xverbose-phases=linker", // Enable verbose linking phase from the compiler
-                "-linker-option",
-                "-v",
-            )
-            compilerOptions.freeCompilerArgs.addAll(compilerArgs)
-        }
-    }
 }
-
-private fun findMingwHome(): String =
-    System.getenv("MINGW_PREFIX")?.takeUnless { it.isBlank() }
-        ?: typedProp("mingw.prefix")
-        ?: throw IllegalStateException(
-            "Cannot determine MinGW prefix location. Please verify MinGW is installed correctly " +
-                "and that either the `MINGW_PREFIX` environment variable or the `mingw.prefix` Gradle property is set.",
-        )

runtime/runtime-core/mingw/src/aws/smithy/kotlin/runtime/net/DefaultHostResolverMingw.kt

@@ -5,18 +5,19 @@
 
 package aws.smithy.kotlin.runtime.util
 
-import aws.smithy.kotlin.native.winver.*
+import aws.sdk.kotlin.crt.util.osVersionFromKernel
 import kotlinx.cinterop.*
 import platform.posix.environ
-import platform.posix.memcpy
 
 public actual object SystemDefaultProvider : SystemDefaultProviderBase() {
     actual override val filePathSeparator: String = "\\"
+
+    // FIXME We currently get the OS info by parsing from Kernel32.dll. Is there a less hacky way we can do this?
     actual override fun osInfo(): OperatingSystem = OperatingSystem(OsFamily.Windows, osVersionFromKernel())
 
     actual override fun getAllEnvVars(): Map<String, String> = memScoped {
         generateSequence(0) { it + 1 }
-            .map { idx -> environ.get(idx)?.toKString() }
+            .map { idx -> environ?.get(idx)?.toKString() }
             .takeWhile { it != null }
             .associate { env ->
                 val parts = env?.split("=", limit = 2)
@@ -25,87 +26,3 @@ public actual object SystemDefaultProvider : SystemDefaultProviderBase() {
             }
     }
 }
-
-// The functions below are adapted from C++ SDK:
-// https://github.com/aws/aws-sdk-cpp/blob/0e6085bf0dd9a1cb1f27d101c4cf2db6ade6f307/src/aws-cpp-sdk-core/source/platform/windows/OSVersionInfo.cpp#L49-L106
-
-private val wordHexFormat = HexFormat {
-    upperCase = false
-    number {
-        removeLeadingZeros = true
-        minLength = 4
-    }
-}
-
-private data class LangCodePage(
-    val language: UShort,
-    val codePage: UShort,
-)
-
-private fun osVersionFromKernel(): String? = memScoped {
-    withFileVersionInfo("Kernel32.dll") { versionInfoPtr ->
-        getLangCodePage(versionInfoPtr)?.let { langCodePage ->
-            getProductVersion(versionInfoPtr, langCodePage)
-        }
-    }
-}
-
-private inline fun <R> withFileVersionInfo(fileName: String, block: (CPointer<ByteVarOf<Byte>>) -> R?): R? {
-    val blobSize = GetFileVersionInfoSizeW(fileName, null)
-    val blob = ByteArray(blobSize.convert())
-    blob.usePinned { pinned ->
-        val result = GetFileVersionInfoW(fileName, 0u, blobSize, pinned.addressOf(0))
-        return if (result == 0) {
-            null
-        } else {
-            block(pinned.addressOf(0))
-        }
-    }
-}
-
-private fun MemScope.getLangCodePage(versionInfoPtr: CPointer<ByteVarOf<Byte>>): LangCodePage? {
-    // Get _any_ language pack and codepage since they should all have the same version
-    val langAndCodePagePtr = alloc<COpaquePointerVar>()
-    val codePageSize = alloc<UIntVar>()
-    val result = VerQueryValueW(
-        versionInfoPtr,
-        """\VarFileInfo\Translation""",
-        langAndCodePagePtr.ptr,
-        codePageSize.ptr,
-    )
-
-    return if (result == 0) {
-        null
-    } else {
-        val langAndCodePage = langAndCodePagePtr.value!!.reinterpret<UIntVar>().pointed.value
-        val language = (langAndCodePage and 0x0000ffffu).toUShort() // low WORD
-        val codePage = (langAndCodePage and 0xffff0000u shr 16).toUShort() // high WORD
-        LangCodePage(language, codePage)
-    }
-}
-
-private fun MemScope.getProductVersion(versionInfoPtr: CPointer<ByteVarOf<Byte>>, langCodePage: LangCodePage): String? {
-    val versionId = buildString {
-        // Something like: \StringFileInfo\04090fb0\ProductVersion
-        append("""\StringFileInfo\""")
-        append(langCodePage.language.toHexString(wordHexFormat))
-        append(langCodePage.codePage.toHexString(wordHexFormat))
-        append("""\ProductVersion""")
-    }
-
-    // Get the block corresponding to versionId
-    val block = alloc<COpaquePointerVar>()
-    val blockSize = alloc<UIntVar>()
-    val result = VerQueryValueW(versionInfoPtr, versionId, block.ptr, blockSize.ptr)
-
-    return if (result == 0) {
-        null
-    } else {
-        // Copy the bytes into a Kotlin byte array
-        val blockBytes = ByteArray(blockSize.value.convert())
-        blockBytes.usePinned { pinned ->
-            memcpy(pinned.addressOf(0), block.value!!.reinterpret<ByteVar>(), blockSize.value.convert())
-        }
-        blockBytes.decodeToString()
-    }
-}

runtime/runtime-core/mingw/src/aws/smithy/kotlin/runtime/util/SystemDefaultProviderMingw.kt

@@ -13,7 +13,6 @@ class SystemPlatformProviderMingwTest {
     @Test
     fun testOsInfo() = runTest {
         val osInfo = PlatformProvider.System.osInfo()
-        println(osInfo)
         assertEquals(OsFamily.Windows, osInfo.family)
         assertNotNull(osInfo.version)
     }

runtime/runtime-core/mingw/test/aws/smithy/kotlin/runtime/util/SystemPlatformProviderMingwTest.kt

@@ -0,0 +1,26 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package aws.smithy.kotlin.runtime.net
+
+import aws.sdk.kotlin.crt.io.CrtHostAddress
+import aws.sdk.kotlin.crt.use
+import aws.sdk.kotlin.crt.io.HostResolver as CrtHostResolver
+
+internal actual object DefaultHostResolver : HostResolver {
+    actual override suspend fun resolve(hostname: String): List<HostAddress> {
+        val results = CrtHostResolver().use {
+            it.resolve(hostname)
+        }
+        return results.map { it.toHostAddress() }
+    }
+
+    // No-op, matches JVM implementation
+    actual override fun purgeCache(addr: HostAddress?) { }
+
+    // No-op, matches JVM implementation
+    actual override fun reportFailure(addr: HostAddress) { }
+
+    private fun CrtHostAddress.toHostAddress() = HostAddress(host, IpAddr.parse(address))
+}

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

@@ -19,6 +19,7 @@ public abstract class SystemDefaultProviderBase : PlatformProvider {
             val size = memScoped {
                 val statResult = alloc<stat>()
                 if (stat(path, statResult.ptr) != 0) return@withContext null
+                @OptIn(UnsafeNumber::class)
                 statResult.st_size.convert<Int>()
             }