provs/build.gradle

buildscript {
    ext.kotlin_version_no = "1.7.20"
    ext.CI_PROJECT_ID = System.env.CI_PROJECT_ID

    repositories {
        mavenCentral()
    }
}

plugins {
    id "org.jetbrains.kotlin.jvm" version "$kotlin_version_no"
    id 'org.jetbrains.kotlin.plugin.serialization' version "$kotlin_version_no"
    id "java"
    id "java-test-fixtures"
}
apply plugin: "maven-publish"


version = "0.29.13-SNAPSHOT"
group = "org.domaindrivenarchitecture.provs"


repositories {
    mavenCentral()
}


java {
    // https://stackoverflow.com/questions/21904269/configure-gradle-to-publish-sources-and-javadoc
    withSourcesJar()
    withJavadocJar()

    toolchain {
        languageVersion = JavaLanguageVersion.of(11)
    }
}

jar {
    duplicatesStrategy(DuplicatesStrategy.EXCLUDE)
}


test {
    // set properties for the tests
    def propertiesForTests = ["testdockerwithoutsudo"]
    for (def prop : propertiesForTests) {
        def value = System.getProperty(prop)
        if (value != null) {
            systemProperty prop, value
        }
    }

    useJUnitPlatform {
        def excludedTags = System.getProperty("excludeTags")
        if (System.getProperty("excludeTags") != null) {
            excludeTags(excludedTags.split(","))
        }
        if (System.getenv("CI_JOB_TOKEN") != null) {
            excludeTags("containernonci")
        }
    }
}

compileJava.options.debugOptions.debugLevel = "source,lines,vars"
compileTestFixturesJava.options.debugOptions.debugLevel = "source,lines,vars"
compileTestJava.options.debugOptions.debugLevel = "source,lines,vars"


dependencies {

    api("org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version_no")
    api("org.jetbrains.kotlinx:kotlinx-serialization-json:1.3.2")
    api("org.jetbrains.kotlinx:kotlinx-serialization-core:1.3.2")
    api("org.jetbrains.kotlinx:kotlinx-cli:0.3.4")

    api('com.charleskorn.kaml:kaml:0.54.0')

    api("org.slf4j:slf4j-api:1.7.36")
    api('ch.qos.logback:logback-classic:1.2.11')
    api('ch.qos.logback:logback-core:1.2.11')

    implementation("org.jetbrains.kotlin:kotlin-reflect:$kotlin_version_no")
    implementation("com.hierynomus:sshj:0.32.0")

    implementation("aws.sdk.kotlin:s3:0.17.1-beta")

    testFixturesApi("org.junit.jupiter:junit-jupiter-api:5.8.2")
    testFixturesApi('io.mockk:mockk:1.12.3')

    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.8.2")
}


tasks.register('uberjarDesktop', Jar) {

    from sourceSets.main.output

    dependsOn configurations.runtimeClasspath
    from {
        configurations.runtimeClasspath.findAll { it.name.endsWith("jar") }.collect { zipTree(it) }
    } {
        duplicatesStrategy(DuplicatesStrategy.EXCLUDE)
        exclude "META-INF/*.RSA", "META-INF/*.SF", "META-INF/*.DSA"
    }

    manifest {
        attributes "Implementation-Title": "Uberjar of provs",
                "Implementation-Version": project.version,
                "Main-Class": "org.domaindrivenarchitecture.provs.desktop.application.ApplicationKt"
    }
    archiveFileName = "provs-desktop.jar"
}


tasks.register('uberjarServer', Jar) {

    from sourceSets.main.output

    dependsOn configurations.runtimeClasspath
    from {
        configurations.runtimeClasspath.findAll { it.name.endsWith("jar") }.collect { zipTree(it) }
    } {
        duplicatesStrategy(DuplicatesStrategy.EXCLUDE)
        exclude "META-INF/*.RSA", "META-INF/*.SF", "META-INF/*.DSA"
    }

    manifest {
        attributes "Implementation-Title": "Uberjar of provs",
                "Implementation-Version": project.version,
                "Main-Class": "org.domaindrivenarchitecture.provs.server.application.ApplicationKt"
    }
    archiveFileName = "provs-server.jar"
}


