import org.apache.tools.ant.filters.ReplaceTokens //import org.apache.tools.ant.filters.ReplaceRegexp import org.gradle.internal.os.OperatingSystem import org.gradle.plugins.ide.eclipse.model.* import groovy.transform.ExternalizeMethods buildscript { dependencies { classpath 'org.openclover:clover:4.3.1' classpath 'org.apache.commons:commons-compress:1.18' } } plugins { id 'java' id 'application' id 'eclipse' id 'com.github.johnrengelman.shadow' version '4.0.3' id 'com.install4j.gradle' version '7.0.9' } repositories { jcenter() mavenCentral() mavenLocal() flatDir { dirs gradlePluginsDir } } mainClassName = launcherClass def cloverInstrDir = file("$buildDir/$cloverSourcesInstrDir") def classes = "$jalviewDir/$classesDir" if (clover.equals("true")) { use_clover = true classes = "$buildDir/$cloverClassesDir" } else { use_clover = false classes = "$jalviewDir/$classesDir" } // configure classpath/args for j8/j11 compilation def jalviewDirAbsolutePath = file(jalviewDir).getAbsolutePath() def libDir def libDistDir def compile_source_compatibility def compile_target_compatibility ext { getdownWebsiteDir = jalviewDir + '/' + getdown_website_dir + '/' + JAVA_VERSION getdownDir = "" reportRsyncCmd = false buildDist = true buildProperties = buildPropertiesFile getdownLauncher = jalviewDir + '/' + getdown_lib_dir + '/' + getdown_launcher switch (CHANNEL) { case "BUILD": // TODO: get bamboo build artifact URL for getdown artifacts getdown_channel_base = bamboo_channelbase getdown_channel_name = bamboo_planKey + '/'+JAVA_VERSION getdown_app_base = bamboo_channelbase + '/'+ bamboo_planKey + bamboo_getdown_channel_suffix + '/'+JAVA_VERSION getdown_app_dir = getdown_app_dir_alt buildProperties = jalviewDir + "/" + classesDir +"/" + buildPropertiesFile break case "RELEASE": getdown_channel_name = CHANNEL.toLowerCase() getdownDir = getdown_channel_name + "/" + JAVA_VERSION getdown_app_base = getdown_channel_base + "/" + getdownDir getdown_app_dir = getdown_app_dir_release buildProperties = jalviewDir + "/" + classesDir +"/" + buildPropertiesFile reportRsyncCommand = true break case "ARCHIVE": getdown_channel_name = CHANNEL.toLowerCase()+"/"+JALVIEW_VERSION getdownDir = getdown_channel_name + "/" + JAVA_VERSION getdown_app_base = getdown_channel_base + "/" + getdownDir getdown_app_dir = getdown_app_dir_alt if (!file(ARCHIVEDIR+"/"+packageDir).exists()) { print "Must provide an ARCHIVEDIR value to produce an archive distribution" exit } else { packageDir = ARCHIVEDIR + "/" + packageDir buildProperties = ARCHIVEDIR +"/" + classesDir + "/" + buildPropertiesFile buildDist = false } reportRsyncCommand = true break case "ARCHIVELOCAL": getdown_channel_name = "archive" + "/" + JALVIEW_VERSION getdownDir = getdown_channel_name + "/" + JAVA_VERSION getdown_app_base = file(getdownWebsiteDir).toURI().toString() getdown_app_dir = getdown_app_dir_alt if (!file(ARCHIVEDIR+"/"+packageDir).exists()) { print "Must provide an ARCHIVEDIR value to produce an archive distribution" exit } else { packageDir = ARCHIVEDIR + "/" + packageDir buildProperties = ARCHIVEDIR +"/" + classesDir + "/" + buildPropertiesFile buildDist = false } reportRsyncCommand = true getdownLauncher = jalviewDir + '/' + getdown_lib_dir + '/' + getdown_launcher_local break case "DEVELOP": getdown_channel_name = CHANNEL.toLowerCase() getdownDir = getdown_channel_name + "/" + JAVA_VERSION getdown_app_base = getdown_channel_base + "/" + getdownDir getdown_app_dir = getdown_app_dir_alt buildProperties = jalviewDir + "/" + classesDir +"/" + buildPropertiesFile reportRsyncCommand = true break case "TEST-RELEASE": getdown_channel_name = CHANNEL.toLowerCase() getdownDir = getdown_channel_name + "/" + JAVA_VERSION getdown_app_base = getdown_channel_base + "/" + getdownDir getdown_app_dir = getdown_app_dir_alt buildProperties = jalviewDir + "/" + classesDir +"/" + buildPropertiesFile reportRsyncCommand = true break case ~/^SCRATCH(|-[-\w]*)$/: getdown_channel_name = CHANNEL getdownDir = getdown_channel_name + "/" + JAVA_VERSION getdown_app_base = getdown_channel_base + "/" + getdownDir getdown_app_dir = getdown_app_dir_alt buildProperties = jalviewDir + "/" + classesDir +"/" + buildPropertiesFile reportRsyncCommand = true break case "LOCAL": getdown_app_base = file(getdownWebsiteDir).toURI().toString() getdown_app_dir = getdown_app_dir_alt buildProperties = jalviewDir + "/" + classesDir +"/" + buildPropertiesFile getdownLauncher = jalviewDir + '/' + getdown_lib_dir + '/' + getdown_launcher_local break default: // something wrong specified print("CHANNEL must be one of BUILD, RELEASE, ARCHIVE, DEVELOP, TEST-RELEASE, SCRATCH-..., LOCAL [default]") exit break } println("Using a "+CHANNEL+" profile. appbase="+getdown_app_base) getdownAppDir = getdownWebsiteDir + '/' + getdown_app_dir //getdownJ11libDir = getdownWebsiteDir + '/' + getdown_j11lib_dir getdownResourceDir = getdownWebsiteDir + '/' + getdown_resource_dir getdownInstallDir = getdownWebsiteDir + '/' + getdown_install_dir getdownFilesDir = jalviewDir + '/' + getdown_files_dir + '/' + JAVA_VERSION + '/' getdownFilesInstallDir = getdownFilesDir+"/"+getdown_install_dir /* compile without modules -- using classpath libraries modules_compileClasspath = fileTree(dir: "$jalviewDir/$j11modDir", include: ["*.jar"]) modules_runtimeClasspath = modules_compileClasspath */ gitHash = "" gitBranch = "" } def JAVA_INTEGER_VERSION def additional_compiler_args = [] // these are getdown.txt properties defined dependent on the JAVA_VERSION def getdown_alt_java_min_version def getdown_alt_java_max_version // this property is assigned below and expanded to multiple lines in the getdown task def getdown_alt_multi_java_location // this property is for the Java library used in eclipse def eclipse_java_runtime_name if (JAVA_VERSION.equals("1.8")) { JAVA_INTEGER_VERSION = "8" //libDir = j8libDir libDir = j11libDir libDistDir = j8libDir compile_source_compatibility = 1.8 compile_target_compatibility = 1.8 getdown_alt_java_min_version = getdown_alt_java8_min_version getdown_alt_java_max_version = getdown_alt_java8_max_version getdown_alt_multi_java_location = getdown_alt_java8_txt_multi_java_location eclipse_java_runtime_name = "JavaSE-1.8" } else if (JAVA_VERSION.equals("11")) { JAVA_INTEGER_VERSION = "11" libDir = j11libDir libDistDir = j11libDir compile_source_compatibility = 11 compile_target_compatibility = 11 getdown_alt_java_min_version = getdown_alt_java11_min_version getdown_alt_java_max_version = getdown_alt_java11_max_version getdown_alt_multi_java_location = getdown_alt_java11_txt_multi_java_location eclipse_java_runtime_name = "JavaSE-11" /* compile without modules -- using classpath libraries additional_compiler_args += [ '--module-path', ext.modules_compileClasspath.asPath, '--add-modules', j11modules ] */ } else if (JAVA_VERSION.equals("12") || JAVA_VERSION.equals("13")) { JAVA_INTEGER_VERSION = JAVA_VERSION libDir = j11libDir libDistDir = j11libDir compile_source_compatibility = JAVA_VERSION compile_target_compatibility = JAVA_VERSION getdown_alt_java_min_version = getdown_alt_java11_min_version getdown_alt_java_max_version = getdown_alt_java11_max_version getdown_alt_multi_java_location = getdown_alt_java11_txt_multi_java_location eclipse_java_runtime_name = "JavaSE-11" /* compile without modules -- using classpath libraries additional_compiler_args += [ '--module-path', ext.modules_compileClasspath.asPath, '--add-modules', j11modules ] */ } else { throw new GradleException("JAVA_VERSION=$JAVA_VERSION not currently supported by Jalview") } sourceSets { main { java { srcDirs "$jalviewDir/$sourceDir" outputDir = file("$classes") } resources { srcDirs "$jalviewDir/$resourceDir" } jar.destinationDir = file("$jalviewDir/$packageDir") compileClasspath = files(sourceSets.main.java.outputDir) compileClasspath += fileTree(dir: "$jalviewDir/$libDir", include: ["*.jar"]) runtimeClasspath = compileClasspath } clover { java { srcDirs = [ cloverInstrDir ] outputDir = file("${buildDir}/${cloverClassesDir}") } resources { srcDirs = sourceSets.main.resources.srcDirs } compileClasspath = configurations.cloverRuntime + files( sourceSets.clover.java.outputDir ) compileClasspath += files(sourceSets.main.java.outputDir) compileClasspath += sourceSets.main.compileClasspath compileClasspath += fileTree(dir: "$jalviewDir/$utilsDir", include: ["**/*.jar"]) compileClasspath += fileTree(dir: "$jalviewDir/$libDir", include: ["*.jar"]) runtimeClasspath = compileClasspath } test { java { srcDirs "$jalviewDir/$testSourceDir" outputDir = file("$jalviewDir/$testOutputDir") } resources { srcDirs = sourceSets.main.resources.srcDirs } compileClasspath = files( sourceSets.test.java.outputDir ) if (use_clover) { compileClasspath += sourceSets.clover.compileClasspath } else { compileClasspath += files(sourceSets.main.java.outputDir) } compileClasspath += fileTree(dir: "$jalviewDir/$utilsDir", include: ["**/*.jar"]) compileClasspath += fileTree(dir: "$jalviewDir/$libDir", include: ["*.jar"]) runtimeClasspath = compileClasspath } } // clover bits dependencies { if (use_clover) { cloverCompile 'org.openclover:clover:4.3.1' testCompile 'org.openclover:clover:4.3.1' } } configurations { cloverRuntime cloverRuntime.extendsFrom cloverCompile } eclipse { project { name = "Jalview with gradle build" natures 'org.eclipse.jdt.core.javanature', 'org.eclipse.jdt.groovy.core.groovyNature', 'org.eclipse.buildship.core.gradleprojectnature' buildCommand 'org.eclipse.jdt.core.javabuilder' buildCommand 'org.eclipse.buildship.core.gradleprojectbuilder' } classpath { //defaultOutputDir = sourceSets.main.java.outputDir def removeThese = [] configurations.each{ if (it.isCanBeResolved()) { removeThese += it } } minusConfigurations += removeThese plusConfigurations = [ ] file { whenMerged { cp -> def removeTheseToo = [] HashMap addedSrcPath = new HashMap<>(); cp.entries.each { entry -> if (entry.kind == 'src') { if (addedSrcPath.getAt(entry.path) || !(entry.path == "src" || entry.path == "test")) { removeTheseToo += entry } else { addedSrcPath.putAt(entry.path, true) } } } cp.entries.removeAll(removeTheseToo) print ("CP="+cp.inspect()) cp.entries += new Output("bin/main") cp.entries += new Library(fileReference(helpParentDir)) cp.entries += new Library(fileReference(resourceDir)) HashMap addedLibPath = new HashMap<>(); // changing from sourcesets.main.classpath to specific Java version lib //sourceSets.main.compileClasspath.each{ fileTree("$jalviewDir/$libDistDir").include("**/*.jar").include("*.jar").each { //don't want to add outputDir as eclipse is using its own output dir in bin/main if (it.isDirectory() || ! it.exists()) { // don't add dirs to classpath return } def itPath = it.toString() if (itPath.startsWith(jalviewDirAbsolutePath+"/")) { itPath = itPath.substring(jalviewDirAbsolutePath.length()+1) } if (addedLibPath.get(itPath)) { //println("Not adding duplicate entry "+itPath) } else { //println("Adding entry "+itPath) cp.entries += new Library(fileReference(itPath)) addedLibPath.put(itPath, true) } } // changing from sourcesets.main.classpath to specific Java version lib //sourceSets.test.compileClasspath.each{ fileTree(dir: "$jalviewDir/$utilsDir", include: ["**/*.jar"]).each { //if ((it.isDirectory() || ! it.exists()) && ! (it.equals(sourceSets.main.java.outputDir))) { //no longer want to add outputDir as eclipse is using its own output dir in bin/main if (it.isDirectory() || ! it.exists()) { // don't add dirs to classpath return false // groovy "break" in .each loop } def itPath = it.toString() if (itPath.startsWith(jalviewDirAbsolutePath+"/")) { itPath = itPath.substring(jalviewDirAbsolutePath.length()+1) } if (addedLibPath.get(itPath)) { // don't duplicate } else { def lib = new Library(fileReference(itPath)) // this doesn't work... yet. Adding test=true attribute using withXml below //def attrs = new Node(null, 'attributes', ["test":"true"]) //lib.appendNode(attrs) // cp.entries += lib addedLibPath.put(itPath, true) } } } // withXml changes ignored by buildship, these add the "test=true" attribute withXml { def node = it.asNode() def srcTestAttributes node.children().each{ cpe -> def attributes = cpe.attributes() if (attributes.get("kind") == "src" && attributes.get("path") == "test") { srcTestAttributes = cpe.find { a -> a.name() == "attributes" } return } } def addTestAttribute = true srcTestAttributes.each{a -> if (a.name() == "attribute" && a.attributes().getAt("name") == "test") { addTestAttribute = false } } if (addTestAttribute) { srcTestAttributes.append(new Node(null, "attribute", [name:"test", value:"true"])) } node.children().each{ cpe -> def attributes = cpe.attributes() if (attributes.get("kind") == "lib" && attributes.get("path").startsWith("utils/")) { cpe.appendNode('attributes') .appendNode('attribute', [name:"test", value:"true"]) } } } // withXML } // file containers 'org.eclipse.buildship.core.gradleclasspathcontainer' } // classpath jdt { // for the IDE, use java 11 compatibility sourceCompatibility = compile_source_compatibility targetCompatibility = compile_target_compatibility javaRuntimeName = eclipse_java_runtime_name file { withProperties { props -> def jalview_prefs = new Properties() def ins = new FileInputStream(jalviewDirAbsolutePath+"/"+eclipse_extra_jdt_prefs_file) jalview_prefs.load(ins) ins.close() jalview_prefs.forEach { t, v -> if (props.getAt(t) == null) { props.putAt(t, v) } } } } } //synchronizationTasks eclipseClasspath //autoBuildTasks eclipseClasspath } task cloverInstr() { // only instrument source, we build test classes as normal inputs.files files (sourceSets.main.allJava) // , fileTree(dir:"$jalviewDir/$testSourceDir", include: ["**/*.java"])) outputs.dir cloverInstrDir doFirst { delete cloverInstrDir def argsList = ["--initstring", "${buildDir}/clover/clover.db", "-d", "${buildDir}/${cloverSourcesInstrDir}"] argsList.addAll(inputs.files.files.collect({ file -> file.absolutePath })) String[] args = argsList.toArray() println("About to instrument "+args.length +" files") com.atlassian.clover.CloverInstr.mainImpl(args) } } task cloverReport { group = "Verification" description = "Createst the Clover report" inputs.dir "${buildDir}/clover" outputs.dir "${reportsDir}/clover" onlyIf { file("${buildDir}/clover/clover.db").exists() } doFirst { def argsList = ["--initstring", "${buildDir}/clover/clover.db", "-o", "${reportsDir}/clover"] String[] args = argsList.toArray() com.atlassian.clover.reporters.html.HtmlReporter.runReport(args) // and generate ${reportsDir}/clover/clover.xml args = ["--initstring", "${buildDir}/clover/clover.db", "-o", "${reportsDir}/clover/clover.xml"].toArray() com.atlassian.clover.reporters.xml.XMLReporter.runReport(args) } } // end clover bits compileJava { doFirst { sourceCompatibility = compile_source_compatibility targetCompatibility = compile_target_compatibility options.compilerArgs = additional_compiler_args print ("Setting target compatibility to "+targetCompatibility+"\n") } } compileTestJava { if (use_clover) { dependsOn compileCloverJava classpath += configurations.cloverRuntime } else { classpath += sourceSets.main.runtimeClasspath } doFirst { sourceCompatibility = compile_source_compatibility targetCompatibility = compile_target_compatibility options.compilerArgs = additional_compiler_args print ("Setting target compatibility to "+targetCompatibility+"\n") } } compileCloverJava { doFirst { sourceCompatibility = compile_source_compatibility targetCompatibility = compile_target_compatibility options.compilerArgs += additional_compiler_args print ("Setting target compatibility to "+targetCompatibility+"\n") } classpath += configurations.cloverRuntime } clean { delete sourceSets.main.java.outputDir } cleanTest { delete sourceSets.test.java.outputDir delete cloverInstrDir } // format is a string like date.format("dd MMMM yyyy") def getDate(format) { def date = new Date() return date.format(format) } task setGitVals { def hashStdOut = new ByteArrayOutputStream() exec { commandLine "git", "rev-parse", "--short", "HEAD" standardOutput = hashStdOut ignoreExitValue true } def branchStdOut = new ByteArrayOutputStream() exec { commandLine "git", "rev-parse", "--abbrev-ref", "HEAD" standardOutput = branchStdOut ignoreExitValue true } project.ext.gitHash = hashStdOut.toString().trim() project.ext.gitBranch = branchStdOut.toString().trim() outputs.upToDateWhen { false } } task createBuildProperties(type: WriteProperties) { dependsOn setGitVals inputs.dir("$jalviewDir/$sourceDir") inputs.dir("$classes") inputs.dir("$jalviewDir/$resourceDir") outputFile (buildProperties) // taking time specific comment out to allow better incremental builds comment "--Jalview Build Details--\n"+getDate("yyyy-MM-dd HH:mm:ss") //comment "--Jalview Build Details--\n"+getDate("yyyy-MM-dd") property "BUILD_DATE", getDate("HH:mm:ss dd MMMM yyyy") property "VERSION", JALVIEW_VERSION property "INSTALLATION", INSTALLATION+" git-commit:"+project.ext.gitHash+" ["+project.ext.gitBranch+"]" outputs.file(outputFile) } def buildingHTML = "$jalviewDir/$docDir/building.html" task deleteBuildingHTML(type: Delete) { delete buildingHTML } task convertBuildingMD(type: Exec) { dependsOn deleteBuildingHTML def buildingMD = "$jalviewDir/$docDir/building.md" def css = "$jalviewDir/$docDir/github.css" def pandoc = null pandoc_exec.split(",").each { if (file(it.trim()).exists()) { pandoc = it.trim() return true } } def hostname = "hostname".execute().text.trim() if ((pandoc == null || ! file(pandoc).exists()) && hostname.equals("jv-bamboo")) { pandoc = System.getProperty("user.home")+"/buildtools/pandoc/bin/pandoc" } doFirst { if (pandoc != null && file(pandoc).exists()) { commandLine pandoc, '-s', '-o', buildingHTML, '--metadata', 'pagetitle="Building Jalview from Source"', '--toc', '-H', css, buildingMD } else { println("Cannot find pandoc. Skipping convert building.md to HTML") throw new StopExecutionException() } } ignoreExitValue true inputs.file(buildingMD) inputs.file(css) outputs.file(buildingHTML) } clean { delete buildingHTML } task syncDocs(type: Sync) { dependsOn convertBuildingMD def syncDir = "$classes/$docDir" from fileTree("$jalviewDir/$docDir") into syncDir } def helpFile = "$classes/$helpDir/help.jhm" task copyHelp(type: Copy) { def inputDir = "$jalviewDir/$helpParentDir/$helpDir" def outputDir = "$classes/$helpDir" from(inputDir) { exclude '**/*.gif' exclude '**/*.jpg' exclude '**/*.png' filter(ReplaceTokens, beginToken: '$$', endToken: '$$', tokens: ['Version-Rel': JALVIEW_VERSION,'Year-Rel': getDate("yyyy")]) } from(inputDir) { include '**/*.gif' include '**/*.jpg' include '**/*.png' } into outputDir inputs.dir(inputDir) outputs.files(helpFile) outputs.dir(outputDir) } task syncLib(type: Sync) { def syncDir = "$classes/$libDistDir" from fileTree("$jalviewDir/$libDistDir") into syncDir } task syncResources(type: Sync) { from "$jalviewDir/$resourceDir" include "**/*.*" exclude "install4j" into "$classes" preserve { include "**" } } task prepare { dependsOn syncResources dependsOn syncDocs dependsOn copyHelp } //testReportDirName = "test-reports" // note that test workingDir will be $jalviewDir test { dependsOn prepare dependsOn compileJava if (use_clover) { dependsOn cloverInstr } if (use_clover) { print("Running tests " + (use_clover?"WITH":"WITHOUT") + " clover [clover="+use_clover+"]\n") } useTestNG() { includeGroups testngGroups preserveOrder true useDefaultListeners=true } workingDir = jalviewDir //systemProperties 'clover.jar' System.properties.clover.jar sourceCompatibility = compile_source_compatibility targetCompatibility = compile_target_compatibility jvmArgs += additional_compiler_args print ("Setting target compatibility to "+targetCompatibility+"\n") } task buildIndices(type: JavaExec) { dependsOn copyHelp classpath = sourceSets.main.compileClasspath main = "com.sun.java.help.search.Indexer" workingDir = "$classes/$helpDir" def argDir = "html" args = [ argDir ] inputs.dir("$workingDir/$argDir") outputs.dir("$classes/doc") outputs.dir("$classes/help") outputs.file("$workingDir/JavaHelpSearch/DOCS") outputs.file("$workingDir/JavaHelpSearch/DOCS.TAB") outputs.file("$workingDir/JavaHelpSearch/OFFSETS") outputs.file("$workingDir/JavaHelpSearch/POSITIONS") outputs.file("$workingDir/JavaHelpSearch/SCHEMA") outputs.file("$workingDir/JavaHelpSearch/TMAP") } task compileLinkCheck(type: JavaCompile) { options.fork = true classpath = files("$jalviewDir/$utilsDir") destinationDir = file("$jalviewDir/$utilsDir") source = fileTree(dir: "$jalviewDir/$utilsDir", include: ["HelpLinksChecker.java", "BufferedLineReader.java"]) inputs.file("$jalviewDir/$utilsDir/HelpLinksChecker.java") inputs.file("$jalviewDir/$utilsDir/HelpLinksChecker.java") outputs.file("$jalviewDir/$utilsDir/HelpLinksChecker.class") outputs.file("$jalviewDir/$utilsDir/BufferedLineReader.class") } def helplinkscheckertouchfile = file("$jalviewDir/$utilsDir/HelpLinksChecker.touch") task linkCheck(type: JavaExec) { dependsOn prepare, compileLinkCheck classpath = files("$jalviewDir/$utilsDir") main = "HelpLinksChecker" workingDir = jalviewDir def help = "$classes/$helpDir" args = [ "$classes/$helpDir", "-nointernet" ] doLast { helplinkscheckertouchfile.createNewFile() } inputs.dir("$classes/$helpDir") outputs.file(helplinkscheckertouchfile) } // import the pubhtmlhelp target ant.properties.basedir = "$jalviewDir" ant.properties.helpBuildDir = jalviewDirAbsolutePath+"/$classes/$helpDir" ant.importBuild "$utilsDir/publishHelp.xml" task cleanPackageDir(type: Delete) { delete fileTree("$jalviewDir/$packageDir").include("*.jar") } jar { dependsOn linkCheck dependsOn buildIndices dependsOn createBuildProperties manifest { attributes "Main-Class": mainClass, "Permissions": "all-permissions", "Application-Name": "Jalview Desktop", "Codebase": application_codebase } destinationDir = file("$jalviewDir/$packageDir") archiveName = rootProject.name+".jar" exclude "cache*/**" exclude "*.jar" exclude "*.jar.*" exclude "**/*.jar" exclude "**/*.jar.*" inputs.dir("$classes") outputs.file("$jalviewDir/$packageDir/$archiveName") } task copyJars(type: Copy) { from fileTree("$classes").include("**/*.jar").include("*.jar").files into "$jalviewDir/$packageDir" } // doing a Sync instead of Copy as Copy doesn't deal with "outputs" very well task syncJars(type: Sync) { from fileTree("$jalviewDir/$libDistDir").include("**/*.jar").include("*.jar").files into "$jalviewDir/$packageDir" preserve { include jar.archiveName } } task makeDist { group = "build" description = "Put all required libraries in dist" // order of "cleanPackageDir", "copyJars", "jar" important! jar.mustRunAfter cleanPackageDir syncJars.mustRunAfter cleanPackageDir dependsOn cleanPackageDir dependsOn syncJars dependsOn jar outputs.dir("$jalviewDir/$packageDir") } task cleanDist { dependsOn cleanPackageDir dependsOn cleanTest dependsOn clean } shadowJar { group = "distribution" if (buildDist) { dependsOn makeDist } from ("$jalviewDir/$libDistDir") { include("*.jar") } manifest { attributes 'Implementation-Version': JALVIEW_VERSION } mainClassName = shadowJarMainClass mergeServiceFiles() classifier = "all-"+JALVIEW_VERSION+"-j"+JAVA_VERSION minimize() } task getdownWebsite() { group = "distribution" description = "Create the getdown minimal app folder, and website folder for this version of jalview. Website folder also used for offline app installer" if (buildDist) { dependsOn makeDist } // clean the getdown website and files dir before creating getdown folders delete project.ext.getdownWebsiteDir delete project.ext.getdownFilesDir def getdownWebsiteResourceFilenames = [] def getdownTextString = "" def getdownResourceDir = project.ext.getdownResourceDir def getdownAppDir = project.ext.getdownAppDir def getdownResourceFilenames = [] doFirst { copy { from buildProperties rename(buildPropertiesFile, getdown_build_properties) into project.ext.getdownAppDir } getdownWebsiteResourceFilenames += getdown_app_dir+"/"+getdown_build_properties // go through properties looking for getdown_txt_... def props = project.properties.sort { it.key } if (getdown_alt_java_min_version.length() > 0) { props.put("getdown_txt_java_min_version", getdown_alt_java_min_version) } if (getdown_alt_java_max_version.length() > 0) { props.put("getdown_txt_java_max_version", getdown_alt_java_max_version) } props.put("getdown_txt_multi_java_location", getdown_alt_multi_java_location) props.put("getdown_txt_appbase", getdown_app_base) props.each{ prop, val -> if (prop.startsWith("getdown_txt_") && val != null) { if (prop.startsWith("getdown_txt_multi_")) { def key = prop.substring(18) val.split(",").each{ v -> def line = key + " = " + v + "\n" getdownTextString += line } } else { // file values rationalised if (val.indexOf('/') > -1 || prop.startsWith("getdown_txt_resource")) { def r = null if (val.indexOf('/') == 0) { // absolute path r = file(val) } else if (val.indexOf('/') > 0) { // relative path (relative to jalviewDir) r = file( jalviewDir + '/' + val ) } if (r.exists()) { val = getdown_resource_dir + '/' + r.getName() getdownWebsiteResourceFilenames += val getdownResourceFilenames += r.getPath() } } if (! prop.startsWith("getdown_txt_resource")) { def line = prop.substring(12) + " = " + val + "\n" getdownTextString += line } } } } getdownWebsiteResourceFilenames.each{ filename -> getdownTextString += "resource = "+filename+"\n" } getdownResourceFilenames.each{ filename -> copy { from filename into project.ext.getdownResourceDir } } def codeFiles = [] fileTree(file(packageDir)).each{ f -> if (f.isDirectory()) { def files = fileTree(dir: f, include: ["*"]).getFiles() codeFiles += files } else if (f.exists()) { codeFiles += f } } codeFiles.sort().each{f -> def line = "code = " + getdown_app_dir + '/' + f.getName() + "\n" getdownTextString += line copy { from f.getPath() into project.ext.getdownAppDir } } // NOT USING MODULES YET, EVERYTHING SHOULD BE IN dist /* if (JAVA_VERSION.equals("11")) { def j11libFiles = fileTree(dir: "$jalviewDir/$j11libDir", include: ["*.jar"]).getFiles() j11libFiles.sort().each{f -> def line = "code = " + getdown_j11lib_dir + '/' + f.getName() + "\n" getdownTextString += line copy { from f.getPath() into project.ext.getdownJ11libDir } } } */ // getdown-launcher.jar should not be in main application class path so the main application can move it when updated. Listed as a resource so it gets updated. //getdownTextString += "class = " + file(getdownLauncher).getName() + "\n" getdownTextString += "resource = " + getdown_launcher_new + "\n" getdownTextString += "class = " + mainClass + "\n" def getdown_txt = file(project.ext.getdownWebsiteDir + "/getdown.txt") getdown_txt.write(getdownTextString) def launch_jvl = file(project.ext.getdownWebsiteDir + "/" + getdown_launch_jvl) launch_jvl.write("appbase="+props.get("getdown_txt_appbase")) copy { from getdownLauncher rename(file(getdownLauncher).getName(), getdown_launcher_new) into project.ext.getdownWebsiteDir } copy { from getdownLauncher if (file(getdownLauncher).getName() != getdown_launcher) { rename(file(getdownLauncher).getName(), getdown_launcher) } into project.ext.getdownWebsiteDir } if (! (CHANNEL.startsWith("ARCHIVE") || CHANNEL.startsWith("DEVELOP"))) { copy { from getdown_txt from getdownLauncher from getdownWebsiteDir+"/"+getdown_build_properties if (file(getdownLauncher).getName() != getdown_launcher) { rename(file(getdownLauncher).getName(), getdown_launcher) } into getdownInstallDir } copy { from getdownInstallDir into getdownFilesInstallDir } } copy { from getdown_txt from launch_jvl from getdownLauncher from getdownWebsiteDir+"/"+getdown_build_properties if (file(getdownLauncher).getName() != getdown_launcher) { rename(file(getdownLauncher).getName(), getdown_launcher) } into getdownFilesDir } copy { from getdownResourceDir into project.ext.getdownFilesDir + '/' + getdown_resource_dir } } if (buildDist) { inputs.dir(jalviewDir + '/' + packageDir) } outputs.dir(project.ext.getdownWebsiteDir) outputs.dir(project.ext.getdownFilesDir) } task getdownDigest(type: JavaExec) { group = "distribution" description = "Digest the getdown website folder" dependsOn getdownWebsite doFirst { classpath = files(getdownWebsiteDir + '/' + getdown_launcher) } main = "com.threerings.getdown.tools.Digester" args project.ext.getdownWebsiteDir inputs.dir(project.ext.getdownWebsiteDir) outputs.file(project.ext.getdownWebsiteDir + '/' + "digest2.txt") } task getdown() { group = "distribution" description = "Create the minimal and full getdown app folder for installers and website and create digest file" dependsOn getdownDigest doLast { if (reportRsyncCommand) { def fromDir = getdownWebsiteDir + (getdownWebsiteDir.endsWith("/")?"":"/") def toDir = getdown_rsync_dest + "/" + getdownDir + (getdownDir.endsWith("/")?"":"/") println "LIKELY RSYNC COMMAND:" println "mkdir -p '$toDir'\nrsync -avh --delete '$fromDir' '$toDir'" if (RUNRSYNC == "true") { exec { commandLine "mkdir", "-p", toDir } exec { commandLine "rsync", "-avh", "--delete", fromDir, toDir } } } } } clean { delete project.ext.getdownWebsiteDir delete project.ext.getdownFilesDir } install4j { def install4jHomeDir = "/opt/install4j" def hostname = "hostname".execute().text.trim() if (hostname.equals("jv-bamboo")) { install4jHomeDir = System.getProperty("user.home")+"/buildtools/install4j" } else if (OperatingSystem.current().isMacOsX()) { install4jHomeDir = '/Applications/install4j.app/Contents/Resources/app' if (! file(install4jHomeDir).exists()) { install4jHomeDir = System.getProperty("user.home")+install4jHomeDir } } else if (OperatingSystem.current().isLinux()) { install4jHomeDir = System.getProperty("user.home")+"/buildtools/install4j" } installDir = file(install4jHomeDir) mediaTypes = Arrays.asList(install4jMediaTypes.split(",")) if (install4jFaster.equals("true")) { faster = true } } def install4jConf def macosJavaVMDir def macosJavaVMTgz def windowsJavaVMDir def windowsJavaVMTgz def install4jDir = "$jalviewDir/$install4jResourceDir" def install4jConfFile = "jalview-installers-java"+JAVA_VERSION+".install4j" install4jConf = "$install4jDir/$install4jConfFile" task copyInstall4jTemplate(type: Copy) { macosJavaVMDir = System.env.HOME+"/buildtools/jre/openjdk-java_vm/getdown/macos-jre"+JAVA_VERSION+"/jre" macosJavaVMTgz = System.env.HOME+"/buildtools/jre/openjdk-java_vm/install4j/tgz/macos-jre"+JAVA_VERSION+".tar.gz" windowsJavaVMDir = System.env.HOME+"/buildtools/jre/openjdk-java_vm/getdown/windows-jre"+JAVA_VERSION+"/jre" windowsJavaVMTgz = System.env.HOME+"/buildtools/jre/openjdk-java_vm/install4j/tgz/windows-jre"+JAVA_VERSION+".tar.gz" from (install4jDir) { include install4jTemplate rename (install4jTemplate, install4jConfFile) filter(ReplaceTokens, beginToken: '', endToken: '', tokens: ['9999999999': JAVA_VERSION]) filter(ReplaceTokens, beginToken: '$$', endToken: '$$', tokens: [ 'JAVA_VERSION': JAVA_VERSION, 'JAVA_INTEGER_VERSION': JAVA_INTEGER_VERSION, 'VERSION': JALVIEW_VERSION, 'MACOS_JAVA_VM_DIR': macosJavaVMDir, 'MACOS_JAVA_VM_TGZ': macosJavaVMTgz, 'WINDOWS_JAVA_VM_DIR': windowsJavaVMDir, 'WINDOWS_JAVA_VM_TGZ': windowsJavaVMTgz, 'INSTALL4JINFOPLISTFILEASSOCIATIONS': install4jInfoPlistFileAssociations, 'COPYRIGHT_MESSAGE': install4jCopyrightMessage, 'MACOS_BUNDLE_ID': install4jMacOSBundleId, 'GETDOWN_RESOURCE_DIR': getdown_resource_dir, 'GETDOWN_DIST_DIR': getdown_app_dir, 'GETDOWN_ALT_DIR': getdown_app_dir_alt, 'GETDOWN_INSTALL_DIR': getdown_install_dir ] ) if (OSX_KEYPASS=="") { filter(ReplaceTokens, beginToken: 'codeSigning macEnabled="', endToken: '"', tokens: ['true':'codeSigning macEnabled="false"']) filter(ReplaceTokens, beginToken: 'runPostProcessor="true" ',endToken: 'Processor', tokens: ['post':'runPostProcessor="false" postProcessor']) } } into install4jDir outputs.files(install4jConf) doLast { // include file associations in installer def installerFileAssociationsXml = file("$install4jDir/$install4jInstallerFileAssociations").text ant.replaceregexp( byline: false, flags: "s", match: '', replace: installerFileAssociationsXml, file: install4jConf ) /* // include uninstaller applescript app files in dmg def installerDMGUninstallerXml = file("$install4jDir/$install4jDMGUninstallerAppFiles").text ant.replaceregexp( byline: false, flags: "s", match: '', replace: installerDMGUninstallerXml, file: install4jConf ) */ } } task installers(type: com.install4j.gradle.Install4jTask) { group = "distribution" description = "Create the install4j installers" dependsOn getdown dependsOn copyInstall4jTemplate projectFile = file(install4jConf) println("Using projectFile "+projectFile) variables = [majorVersion: version.substring(2, 11), build: 001, OSX_KEYSTORE: OSX_KEYSTORE, JSIGN_SH: JSIGN_SH] destination = "$jalviewDir/$install4jBuildDir/$JAVA_VERSION" buildSelected = true if (OSX_KEYPASS) { macKeystorePassword=OSX_KEYPASS } inputs.dir(project.ext.getdownWebsiteDir) inputs.file(install4jConf) inputs.dir(macosJavaVMDir) inputs.dir(windowsJavaVMDir) outputs.dir("$jalviewDir/$install4jBuildDir/$JAVA_VERSION") } clean { delete install4jConf } task sourceDist (type: Tar) { def VERSION_UNDERSCORES = JALVIEW_VERSION.replaceAll("\\.", "_") def outputFileName = project.name + "_" + VERSION_UNDERSCORES + ".tar.gz" // cater for buildship < 3.1 [3.0.1 is max version in eclipse 2018-09] try { archiveFileName = outputFileName } catch (Exception e) { archiveName = outputFileName } compression Compression.GZIP into project.name def EXCLUDE_FILES=["build/*","bin/*","test-output/","test-reports","tests","clover*/*" ,".*" ,"benchmarking/*" ,"**/.*" ,"*.class" ,"**/*.class","$j11modDir/**/*.jar","appletlib","**/*locales" ,"*locales/**", ,"utils/InstallAnywhere"] def PROCESS_FILES=[ "AUTHORS", "CITATION", "FEATURETODO", "JAVA-11-README", "FEATURETODO", "LICENSE", "**/README", "RELEASE", "THIRDPARTYLIBS","TESTNG", "build.gradle", "gradle.properties", "**/*.java", "**/*.html", "**/*.xml", "**/*.gradle", "**/*.groovy", "**/*.properties", "**/*.perl", "**/*.sh"] from(jalviewDir) { exclude (EXCLUDE_FILES) include (PROCESS_FILES) filter(ReplaceTokens, beginToken: '$$', endToken: '$$', tokens: ['Version-Rel': JALVIEW_VERSION,'Year-Rel': getDate("yyyy")]) } from(jalviewDir) { exclude (EXCLUDE_FILES) exclude (PROCESS_FILES) exclude ("appletlib") exclude ("**/*locales") exclude ("*locales/**") exclude ("utils/InstallAnywhere") exclude (getdown_files_dir) exclude (getdown_website_dir) // exluding these as not using jars as modules yet exclude ("$j11modDir/**/*.jar") } // from (jalviewDir) { // // explicit includes for stuff that seemed to not get included // include(fileTree("test/**/*.")) // exclude(EXCLUDE_FILES) // exclude(PROCESS_FILES) // } } task helppages { dependsOn copyHelp dependsOn pubhtmlhelp inputs.dir("$classes/$helpDir") outputs.dir("$helpOutputDir") }