Multiplatform

build.gradle.kts

@@ -1,57 +1,41 @@
-apply {
-    from("https://raw.githubusercontent.com/ligi/gradle-common/master/versions_plugin_stable_only.gradle")
-}
-
-buildscript {
-    repositories {
-        jcenter()
-        maven("https://jitpack.io")
-    }
-
-    dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${Versions.kotlin}")
-        classpath("com.github.ben-manes:gradle-versions-plugin:${Versions.versions_plugin}")
-    }
-}
-
-
-subprojects {
-    repositories {
-        jcenter()
-        maven("https://jitpack.io")
-        maven("https://kotlin.bintray.com/kotlinx")
-    }
-
-    apply(plugin = "jacoco")
-    apply(plugin = "maven")
-    apply(plugin = "kotlin")
-
-    tasks.withType<Test> {
-        useJUnitPlatform()
-    }
-
-    configure<JavaPluginExtension> {
-        withSourcesJar()
-        withJavadocJar()
-    }
-
-    afterEvaluate {
-
-        dependencies {
-            "implementation"("org.jetbrains.kotlin:kotlin-stdlib:${Versions.kotlin}")
-
-            "testImplementation"("org.assertj:assertj-core:3.22.0")
-            "testImplementation"("org.junit.jupiter:junit-jupiter-api:${Versions.jupiter}")
-            "testImplementation"("org.junit.jupiter:junit-jupiter-params:${Versions.jupiter}")
-            "testRuntime"("org.junit.jupiter:junit-jupiter-engine:${Versions.jupiter}")
-
-            "testImplementation"("org.jetbrains.kotlin:kotlin-test")
-            "testImplementation"("io.mockk:mockk:1.12.0")
-        }
-
-
-    }
-    val compileTestKotlin by tasks.getting(org.jetbrains.kotlin.gradle.tasks.KotlinCompile::class) {
-        kotlinOptions.jvmTarget = "1.8"
-    }
-}
+//apply {
+//    from("https://raw.githubusercontent.com/ligi/gradle-common/master/versions_plugin_stable_only.gradle")
+//}
+
+
+//subprojects {
+//    repositories {
+//        mavenCentral()
+//        maven("https://jitpack.io")
+//        maven("https://kotlin.bintray.com/kotlinx")
+//    }
+//
+//    tasks.withType<Test> {
+//        useJUnitPlatform()
+//    }
+//
+//    configure<JavaPluginExtension> {
+//        withSourcesJar()
+//        withJavadocJar()
+//    }
+//
+//    afterEvaluate {
+//
+//        dependencies {
+//            "implementation"("org.jetbrains.kotlin:kotlin-stdlib:${Versions.kotlin}")
+//
+//            "testImplementation"("org.assertj:assertj-core:3.22.0")
+//            "testImplementation"("org.junit.jupiter:junit-jupiter-api:${Versions.jupiter}")
+//            "testImplementation"("org.junit.jupiter:junit-jupiter-params:${Versions.jupiter}")
+//            "testImplementation"("org.junit.jupiter:junit-jupiter-engine:${Versions.jupiter}")
+//
+//            "testImplementation"("org.jetbrains.kotlin:kotlin-test")
+//            "testImplementation"("io.mockk:mockk:1.12.4")
+//        }
+//
+//
+//    }
+////    val compileTestKotlin by tasks.getting(org.jetbrains.kotlin.gradle.tasks.KotlinCompile::class) {
+////        kotlinOptions.jvmTarget = "1.8"
+////    }
+//}

buildSrc/src/main/kotlin/Versions.kt

@@ -1,5 +1,10 @@
 object Versions {
-    const val kotlin = "1.3.72"
+    const val kotlin = "1.7.10"
+    const val serialization= "1.3.3"
     const val versions_plugin = "0.28.0"
     const val jupiter = "5.6.2"
+    const val okhttp = "4.10.0"
+    const val coroutines = "1.6.4"
+    const val ktor = "2.1.0"
+    const val okio = "3.2.0"
 }

example/build.gradle.kts

