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'
    id 'visual-studio'
}

apply plugin: 'org.standardout.bnd-platform'
apply from: 'versioning.gradle'

version = "${Versioning.version}-SNAPSHOT"

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

allprojects {
    repositories {
        mavenCentral()
    }
}

subprojects {

}

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

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


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

task showIt() {
    println "Showing It"
    println Versioning.releaseTag
    doLast {
        println Versioning
    }
}

task copyNatives(type: Copy) {

    // driftfx
    from "native-repo/org/eclipse/fx/drift/driftfx_release_windows/$Versioning.fullVersion/driftfx_release_windows-${Versioning.fullVersion}.dll"
    from "native-repo/org/eclipse/fx/drift/driftfx_release_linux/$Versioning.fullVersion/driftfx_release_linux-${Versioning.fullVersion}.so"
    from "native-repo/org/eclipse/fx/drift/driftfx_release_macos/$Versioning.fullVersion/driftfx_release_macos-${Versioning.fullVersion}.dylib"
    
    // driftcpp
    from "native-repo/org/eclipse/fx/drift/driftcpp_release_windows/$Versioning.fullVersion/driftcpp_release_windows-${Versioning.fullVersion}.dll"
    from "native-repo/org/eclipse/fx/drift/driftcpp_release_linux/$Versioning.fullVersion/driftcpp_release_linux-${Versioning.fullVersion}.so"
    from "native-repo/org/eclipse/fx/drift/driftcpp_release_macos/$Versioning.fullVersion/driftcpp_release_macos-${Versioning.fullVersion}.dylib"
    

    into 'org.eclipse.fx.drift/src/main/resources/native'

    rename { fileName ->
        fileName
            .replaceAll("driftfx_release_windows-.*[.]dll", "driftfx.dll")
            .replaceAll("driftfx_release_linux-.*[.]so", "libdriftfx.so")
            .replaceAll("driftfx_release_macos-.*[.]dylib", "libdriftfx.dylib")

            .replaceAll("driftcpp_release_windows-.*[.]dll", "driftcpp.dll")
            .replaceAll("driftcpp_release_linux-.*[.]so", "libdriftcpp.so")
            .replaceAll("driftcpp_release_macos-.*[.]dylib", "libdriftcpp.dylib")
    }
    
}



task buildMultireleaseJar(type: Jar, dependsOn: [
    copyNatives,
    project(':org.eclipse.fx.drift').tasks['classes'],
    project(':org.eclipse.fx.drift.java8').tasks['classes'],
    project(':org.eclipse.fx.drift.java11').tasks['classes']
]) {
    archiveBaseName = 'org.eclipse.fx.drift'
    archiveVersion = '' //"$fullVersion"

    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': "${Versioning.bundleVersion}",
                "Multi-Release": true,
                'Export-Package': "org.eclipse.fx.drift;version=\"${Versioning.version}\",org.eclipse.fx.drift.impl;version=\"${Versioning.version}\",org.eclipse.fx.drift.util;version=\"${Versioning.version}\"",
                'Import-Package': "org.osgi.framework,org.osgi.framework.wiring",
                'Private-Package': 'org.eclipse.fx.drift.internal',
                'Bundle-ActivationPolicy': 'lazy',
                'Bundle-Activator': 'org.eclipse.fx.drift.internal.OSGiActivator',
                'Bundle-NativeCode': 'native/driftfx.dll;native/driftcpp.dll;osname=Win32;processor=x86-64,native/libdriftfx.so;native/libdriftcpp.so;osname=Linux;processor=x86-64,native/libdriftfx.dylib;native/libdriftcpp.dylib;osname=MacOSX;processor=x86-64',
                'Drift-Version': "$Versioning.version",
                'Drift-Qualifier': "$Versioning.qualifier",
                'Drift-Timestamp': "$Versioning.timestamp",
                'Drift-SHA': "$Versioning.gitSHA"
        )
    }
    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 = Versioning.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.github = new GithubAPI(githubOrga, githubRepo, System.getenv('GITHUB_ACCESS_TOKEN'))

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


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 githubRef = System.getenv('GITHUB_REF')

        def req = 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=${Versioning.gitSHA}&GITHUB_REF=$githubRef")
        .build()
        def res = client.newCall(req).execute()

        assert res.code == 201
        println "triggered jenkins build"
    }
}

