build.gradle

/**
 * Copyright (c) KMG. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 */

import org.gradle.internal.jvm.Jvm

import java.util.regex.Matcher

buildscript {
    repositories {
        mavenLocal()
        mavenCentral()
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }
    dependencies {
        classpath group: 'com.github.spotbugs.snom', name: 'spotbugs-gradle-plugin', version: spotbugsPluginVersion
        classpath group: 'gradle.plugin.com.palantir.graal', name: 'gradle-graal', version: graalvmPluginVersion
        classpath group: 'com.google.cloud.tools.jib', name: 'com.google.cloud.tools.jib.gradle.plugin', version: jibVersion
        // classpath group: 'org.hidetake', name:'gradle-ssh-plugin', version: sshPluginVersion
        //classpath group: 'ru.vyarus', name:'gradle-mkdocs-plugin', version: mkdocsPluginVersion
    }

    println "Build JVM Version      : " + Jvm.current()
    println "Build Gradle Version   : $gradle.gradleVersion"
    println "Build SBK Version      : $sbkVersion"
}

def SbkMainClass = "io.sbk.main.SbkMain"

gradle.rootProject {
    //only for root project
    apply plugin: 'com.google.cloud.tools.jib'
}

allprojects {

    if (project.name == "drivers") {
        return
    }

    repositories {
        mavenLocal()
        mavenCentral()
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }
    group = sbkGroup

    apply plugin: 'java'
    apply plugin: 'idea'
    apply plugin: 'eclipse'
    apply plugin: 'checkstyle'
    apply plugin: 'application'

    // Disable graalvm builds
    //apply plugin: "com.palantir.graal"

    apply from: "$rootDir/gradle/java.gradle"
    apply from: "$rootDir/gradle/application.gradle"
    apply from: "$rootDir/gradle/checkstyle.gradle"
    apply from: "$rootDir/gradle/eclipse.gradle"
    apply from: "$rootDir/gradle/idea.gradle"
    apply from: "$rootDir/gradle/jacoco.gradle"

    def sbkProjectName = project.name
    def sbkClass = project.name
    if (project.parent) {
        if (project.parent.name == "drivers") {
            sbkProjectName = rootProject.name + "-" + sbkProjectName
        }
    }

    base {
        archivesName = sbkProjectName
    }

    version = sbkVersion

    configurations.all {
        exclude group: sbkGroup, module: "sbktemplate"
    }


    jar {
        manifest {
            attributes 'Name': sbkProjectName.toUpperCase(),
                    'Specification-Title': "Storage Benchmark Kit",
                    'Specification-Version': sbkVersion,
                    'Specification-Vendor': "KMG",
                    'Implementation-Title': sbkProjectName.toUpperCase(),
                    'Implementation-Version': sbkVersion,
                    'Implementation-Vendor': "KMG"
        }
    }

    distributions {
        main {
            distributionBaseName.set(sbkProjectName)
        }
    }

    application {
        mainClass = SbkMainClass
        applicationName = sbkProjectName
        def className = sbkClass
        if (sbkClass.equalsIgnoreCase(rootProject.name)) {
            className = ""
        }

        applicationDefaultJvmArgs = ['-Dsbk.applicationName=' + applicationName, '-Dsbk.className=' + className,
                                     '-Dsbk.appHome=SBK_APP_HOME', '-Dsbk.jmxExport=false']

        /*
        applicationDefaultJvmArgs = ['-Dsbk.applicationName=' + applicationName, '-Dsbk.className=' + className,
                                     '-Dsbk.appHome=SBK_APP_HOME', '-Dsbk.jmxExport=false',
                                     '--add-exports=java.base/jdk.internal.misc=ALL-UNNAMED',
                                     '--add-exports=java.base/sun.nio.ch=ALL-UNNAMED',
                                     '--add-exports=java.management/com.sun.jmx.mbeanserver=ALL-UNNAMED',
                                     '--add-exports=jdk.internal.jvmstat/sun.jvmstat.monitor=ALL-UNNAMED',
                                     '--add-exports=java.base/sun.reflect.generics.reflectiveObjects=ALL-UNNAMED',
                                     '--add-opens=jdk.management/com.sun.management.internal=ALL-UNNAMED',
                                     '--illegal-access=permit']
         */

        startScripts {
            doLast {

                def jmxPort = jmxSbmPort

                if (project.path.startsWith(":driver-") || project.name == rootProject.name ||
                        project.name.startsWith('sbk-api')) {
                    jmxPort = jmxSbkPort
                }

                unixScript.text = unixScript.text.replace('SBK_APP_HOME', '\$APP_HOME')

                //make sure that we enclose $APP_HOME within ' ' character set
                unixScript.text = unixScript.text.replace("-Dsbk.appHome=\$APP_HOME", "-Dsbk.appHome='\$APP_HOME'")

                // Replace the classpath on windows with the pathing JAR and the main archive
                unixScript.text = unixScript.text.replaceAll('CLASSPATH=.*',
                        Matcher.quoteReplacement(
                                "CLASSPATH=\$APP_HOME/lib/${pathingJar.archiveFileName.get()}:\$APP_HOME/lib/${jar.archiveFileName.get()}"))

                if (jmxExport.matches("true")) {
                    unixScript.text = unixScript.text.replace("-Dsbk.jmxExport=false", "-Dsbk.jmxExport=true" + "\" \"" +
                            "-javaagent:'\$APP_HOME'/lib/${jmxAgent}-${jmxPrometheusVersion}.jar" +
                            "=$jmxPort:'\$APP_HOME'/bin/jmx-config.yml")
                }
                windowsScript.text = windowsScript.text.replace('SBK_APP_HOME', '%~dp0..')
                //make sure that we enclose $APP_HOME within ' ' character set
                windowsScript.text = windowsScript.text.replace("-Dsbk.appHome=\$APP_HOME", "-Dsbk.appHome='\$APP_HOME'")
                windowsScript.text = windowsScript.text.replaceAll('set CLASSPATH=.*',
                        Matcher.quoteReplacement(
                                "set CLASSPATH=%APP_HOME%\\lib\\${pathingJar.archiveFileName.get()};%APP_HOME%\\lib\\${jar.archiveFileName.get()}"))
                if (jmxExport.matches("true")) {
                    windowsScript.text = windowsScript.text.replace("-Dsbk.jmxExport=false", "-Dsbk.jmxExport=true" + "\" \"" +
                            "-javaagent:'\$APP_HOME'\\lib\\${jmxAgent}-${jmxPrometheusVersion}.jar" +
                            "=$jmxPort:'\$APP_HOME'\\bin\\jmx-config.yml")
                }
            }

            copy {
                from "$rootDir/jmx-config.yml"
                into outputDir
            }
        }
    }

    task generateDashboards(type: Copy) {
        if (project.path.startsWith(":drivers")) {
            def outDir = 'build/dashboard'
            def outFile = sbkProjectName + "-" + sbkVersion + ".json"
            def sbkClassName = sbkClass.toLowerCase().capitalize()

            /*
            call with parameter
            ./gradlew generateDashboards -Poutdir="/Users/kmg/projects/SBK/grafana/dashboards"
            to generate dashboard files on single folder
             */
            if (project.hasProperty("outdir")) {
                outDir = outdir
                outFile = sbkProjectName + ".json"
            }

            from "$rootDir/dashboard-template.json"
            into outDir
            filter { line -> line.replaceAll('SBK@2020', sbkClassName) }
            rename 'dashboard-template.json', outFile

            doLast {
                println "generating file : " + outDir + "/" + outFile
            }
        }
    }

    task generateDockerfiles() {
        def driversToSkip = ["sbk-api", "perl", "sbm", "sbk-gem", "drivers", "sbk-yal", "sbk-gem-yal"]
        def buffer = ""
        def outDir = 'build/dockers'
        def outFile = sbkProjectName + "-" + sbkVersion

        /*
                call with parameter
            ./gradlew generateDockerfiles -Poutdir="/Users/kmg/projects/SBK/dockers"
            to generate dashboard files on single folder
        */
        if (project.hasProperty("outdir")) {
            outDir = outdir
            outFile = sbkProjectName
        }


        if (project.path.startsWith(":drivers")) {
            doLast {
                println "generating file : " + outDir + "/" + outFile

                configurations.compileClasspath.resolvedConfiguration.resolvedArtifacts.each { artifact ->
                    def id = artifact.moduleVersion.id
                    if (id.group.toString() == sbkGroup) {
                        if (!driversToSkip.contains(id.name)) {
                            buffer += "COPY --chown=root:root " + "drivers/"+  id.name + " \${APP_HOME}/drivers/" +
                                    id.name + "\n"
                        }
                    }
                }
                buffer += "COPY --chown=root:root " + "drivers/"+ project.name + " \${APP_HOME}/drivers/" + project.name + "\n"
                copy {
                    from "$rootDir/driver-docker-template"
                    into outDir
                    filter { line -> line.replaceAll('PROJECT@SBK', project.name) }
                    filter { line -> line.replaceAll('APP@SBK', sbkProjectName) }
                    filter { line -> line.replace("COPY@SBK", buffer) }
                    rename 'driver-docker-template', outFile
                }
            }
        } else if (project.name == rootProject.name) {
            doLast {
                println "generatering file : " + outDir + "/" + outFile

                configurations.compileClasspath.resolvedConfiguration.resolvedArtifacts.each { artifact ->
                    def id = artifact.moduleVersion.id
                    if (id.group.toString() == sbkGroup) {
                        if (!driversToSkip.contains(id.name)) {
                            buffer += "COPY --chown=root:root " + "drivers/"+ id.name + " \${APP_HOME}/drivers/" +
                                    id.name + "\n"
                        }
                    }
                }
                copy {
                    from "$rootDir/docker-template"
                    into outDir
                    filter { line -> line.replace("COPY@SBK", buffer) }
                    rename 'docker-template', outFile
                }
            }
        }
    }

    /*
    graal {
        def className = sbkClass.capitalize();
        mainClass SbkMainClass
        outputName sbkProjectName
        javaVersion '17'
        graalVersion '21.0.0'
        option "-Dsbk.applicationName=$applicationName -Dsbk.className=$sbkClass"
        option "--initialize-at-build-time=io.sbk.$className"
        option "-H:+AllowIncompleteClasspath"
        option "-H:ResourceConfigurationFiles=$rootDir/resource-config.json"
        option "-H:ReflectionConfigurationFiles=$rootDir/reflection-config.json"
        option "--no-fallback"
        option "-H:Optimize=3"
    }
    */
}

