build.gradle

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        
        classpath 'org.apache.httpcomponents:httpclient:4.5.9'
        classpath 'org.apache.httpcomponents:httpmime:4.5.9'


        classpath 'org.standardout:bnd-platform:1.7.0'
        classpath 'com.squareup.okhttp3:okhttp:4.8.0'
    }

}

plugins {
    id 'java'
    id 'eclipse'

    id 'maven-publish'
}

apply plugin: 'org.standardout.bnd-platform'

version = "${getVersion()}-SNAPSHOT"

def revision = System.getProperty("revision")


def getGitHash() {
  if (System.getenv("CI")) {
    System.getenv("GITHUB_SHA")
  } else {
    getLocalGitHash()
  }
}

def getGitTimestamp() {
    def stdout = new ByteArrayOutputStream()
    exec {
        commandLine 'git', 'log', '-1', '--date=iso-strict', '--format=%cd', 'HEAD'
        standardOutput = stdout
    }
    return java.time.OffsetDateTime.parse(stdout.toString().trim()).toInstant()    
}

def getLocalShortGitHash() {
    def stdout = new ByteArrayOutputStream()
    exec {
        commandLine 'git', 'rev-parse', '--short', 'HEAD'
        standardOutput = stdout
    }
    return stdout.toString().trim()
}

def getLocalGitHash() {
    def stdout = new ByteArrayOutputStream()
    exec {
        commandLine 'git', 'rev-parse', 'HEAD'
        standardOutput = stdout
    }
    return stdout.toString().trim()
}

def getReleaseTag() {
    def stdout = new ByteArrayOutputStream()
    exec {
        commandLine 'git', 'describe', '--tags'
        ignoreExitValue true
        standardOutput = stdout
    }
    def tag = stdout.toString().trim()
    if (tag.matches('R[0-9]+\\.[0-9]+\\.[0-9]+')) {
        return tag
    }
    return null
}

def getVersion() {
    def tag = getReleaseTag()
    if (tag != null) {
        return tag.substring(1)
    } else {
        return '999.0.0'
    }
    
}

def getQualifier() {
    if (getReleaseTag() == null)
        "${toTimestamp(getGitTimestamp())}-${getLocalShortGitHash()}"
    else
        null
}

def toTimestamp(instant) {
    return java.time.format.DateTimeFormatter.ofPattern("yyyyMMdd-HHmmss").withZone( ZoneId.of("UTC") ).format(instant)
}

task showInfo {
    doLast {
        println "Release Tag: ${getReleaseTag()}"
        println "Version: ${getVersion()}"
        println "Qualifier: ${getQualifier()}"
        println "last commit: ${getGitTimestamp()}" 
        println " -> ${toTimestamp(getGitTimestamp())}"
    }
}



allprojects {
    repositories {
        mavenCentral()
    }
}

subprojects {

}

def test() {

    println "executing test()"
    "foo bar"
}

def getJava8() {
	"${System.getenv('JAVA_HOME_8')}/bin/javac"
}

def getJava11() {
	"${System.getenv('JAVA_HOME_11')}/bin/javac"
}

def releaseTag = getReleaseTag()
def version = getVersion()
def qualifier = getQualifier()
def fullVersion = releaseTag == null ? "${version}-${qualifier}" : "$version"
def bundleVersion = releaseTag == null ? "${version}.${qualifier}" : "$version"



subprojects.each { subproject -> evaluationDependsOn( subproject.path ) }

task buildMrJar(type: Jar, dependsOn: [ 
    subprojects.tasks['classes'],
    showInfo
]) {
    archiveBaseName = 'org.eclipse.fx.drift'

    from( project(':org.eclipse.fx.drift').sourceSets.main.output ) {
        exclude 'org/eclipse/fx/drift/DriftFXSurface.class'
        exclude 'org/eclipse/fx/drift/internal/DriftUtil.class'
    }
    from project(':org.eclipse.fx.drift.java8').sourceSets.main.output

    into('META-INF/versions/11') {
        from project(':org.eclipse.fx.drift.java11').sourceSets.main.output
    }

    // manual header
    manifest {
        attributes(
                "Manifest-Version": "1.0",
                'Bundle-ManifestVersion': '2',
                'Bundle-SymbolicName': 'org.eclipse.fx.drift',
                'Bundle-Version': "${bundleVersion}",
                "Multi-Release": true,
                'Export-Package': "org.eclipse.fx.drift;version=\"${version}\",org.eclipse.fx.drift.impl;version=\"${version}\"",
                'Private-Package': 'org.eclipse.fx.drift.internal',
                'Bundle-Activator': 'org.eclipse.fx.drift.internal.OSGiActivator',
                'Bundle-NativeCode': 'native/driftfx.dll;osname=Win32;processor=x86-64,native/driftcpp.dll;osname=Win32;processor=x86-64,native/libdriftfx.so;osname=Linux;processor=x86-64,native/libdriftcpp.so;osname=Linux;processor=x86-64,native/libdriftfx.dylib;osname=MacOSX;processor=x86-64,native/libdriftcpp.dylib;osname=MacOSX;processor=x86-64'
        )
    }
    doLast {
        println "${version}"
    }
}