@@ -1,11 +1,12 @@
 plugins {
+    kotlin("jvm")
     application
 }
 
 application {
-    mainClassName = "org.kethereum.example_cli.ExampleCLIKt"
+    mainClass.set("io.ipfs.example_cli.ExampleCLIKt")
 }
 
 dependencies {
-    implementation(project(":lib"))
+    implementation(project(":ipfs-api"))
 }

example/src/main/kotlin/io/ipfs/example_cli/ExampleInfuraCLI.kt

@@ -0,0 +1,25 @@
+package io.ipfs.example_cli
+
+import io.ipfs.kotlin.commands.AddProgress
+import io.ipfs.kotlin.commands.UploadProgress
+import io.ipfs.kotlin.defaults.InfuraIPFS
+import kotlinx.coroutines.runBlocking
+import okio.Path.Companion.toOkioPath
+import java.io.File
+
+fun main(args: Array<String>) = runBlocking {
+    require(args.size == 3)
+    val projectId = args[0]
+    val projectSecret = args[1]
+    val filePath = args[2]
+    val ipfs = InfuraIPFS(projectId, projectSecret)
+    println(ipfs.info.version())
+    println(
+        ipfs.add.file(
+            File(filePath).toOkioPath()
+        ) { uploadProgress: UploadProgress?, addProgress: AddProgress? ->
+            uploadProgress?.let { println(it) }
+            addProgress?.let { println(it) }
+        }
+    )
+}

gradle.properties

@@ -0,0 +1,3 @@
+kotlin.code.style=official
+
+kotlin.native.binary.memoryModel=experimental

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.4-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.5.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

ipfs-api/build.gradle.kts

@@ -0,0 +1,114 @@
+plugins {
+    kotlin("multiplatform")
+    kotlin("plugin.serialization")
+    id("jacoco")
+    id("com.github.ben-manes.versions")
+    id("maven-publish")
+}
+
+group = "com.github.ligi"
+version = "0.16"
+
+
+repositories {
+    mavenCentral()
+}
+
+kotlin {
+    val darwinTargets = arrayOf(
+        "macosX64", "macosArm64",
+        "iosArm64", "iosX64", "iosSimulatorArm64",
+        "tvosArm64", "tvosX64", "tvosSimulatorArm64",
+        "watchosArm32", "watchosArm64", "watchosX86", "watchosX64", "watchosSimulatorArm64",
+    )
+    val linuxTargets = arrayOf("linuxX64", /*"linuxArm64"*/)
+    val mingwTargets = arrayOf("mingwX64")
+    val nativeTargets = linuxTargets + darwinTargets + mingwTargets
+
+    jvm {
+        compilations.all {
+            kotlinOptions.jvmTarget = "11"
+        }
+    }
+    js(IR) {
+        nodejs()
+    }
+    for (target in nativeTargets) {
+        targets.add(presets.getByName(target).createTarget(target))
+    }
+    sourceSets {
+        val commonMain by getting {
+            dependencies {
+                implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:${Versions.serialization}")
+                api("io.ktor:ktor-client-core:${Versions.ktor}")
+                implementation("io.ktor:ktor-client-content-negotiation:${Versions.ktor}")
+                implementation("io.ktor:ktor-serialization-kotlinx-json:${Versions.ktor}")
+                api("com.squareup.okio:okio:${Versions.okio}")
+            }
+        }
+        val commonTest by getting {
+            dependencies {
+                implementation(kotlin("test"))
+                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:${Versions.coroutines}")
+                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:${Versions.coroutines}")
+            }
+        }
+
+        val jvmMain by getting {
+            dependsOn(commonMain)
+            dependencies {
+                implementation("io.ktor:ktor-client-okhttp:${Versions.ktor}")
+            }
+        }
+
+        val jsMain by getting {
+            dependsOn(commonMain)
+            dependencies {
+                implementation("io.ktor:ktor-client-js:${Versions.ktor}")
+                implementation("com.squareup.okio:okio-nodefilesystem:${Versions.okio}")
+            }
+        }
+
+
+        val jvmTest by getting {
+            dependencies {
+                implementation("org.mockito:mockito-core:4.5.1")
+                implementation("com.squareup.okhttp3:mockwebserver:${Versions.okhttp}")
+                implementation("org.assertj:assertj-core:3.22.0")
+            }
+        }
+        val nativeMain by creating {
+            dependsOn(commonMain)
+        }
+
+        val darwinMain by creating {
+            dependsOn(nativeMain)
+            dependencies {
+                implementation("io.ktor:ktor-client-darwin:${Versions.ktor}")
+            }
+        }
+        darwinTargets.forEach { target ->
+            getByName("${target}Main") {
+                dependsOn(darwinMain)
+            }
+        }
+        val linuxAndMingwMain by creating {
+            dependsOn(nativeMain)
+            dependencies {
+                implementation("io.ktor:ktor-client-curl:${Versions.ktor}")
+            }
+        }
+        (mingwTargets + linuxTargets).forEach { target ->
+            getByName("${target}Main") {
+                dependsOn(linuxAndMingwMain)
+            }
+        }
+
+    }
+}
+
+tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
+    kotlinOptions {
+        jvmTarget = "11"
+    }
+}