ext {
    UpdateSiteReleaseBase = "efxclipse/driftfx/releases"
    UpdateSiteNightlyBase = "efxclipse/driftfx/nightly"

    UpdateSitePath = Versioning.releaseMode ? "efxclipse/driftfx/$Versioning.version" : "efxclipse/driftfx/nightly/$Versioning.qualifier"
}

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

        def target = "$remoteDirectory/$UpdateSitePath"
        println "Deploying update site to '$target'"

        // 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 updateCompositeUpdateSite() {

    doLast {
        def remoteHost = "genie.efxclipse@projects-storage.eclipse.org"
        def compositeDirectory = "/home/data/httpd/download.eclipse.org"
        def target = "${compositeDirectory}/${UpdateSiteBaseNightly}"
        def stdout = new ByteArrayOutputStream()
        exec {
            commandLine 'ssh', "$remoteHost", "ls", "$target"
            standardOutput = stdout
        }


    }
}
*/

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

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

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

    into('libs/debug') {
        from fileTree("$buildDir/native-repo/org/eclipse/fx/drift/driftcpp_debug_windows") {
            include "**/*${Versioning.fullVersion}.dll"
            include "*/*${Versioning.fullVersion}.lib"
            eachFile { path = "libs/debug/$name" } // flatten into libs
            includeEmptyDirs = false
        }
        from fileTree("$buildDir/native-repo/org/eclipse/fx/drift/driftcpp_debug_linux") {
            include "**/*${Versioning.fullVersion}.so"
            eachFile { path = "libs/debug/$name" } // flatten into libs
            includeEmptyDirs = false
        }
        from fileTree("$buildDir/native-repo/org/eclipse/fx/drift/driftcpp_debug_macos") {
            include "**/*${Versioning.fullVersion}.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 "**/*${Versioning.fullVersion}.dll"
            include "*/*${Versioning.fullVersion}.lib"
            eachFile { path = "libs/release/$name" } // flatten into libs
            includeEmptyDirs = false
        }
        from fileTree("$buildDir/native-repo/org/eclipse/fx/drift/driftcpp_release_linux") {
            include "**/*${Versioning.fullVersion}.so"
            eachFile { path = "libs/release/$name" } // flatten into libs
            includeEmptyDirs = false
        }
        from fileTree("$buildDir/native-repo/org/eclipse/fx/drift/driftcpp_release_macos") {
            include "**/*${Versioning.fullVersion}.dylib"
            eachFile { path = "libs/release/$name" } // flatten into libs
            includeEmptyDirs = false
        }
    }

    archiveBaseName = "dist"
    archiveVersion = Versioning.fullVersion

}

task publishGithubRelease() {
    doLast {
        if (Versioning.releaseMode) {

            def release = github.createRelease(Versioning.releaseTag, Versioning.gitSHA, "DriftFX $Versioning.version", """
            
            ### Update Site
            https://download.eclipse.org/$UpdateSitePath
            ### Maven
            Repo: https://repo.eclipse.org/content/groups/efxclipse   
            Group Id: `org.eclipse.fx`    
            Artifact Id: `org.eclipse.fx.drift`   
            Version: `$Versioning.version`   

            """.stripIndent().trim(), false)

            def releaseId = release.id
            println "Created Release $releaseId"

            def uploadUrl = release.upload_url

            def distZip = file("build/distributions/dist-${Versioning.version}.zip")
            def r = github.uploadAsset(release.upload_url, 
                "application/zip", distZip,
                "driftfx-dist-${Versioning.version}.zip",
                null)

            def modify = github.modifyRelease(releaseId, Versioning.releaseTag, true)
            println new groovy.json.JsonBuilder(modify).toPrettyString()

        } else {

          def release = github.createRelease(Versioning.timestamp, Versioning.gitSHA, "DriftFX Nightly $Versioning.qualifier", """
            This is a nightly build. (The Version number 999.0.0 indicates nightly builds)

            ### Update Site
            https://download.eclipse.org/$UpdateSitePath
            ### Maven
            Repo: https://repo.eclipse.org/content/groups/efxclipse 
            Group Id: `org.eclipse.fx`    
            Artifact Id: `org.eclipse.fx.drift`   
            Version: `$Versioning.version-SNAPSHOT`   

            """.stripIndent().trim(), true)
            println new groovy.json.JsonBuilder(release).toPrettyString()
            def releaseId = release.id
            println "Created Nightly Release $releaseId"

            def uploadUrl = release.upload_url

            def distZip = file("build/distributions/dist-${Versioning.fullVersion}.zip")
            def r = github.uploadAsset(release.upload_url, 
                "application/zip", distZip,
                "driftfx-dist-${Versioning.fullVersion}.zip",
                null)

            println "going to modify release..."
            
            def modify = github.modifyRelease(releaseId, Versioning.timestamp, true)
            println new groovy.json.JsonBuilder(modify).toPrettyString()


        }

    }
}

task undoRelease() {
    doLast {
         def modify = github.modifyRelease("${System.getenv("RELID")}", true)
         println new groovy.json.JsonBuilder(modify).toPrettyString()
    }
}

publishing {
    publications {
        maven(MavenPublication) {
            groupId = 'org.eclipse.fx'
            artifactId = 'org.eclipse.fx.drift'
            version = "${Versioning.version}${Versioning.releaseMode ? '' : '-SNAPSHOT'}"
            artifact("$buildDir/signed/org.eclipse.fx.drift.jar") {
                extension 'jar'
            }
        }
    }
    repositories {
        maven {
            name = "GitHubPackages"
            url = "https://maven.pkg.github.com/$githubOrga/$githubRepo"
            credentials {
                username = "redrezo"
                password = "${System.getenv('GITHUB_ACCESS_TOKEN')}"
            }
        }

        if (project.hasProperty('eclipseRepoUsername')) {
            maven {
                name = 'EclipseNexus'
                def releasesUrl = 'https://repo.eclipse.org/content/repositories/efxclipse-releases'
                def snapshotsUrl = 'https://repo.eclipse.org/content/repositories/efxclipse-snapshots'
                url = Versioning.releaseMode ? releasesUrl : snapshotsUrl
                credentials {
                    username eclipseRepoUsername
                    password eclipseRepoPassword
                }
                authentication {
                    basic(BasicAuthentication)
                }
            }
        }
    }
}