Implement linux target and actual implementations

Author: chippmann

sqliter-driver/build.gradle.kts

@@ -18,29 +18,30 @@ fun configInterop(target: org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTar
 val onWindows = org.jetbrains.kotlin.konan.target.HostManager.hostIsMingw
 
 kotlin {
-    val knTargets = listOf(
-        macosX64(),
-        iosX64(),
-        iosArm64(),
-        iosArm32(),
-        watchosArm32(),
-        watchosArm64(),
-        watchosX86(),
-        watchosX64(),
-        tvosArm64(),
-        tvosX64(),
-        mingwX64("mingw") {
-            compilations.forEach {
-                it.kotlinOptions.freeCompilerArgs += listOf("-linker-options", "-Lc:\\msys64\\mingw64\\lib")
-            }
-        }
-    )
+	val knTargets = listOf(
+		macosX64(),
+		iosX64(),
+		iosArm64(),
+		iosArm32(),
+		watchosArm32(),
+		watchosArm64(),
+		watchosX86(),
+		watchosX64(),tvosArm64(),
+		tvosX64(),
+		mingwX64("mingw") {
+			compilations.forEach {
+				it.kotlinOptions.freeCompilerArgs += listOf("-linker-options", "-Lc:\\msys64\\mingw64\\lib")
+			}
+		},
+		linuxX64()
+	)
 
-    knTargets.forEach { configInterop(it) }
+	knTargets.forEach { configInterop(it) }
 
     knTargets.forEach { target ->
-        val test by target.compilations.getting
-        test.kotlinOptions.freeCompilerArgs += listOf("-linker-options", "-lsqlite3")
+        configInterop(target)
+		val test by target.compilations.getting
+		test.kotlinOptions.freeCompilerArgs += listOf("-linker-options", "-lsqlite3", "-L/usr/lib")
     }
 
     sourceSets {
@@ -63,20 +64,32 @@ kotlin {
             dependsOn(nativeCommonMain)
         }
 
+		val linuxMain = sourceSets.maybeCreate("linuxX64Main").apply {
+			dependsOn(nativeCommonMain)
+		}
+
         val mingwMain = sourceSets.maybeCreate("mingwMain").apply {
             dependsOn(nativeCommonMain)
         }
         knTargets.forEach { target ->
-            if (target.name.startsWith("mingw")) {
-                target.compilations.getByName("main").source(mingwMain)
-                target.compilations.getByName("test").source(nativeCommonTest)
-            } else {
-                target.compilations.getByName("main").source(appleMain)
-                target.compilations.getByName("test").source(nativeCommonTest)
-            }
-        }
+            when {
+					target.name.startsWith("mingw") -> {
+						target.compilations.getByName("main").source(mingwMain)
+						target.compilations.getByName("test").source(nativeCommonTest)
+					}
+					target.name.startsWith("linux") -> {
+						target.compilations.getByName("main").source(linuxMain)
+						target.compilations.getByName("test").source(nativeCommonTest)
+					}
+					else -> {
+						target.compilations.getByName("main").source(appleMain)
+						target.compilations.getByName("test").source(nativeCommonTest)
+					}
+				}
 
-    }
+		}
+	}
 }
 
-apply(from = "../gradle/gradle-mvn-mpp-push.gradle")
+apply(from = "../gradle/gradle-mvn-mpp-push.gradle")
+

sqliter-driver/src/linuxX64Main/kotlin/co/touchlab/sqliter/DatabaseFileContext.kt

@@ -0,0 +1,61 @@
+package co.touchlab.sqliter
+
+import co.touchlab.sqliter.internal.File
+import co.touchlab.sqliter.internal.FileFilter
+import kotlinx.cinterop.memScoped
+import kotlinx.cinterop.refTo
+import kotlinx.cinterop.toKString
+import platform.posix.NULL
+import platform.posix.PATH_MAX
+import platform.posix.getcwd
+import platform.posix.getenv
+
+actual object DatabaseFileContext {
+    actual fun deleteDatabase(name: String, basePath: String?) {
+        deleteDatabaseFile(databaseFile(name, basePath))
+    }
+
+    actual fun databasePath(databaseName: String, datapathPath: String?): String {
+        return databaseFile(databaseName, datapathPath).path
+    }
+
+    internal fun databaseDirPath(): String {
+        return getHomeDirPath() ?: memScoped {
+            val buff = ByteArray(PATH_MAX)
+            if (getcwd(buff.refTo(0), buff.size.toULong()) != NULL) {
+                return buff.toKString()
+            }
+            throw IllegalStateException("Cannot get home dir or current dir")
+        }
+    }
+
+    internal fun getHomeDirPath(): String? = getenv("HOME")?.toKString()
+
+    internal fun databaseFile(databaseName: String, datapathPath: String?): File =
+        File(datapathPath ?: databaseDirPath(), databaseName)
+
+    internal fun deleteDatabaseFile(file: File): Boolean {
+        var deleted = false
+        deleted = deleted or file.delete()
+        deleted = deleted or File(file.getPath() + "-journal").delete()
+        deleted = deleted or File(file.getPath() + "-shm").delete()
+        deleted = deleted or File(file.getPath() + "-wal").delete()
+
+        //TODO: Implement file list
+        val dir = file.getParentFile()
+        if (dir != null) {
+            val prefix = file.getName() + "-mj"
+            val files = dir.listFiles(object : FileFilter {
+                override fun accept(candidate: File): Boolean {
+                    return candidate.getName().startsWith(prefix)
+                }
+            })
+            if (files != null) {
+                for (masterJournal in files) {
+                    deleted = deleted or masterJournal.delete()
+                }
+            }
+        }
+        return deleted
+    }
+}

sqliter-driver/src/linuxX64Main/kotlin/co/touchlab/sqliter/concurrency/Lock.kt

@@ -0,0 +1,44 @@
+package co.touchlab.sqliter.concurrency
+
+import kotlinx.cinterop.Arena
+import kotlinx.cinterop.alloc
+import kotlinx.cinterop.ptr
+import platform.posix.*
+import kotlin.native.concurrent.freeze
+
+/**
+ * A simple lock.
+ * Implementations of this class should be re-entrant.
+ */
+actual class Lock actual constructor() {
+    private val arena = Arena()
+    private val attr = arena.alloc<pthread_mutexattr_t>()
+    private val mutex = arena.alloc<pthread_mutex_t>()
+
+    init {
+        pthread_mutexattr_init(attr.ptr)
+        pthread_mutexattr_settype(attr.ptr, PTHREAD_MUTEX_RECURSIVE.toInt())
+        pthread_mutex_init(mutex.ptr, attr.ptr)
+        freeze()
+    }
+
+    actual fun lock() {
+        pthread_mutex_lock(mutex.ptr)
+    }
+
+    actual fun unlock() {
+        pthread_mutex_unlock(mutex.ptr)
+    }
+
+    actual fun tryLock(): Boolean = pthread_mutex_trylock(mutex.ptr) == 0
+
+    fun internalClose() {
+        pthread_mutex_destroy(mutex.ptr)
+        pthread_mutexattr_destroy(attr.ptr)
+        arena.clear()
+    }
+}
+
+actual inline fun Lock.close() {
+    internalClose()
+}