task printDependencies {

    doLast {
        project.subprojects.findAll().each {
            println "subproject : " + it.name
            it.configurations.each {k ->
                k.dependencies.each { dep ->
                        if (dep.group.toString() == sbkGroup) {
                            println "\tgroup: ${dep.group}, version: ${dep.version},  name: ${dep.name}"
                            def projName = dep.name
                            while (projName) {
                                def proj = project.findProject(projName)
                                if (!proj) {
                                    //search inside drivers
                                    proj = project.findProject("drivers:"+projName)
                                }
                                projName = null
                                if (proj) {
                                    proj.configurations.each {x->
                                        x.dependencies.each { y ->
                                            if(y.group.toString() == sbkGroup) {
                                                println "\tgroup: ${y.group}, version: ${y.version},  name: ${y.name}"
                                                projName = y.name
                                            }
                                        }
                                    }
                                } else {
                                    break
                                }
                            }
                        }
                }
            }
            println()
        }

        println("Root project : " + rootProject.name)
        rootProject.configurations.each {k ->
            k.dependencies.each {dep ->
                if (dep.group.toString() == sbkGroup) {
                    println "\tgroup: ${dep.group}, version: ${dep.version},  name: ${dep.name}"
                }
            }
        }

        /*
        configurations.compileClasspath.resolvedConfiguration.resolvedArtifacts.each { artifact ->
            def id = artifact.moduleVersion.id
            if (id.group.toString() == sbkGroup) {
                println "\tgroup: ${id.group}, version: ${id.version},  name: ${id.name}"
            }
        }
        */
        println()
    }
}