tasks.register('uberjarSyspec', Jar) {

    from sourceSets.main.output

    dependsOn configurations.runtimeClasspath
    from {
        configurations.runtimeClasspath.findAll { it.name.endsWith("jar") }.collect { zipTree(it) }
    } {
        duplicatesStrategy(DuplicatesStrategy.EXCLUDE)
        exclude "META-INF/*.RSA", "META-INF/*.SF", "META-INF/*.DSA"
    }

    manifest {
        attributes "Implementation-Title": "Uberjar of provs",
                "Implementation-Version": project.version,
                "Main-Class": "org.domaindrivenarchitecture.provs.syspec.application.ApplicationKt"
    }
    archiveFileName = "provs-syspec.jar"
}
def projectRoot = rootProject.projectDir


// copy jar to /usr/local/bin and make it executable
// Remark: to be able to use it you must have jarwrapper installed (sudo apt install jarwrapper)
tasks.register('installlocally') {
    dependsOn(uberjarServer, uberjarDesktop, uberjarSyspec)
    doLast {
        exec { commandLine("sh", "-c", "sudo apt-get update & sudo apt-get install jarwrapper") }
        exec { commandLine("sh", "-c", "sudo cp $projectRoot/build/libs/provs-server.jar /usr/local/bin/") }
        exec { commandLine("sh", "-c", "sudo cp $projectRoot/build/libs/provs-desktop.jar /usr/local/bin/") }
        exec { commandLine("sh", "-c", "sudo cp $projectRoot/build/libs/provs-syspec.jar /usr/local/bin/") }
        exec { commandLine("sh", "-c", "sudo chmod 755 /usr/local/bin/provs-server.jar") }
        exec { commandLine("sh", "-c", "sudo chmod 755 /usr/local/bin/provs-desktop.jar") }
        exec { commandLine("sh", "-c", "sudo chmod 755 /usr/local/bin/provs-syspec.jar") }
    }
}


// publish to repo.prod.meissa.de with task "publishLibraryPublicationToMeissaRepository" -- (using pattern "publishLibraryPublicationTo<MAVEN REPOSITORY NAME>Repository")
publishing {
    publications {
        library(MavenPublication) {
            groupId 'org.domaindrivenarchitecture'
            artifactId 'provs'
            from components.java
        }
    }

    repositories {
        maven {
            name = "gitlab"
            url = "https://gitlab.com/api/v4/projects/$CI_PROJECT_ID/packages/maven"
            credentials(HttpHeaderCredentials) {
                name = "Job-Token"
                value = System.getenv("CI_JOB_TOKEN")
            }
            authentication {
                header(HttpHeaderAuthentication)
            }
        }
        maven {
            name = "meissa"
            url = uri("https://repo.prod.meissa.de/api/packages/meissa/maven")

            credentials(HttpHeaderCredentials) {
                name = "Authorization"
                def publishPackageTokenName = "MEISSA_PUBLISH_PACKAGE_TOKEN"
                if (System.getenv("CI_JOB_TOKEN") != null) {
                    def tokenFromEnv = System.getenv(publishPackageTokenName)
                    if (tokenFromEnv == null) {
                        println "Error: $publishPackageTokenName not found"
                    } else {
                        value = "token " + tokenFromEnv
                        println "$publishPackageTokenName found - "
                    }
                } else {
                    // use project-property (define e.g. in "~/.gradle/gradle.properties") when not running in ci
                    // you can create a token in gitea "Profile and Settings ... > Settings > Applications", Token Name, Select scopes (write:package) > "Generate Token"
                    if (!project.hasProperty(publishPackageTokenName)) {
                        // if token is missing, provide a dummy in order to avoid error "Could not get unknown property 'MEISSA_PUBLISH_PACKAGE_TOKEN' for Credentials [header: Authorization]" for other gradle tasks
                        ext.MEISSA_PUBLISH_PACKAGE_TOKEN = "Token $publishPackageTokenName not provided in file \".gradle/gradle.properties\""
                        println "Error: Token $publishPackageTokenName not found"
                    } else {
                        value = "token " + project.property(publishPackageTokenName)
                    }
                }
            }

            authentication {
                header(HttpHeaderAuthentication)
            }
        }
    }
}