bootstrap JVM bindings

Author: aajtodd

.editorconfig

@@ -0,0 +1,3 @@
+[*.{kt,kts}]
+# ktlint rules to disable
+disabled_rules=no-wildcard-imports,filename

.github/workflows/ci.yaml

@@ -0,0 +1,38 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - '*'
+      - '!main'
+
+env:
+  BUILDER_VERSION: v0.7.7
+  BUILDER_SOURCE: releases
+  BUILDER_HOST: https://d19elf31gohf1l.cloudfront.net
+  PACKAGE_NAME: aws-crt-kotlin
+  LINUX_BASE_IMAGE: ubuntu-16-x64
+  RUN: ${{ github.run_id }}-${{ github.run_number }}
+
+jobs:
+  linux-compat:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        image:
+          - manylinux2014-x64
+          #- manylinux2014-x86 until we find 32-bit linux binaries we can use
+    steps:
+        # We can't use the `uses: docker://image` version yet, GitHub lacks authentication for actions -> packages
+    - name: Checkout Sources
+      uses: actions/checkout@v2
+      with:
+        submodules: true
+    - name: Build ${{ env.PACKAGE_NAME }}
+      run: |
+        echo "${{ secrets.GITHUB_TOKEN }}" | docker login docker.pkg.github.com -u awslabs --password-stdin
+        export DOCKER_IMAGE=docker.pkg.github.com/awslabs/aws-crt-builder/aws-crt-${{ matrix.image }}:${{ env.BUILDER_VERSION }}
+        docker pull $DOCKER_IMAGE
+        docker run --mount type=bind,source=$(pwd),target=/root/${{ env.PACKAGE_NAME }} \
+          --env GITHUB_REF $DOCKER_IMAGE build -p ${{ env.PACKAGE_NAME }} --build-dir=/root/${{ env.PACKAGE_NAME }} --spec=downstream
+

.gitignore

@@ -0,0 +1,13 @@
+.DS_Store
+/dist
+/ideaSDK
+/android-studio/sdk
+out/
+/tmp
+workspace.xml
+*.versionsBackup
+.gradle/
+build/
+*.iml
+.idea/
+local.properties

README.md

@@ -1,13 +1,66 @@
-## My Project
+## AWS CRT Kotlin
 
-TODO: Fill this README out!
+Kotlin bindings to the AWS Common Runtime
 
-Be sure to:
+[![License][apache-badge]][apache-url]
 
-* Change the title in this README
-* Edit your repository description on GitHub
+[apache-badge]: https://img.shields.io/badge/License-Apache%202.0-blue.svg
+[apache-url]: LICENSE
 
 ## License
 
 This project is licensed under the Apache-2.0 License.
 