/*
   Example command : ./gradlew printdrivers -Preadme
   another command : ./gradlew printdrivers -Preadme -Pdec   (add the project description)
 */
task printDrivers {
    String readmePrefix = "drivers/"

    doLast {
        int i = 1;
        println();
        project.subprojects.findAll().each {
            if (it.parent.name == "drivers") {
                String out = it.name
                String dec = it.getDescription()
                if (project.hasProperty("readme")) {
                    if (dec != null && project.hasProperty("dec")) {
                        out = "[" + it.name.capitalize() + "](" + readmePrefix + it.name + " \"" + dec + "\"" + ")"
                    } else {
                        out = "[" + it.name.capitalize() + "](" + readmePrefix + it.name + ")"
                    }
                }
                printf("%4d. %s\n", i, out)
                i++;
            }
        }
    }
}


//create a single Jar with all dependencies
task buildJar(type: Jar) {
    manifest {
        attributes 'Name': rootProject.name.toUpperCase(),
                'Specification-Title': "Storage Benchmark Kit",
                'Specification-Version': sbkVersion,
                'Specification-Vendor': "KMG",
                'Implementation-Title': rootProject.name.toUpperCase(),
                'Implementation-Version': sbkVersion,
                'Implementation-Vendor': "KMG",
                'Main-Class': SbkMainClass
    }
    zip64 true
    archiveBaseName = rootProject.name
    from { configurations.api.collect { it.isDirectory() ? it : zipTree(it) } }
    exclude 'META-INF/*.RSA'
    exclude 'META-INF/*.SF'
    exclude 'META-INF/*.DSA'
    with jar
}

