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: '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"

allprojects {
    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'
    // apply plugin: "com.github.spotbugs"

    // 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/spotbugs.gradle"
    apply from: "$rootDir/gradle/idea.gradle"
    apply from: "$rootDir/gradle/jacoco.gradle"
    apply from: "$rootDir/gradle/protobuf.gradle"

    def sbkProjectName = rootProject.name + project.path.replace(":", "-")
    sbkProjectName = sbkProjectName.replace(rootProject.name + "-" + rootProject.name + "-", rootProject.name + "-")
    sbkProjectName = sbkProjectName.replace(rootProject.name + "-driver-", rootProject.name + "-")
    sbkProjectName = sbkProjectName.replace("--", "-")
    if (sbkProjectName == rootProject.name + "-") {
        sbkProjectName = rootProject.name
    }
    archivesBaseName = sbkProjectName
    version = sbkVersion

    def sbkClass = ""
    if (project.path.startsWith(":driver-")) {
        sbkClass = project.path.replace(":driver-", "")
    }

    configurations.all {
        exclude group: sbkGroup, module: "driver-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(archivesBaseName)
        }
    }

    application {
        mainClass = SbkMainClass
        applicationName = archivesBaseName

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

        /*
        applicationDefaultJvmArgs = ['-Dsbk.applicationName=' + applicationName, '-Dsbk.className=' + sbkClass,
                                     '-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 = jmxSbkRamPort

                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(":driver-")) {
            def outDir = 'build/dashboard'
            def outFile = sbkProjectName + "-" + sbkVersion + ".json"
            def sbkClassUpperCase = sbkClass.toUpperCase()

            /*
            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', sbkClassUpperCase) }
            rename 'dashboard-template.json', outFile

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

    task generateDockerfiles() {
        def driversToSkip = ["sbk-api", "state", "time", "perl"]
        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(":driver-")) {
            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 " + id.name + " \${APP_HOME}/" + id.name + "\n"
                        }
                    }
                }
                buffer += "COPY --chown=root:root " + project.name + " \${APP_HOME}/" + 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 " + id.name + " \${APP_HOME}/" + 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.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()
        }
        println("Root project : " + rootProject.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 = ""

    doLast {
        int i = 1;
        println();
        project.subprojects.findAll().each {
            if (it.name.startsWith("driver-") && !it.name.equals("driver-template")) {
                String out = it.name
                String dec = it.getDescription()
                if (project.hasProperty("readme")) {
                    String name = it.name.replace("driver-", "")
                    if (dec != null && project.hasProperty("dec")) {
                        out = "[" + name.capitalize() + "](" + readmePrefix + it.name + " \"" + dec + "\"" + ")"
                    } else {
                        out = "[" + 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 SbkGem(type: CreateStartScripts) {
    mainClass = 'io.sbk.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" +
                        "=$jmxSbkRamPort:'\$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" +
                        "=$jmxSbkRamPort:'\$APP_HOME'\\bin\\jmx-config.yml")
            }
        }
    }
}

task SbkGemYal(type: CreateStartScripts) {
    mainClass = 'io.sbk.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" +
                        "=$jmxSbkRamPort:'\$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" +
                        "=$jmxSbkRamPort:'\$APP_HOME'\\bin\\jmx-config.yml")
            }
        }
    }
}

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 = "driver-sbktemplate"
        String driverName = templateName

        if (project.hasProperty("driver")) {
            String name1 = driver
            if (name1.equalsIgnoreCase("driver") || name1.equalsIgnoreCase("driver-")) {
                println "driver name is missing"
                return
            } else if (name1.startsWith("driver-")) {
                driverName = name1
            } else {
                driverName = "driver-" + name1
            }
            driverName = driverName.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/$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 = "driver-sbktemplate"
        String driverName = templateName
        String sbkDriverName = ""

        if (project.hasProperty("driver")) {
            String name1 = driver
            if (name1.equalsIgnoreCase("driver") || name1.equalsIgnoreCase("driver-")) {
                println "driver name is missing"
                return
            } else if (name1.startsWith("driver-")) {
                driverName = name1
                String[] lt = name1.split("driver-")
                if (lt.length < 2) {
                    println "Missing driver name"
                    return
                }
                sbkDriverName = lt[1]
            } else {
                driverName = "driver-" + name1
                sbkDriverName = name1
            }
            driverName = driverName.toLowerCase()
            sbkDriverName = sbkDriverName.capitalize()
        } else {
            println "driver name is missing user -Pdriver "
            return
        }

        println "Add Driver: $driverName"
        if (driverName.contains(templateName)) {
            println "Invalid driver name"
            return
        }
        copy {
            from "$rootDir/$templateName"
            into "$rootDir/$driverName"
            from("$driverName/src/main/java/io/sbk/SbkTemplate") {
                into "src/main/java/io/sbk/$sbkDriverName"
            }
            exclude 'build'
            rename "SbkTemplate", sbkDriverName
            filter { line -> line.replaceAll('SbkTemplate', sbkDriverName) }
        }
        delete "$driverName/src/main/java/io/sbk/SbkTemplate"

        def inFile1 = new File("$rootDir/build-drivers.gradle").newInputStream()
        String outText1 = ""
        inFile1.eachLine {
            String line = it
            if (line.contains(templateName)) {
                outText1 += "    api project(':$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 '$driverName'\n"
            }
            outText2 += line + "\n"
        }
        inFile2.close()
        File outFile2 = new File("$rootDir/settings-drivers.gradle")
        outFile2.write(outText2)
    }
}

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

apply from: "$rootDir/build-drivers.gradle"