+## Building
+
+Kotlin Multiplatform projects are in [Alpha](https://kotlinlang.org/docs/reference/evolution/components-stability.html). The CRT interfaces are subject to change.
+
+### Linux/Unix
+Install some version of libcrypto on which s2n depends. See the [s2n](https://github.com/awslabs/s2n) documentation.
+
+```
+apt-get install libssl-dev
+```
+
+Set the path to `libcrypto.a` either as a command line argument to gradle `-PlibcryptoPath=PATH` or in your `local.properties` file.
+
+
+### OSX
+
+
+### Windows
+
+
+## Elasticurl App
+
+The `elasticurl` project contains an MPP (JVM and Native only) executable that provides a simple testing application for exercising the CRT bindings. 
+
+**Native**
+
+```
+# replace "PLATFORM" with the target platform you want to run (e.g. macosX64, linuxX64, etc)
+
+./elasticurl/bin/PLATFORM/elasticurl.kexe [OPTIONS] URL
+```
+
+
+**JVM**
+```
+java -jar ./elasticurl/libs/elasticurl-jvm.jar [OPTIONS] URL
+```
+
+NOTE: You can also use the convenience script `./scripts/elasticurlJvm.sh [OPTIONS] URL`
+
+To enable memory tracing specify the environment variable `CRTDEBUG=trace=N` and provide the CLI option `-v trace`
+
+e.g.
+```
+CRTDEBUG=trace=2 ./elasticurl/bin/macosX64/elasticurl.kexe -v trace https://aws.amazon.com
+```
+
+
+**Integration Test**
+
+Run the simple elasticurl integration test script
+
+`./scripts/elasticurl-test.sh`

build.gradle.kts

@@ -0,0 +1,132 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+import org.jetbrains.kotlin.konan.target.HostManager
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
+import java.util.Properties
+
+plugins {
+    kotlin("multiplatform") version "1.4.21"
+    `maven`
+    `maven-publish`
+}
+
+group = "software.amazon.awssdk.crt"
+version = "0.1.0-SNAPSHOT"
+description = "Kotlin Multiplatform bindings for AWS SDK Common Runtime"
+
+allprojects {
+    repositories {
+        mavenLocal()
+        mavenCentral()
+        jcenter()
+        maven ("https://dl.bintray.com/kotlin/kotlin-eap")
+        maven ("https://kotlin.bintray.com/kotlinx")
+    }
+}
+
+// See: https://kotlinlang.org/docs/reference/opt-in-requirements.html#opting-in-to-using-api
+val experimentalAnnotations = listOf("kotlin.RequiresOptIn")
+
+
+kotlin {
+    explicitApi()
+
+    jvm()
+
+    val kotlinVersion: String by project
+    val coroutinesVersion: String by project
+
+    sourceSets {
+        val commonMain by getting {
+            dependencies {
+                implementation(kotlin("stdlib-common"))
+                // native multithreading support for coroutines is not stable...
+                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutinesVersion-native-mt")
+            }
+        }
+        val commonTest by getting {
+            dependencies {
+                implementation(kotlin("test-common"))
+                implementation(kotlin("test-annotations-common"))
+            }
+        }
+
+        val jvmMain by getting {
+            dependencies {
+                api("org.jetbrains.kotlin:kotlin-stdlib")
+                val crtJavaVersion: String by project
+                implementation("software.amazon.awssdk.crt:aws-crt:$crtJavaVersion")
+
+                // FIXME - temporary integration with CompletableFuture while we work out a POC on the jvm target
+                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-jdk8:$coroutinesVersion")
+            }
+        }
+
+        val jvmTest by getting {
+            dependencies {
+                val junitVersion: String by project
+                api("org.jetbrains.kotlin:kotlin-test:$kotlinVersion")
+                api("org.jetbrains.kotlin:kotlin-test-junit5:$kotlinVersion")
+                implementation("org.junit.jupiter:junit-jupiter:$junitVersion")
+                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-debug:$coroutinesVersion")
+            }
+        }
+
+    }
+
+    sourceSets.all {
+        println("configuring source set $name")
+        val srcDir = if (name.endsWith("Main")) "src" else "test"
+        val resourcesPrefix = if (name.endsWith("Test")) "test-" else ""
+        // source set name should always be the platform followed by a suffix of either "Main" or "Test
+        // e.g. jvmMain, commonTest, etc
+        val platform = name.substring(0, name.length - 4)
+
+        kotlin.srcDir("src/$platform/$srcDir")
+        resources.srcDir("src/$platform/${resourcesPrefix}resources")
+        experimentalAnnotations.forEach { languageSettings.useExperimentalAnnotation(it) }
+    }
+}
+
+// have to configure JVM test task to use junit platform when using junit5
+val jvmTest: Test by tasks
+jvmTest.apply {
+    testLogging {
+        events("passed", "skipped", "failed")
+        showStandardStreams = true
+    }
+
+    useJUnitPlatform()
+}
+
+val ktlint by configurations.creating
+val ktlintVersion: String by project
+
+dependencies {
+    ktlint("com.pinterest:ktlint:$ktlintVersion")
+}
+
+val lintPaths = listOf(
+    "src/**/*.kt",
+    "elasticurl/**/*.kt"
+)
+
+tasks.register<JavaExec>("ktlint") {
+    description = "Check Kotlin code style."
+    group = "Verification"
+    classpath = configurations.getByName("ktlint")
+    main = "com.pinterest.ktlint.Main"
+    args = lintPaths
+}
+
+tasks.register<JavaExec>("ktlintFormat") {
+    description = "Auto fix Kotlin code style violations"
+    group = "formatting"
+    classpath = configurations.getByName("ktlint")
+    main = "com.pinterest.ktlint.Main"
+    args = listOf("-F") + lintPaths
+}
+
+tasks.check.get().dependsOn(":ktlint")

elasticurl/build.gradle.kts

@@ -0,0 +1,48 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+plugins {
+    kotlin("multiplatform")
+    application
+}
+
+
+kotlin {
+    jvm() {
+        withJava()
+        val jvmJar by tasks.getting(org.gradle.jvm.tasks.Jar::class) {
+            doFirst {
+                manifest {
+                    attributes["Main-Class"] = "ApplicationKt"
+                }
+                from(configurations.getByName("runtimeClasspath").map { if (it.isDirectory) it else zipTree(it) })
+            }
+        }
+    }
+
+    sourceSets {
+        commonMain {
+            dependencies {
+                val kotlinxCliVersion: String by project
+                val coroutinesVersion: String by project
+
+                implementation(kotlin("stdlib-common"))
+                implementation("org.jetbrains.kotlinx:kotlinx-cli:$kotlinxCliVersion")
+                implementation(project(":"))
+                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutinesVersion-native-mt")
+            }
+        }
+
+        val jvmMain by getting {
+            dependencies {
+                implementation("org.jetbrains.kotlin:kotlin-stdlib")
+            }
+        }
+    }
+}
+
+application {
+    mainClassName = "ApplicationKt"
+}