task downloadGithubArtifact {
    outputs.files(
        "$buildDir/downloaded/github-artifacts.zip",
        "$buildDir/downloaded/native-repo.zip")
    doLast {
        def runId = System.getenv('GITHUB_RUN_ID')
        def runArtifacts = github.getArtifacts(runId)

        def artifactUnsigned = runArtifacts.artifacts.find { it.name == 'artifact-unsigned' }
        github.downloadArtifact(artifactUnsigned.archive_download_url, "$buildDir/downloaded/github-artifacts.zip")
        
        def artifactNativeRepo = runArtifacts.artifacts.find { it.name == 'native-repo'}
        github.downloadArtifact(artifactNativeRepo.archive_download_url, "$buildDir/downloaded/native-repo.zip")
    }
}

task askGithub {
    doLast {
        def runId = System.getenv('GITHUB_RUN_ID')
        def runArtifacts = github.getArtifacts(runId)
        println runArtifacts
        println '---'
        println groovy.json.JsonOutput.toJson(runArtifacts)
    }
}

task unzipGithubArtifact(type: Copy) {
    dependsOn downloadGithubArtifact
    from {
        zipTree("$buildDir/downloaded/github-artifacts.zip")
    }
    into "$buildDir/unsigned"


}
task unzipNativeRepo(type: Copy) {
    dependsOn downloadGithubArtifact
    inputs.files("$buildDir/downloaded/native-repo.zip")
    from {
        zipTree("$buildDir/downloaded/native-repo.zip")
    }
    into "$buildDir/native-repo"
}

task signJarFiles() {
    dependsOn unzipGithubArtifact
    doLast {
        def sourceFile = "$buildDir/unsigned/org.eclipse.fx.drift.jar"
        def targetFile = "$buildDir/signed/org.eclipse.fx.drift.jar"
        mkdir "$buildDir/signed"
        def stdout = new ByteArrayOutputStream()
        exec {
            commandLine 'curl', '-sS', '-o', targetFile, '-F', "file=@$sourceFile", 'http://build.eclipse.org:31338/sign'
            standardOutput = stdout
        }
        println "${new File(targetFile)}"
    }
}

platform {

    featureId = 'org.eclipse.fx.drift.feature'
    featureName = 'DriftFX'
    featureVersion = "$bundleVersion"
    featureProvider = "BestSolution"

    categoryId = 'org.eclipse.fx.drift'
    categoryName = 'e(fx)clipse Drift'

    fetchSources = false
    useBndHashQualifiers = false
    useFeatureHashQualifiers = false
    //generatePlatformFeature = false

    bundle file("$buildDir/signed/org.eclipse.fx.drift.jar")
    
/*    bundle file("$buildDir/downloaded/org.eclipse.fx.drift.jar"), {
        bnd {
            version = '2.5.0'
            symbolicName = 'the.super.drift'
        }
    }*/

/*
    feature (id: 'org.eclipse.fx.drift.feature', name: 'DriftFX Runtime', version: '') {
        plugin file("$buildDir/downloaded/org.eclipse.fx.drift.jar")
    }
*/
}

task ghCreateRelease() {
    dependsOn updateSiteZip
    doLast {

    }
}

ext.githubToken = System.getenv('GH_ACCESS_TOKEN')


ext.github = new GithubAPI(githubOrga, githubRepo, System.getenv('GH_ACCESS_TOKEN'))

import okhttp3.*
ext.client = new OkHttpClient()



task listGithubReleases() {
    doLast {

        println "${getReleaseTag()}"

        println github.getReleases()
        println '---'

        println "by tag asdf: ${github.getReleaseByTagName('asdf')}"
        println "by tag test123: ${github.getReleaseByTagName('test123')}"
    }
}

