build.gradle

import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

/*
* Copyright © 2017-2024  Kynetics, Inc.
*
* This program and the accompanying materials are made
* available under the terms of the Eclipse Public License 2.0
* which is available at https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*/

plugins {
    id 'java'
    id 'jacoco'
    alias(libs.plugins.kotlin.jvm) apply false
    alias(libs.plugins.license.report)  apply true
    alias(libs.plugins.dokka)  apply false
    alias(libs.plugins.sonarqube)  apply true
}

final def app_version = '2.0.0'
ext.keep_test_container_alive = project.hasProperty('keep_test_container_alive') ? project.getProperty('keep_test_container_alive').toBoolean() : false

def sonarProjectKey = System.getenv("SONAR_CLOUD_PROJECT_KEY")
def sonarProjectName = System.getenv("SONAR_CLOUD_PROJECT_NAME")
def sonarProjectOrganization = System.getenv("SONAR_CLOUD_ORGANIZATION")

sonar {
    properties {
        property "sonar.projectKey", sonarProjectKey
        property "sonar.projectName", sonarProjectName
        property "sonar.organization", sonarProjectOrganization
        property "sonar.sourceEncoding", "UTF-8"
        property "sonar.host.url", "https://sonarcloud.io"
    }
}

allprojects {
    apply plugin: 'org.jetbrains.kotlin.jvm'
    apply plugin: 'maven-publish'
    apply plugin: 'java'
    apply plugin: "org.sonarqube"

    apply from: "$rootDir/ktlint.gradle"

    dependencies {

        implementation libs.kotlin.stdlib
        implementation libs.kotlin.coroutines.jdk8
        implementation libs.joda.time
    }

    publishing {
        publications {
            mavenJava(MavenPublication) {
                from components.java
            }
        }
    }

    java {
        toolchain {
            languageVersion = JavaLanguageVersion.of(17)
        }
    }

    jacocoTestReport {
        mustRunAfter test
        sourceSets sourceSets.main

        reports {
            xml.required = true
            html.required = true
        }
    }
}

project(':ddi-consumer') {
    group 'org.eclipse.hara.hara-ddiclient'
    version app_version

    final def subprj = ':ddi-consumer:ddi-api'
    dependencies {
        implementation project(subprj)
        implementation project(':hara-ddiclient-api')
        implementation libs.retrofit.converter.gson
    }
    allprojects {
        dependencies {
            implementation libs.okhttp
            implementation libs.retrofit
            implementation libs.slf4j.api
        }
    }
    project(subprj) {
        dependencies {
            implementation libs.gson
            testImplementation libs.testng
        }
        test {
            useTestNG()
        }

    }
}

project(':ddi-consumer:ddi-api') {
    group 'org.eclipse.hara.hara-ddiclient.ddi-consumer'
    version app_version

    dependencies {
    }
}

project(':hara-ddiclient-api') {
    group 'org.eclipse.hara.hara-ddiclient.api'
    version app_version
    dependencies {
        implementation libs.okhttp
    }
}

project(':virtual-device'){
    group 'org.eclipse.hara.hara-virtual-device'
    version app_version
    apply plugin: 'application'
    apply plugin: 'jacoco'

    dependencies {
        implementation rootProject
        implementation project(':hara-ddiclient-api')
        implementation project(':ddi-consumer')
        implementation project(':ddi-consumer:ddi-api')

        implementation libs.okhttp
        implementation libs.slf4j.simple

        testImplementation libs.kotlin.stdlib
        testImplementation libs.kotlin.coroutines.jdk8
        testImplementation libs.testng
        testImplementation libs.mockk
        testImplementation libs.retrofit
        testImplementation libs.okhttp
        testImplementation libs.okhttp.logging
        testImplementation libs.retrofit.converter.gson
    }

    jacocoTestReport {
        mustRunAfter test
        sourceSets sourceSets.main

        reports {
            xml.required = true
            html.required = true
        }
    }

    test {
        dependsOn ':waitingHawkbitServer'

        useTestNG()

        afterTest { desc, result ->
            logger.quiet "Executing test ${desc.name} [${desc.className}] with result: ${result.resultType}"
        }
    }

    mainClassName = 'org.eclipse.hara.ddiclient.virtualdevice.MainKt'

    tasks.withType(KotlinCompile).configureEach {
        kotlinOptions.freeCompilerArgs += ["-opt-in=kotlin.RequiresOptIn"]
    }

    tasks.withType(JavaCompile).configureEach {
        javaCompiler = javaToolchains.compilerFor {
            languageVersion = JavaLanguageVersion.of(17)
        }
    }
}