task SbkYal(type: CreateStartScripts) {
    mainClass = 'io.sbk.main.SbkYalMain'
    applicationName = 'sbk-yal'
    defaultJvmOpts = ['-Dsbk.applicationName=' + rootProject.name, '-Dsbk.appHome=SBK_APP_HOME', '-Dsbk.jmxExport=false']
    outputDir = startScripts.outputDir
    classpath = startScripts.classpath
    SbkYal {
        doLast {
            unixScript.text = unixScript.text.replace('SBK_APP_HOME', '\$APP_HOME')

            //make sure that we enclose $APP_HOME within ' ' character set
            unixScript.text = unixScript.text.replace("-Dsbk.appHome=\$APP_HOME", "-Dsbk.appHome='\$APP_HOME'")

            // Replace the classpath on windows with the pathing JAR and the main archive
            unixScript.text = unixScript.text.replaceAll('CLASSPATH=.*',
                    Matcher.quoteReplacement(
                            "CLASSPATH=\$APP_HOME/lib/${pathingJar.archiveFileName.get()}:\$APP_HOME/lib/${jar.archiveFileName.get()}"))

            if (jmxExport.matches("true")) {
                unixScript.text = unixScript.text.replace("-Dsbk.jmxExport=false", "-Dsbk.jmxExport=true" + "\" \"" +
                        "-javaagent:'\$APP_HOME'/lib/${jmxAgent}-${jmxPrometheusVersion}.jar" +
                        "=$jmxSbmPort:'\$APP_HOME'/bin/jmx-config.yml")
            }
            windowsScript.text = windowsScript.text.replace('SBK_APP_HOME', '%~dp0..')
            //make sure that we enclose $APP_HOME within ' ' character set
            windowsScript.text = windowsScript.text.replace("-Dsbk.appHome=\$APP_HOME", "-Dsbk.appHome='\$APP_HOME'")
            windowsScript.text = windowsScript.text.replaceAll('set CLASSPATH=.*',
                    Matcher.quoteReplacement(
                            "set CLASSPATH=%APP_HOME%\\lib\\${pathingJar.archiveFileName.get()};%APP_HOME%\\lib\\${jar.archiveFileName.get()}"))
            if (jmxExport.matches("true")) {
                windowsScript.text = windowsScript.text.replace("-Dsbk.jmxExport=false", "-Dsbk.jmxExport=true" + "\" \"" +
                        "-javaagent:'\$APP_HOME'\\lib\\${jmxAgent}-${jmxPrometheusVersion}.jar" +
                        "=$jmxSbmPort:'\$APP_HOME'\\bin\\jmx-config.yml")
            }
        }
    }
}