lib/src/main/kotlin/io/ipfs/kotlin/IPFS.kt → ipfs-api/src/commonMain/kotlin/io/ipfs/kotlin/IPFS.kt

@@ -1,15 +1,23 @@
 package io.ipfs.kotlin
 
-import com.squareup.moshi.Moshi
 import io.ipfs.kotlin.commands.*
-import io.ipfs.kotlin.defaults.createMoshi
-import io.ipfs.kotlin.defaults.createOKHTTP
+import io.ipfs.kotlin.defaults.createFileSystem
+import io.ipfs.kotlin.defaults.createKTOR
 import io.ipfs.kotlin.model.MessageWithCode
-import okhttp3.OkHttpClient
+import io.ktor.client.*
+import okio.FileSystem
 
-data class IPFSConfiguration(val base_url: String = "http://127.0.0.1:5001/api/v0/",
-                             val okHttpClient: OkHttpClient = createOKHTTP(),
-                             val moshi: Moshi = createMoshi())
+data class IPFSConfiguration(
+    val base_url: String = "http://127.0.0.1:5001/api/v0/",
+    val ktorClient: HttpClient = createKTOR(),
+    val fileSystem: FileSystem = createFileSystem(),
+    val basicAuthCredentials: BasicAuth? = null
+) {
+    class BasicAuth(
+        val username: String,
+        val password: String
+    )
+}
 
 open class IPFS(configuration: IPFSConfiguration) {
 

ipfs-api/src/commonMain/kotlin/io/ipfs/kotlin/IPFSConnection.kt

@@ -0,0 +1,40 @@
+package io.ipfs.kotlin
+
+import io.ipfs.kotlin.model.MessageWithCode
+import io.ktor.client.request.*
+import io.ktor.client.statement.*
+import io.ktor.http.*
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.json.Json
+
+open class IPFSConnection(val config: IPFSConfiguration) {
+
+    var lastError: MessageWithCode? = null
+
+    private fun buildRequest(cmd: String, block: HttpRequestBuilder.() -> Unit = {}): HttpRequestBuilder {
+        val request = HttpRequestBuilder().apply {
+            url(config.base_url + cmd)
+            contentType(ContentType.Any)
+            config.basicAuthCredentials?.apply {
+                basicAuth(username, password)
+            }
+            block()
+        }
+
+        return request
+    }
+
+    suspend fun callCmd(cmd: String): HttpResponse {
+        val request = buildRequest(cmd)
+        return config.ktorClient.post(request)
+    }
+
+    suspend fun prepareCallCmd(cmd: String, block: HttpRequestBuilder.() -> Unit = {}): HttpStatement {
+        val request = buildRequest(cmd, block)
+        return config.ktorClient.preparePost(request)
+    }
+
+    fun setErrorByJSON(jsonString: String) {
+        lastError = Json.decodeFromString(jsonString)
+    }
+}