build.gradle

/*
* Copyright © 2017-2024  Kynetics  LLC
*
* 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 'org.jetbrains.kotlin.jvm' version '1.8.10'
    id 'io.gitlab.arturbosch.detekt' version '1.17.1'
    id 'jacoco'
    id 'java'
    id 'com.github.jk1.dependency-license-report' version '1.16'
    id("org.jetbrains.dokka") version "1.6.10"
    id "org.sonarqube" version "4.4.1.3373"
}

repositories {
    mavenCentral()
    mavenLocal()
}

final def deps = gradle.settings.app_dependencies
final def tdeps = gradle.settings.test_dependencies
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 from: "$rootDir/ktlint.gradle"
    apply plugin: 'java'
    apply plugin: "org.jetbrains.dokka"
    apply plugin: "org.sonarqube"

    repositories {
        mavenCentral()
        mavenLocal()
    }
    dependencies {
        implementation deps.kotlin_stdlib
        implementation deps.kotlin_x
        implementation deps.joda
    }

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

    java {
        toolchain {
            languageVersion = JavaLanguageVersion.of(11)
            vendor = JvmVendorSpec.ADOPTOPENJDK
        }
    }
}

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 deps.retrofit_converter
    }
    allprojects {
        dependencies {
            implementation deps.okhttp
            implementation deps.retrofit
            implementation deps.slf4j_api

        }
    }
    project(subprj) {
        dependencies {
            implementation deps.gson
            testImplementation tdeps.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 deps.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 deps.slf4j_simple
        implementation deps.okhttp
        testImplementation deps.kotlin_stdlib
        testImplementation deps.kotlin_x
        testImplementation tdeps.testng
        testImplementation tdeps.mockk
        testImplementation deps.retrofit
        testImplementation deps.okhttp
        testImplementation deps.okhttp_logging
        testImplementation deps.retrofit_converter
    }

    jacocoTestReport {
        dependsOn 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}"
        }
        finalizedBy jacocoTestReport
    }

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

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

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

detekt {
    toolVersion = "1.17.1"
    config = files("$rootDir/default-detekt-config.yml", "$rootDir/detekt-config.yml")
    input = files("$projectDir")
    buildUponDefaultConfig = true
}

jacocoTestReport {
    dependsOn tasks.withType(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:8081/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)

    dependsOn ':virtual-device:test'

    useTestNG()

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


dependencies{
    implementation project(':hara-ddiclient-api')
    implementation project(':ddi-consumer')
    implementation project(':ddi-consumer:ddi-api')
    implementation deps.slf4j_api
    implementation deps.joda
    implementation deps.gson
    implementation deps.retrofit_converter
    testImplementation tdeps.testng
    testImplementation deps.kotlin_stdlib
    testImplementation deps.kotlin_x
    testImplementation deps.joda
    testImplementation deps.okhttp
    testImplementation deps.okhttp_logging
    testImplementation deps.retrofit
}