task testGithubRelease() {
    doLast {
        github.createRelease("v1.2.4", getGitHash(), "DriftFX 1.2.4", """
        # The release name
        Finally released.
        https://download.eclipse.org/efxclipse/drift/nightly/or-so
        ## markdown =?
        * maybe
        * maybe not
        """.stripIndent().trim())
    }
}

task notifyJenkins() {
    doLast {
        def jenkinsToken = System.getenv("JENKINS_ACCESS_TOKEN")
        def runId = System.getenv('GITHUB_RUN_ID')
        //def githubToken = System.getenv('GH_ACCESS_TOKEN')

        def request = new Request.Builder()
        .url("https://ci.eclipse.org/efxclipse/job/efxclipse_drift_build/buildWithParameters?token=$jenkinsToken&GITHUB_ACCESS_TOKEN=$githubToken&GITHUB_RUN_ID=$runId&GIT_SHA=${getGitHash()}")
        .build()
        def response = client.newCall(request).execute()
        println "notify jenkins: ${response.code}"
    }
}

task deployUpdateSite() {
    dependsOn updateSite
    doLast {
        def remoteHost = "genie.efxclipse@projects-storage.eclipse.org"
        def remoteDirectory = "/home/data/httpd/download.eclipse.org/efxclipse"

        def target = ""
        if (releaseTag != null) {
            target = "$remoteDirectory/driftfx/$releaseTag"
        } else {
            target = "$remoteDirectory/driftfx/nightly/$qualifier"
        }

        // create update site directory
        def stdout = new ByteArrayOutputStream()
        exec {
            commandLine 'ssh', remoteHost, 'mkdir', '-p', target
            standardOutput = stdout
        }
        println stdout.toString().trim()

        // copy update site
        stdout = new ByteArrayOutputStream()
        exec {
            commandLine 'scp', '-r', 'build/updatesite/features', 'build/updatesite/plugins', 'build/updatesite/content.jar', 'build/updatesite/artifacts.jar', "$remoteHost:$target"
            standardOutput = stdout
        }
        println stdout.toString().trim()
    }
}

task createDistribution(type: Zip) {
    dependsOn updateSiteZip
    dependsOn unzipNativeRepo

    from file("$buildDir/updatesite.zip")

    into('include') {
        from "native-gradle/driftcpp/src/main/public"
    }

    into('libs/debug') {
        from fileTree("$buildDir/native-repo/org/eclipse/fx/drift/driftcpp_debug_windows") {
            include "**/*.dll"
            include "*/*.lib"
            eachFile { path = "libs/debug/$name" } // flatten into libs
            includeEmptyDirs = false
        }
        from fileTree("$buildDir/native-repo/org/eclipse/fx/drift/driftcpp_debug_linux") {
            include "**/*.so"
            eachFile { path = "libs/debug/$name" } // flatten into libs
            includeEmptyDirs = false
        }
        from fileTree("$buildDir/native-repo/org/eclipse/fx/drift/driftcpp_debug_macos") {
            include "**/*.dylib"
            eachFile { path = "libs/debug/$name" } // flatten into libs
            includeEmptyDirs = false
        }
    }

    into('libs/release') {
        from fileTree("$buildDir/native-repo/org/eclipse/fx/drift/driftcpp_release_windows") {
            include "**/*.dll"
            include "*/*.lib"
            eachFile { path = "libs/release/$name" } // flatten into libs
            includeEmptyDirs = false
        }
        from fileTree("$buildDir/native-repo/org/eclipse/fx/drift/driftcpp_release_linux") {
            include "**/*.so"
            eachFile { path = "libs/release/$name" } // flatten into libs
            includeEmptyDirs = false
        }
        from fileTree("$buildDir/native-repo/org/eclipse/fx/drift/driftcpp_release_macos") {
            include "**/*.dylib"
            eachFile { path = "libs/release/$name" } // flatten into libs
            includeEmptyDirs = false
        }
    }

    archiveBaseName = "dist"
    archiveVersion = "$fullVersion"

}

task uploadDistribution

publishing {
    publications {
        maven(MavenPublication) {
            groupId = 'org.eclipse.fx.drift'
            artifactId = 'org.eclipse.fx.drift'
            version = "1.3"
            artifact("$buildDir/signed/org.eclipse.fx.drift.jar") {
                extension 'jar'
            }
        }
    }
    repositories {
        maven {
            url = "$buildDir/maven-repo"
        }
    }
}