utils/debian/debian_build.gradle

   1 /* Convention for properties.  Read from gradle.properties, use lower_case_underlines for property names.
   2  * For properties set within build.gradle, use camelCaseNoSpace.
   3  */
   4 import org.apache.tools.ant.filters.ReplaceTokens
   5
   6 plugins {
   7   id 'java'
   8   id 'application'
   9 }
  10
  11 // in ext the values are cast to Object. Ensure string values are cast as String (and not GStringImpl) for later use
  12 def string(Object o) {
  13   return o == null ? "" : o.toString()
  14 }
  15
  16 def overrideProperties(String propsFileName, boolean output = false) {
  17   if (propsFileName == null) {
  18     return
  19   }
  20   def propsFile = file(propsFileName)
  21   if (propsFile != null && propsFile.exists()) {
  22     println("Using properties from file '${propsFileName}'")
  23     try {
  24       def p = new Properties()
  25       def localPropsFIS = new FileInputStream(propsFile)
  26       p.load(localPropsFIS)
  27       localPropsFIS.close()
  28       p.each {
  29         key, val ->
  30           def oldval
  31           if (project.hasProperty(key)) {
  32             oldval = project.findProperty(key)
  33             project.setProperty(key, val)
  34             if (output) {
  35               println("Overriding property '${key}' ('${oldval}') with ${file(propsFile).getName()} value '${val}'")
  36             }
  37           } else {
  38             ext.setProperty(key, val)
  39             if (output) {
  40               println("Setting ext property '${key}' with ${file(propsFile).getName()}s value '${val}'")
  41             }
  42           }
  43       }
  44     } catch (Exception e) {
  45       println("Exception reading local.properties")
  46       e.printStackTrace()
  47     }
  48   }
  49 }
  50
  51 project.ext {
  52   jalviewDirAbsolutePath = file(jalviewDir).getAbsolutePath()
  53   jalviewDirRelativePath = jalviewDir
  54
  55   propertiesChannelName = "release"
  56   channelDir = string("${jalviewDir}/${channel_properties_dir}/${propertiesChannelName}")
  57   channelGradleProperties = string("${channelDir}/channel_gradle.properties")
  58   overrideProperties(channelGradleProperties, false)
  59
  60   ////
  61   // Import releaseProps from the RELEASE file
  62   // or a file specified via JALVIEW_RELEASE_FILE if defined
  63   // Expect jalview.version and target release branch in jalview.release
  64   def releaseProps = new Properties();
  65   def releasePropFile = findProperty("JALVIEW_RELEASE_FILE");
  66   def defaultReleasePropFile = "${jalviewDirAbsolutePath}/RELEASE";
  67   try {
  68     (new File(releasePropFile!=null ? releasePropFile : defaultReleasePropFile)).withInputStream {
  69      releaseProps.load(it)
  70     }
  71   } catch (Exception fileLoadError) {
  72     throw new Error("Couldn't load release properties file "+(releasePropFile==null ? defaultReleasePropFile : "from custom location: releasePropFile"),fileLoadError);
  73   }
  74   ////
  75   // Set JALVIEW_VERSION if it is not already set
  76   if (findProperty("JALVIEW_VERSION")==null || "".equals(JALVIEW_VERSION)) {
  77     JALVIEW_VERSION = releaseProps.get("jalview.version")
  78   }
  79
  80   // essentials
  81   bareSourceDir = string(source_dir)
  82   sourceDir = string("${jalviewDir}/${bareSourceDir}")
  83   resourceDir = string("${jalviewDir}/${resource_dir}")
  84   bareTestSourceDir = string(test_source_dir)
  85   testDir = string("${jalviewDir}/${bareTestSourceDir}")
  86
  87   classesDir = string("${jalviewDir}/${classes_dir}")
  88
  89   useClover = false
  90
  91   resourceClassesDir = classesDir
  92
  93   testSourceDir = testDir
  94   testClassesDir = "${jalviewDir}/${test_output_dir}"
  95
  96   buildProperties = string("${classesDir}/${build_properties_file}")
  97   getdownSetAppBaseProperty = false // whether to pass the appbase and appdistdir to the application
  98
  99   install4jApplicationName = "${jalview_name}"
 100
 101   println("Using a ${CHANNEL} profile.")
 102
 103   additional_compiler_args = []
 104   // configure classpath/args for j8/j11 compilation
 105   if (JAVA_VERSION.equals("1.8")) {
 106     JAVA_INTEGER_VERSION = string("8")
 107     //libDir = j8libDir
 108     libDir = j11libDir
 109     libDistDir = j8libDir
 110     compile_source_compatibility = 1.8
 111     compile_target_compatibility = 1.8
 112   } else if (JAVA_VERSION.equals("11")) {
 113     JAVA_INTEGER_VERSION = string("11")
 114     libDir = j11libDir
 115     libDistDir = j11libDir
 116     compile_source_compatibility = 11
 117     compile_target_compatibility = 11
 118   } else {
 119     throw new GradleException("JAVA_VERSION=${JAVA_VERSION} not currently supported by Jalview")
 120   }
 121
 122   resourceBuildDir = string("${buildDir}/resources")
 123   resourcesBuildDir = string("${resourceBuildDir}/resources_build")
 124   helpBuildDir = string("${resourceBuildDir}/help_build")
 125   docBuildDir = string("${resourceBuildDir}/doc_build")
 126
 127   if (buildProperties == null) {
 128     buildProperties = string("${resourcesBuildDir}/${build_properties_file}")
 129   }
 130   buildingHTML = string("${jalviewDir}/${doc_dir}/building.html")
 131   helpParentDir = string("${jalviewDir}/${help_parent_dir}")
 132   helpSourceDir = string("${helpParentDir}/${help_dir}")
 133   helpFile = string("${helpBuildDir}/${help_dir}/help.jhm")
 134
 135   // ENDEXT
 136 }
 137
 138
 139 sourceSets {
 140   main {
 141     java {
 142       srcDirs sourceDir
 143       outputDir = file(classesDir)
 144     }
 145
 146     resources {
 147       srcDirs = [ resourcesBuildDir, docBuildDir, helpBuildDir ]
 148     }
 149
 150     compileClasspath = files(sourceSets.main.java.outputDir)
 151     compileClasspath += fileTree(dir: "${jalviewDir}/${libDir}", include: ["*.jar"])
 152
 153
 154     compileClasspath = files(sourceSets.main.java.outputDir)
 155     compileClasspath += fileTree(dir: "${jalviewDir}/${libDir}", include: ["*.jar"])
 156
 157     runtimeClasspath = compileClasspath
 158     runtimeClasspath += files(sourceSets.main.resources.srcDirs)
 159   }
 160
 161   test {
 162     java {
 163       srcDirs testSourceDir
 164       outputDir = file(testClassesDir)
 165     }
 166
 167     resources {
 168       srcDirs = useClover ? sourceSets.clover.resources.srcDirs : sourceSets.main.resources.srcDirs
 169     }
 170
 171     compileClasspath = files( sourceSets.test.java.outputDir )
 172     compileClasspath += useClover ? sourceSets.clover.compileClasspath : sourceSets.main.compileClasspath
 173     compileClasspath += fileTree(dir: "${jalviewDir}/${utils_dir}/testnglibs", include: ["**/*.jar"])
 174
 175     runtimeClasspath = compileClasspath
 176     runtimeClasspath += files(sourceSets.test.resources.srcDirs)
 177   }
 178  /*  test {
 179     java {
 180       srcDirs testSourceDir
 181       outputDir = file(testClassesDir)
 182     }
 183
 184     resources {
 185       srcDirs = sourceSets.main.resources.srcDirs
 186     }
 187
 188     compileClasspath = files( sourceSets.test.java.outputDir )
 189     compileClasspath += sourceSets.main.compileClasspath
 190     compileClasspath += fileTree(dir: "${jalviewDir}/${utils_dir}/testnglibs", include: ["**   REMOVE_THIS_GAP  /*.jar"])
 191
 192     runtimeClasspath = compileClasspath
 193   }
 194 */
 195 }
 196
 197
 198 compileJava {
 199   sourceCompatibility = compile_source_compatibility
 200   targetCompatibility = compile_target_compatibility
 201   options.compilerArgs = additional_compiler_args
 202   doFirst {
 203     print ("Setting target compatibility to "+compile_target_compatibility+"\n")
 204   }
 205 }
 206
 207
 208 compileTestJava {
 209   doFirst {
 210     sourceCompatibility = compile_source_compatibility
 211     targetCompatibility = compile_target_compatibility
 212     options.compilerArgs = additional_compiler_args
 213     print ("Setting target compatibility to "+targetCompatibility+"\n")
 214   }
 215 }
 216
 217
 218 clean {
 219   doFirst {
 220     delete sourceSets.main.java.outputDir
 221   }
 222 }
 223
 224
 225 cleanTest {
 226   doFirst {
 227     delete sourceSets.test.java.outputDir
 228   }
 229 }
 230
 231
 232 // format is a string like date.format("dd MMMM yyyy")
 233 def getDate(format) {
 234   def date = new Date()
 235   return date.format(format)
 236 }
 237
 238
 239 task copyDocs(type: Copy) {
 240   def inputDir = "${jalviewDir}/${doc_dir}"
 241   def outputDir = "${docBuildDir}/${doc_dir}"
 242   from(inputDir) {
 243     include('**/*.txt')
 244     include('**/*.md')
 245     include('**/*.html')
 246     include('**/*.xml')
 247     filter(ReplaceTokens,
 248       beginToken: '$$',
 249       endToken: '$$',
 250       tokens: [
 251         'Version-Rel': JALVIEW_VERSION,
 252         'Year-Rel': getDate("yyyy")
 253       ]
 254     )
 255   }
 256   from(inputDir) {
 257     exclude('**/*.txt')
 258     exclude('**/*.md')
 259     exclude('**/*.html')
 260     exclude('**/*.xml')
 261   }
 262   into outputDir
 263
 264   inputs.dir(inputDir)
 265   outputs.dir(outputDir)
 266 }
 267
 268
 269 task copyHelp(type: Copy) {
 270   def inputDir = helpSourceDir
 271   def outputDir = "${helpBuildDir}/${help_dir}"
 272   from(inputDir) {
 273     include('**/*.txt')
 274     include('**/*.md')
 275     include('**/*.html')
 276     include('**/*.hs')
 277     include('**/*.xml')
 278     include('**/*.jhm')
 279     filter(ReplaceTokens,
 280       beginToken: '$$',
 281       endToken: '$$',
 282       tokens: [
 283         'Version-Rel': JALVIEW_VERSION,
 284         'Year-Rel': getDate("yyyy")
 285       ]
 286     )
 287   }
 288   from(inputDir) {
 289     exclude('**/*.txt')
 290     exclude('**/*.md')
 291     exclude('**/*.html')
 292     exclude('**/*.hs')
 293     exclude('**/*.xml')
 294     exclude('**/*.jhm')
 295   }
 296   into outputDir
 297
 298   inputs.dir(inputDir)
 299   outputs.files(helpFile)
 300   outputs.dir(outputDir)
 301 }
 302
 303 task releasesTemplates {
 304   group "help"
 305   description "Recreate whatsNew.html and releases.html from markdown files and templates in help"
 306
 307   dependsOn copyHelp
 308
 309   def releasesTemplateFile = file("${jalviewDir}/${releases_template}")
 310   def whatsnewTemplateFile = file("${jalviewDir}/${whatsnew_template}")
 311   def releasesHtmlFile = file("${helpBuildDir}/${help_dir}/${releases_html}")
 312   def whatsnewHtmlFile = file("${helpBuildDir}/${help_dir}/${whatsnew_html}")
 313   def releasesMdDir = "${jalviewDir}/${releases_dir}"
 314   def whatsnewMdDir = "${jalviewDir}/${whatsnew_dir}"
 315
 316   doFirst {
 317     def JALVIEW_VERSION_UNDERSCORES = JALVIEW_VERSION.replaceAll("\\.", "_")
 318     def releaseMdFile = file("${releasesMdDir}/release-${JALVIEW_VERSION_UNDERSCORES}.md")
 319     def whatsnewMdFile = file("${whatsnewMdDir}/whatsnew-${JALVIEW_VERSION_UNDERSCORES}.md")
 320
 321     if (CHANNEL == "RELEASE") {
 322       if (!releaseMdFile.exists()) {
 323         throw new GradleException("File ${releaseMdFile} must be created for RELEASE")
 324       }
 325       if (!whatsnewMdFile.exists()) {
 326         throw new GradleException("File ${whatsnewMdFile} must be created for RELEASE")
 327       }
 328     }
 329
 330     def releaseFiles = fileTree(dir: releasesMdDir, include: "release-*.md")
 331     def releaseFilesDates = releaseFiles.collectEntries {
 332       [(it): getDate("")]
 333     }
 334     releaseFiles = releaseFiles.sort { a,b -> releaseFilesDates[a].compareTo(releaseFilesDates[b]) }
 335
 336     def releasesTemplate = releasesTemplateFile.text
 337     def m = releasesTemplate =~ /(?s)__VERSION_LOOP_START__(.*)__VERSION_LOOP_END__/
 338     def versionTemplate = m[0][1]
 339
 340     def versionsHtml = ""
 341     def linkedVersions = []
 342
 343     releasesTemplate = releasesTemplate.replaceAll("(?s)__VERSION_LOOP_START__.*__VERSION_LOOP_END__", versionsHtml)
 344     releasesHtmlFile.text = releasesTemplate
 345
 346     whatsnewHtmlFile.text = "Debian build " + getDate("yyyy-MM-dd HH:mm:ss")
 347   }
 348
 349   inputs.file(releasesTemplateFile)
 350   inputs.file(whatsnewTemplateFile)
 351   inputs.dir(releasesMdDir)
 352   inputs.dir(whatsnewMdDir)
 353   outputs.file(releasesHtmlFile)
 354   outputs.file(whatsnewHtmlFile)
 355 }
 356
 357 task copyResources(type: Copy) {
 358   group = "build"
 359   description = "Copy (and make text substitutions in) the resources dir to the build area"
 360
 361   def inputDir = resourceDir
 362   def outputDir = resourcesBuildDir
 363   from(inputDir) {
 364     include('**/*.txt')
 365     include('**/*.md')
 366     include('**/*.html')
 367     include('**/*.xml')
 368     filter(ReplaceTokens,
 369       beginToken: '$$',
 370       endToken: '$$',
 371       tokens: [
 372         'Version-Rel': JALVIEW_VERSION,
 373         'Year-Rel': getDate("yyyy")
 374       ]
 375     )
 376   }
 377   from(inputDir) {
 378     exclude('**/*.txt')
 379     exclude('**/*.md')
 380     exclude('**/*.html')
 381     exclude('**/*.xml')
 382   }
 383   into outputDir
 384
 385   inputs.dir(inputDir)
 386   outputs.dir(outputDir)
 387 }
 388
 389 task copyChannelResources(type: Copy) {
 390   dependsOn copyResources
 391   group = "build"
 392   description = "Copy the channel resources dir to the build resources area"
 393
 394   def inputDir = "${channelDir}/${resource_dir}"
 395   def outputDir = resourcesBuildDir
 396   from inputDir
 397   into outputDir
 398
 399   inputs.dir(inputDir)
 400   outputs.dir(outputDir)
 401 }
 402
 403 task createBuildProperties(type: Copy) {
 404   // using the build_properties already included in the source tarball
 405   def inputFile = "build_properties"
 406   def outputFile = buildProperties
 407   from inputFile
 408   into file(outputFile).getParent()
 409   rename(file(inputFile).getName(), file(outputFile).getName())
 410
 411   inputs.file(inputFile)
 412   outputs.file(outputFile)
 413 }
 414
 415
 416 task buildIndices(type: JavaExec) {
 417   dependsOn copyHelp
 418   classpath = sourceSets.main.compileClasspath
 419   main = "com.sun.java.help.search.Indexer"
 420   workingDir = "${helpBuildDir}/${help_dir}"
 421   def argDir = "html"
 422   args = [ argDir ]
 423   inputs.dir("${workingDir}/${argDir}")
 424
 425   outputs.dir("${classesDir}/doc")
 426   outputs.dir("${classesDir}/help")
 427   outputs.file("${workingDir}/JavaHelpSearch/DOCS")
 428   outputs.file("${workingDir}/JavaHelpSearch/DOCS.TAB")
 429   outputs.file("${workingDir}/JavaHelpSearch/OFFSETS")
 430   outputs.file("${workingDir}/JavaHelpSearch/POSITIONS")
 431   outputs.file("${workingDir}/JavaHelpSearch/SCHEMA")
 432   outputs.file("${workingDir}/JavaHelpSearch/TMAP")
 433 }
 434
 435 task buildResources {
 436   dependsOn copyResources
 437   dependsOn copyChannelResources
 438   dependsOn createBuildProperties
 439 }
 440
 441 task prepare {
 442   dependsOn buildResources
 443   dependsOn copyDocs
 444   dependsOn copyHelp
 445   dependsOn releasesTemplates
 446   dependsOn buildIndices
 447 }
 448
 449
 450 compileJava.dependsOn prepare
 451 run.dependsOn compileJava
 452 //run.dependsOn prepare
 453
 454
 455 //testReportDirName = "test-reports" // note that test workingDir will be $jalviewDir
 456 test {
 457   dependsOn prepare
 458   dependsOn compileJava //?
 459
 460   useTestNG() {
 461     includeGroups testng_groups
 462     excludeGroups testng_excluded_groups
 463     preserveOrder true
 464     useDefaultListeners=true
 465   }
 466
 467   maxHeapSize = "1024m"
 468
 469   workingDir = jalviewDir
 470   //systemProperties 'clover.jar' System.properties.clover.jar
 471   def testLaf = project.findProperty("test_laf")
 472   if (testLaf != null) {
 473     println("Setting Test LaF to '${testLaf}'")
 474     systemProperty "laf", testLaf
 475   }
 476   def testHiDPIScale = project.findProperty("test_HiDPIScale")
 477   if (testHiDPIScale != null) {
 478     println("Setting Test HiDPI Scale to '${testHiDPIScale}'")
 479     systemProperty "sun.java2d.uiScale", testHiDPIScale
 480   }
 481   sourceCompatibility = compile_source_compatibility
 482   targetCompatibility = compile_target_compatibility
 483   jvmArgs += additional_compiler_args
 484
 485   doFirst {
 486   }
 487 }
 488
 489
 490 task compileLinkCheck(type: JavaCompile) {
 491   options.fork = true
 492   classpath = files("${jalviewDir}/${utils_dir}")
 493   destinationDir = file("${jalviewDir}/${utils_dir}")
 494   source = fileTree(dir: "${jalviewDir}/${utils_dir}", include: ["HelpLinksChecker.java", "BufferedLineReader.java"])
 495
 496   inputs.file("${jalviewDir}/${utils_dir}/HelpLinksChecker.java")
 497   inputs.file("${jalviewDir}/${utils_dir}/HelpLinksChecker.java")
 498   outputs.file("${jalviewDir}/${utils_dir}/HelpLinksChecker.class")
 499   outputs.file("${jalviewDir}/${utils_dir}/BufferedLineReader.class")
 500 }
 501
 502
 503 task linkCheck(type: JavaExec) {
 504   dependsOn prepare
 505   dependsOn compileLinkCheck
 506
 507   def helpLinksCheckerOutFile = file("${jalviewDir}/${utils_dir}/HelpLinksChecker.out")
 508   classpath = files("${jalviewDir}/${utils_dir}")
 509   main = "HelpLinksChecker"
 510   workingDir = "${helpBuildDir}"
 511   args = [ "${helpBuildDir}/${help_dir}", "-nointernet" ]
 512
 513   def outFOS = new FileOutputStream(helpLinksCheckerOutFile, false) // false == don't append
 514   standardOutput = new org.apache.tools.ant.util.TeeOutputStream(
 515     outFOS,
 516     System.out)
 517   errorOutput = new org.apache.tools.ant.util.TeeOutputStream(
 518     outFOS,
 519     System.err)
 520
 521   inputs.dir(helpBuildDir)
 522   outputs.file(helpLinksCheckerOutFile)
 523 }
 524
 525
 526 // import the pubhtmlhelp target
 527 ant.properties.basedir = "${jalviewDir}"
 528 ant.properties.helpBuildDir = "${helpBuildDir}/${help_dir}"
 529 ant.importBuild "${utils_dir}/publishHelp.xml"
 530
 531
 532 task cleanPackageDir(type: Delete) {
 533   doFirst {
 534     delete fileTree(dir: "${jalviewDir}/${package_dir}", include: "*.jar")
 535   }
 536 }
 537
 538
 539 jar {
 540   dependsOn prepare
 541   dependsOn linkCheck
 542
 543   manifest {
 544     attributes "Main-Class": main_class,
 545     "Permissions": "all-permissions",
 546     "Application-Name": install4jApplicationName,
 547     "Codebase": application_codebase,
 548     "Implementation-Version": JALVIEW_VERSION
 549   }
 550
 551   def outputDir = "${jalviewDir}/${package_dir}"
 552   destinationDirectory = file(outputDir)
 553   archiveFileName = rootProject.name+".jar"
 554
 555   exclude "cache*/**"
 556   exclude "*.jar"
 557   exclude "*.jar.*"
 558   exclude "**/*.jar"
 559   exclude "**/*.jar.*"
 560
 561   inputs.dir(sourceSets.main.java.outputDir)
 562   sourceSets.main.resources.srcDirs.each{ dir ->
 563     inputs.dir(dir)
 564   }
 565
 566   outputs.file("${outputDir}/${archiveFileName}")
 567 }
 568