task SbkGem(type: CreateStartScripts) {
    mainClass = 'io.gem.main.SbkGemMain'
    applicationName = 'sbk-gem'
    defaultJvmOpts = ['-Dsbk.applicationName=' + rootProject.name, '-Dsbk.appHome=SBK_APP_HOME', '-Dsbk.jmxExport=false']
    outputDir = startScripts.outputDir
    classpath = startScripts.classpath
    SbkGem {
        doLast {
            unixScript.text = unixScript.text.replace('SBK_APP_HOME', '\$APP_HOME')

            //make sure that we enclose $APP_HOME within ' ' character set
            unixScript.text = unixScript.text.replace("-Dsbk.appHome=\$APP_HOME", "-Dsbk.appHome='\$APP_HOME'")

            // Replace the classpath on windows with the pathing JAR and the main archive
            unixScript.text = unixScript.text.replaceAll('CLASSPATH=.*',
                    Matcher.quoteReplacement(
                            "CLASSPATH=\$APP_HOME/lib/${pathingJar.archiveFileName.get()}:\$APP_HOME/lib/${jar.archiveFileName.get()}"))

            if (jmxExport.matches("true")) {
                unixScript.text = unixScript.text.replace("-Dsbk.jmxExport=false", "-Dsbk.jmxExport=true" + "\" \"" +
                        "-javaagent:'\$APP_HOME'/lib/${jmxAgent}-${jmxPrometheusVersion}.jar" +
                        "=$jmxSbmPort:'\$APP_HOME'/bin/jmx-config.yml")
            }
            windowsScript.text = windowsScript.text.replace('SBK_APP_HOME', '%~dp0..')
            //make sure that we enclose $APP_HOME within ' ' character set
            windowsScript.text = windowsScript.text.replace("-Dsbk.appHome=\$APP_HOME", "-Dsbk.appHome='\$APP_HOME'")
            windowsScript.text = windowsScript.text.replaceAll('set CLASSPATH=.*',
                    Matcher.quoteReplacement(
                            "set CLASSPATH=%APP_HOME%\\lib\\${pathingJar.archiveFileName.get()};%APP_HOME%\\lib\\${jar.archiveFileName.get()}"))
            if (jmxExport.matches("true")) {
                windowsScript.text = windowsScript.text.replace("-Dsbk.jmxExport=false", "-Dsbk.jmxExport=true" + "\" \"" +
                        "-javaagent:'\$APP_HOME'\\lib\\${jmxAgent}-${jmxPrometheusVersion}.jar" +
                        "=$jmxSbmPort:'\$APP_HOME'\\bin\\jmx-config.yml")
            }
        }
    }
}

task SbkGemYal(type: CreateStartScripts) {
    mainClass = 'io.gem.main.SbkGemYalMain'
    applicationName = 'sbk-gem-yal'
    defaultJvmOpts = ['-Dsbk.applicationName=' + rootProject.name, '-Dsbk.appHome=SBK_APP_HOME', '-Dsbk.jmxExport=false']
    outputDir = startScripts.outputDir
    classpath = startScripts.classpath
    SbkGemYal {
        doLast {
            unixScript.text = unixScript.text.replace('SBK_APP_HOME', '\$APP_HOME')

            //make sure that we enclose $APP_HOME within ' ' character set
            unixScript.text = unixScript.text.replace("-Dsbk.appHome=\$APP_HOME", "-Dsbk.appHome='\$APP_HOME'")

            // Replace the classpath on windows with the pathing JAR and the main archive
            unixScript.text = unixScript.text.replaceAll('CLASSPATH=.*',
                    Matcher.quoteReplacement(
                            "CLASSPATH=\$APP_HOME/lib/${pathingJar.archiveFileName.get()}:\$APP_HOME/lib/${jar.archiveFileName.get()}"))

            if (jmxExport.matches("true")) {
                unixScript.text = unixScript.text.replace("-Dsbk.jmxExport=false", "-Dsbk.jmxExport=true" + "\" \"" +
                        "-javaagent:'\$APP_HOME'/lib/${jmxAgent}-${jmxPrometheusVersion}.jar" +
                        "=$jmxSbmPort:'\$APP_HOME'/bin/jmx-config.yml")
            }
            windowsScript.text = windowsScript.text.replace('SBK_APP_HOME', '%~dp0..')
            //make sure that we enclose $APP_HOME within ' ' character set
            windowsScript.text = windowsScript.text.replace("-Dsbk.appHome=\$APP_HOME", "-Dsbk.appHome='\$APP_HOME'")
            windowsScript.text = windowsScript.text.replaceAll('set CLASSPATH=.*',
                    Matcher.quoteReplacement(
                            "set CLASSPATH=%APP_HOME%\\lib\\${pathingJar.archiveFileName.get()};%APP_HOME%\\lib\\${jar.archiveFileName.get()}"))
            if (jmxExport.matches("true")) {
                windowsScript.text = windowsScript.text.replace("-Dsbk.jmxExport=false", "-Dsbk.jmxExport=true" + "\" \"" +
                        "-javaagent:'\$APP_HOME'\\lib\\${jmxAgent}-${jmxPrometheusVersion}.jar" +
                        "=$jmxSbmPort:'\$APP_HOME'\\bin\\jmx-config.yml")
            }
        }
    }
}

application {
    applicationDistribution.into("bin") {
        duplicatesStrategy = DuplicatesStrategy.EXCLUDE
        from(SbkYal)
        fileMode = 0755
    }

    applicationDistribution.into("bin") {
        duplicatesStrategy = DuplicatesStrategy.EXCLUDE
        from(SbkGem)
        fileMode = 0755
    }

    applicationDistribution.into("bin") {
        duplicatesStrategy = DuplicatesStrategy.EXCLUDE
        from(SbkGemYal)
        fileMode = 0755
    }
}


