corda/node/dist/build.gradle
2018-09-26 12:38:38 +01:00

222 lines
6.5 KiB
Groovy

import org.gradle.internal.jvm.Jvm
import org.apache.tools.ant.taskdefs.condition.Os
apply plugin: 'net.corda.plugins.publish-utils'
description 'Package Node as stand-alone application'
evaluationDependsOn(":node")
evaluationDependsOn(":docs")
evaluationDependsOn(":launcher")
ext {
outputDir = "$buildDir/corda"
tarballDir = "$buildDir/distribution"
tarballBaseName = 'corda-enterprise-distribution'
tarballExtension = "tar.bz2"
}
def tmpDir = "${buildDir}/tmp/"
configurations {
launcherClasspath
}
// Define location of predefined startup scripts, license and README files
sourceSets {
binFiles {
resources {
srcDir file('src/main/resources/bin')
}
}
installerFiles {
resources {
srcDir file('src/main/resources/installer')
}
}
readmeFiles {
resources {
srcDir file('src/main/resources/readme')
}
}
}
// Runtime dependencies of launcher
dependencies {
compile project(':node')
launcherClasspath project(':launcher')
launcherClasspath "org.slf4j:jul-to-slf4j:$slf4j_version"
launcherClasspath "org.apache.logging.log4j:log4j-slf4j-impl:${log4j_version}"
launcherClasspath "org.apache.logging.log4j:log4j-web:${log4j_version}"
// Required by JVM agents:
launcherClasspath "com.google.guava:guava:$guava_version"
launcherClasspath "de.javakaffee:kryo-serializers:0.41"
}
task copyLauncherLibs(type: Copy, dependsOn: [project(':launcher').jar]) {
from configurations.launcherClasspath
into "$buildDir/tmp/launcher-lib"
}
if (Os.isFamily(Os.FAMILY_UNIX)) {
println("Detected *nix system, enabling distribution creation")
task buildLauncher(type: Exec, dependsOn: [copyLauncherLibs]) {
description 'Build Launcher executable'
def relativeDir = "launcher"
def extraArgs = [
"-BjvmOptions=-javaagent:../../lib/quasar-core-${quasar_version}-jdk8.jar=${project(':node:capsule').quasarExcludeExpression}",
'-BuserJvmOptions=-Xmx=4g',
'-BuserJvmOptions=-XX\\:=+UseG1GC',
"-BjvmProperties=java.system.class.loader=${project(':launcher').loaderClassName}"
]
ext {
launcherBinDir = "${tmpDir}/bundles/$relativeDir"
}
workingDir project.projectDir
doFirst {
def currentJvmPathContainsOpenJDK = Jvm.current().javaHome.absolutePath.toLowerCase().contains("openjdk")
if (currentJvmPathContainsOpenJDK) {
throw new BuildCancelledException("Building installer using an openJDK JDK")
}
def launcherLib = copyLauncherLibs.destinationDir
def srcfiles = []
def launcherClasspath = []
fileTree(launcherLib).forEach({ file ->
srcfiles.add("-srcfiles")
srcfiles.add(file.name)
launcherClasspath.add(file.name)
})
commandLine = [
'/usr/bin/env',
'javapackager',
'-deploy',
'-nosign',
'-native', 'image',
'-outdir', "$tmpDir",
'-outfile', 'launcher',
'-name', 'launcher',
"-BmainJar=${project(':launcher').jar.archiveName}",
"-Bclasspath=${launcherClasspath.join(":")}",
'-appclass', "${project(':launcher').launcherClassName}",
'-srcdir', "$launcherLib"
] + srcfiles + extraArgs
}
// Add configuration for running Node application
doLast {
def nodeClasspath = []
def libRelPath = "../lib/"
project(':node').configurations.runtime.forEach({ file ->
nodeClasspath.add(file.getName())
})
nodeClasspath.add(project(':node').jar.archivePath.getName())
new File("${launcherBinDir}/runtime.properties").text = [
"libpath=${libRelPath}",
"classpath=${nodeClasspath.join(':')}",
"plugins=./drivers:./cordapps"].join("\n")
}
}
task buildNode(type: Copy, dependsOn: [buildLauncher, project(':docs').tasks['makeDocs'], project(':node').tasks['jar']]) {
description 'Build stand-alone Corda Node distribution'
def dir = file("$outputDir/corda-enterprise")
into(dir)
from(buildLauncher.launcherBinDir) {
into("launcher")
}
from(project(':node').configurations.runtime) {
into("lib")
}
from(project(':node').jar.archivePath) {
into("lib")
}
from(sourceSets.binFiles.resources) {
into("bin")
}
from(sourceSets.readmeFiles.resources) {
into(".")
}
from(file("src/main/resources/license/LICENSE")) {
into(".")
}
doLast {
new File("${dir}/cordapps").mkdirs()
new File("${dir}/drivers").mkdirs()
println("Stand-alone Corda Node application available at:")
println("${dir}")
}
}
task buildCordaTarball(type: Tar, dependsOn: [buildNode]) {
from outputDir
compression = Compression.BZIP2
baseName = tarballBaseName
destinationDir = file(tarballDir)
extension = tarballExtension
doLast {
println("Distribution tarball available at:")
println("${tarballDir}/${archiveName}")
}
}
task prepareInstallerEnvironment(type: Copy, dependsOn: buildCordaTarball) {
into(tarballDir)
from(sourceSets.installerFiles.resources) {
into("installer")
}
}
task embedLicense(type: Exec, dependsOn: [prepareInstallerEnvironment]) {
commandLine "bash", "-c", "sed -i -e '/QQ_LICENSE_FILE_QQ/{r src/main/resources/license/LICENSE' -e 'd}' $tarballDir/installer/installer.sh"
}
task embedTarball(type: Exec, dependsOn: [embedLicense]) {
commandLine "bash", "-c", "cat ${tarballDir}/${buildCordaTarball.archiveName} >> $tarballDir/installer/installer.sh"
}
task buildInstaller(dependsOn: [embedTarball])
def installerFile = file("$tarballDir/installer/installer.sh")
def installerArtifact = artifacts.add("publish", installerFile) {
type "sh"
builtBy(buildInstaller)
}
publish {
name 'corda-installer'
disableDefaultJar = true
}
} else {
println("Not running on *nix, disabling distribution generation")
}