300 lines
10 KiB
Plaintext
300 lines
10 KiB
Plaintext
import Versions.ktor
|
|
import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTargetWithHostTests
|
|
import java.io.ByteArrayOutputStream
|
|
|
|
buildscript {
|
|
dependencies {
|
|
classpath("app.cash.sqldelight:gradle-plugin:${Versions.sqlDelight}")
|
|
}
|
|
repositories {
|
|
google()
|
|
mavenCentral()
|
|
}
|
|
}
|
|
|
|
plugins {
|
|
kotlin("multiplatform") version Versions.kotlin
|
|
kotlin("plugin.serialization") version Versions.kotlin
|
|
id("app.cash.sqldelight") version Versions.sqlDelight
|
|
application
|
|
}
|
|
|
|
allprojects {
|
|
group = "fr.acinq.lightning"
|
|
version = "0.2.1-SNAPSHOT"
|
|
|
|
repositories {
|
|
// using the local maven repository with Kotlin Multi Platform can lead to build errors that are hard to diagnose.
|
|
// uncomment this only if you need to experiment with snapshot dependencies that have not yet be published.
|
|
mavenLocal()
|
|
maven("https://oss.sonatype.org/content/repositories/snapshots")
|
|
mavenCentral()
|
|
google()
|
|
maven("https://jitpack.io")
|
|
}
|
|
}
|
|
|
|
/** Get the current git commit hash. */
|
|
fun gitCommitHash(): String {
|
|
val stream = ByteArrayOutputStream()
|
|
project.exec {
|
|
commandLine = "git rev-parse --verify --long HEAD".split(" ")
|
|
standardOutput = stream
|
|
}
|
|
return String(stream.toByteArray()).split("\n").first()
|
|
}
|
|
|
|
/**
|
|
* Generates a `BuildVersions` file in build/generated-src containing the current git commit and the lightning-kmp version.
|
|
* See https://stackoverflow.com/a/74771876 for details.
|
|
*/
|
|
val buildVersionsTask by tasks.registering(Sync::class) {
|
|
group = "build"
|
|
from(
|
|
resources.text.fromString(
|
|
"""
|
|
|package fr.acinq.lightning
|
|
|
|
|
|object BuildVersions {
|
|
| const val phoenixdCommit = "${gitCommitHash()}"
|
|
| const val phoenixdVersion = "${project.version}-${gitCommitHash().take(7)}"
|
|
| const val lightningKmpVersion = "${Versions.lightningKmp}"
|
|
|}
|
|
|
|
|
""".trimMargin()
|
|
)
|
|
) {
|
|
rename { "BuildVersions.kt" }
|
|
into("fr/acinq/lightning")
|
|
}
|
|
into(layout.buildDirectory.dir("generated/kotlin/"))
|
|
}
|
|
|
|
kotlin {
|
|
jvm {
|
|
withJava()
|
|
compilations["main"].defaultSourceSet {
|
|
resources.srcDirs("src/jvmMain/kotlin/fr/acinq/lightning/vsock/")
|
|
}
|
|
}
|
|
|
|
fun KotlinNativeTargetWithHostTests.phoenixBinaries() {
|
|
binaries {
|
|
executable("phoenixd") {
|
|
entryPoint = "fr.acinq.lightning.bin.main"
|
|
optimized = false // without this, release mode throws 'Index 0 out of bounds for length 0' in StaticInitializersOptimization.kt
|
|
}
|
|
/*executable("phoenix-cli") {
|
|
entryPoint = "fr.acinq.lightning.cli.main"
|
|
optimized = false // without this, release mode throws 'Index 0 out of bounds for length 0' in StaticInitializersOptimization.kt
|
|
}*/
|
|
}
|
|
}
|
|
|
|
val currentOs = org.gradle.internal.os.OperatingSystem.current()
|
|
val arch = System.getProperty("os.arch")
|
|
|
|
if (currentOs.isLinux && arch != "aarch64") {
|
|
// there is no kotlin native toolchain for linux arm64 yet, but we can still build for the JVM
|
|
// see https://youtrack.jetbrains.com/issue/KT-51794/Cant-run-JVM-targets-on-ARM-Linux-when-using-Kotlin-Multiplatform-plugin
|
|
linuxX64 {
|
|
phoenixBinaries()
|
|
}
|
|
}
|
|
|
|
if (currentOs.isMacOsX) {
|
|
macosX64 {
|
|
phoenixBinaries()
|
|
}
|
|
macosArm64 {
|
|
phoenixBinaries()
|
|
}
|
|
}
|
|
|
|
sourceSets {
|
|
commonMain {
|
|
kotlin.srcDir(buildVersionsTask.map { it.destinationDir })
|
|
dependencies {
|
|
implementation("com.github.raymond98.lightning-kmp:lightning-kmp:v1.6.2-FEECREDIT-8")
|
|
|
|
implementation("org.jetbrains.kotlinx:atomicfu:0.25.0")
|
|
|
|
implementation("org.jetbrains.kotlin:kotlin-stdlib:1.8.20")
|
|
api("fr.acinq.bitcoin:bitcoin-kmp:${Versions.bitcoinKmpVersion}")
|
|
api("co.touchlab:kermit:${Versions.kermitLoggerVersion}")
|
|
api("org.jetbrains.kotlinx:kotlinx-datetime:${Versions.datetimeVersion}")
|
|
api(ktor("network"))
|
|
api(ktor("network-tls"))
|
|
|
|
// ktor serialization
|
|
implementation(ktor("serialization-kotlinx-json"))
|
|
// ktor server
|
|
implementation(ktor("server-core"))
|
|
implementation(ktor("server-content-negotiation"))
|
|
implementation(ktor("server-cio"))
|
|
implementation(ktor("server-websockets"))
|
|
implementation(ktor("server-auth"))
|
|
implementation(ktor("server-status-pages")) // exception handling
|
|
// ktor client (needed for webhook)
|
|
implementation(ktor("client-core"))
|
|
implementation(ktor("client-content-negotiation"))
|
|
implementation(ktor("client-auth"))
|
|
implementation(ktor("client-json"))
|
|
|
|
implementation("com.squareup.okio:okio:${Versions.okio}")
|
|
implementation("com.github.ajalt.clikt:clikt:${Versions.clikt}")
|
|
implementation("app.cash.sqldelight:coroutines-extensions:${Versions.sqlDelight}")
|
|
}
|
|
}
|
|
jvmMain {
|
|
dependencies {
|
|
implementation("app.cash.sqldelight:sqlite-driver:${Versions.sqlDelight}")
|
|
implementation("fr.acinq.secp256k1:secp256k1-kmp-jni-jvm:${Versions.secpJniJvmVersion}")
|
|
implementation(ktor("client-okhttp"))
|
|
implementation("ch.qos.logback:logback-classic:1.2.3")
|
|
implementation("org.bytedeco:javacpp:1.5.10")
|
|
implementation("org.bytedeco:javacpp-presets:1.5.10")
|
|
}
|
|
}
|
|
nativeMain {
|
|
dependencies {
|
|
implementation("app.cash.sqldelight:native-driver:${Versions.sqlDelight}")
|
|
}
|
|
}
|
|
if (currentOs.isLinux) {
|
|
linuxMain {
|
|
dependencies {
|
|
implementation(ktor("client-curl"))
|
|
}
|
|
}
|
|
}
|
|
if (currentOs.isMacOsX) {
|
|
macosMain {
|
|
dependencies {
|
|
implementation(ktor("client-darwin"))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fun Zip.configureZip(dir: String, classifier: String) {
|
|
group = "package"
|
|
description = "build and package $dir release executables"
|
|
archiveBaseName = "phoenix"
|
|
archiveClassifier = classifier
|
|
|
|
from("$projectDir/build/bin/$dir/phoenixdReleaseExecutable") {
|
|
include("*.kexe")
|
|
rename("phoenixd.kexe", "phoenixd")
|
|
}
|
|
from("$projectDir/build/bin/$dir/phoenix-cliReleaseExecutable") {
|
|
include("*.kexe")
|
|
rename("phoenix-cli.kexe", "phoenix-cli")
|
|
}
|
|
into("${archiveBaseName.get()}-${archiveVersion.get()}-${archiveClassifier.get()}")
|
|
}
|
|
|
|
if (currentOs.isLinux) {
|
|
val packageLinuxX64 by tasks.register("packageLinuxX64", Zip::class) {
|
|
dependsOn(":linuxX64Binaries")
|
|
configureZip("linuxX64", "linux-x64")
|
|
}
|
|
}
|
|
|
|
if (currentOs.isMacOsX) {
|
|
val packageMacosX64 by tasks.register("packageMacosX64", Zip::class) {
|
|
dependsOn(":macosX64Binaries")
|
|
configureZip("macosX64", "macos-x64")
|
|
}
|
|
val packageMacosArm by tasks.register("packageMacosArm64", Zip::class) {
|
|
dependsOn(":macosArm64Binaries")
|
|
configureZip("macosArm64", "macos-arm64")
|
|
}
|
|
}
|
|
}
|
|
|
|
application {
|
|
mainClass = "fr.acinq.lightning.bin.MainKt"
|
|
|
|
// Set java.library.path to include the directory where the shared library is generated
|
|
applicationDefaultJvmArgs = listOf("-Djava.library.path=${layout.buildDirectory.dir("libs").get().asFile}")
|
|
applicationDefaultJvmArgs = listOf("-DLIBS_PATH=${layout.buildDirectory.dir("libs").get().asFile.absolutePath.replace("\\", "/")}")
|
|
}
|
|
|
|
val cliScripts by tasks.register("cliScripts", CreateStartScripts::class) {
|
|
mainClass.set("fr.acinq.lightning.cli.PhoenixCliKt")
|
|
outputDir = tasks.startScripts.get().outputDir
|
|
classpath = tasks.startScripts.get().classpath
|
|
applicationName = "phoenix-cli"
|
|
}
|
|
|
|
tasks.startScripts {
|
|
dependsOn(cliScripts)
|
|
}
|
|
|
|
val setLibPath by tasks.register<Exec>("runLinuxExecutable") {
|
|
val libsDir = layout.buildDirectory.dir("libs").get().asFile
|
|
val linuxLibsPath = libsDir.absolutePath.replace("\\", "/")
|
|
|
|
// Set the environment variable
|
|
environment("LIBS_PATH", linuxLibsPath)
|
|
|
|
// Mark the task as always out-of-date
|
|
outputs.upToDateWhen { false }
|
|
|
|
// Execute the command
|
|
commandLine("sh", "-c", "LIBS_PATH=$linuxLibsPath; export LIBS_PATH=$linuxLibsPath")
|
|
}
|
|
|
|
|
|
|
|
val compileNative by tasks.register<Exec>("compileNative") {
|
|
group = "build"
|
|
description = "Compile the native C++ code into a shared library"
|
|
|
|
val outputDir = layout.buildDirectory.dir("libs").get().asFile
|
|
val nativeSourceDir = file("src/commonMain/kotlin/fr/acinq/lightning/vsock/native")
|
|
|
|
// Locate the JNI headers - adjust these paths based on your actual JDK location
|
|
val jdkHome = System.getenv("JAVA_HOME") ?: "/usr/lib/jvm/default-java"
|
|
val jniIncludeDir = file("$jdkHome/include")
|
|
val jniPlatformIncludeDir = file("$jniIncludeDir/linux") // or "win32" for Windows, "darwin" for macOS
|
|
|
|
inputs.dir(nativeSourceDir)
|
|
outputs.dir(outputDir)
|
|
|
|
commandLine("g++", "-I$jniIncludeDir", "-I$jniPlatformIncludeDir", "-shared", "-o", outputDir.resolve("libjniVSockImpl.so"), nativeSourceDir.resolve("VSockImpl.cpp"), "-fPIC")
|
|
}
|
|
|
|
tasks.withType<Tar> {
|
|
dependsOn(compileNative)
|
|
dependsOn(setLibPath)
|
|
}
|
|
|
|
tasks.withType<Zip> {
|
|
dependsOn(compileNative)
|
|
dependsOn(setLibPath)
|
|
}
|
|
|
|
distributions {
|
|
main {
|
|
distributionBaseName = "phoenix"
|
|
distributionClassifier = "jvm"
|
|
}
|
|
}
|
|
|
|
// forward std input when app is run via gradle (otherwise keyboard input will return EOF)
|
|
tasks.withType<JavaExec> {
|
|
standardInput = System.`in`
|
|
}
|
|
|
|
sqldelight {
|
|
databases {
|
|
create("PhoenixDatabase") {
|
|
packageName.set("fr.acinq.phoenix.db")
|
|
srcDirs.from("src/commonMain/sqldelight/phoenixdb")
|
|
}
|
|
}
|
|
}
|
|
|