task deleteDriver() {
    doLast {
        String templateName = "sbktemplate"
        String driverName = templateName

        if (project.hasProperty("driver")) {
            driverName = driver.toLowerCase()
        } else {
            println "driver name is missing user -Pdriver "
            return
        }
        println "Delete Driver : $driverName"
        if (driverName.contains(templateName)) {
            println "Invalid driver name"
            return
        }
        delete "$rootDir/drivers/$driverName"

        def inFile1 = new File("$rootDir/settings-drivers.gradle").newInputStream()
        String outText1 = ""
        inFile1.eachLine {
            String line = it
            if (!line.contains(driverName)) {
                outText1 += line + "\n"
            }
        }
        inFile1.close()
        File outFile1 = new File("$rootDir/settings-drivers.gradle")
        outFile1.write(outText1)

        def inFile2 = new File("$rootDir/build-drivers.gradle").newInputStream()
        String outText2 = ""
        inFile2.eachLine {
            String line = it
            if (!line.contains(driverName)) {
                outText2 += line + "\n"
            }
        }
        inFile2.close()
        File outFile2 = new File("$rootDir/build-drivers.gradle")
        outFile2.write(outText2)
    }
}


task addDriver(dependsOn: deleteDriver) {
    doLast {
        String templateName = "sbktemplate"
        String driverName = templateName
        String sbkDriverName = driverName.capitalize()

        if (project.hasProperty("driver")) {
            driverName = driver.toLowerCase()
        } else {
            println "driver name is missing user -Pdriver "
            return
        }
        sbkDriverName = driverName.capitalize()
        println "Add Driver: $sbkDriverName"
        if (driverName.contains(templateName)) {
            println "Invalid driver name"
            return
        }

        copy {
            from "drivers/$templateName"
            into "drivers/$driverName"
            exclude 'build'
            rename "SbkTemplate", "$sbkDriverName"
            filter { line -> line.replaceAll('SbkTemplate', sbkDriverName) }
        }
        copy {
            from "drivers/$driverName/src/main/java/io/sbk/driver/SbkTemplate"
            into "drivers/$driverName/src/main/java/io/sbk/driver/$sbkDriverName"
            rename "SbkTemplate", "$sbkDriverName"
            filter { line -> line.replaceAll('SbkTemplate', sbkDriverName) }
        }
        delete "drivers/$driverName/src/main/java/io/sbk/driver/SbkTemplate"

        def inFile1 = new File("$rootDir/build-drivers.gradle").newInputStream()
        String outText1 = ""
        inFile1.eachLine {
            String line = it
            if (line.contains(templateName)) {
                outText1 += "    api project(':drivers:$driverName')\n"
            }
            outText1 += line + "\n"
        }
        inFile1.close()
        File outFile1 = new File("$rootDir/build-drivers.gradle")
        outFile1.write(outText1)

        def inFile2 = new File("$rootDir/settings-drivers.gradle").newInputStream()
        String outText2 = ""
        inFile2.eachLine {
            String line = it
            if (line.contains(templateName)) {
                outText2 += "include 'drivers:$driverName'\n"
            }
            outText2 += line + "\n"
        }
        inFile2.close()
        File outFile2 = new File("$rootDir/settings-drivers.gradle")
        outFile2.write(outText2)
    }
}


/*
Jib tasks
---------
jib - Builds a container image to a registry.
jibBuildTar - Builds a container image to a tarball.
jibDockerBuild - Builds a container image to a Docker daemon.

example : ./gradlew jibDockerBuild

To push the image to docker hub, first tag the image and the push the image

to tag the image , example command :
 

to push the image, example command:
docker push kmgowda/sbk:latest

 */
gradle.rootProject {

    jib {
        from {
            image = 'openjdk:17-jdk'
        }

        to {
            image = "${project.name}"
            tags = ["latest", project.version]
        }

        container {
            creationTime = 'USE_CURRENT_TIMESTAMP' // Useful for GitOps deployment approach
            mainClass = SbkMainClass
            ports = ['9718/tcp']
        }

    }
}


dependencies {
    api project(":perl")
    api project(":sbk-api")
    api project(":sbk-yal")
    api project(":sbm")
    api project(":sbk-gem")
    api project(":sbk-gem-yal")
}

apply from: "build-drivers.gradle"