build.gradle

plugins {
    id 'java'
    id 'application'
    id 'com.github.johnrengelman.shadow' version '5.2.0'
}

def versionObj = new Version(major: 0, minor: 20, revision: 2)

sourceCompatibility = 15
targetCompatibility = 15

allprojects {
    group 'com.github.natanbc'
    version versionObj.toString()

    repositories {
        jcenter()
        maven { url 'https://dl.bintray.com/natanbc/maven' }
        maven { url 'https://dl.bintray.com/sedmelluq/com.sedmelluq' }
        maven { url 'https://m2.dv8tion.net/releases' }
        maven { url 'https://jitpack.io' }
    }
}

ext {
    //@formatter:off
    configVersion =       '1.4.0'
    jdaNasVersion =       '1.1.0'
    jsr305Version =       '3.0.2'
    koeVersion =          '1864a8b803'
    nettyEpollVersion =   '4.1.52.Final'
    nettyKQueueVersion =  '4.1.52.Final'
    lavaplayerVersion =   '1.3.76'
    lpcrossVersion =      '0.1.1'
    ytRotatorVersion =    '0.1.7'
    lavadspVersion =      '0.7.6'
    logbackVersion =      '1.2.3'
    magmaVersion =        '0.12.5'
    nativeLoaderVersion = '0.7.0'
    prometheusVersion =   '0.9.0'
    sentryVersion =       '1.7.30'
    vertxWebVersion =     '3.9.3'
    
    jattachVersion =      'v1.5'
    //@formatter:on
}

mainClassName = 'andesite.Andesite'

dependencies {
    implementation project(':api')

    //Config
    implementation "com.typesafe:config:$configVersion"
    
    //REST, WebSocket, etc
    implementation "io.vertx:vertx-web:$vertxWebVersion"

    //Audio sending
    implementation "space.npstr.Magma:magma:$magmaVersion"

    //Audio sending
    implementation("moe.kyokobot.koe:core:$koeVersion") {
        exclude group: "org.slf4j", module: "slf4j-api"
    }
    implementation("moe.kyokobot.koe:ext-udpqueue:$koeVersion") {
        exclude group: 'com.sedmelluq', module: 'udp-queue'
    }

    //Native transports
    implementation "io.netty:netty-transport-native-epoll:$nettyEpollVersion:linux-x86_64"
    implementation "io.netty:netty-transport-native-kqueue:$nettyKQueueVersion:osx-x86_64"

    //Audio player
    implementation("com.sedmelluq:lavaplayer:$lavaplayerVersion") {
        exclude group: 'com.sedmelluq', module: 'lavaplayer-natives'
    }
    implementation "com.github.natanbc:lp-cross:$lpcrossVersion"

    //IPv6 rotation
    implementation("com.sedmelluq:lavaplayer-ext-youtube-rotator:$ytRotatorVersion") {
        exclude group: 'com.sedmelluq', module: 'lavaplayer'
    }

    //Audio filters
    implementation "com.github.natanbc:lavadsp:$lavadspVersion"
    //Native library loading
    implementation "com.github.natanbc:native-loader:$nativeLoaderVersion"

    //Native send system
    implementation("com.sedmelluq:jda-nas:$jdaNasVersion") {
        exclude group: 'com.sedmelluq', module: 'udp-queue'
    }

    //Logger implementation
    implementation "ch.qos.logback:logback-classic:$logbackVersion"

    //Error tracking
    implementation "io.sentry:sentry:$sentryVersion"
    implementation "io.sentry:sentry-logback:$sentryVersion"

    //Metrics
    implementation "io.prometheus:simpleclient:$prometheusVersion"
    implementation "io.prometheus:simpleclient_hotspot:$prometheusVersion"
    implementation "io.prometheus:simpleclient_logback:$prometheusVersion"

    //Code safety
    implementation "com.google.code.findbugs:jsr305:$jsr305Version"
}

def natives = [
        'all',
        'darwin',
        'freebsd-x86-64',
        'linux-aarch64',
        'linux-arm',
        'linux-x86',
        'linux-x86-64',
        'linux-musl-aarch64',
        'linux-musl-x86-64',
        'win-x86',
        'win-x86-64'
]

task buildAll {}

task buildImages {}

buildAll.dependsOn ':jattach-debug-plugin:jar'
buildAll.dependsOn ':api:jar'
buildAll.dependsOn ':api:javadoc'

task ci {
    dependsOn buildAll
    dependsOn buildImages
}

import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar

jar {
    manifest {
        attributes(
                'Main-Class': mainClassName
        )
    }
}
natives.each { arch ->
    def shadowTask = task("shadow-${arch}", type: ShadowJar) {
        archiveClassifier.set(arch)

        from project.sourceSets.main.output
        configurations = [ project.configurations.runtimeClasspath ]
        manifest.inheritFrom project.tasks.jar.manifest

        exclude 'natives/linux-aarch32/**'
        exclude 'natives/linux-armhf/**'

        exclude 'module-info.class'
        exclude 'lombok/**'
        exclude 'vertx-web-js/**'
        exclude 'vertx-web/**'
        exclude 'vertx-auth-common-js/**'
        exclude 'vertx-auth-common/**'
        exclude 'vertx-bridge-common-js/**'
        exclude 'vertx-bridge-common/**'
        exclude 'vertx-core/**'
        exclude 'Class50/**'
        exclude 'com/zwitserloot/**'
        exclude 'secondaryLoading.SCL.lombok/**'
        if(arch != 'all') {
            natives.each {
                if(it != arch) {
                    exclude "natives/${it}/**"
                }
            }
        }
    }
    buildAll.dependsOn shadowTask
}

def baseTags = ["natanbc/andesite:${getCommitHash()}"]
//only set latest tag for releases, so `docker pull natanbc/andesite`
//pulls the latest stable version
if(System.getenv("TAG") != null && !System.getenv("TAG").trim().isEmpty()) {
    baseTags << "natanbc/andesite:${version}"
    baseTags << "natanbc/andesite:latest"
}

buildImages.dependsOn createDockerBuild(
        "normal",
        file("Dockerfile"),
        baseTags,
        (ShadowJar)rootProject.tasks.findByName("shadow-linux-x86-64")
)
buildImages.dependsOn createDockerBuild(
        "alpine",
        file("musl/Dockerfile"),
        baseTags.collect {"$it-alpine" },
        (ShadowJar)rootProject.tasks.findByName("shadow-linux-musl-x86-64")
)

def lint = [
        "auxiliaryclass",
        "cast",
        "deprecation",
        "dep-ann",
        "divzero",
        "empty",
        "exports",
        "fallthrough",
        "finally",
        "module",
        "opens",
        "options",
        "overloads",
        "overrides",
        "path",
        "rawtypes",
        "removal",
        "static",
        "try",
        "unchecked",
        "varargs",
        "preview"
]

import org.apache.tools.ant.filters.ReplaceTokens

task sourcesForRelease(type: Copy) {
    from ('src/main/java') {
        include '**/Version.java'
        filter(ReplaceTokens, tokens: [
                VERSION_MAJOR:    versionObj.major,
                VERSION_MINOR:    versionObj.minor,
                VERSION_REVISION: versionObj.revision,
                COMMIT:           getCommitHash(),
                BUILD_NUMBER:     getBuildNumber()
        ])
    }
    into 'build/filteredSrc'

    includeEmptyDirs = false
}

task generateJavaSources(type: SourceTask) {
    def javaSources = sourceSets.main.allJava.filter {
        it.name != 'Version.java'
    }
    source = javaSources + sourcesForRelease.destinationDir

    dependsOn sourcesForRelease
}

compileJava {
    source = generateJavaSources.source

    dependsOn generateJavaSources
}

tasks.withType(JavaCompile) {
    options.encoding = 'UTF-8'
    options.incremental = true
    options.compilerArgs += ["-Xlint:${lint.join(",")}", "-Werror"]
}

compileTestJava.enabled = false
processTestResources.enabled = false

class Version {
    String major, minor, revision

    String toString() {
        "$major.$minor.$revision"
    }
}

static def getCommitHash() {
    def p = Runtime.getRuntime().exec("git rev-parse HEAD")
    p.waitFor()
    p.getIn().text.trim()
}

def createDockerBuild(String name, File dockerfile, List<String> tags, ShadowJar shadowTask) {
    if(!dockerfile.exists()) {
        throw new Exception("Dockerfile '$dockerfile' doesn't exist")
    }
    def dir = new File(project.buildDir, "docker/$name")
    dir.mkdirs()
    def jarTask = (org.gradle.jvm.tasks.Jar)tasks.getByPath(":jattach-debug-plugin:jar")
    def copyResults = tasks.create("dockerCopy-$name", Copy) {
        from(shadowTask.outputs) {
            include "*.jar"
        }
        from(jarTask.outputs) {
            include "*.jar"
        }
        from('.') {
            include "jlink.sh"
        }
        into dir
    }

    def dockerBuild = tasks.create("dockerBuild-$name", Exec) {
        dependsOn copyResults
        workingDir dir
        executable = 'docker'
        def argList = [
                "build",
                "-f",
                dockerfile.getAbsolutePath(),
                "--build-arg",
                "version=${rootProject.version}",
                "--build-arg",
                "jattachVersion=${jattachVersion}",
        ]
        tags.each { argList << "-t" << it }
        argList << "."
        args = argList
    }
    return dockerBuild
}

def getBuildNumber() {
    def properties = [
            "BUILD_NUMBER",
            "TRAVIS_BUILD_NUMBER",
            "GITHUB_RUN_ID"
    ]
    for(name in properties) {
        String property
        if(hasProperty(name)) {
            property = project.properties[name]
        } else {
            property = System.getenv(name) ?: ""
        }
        if(property != "") {
            return property
        }
    }
    return "unable to find build number"
}