boolean doHead(url) {
    def connection = new URL(url).openConnection()
    connection.requestMethod = 'HEAD'
    try {
        connection.responseCode == 200
    } catch (IOException error) {
        false
    }
}

jacocoTestReport {
    mustRunAfter test

    sourceSets sourceSets.main
    subprojects.each {
        sourceSets it.sourceSets.main
    }

    executionData fileTree(project.rootDir.absolutePath).include("**/build/jacoco/test.exec")

    classDirectories.setFrom(files(sourceSets.main.output) +
            files(subprojects.sourceSets.main.output))
    sourceDirectories.setFrom(files(sourceSets.main.allSource.srcDirs) +
            files(subprojects.sourceSets.main.allSource.srcDirs))
    additionalSourceDirs.setFrom(files(sourceSets.main.allSource.srcDirs) +
            files(subprojects.sourceSets.main.allSource.srcDirs))

    reports {
        xml.required = true
        html.required = true
    }
}

def dockerClientDir = new File(project.buildDir, "docker-client")
task makeDockerContex(type: Copy) {
    group "Docker"
    dependsOn ":virtual-device:installDist"

    from new File(project.projectDir, "virtual-device/build/install").getAbsolutePath()
    from new File(project.projectDir, "docker/client").getAbsolutePath()

    into dockerClientDir.getAbsolutePath()

}

task buildImage(){
    group "Docker"
    dependsOn makeDockerContex
    doLast{
        exec {
            workingDir dockerClientDir
            commandLine "docker", "build", ".", "--tag", "hara-virtual-device:$app_version"
        }
    }
}

task stopHawkbitServer() {
    group 'testing'
    doFirst {
        if (!keep_test_container_alive) {
            exec {
                workingDir 'docker/test/'
                commandLine 'docker', 'compose', 'down'
            }
        }
    }
}

task restartHawkbitServer() {
    group 'testing'
    doFirst {
        exec {
            workingDir 'docker/test/'
            commandLine 'docker', 'compose', 'down'
        }
    }

    doLast{
        exec {
            workingDir 'docker/test/'
            commandLine 'docker', 'compose', 'up', '--detach'
        }
    }
}

task waitingHawkbitServer(){
    group 'testing'

    dependsOn 'restartHawkbitServer'

    doFirst {
        def url = 'http://localhost:8080/UI/login'
        println "Waiting for ${url} ..."
        while (!doHead(url)) {
            sleep(5000)
            println "Waiting for ${url} ..."
        }
        println "${url} is up!"
    }

}

test.dependsOn waitingHawkbitServer
test.dependsOn cleanTest
test.finalizedBy stopHawkbitServer

group 'org.eclipse.hara.hara-ddiclient'
version app_version

test {
    systemProperty("LOG_HTTP", project.findProperty("logHttp") ?: "false")
    systemProperty("LOG_INTERNAL", project.findProperty("logInternal") ?: "false")
    systemProperty("BACKOFF_INTERVAL_SECONDS", 45)
    systemProperty("FREQUENT_POLLING_WHILE_UPDATING", false)

    dependsOn ':virtual-device:test'

    useTestNG()

    afterTest { desc, result ->
        logger.quiet "Executing test ${desc.name} [${desc.className}] with result: ${result.resultType}"
    }
}


dependencies{
    implementation project(':hara-ddiclient-api')
    implementation project(':ddi-consumer')
    implementation project(':ddi-consumer:ddi-api')

    implementation libs.slf4j.api
    implementation libs.joda.time
    implementation libs.gson
    implementation libs.retrofit.converter.gson

    testImplementation libs.testng
    testImplementation libs.kotlin.stdlib
    testImplementation libs.kotlin.coroutines.jdk8
    testImplementation libs.joda.time
    testImplementation libs.okhttp
    testImplementation libs.okhttp.logging
    testImplementation libs.retrofit
}