mirror of
https://github.com/boldsuck/haveno.git
synced 2024-12-23 04:29:22 +00:00
500 lines
24 KiB
Groovy
500 lines
24 KiB
Groovy
import org.apache.tools.ant.taskdefs.condition.Os
|
|
|
|
import java.time.LocalDateTime
|
|
import java.util.regex.Pattern
|
|
|
|
task jpackageSanityChecks {
|
|
description 'Interactive sanity checks on the version of the code that will be packaged'
|
|
|
|
doLast {
|
|
if (!System.getenv("CI")) {
|
|
executeCmd("git --no-pager log -5 --oneline")
|
|
ant.input(message: "Above you see the current HEAD and its recent history.\n" +
|
|
"Is this the right commit for packaging? (y=continue, n=abort)",
|
|
addproperty: "sanity-check-1",
|
|
validargs: "y,n")
|
|
if (ant.properties['sanity-check-1'] == 'n') {
|
|
ant.fail('Aborting')
|
|
}
|
|
|
|
executeCmd("git status --short --branch")
|
|
ant.input(message: "Above you see any local changes that are not in the remote branch.\n" +
|
|
"If you have any local changes, please abort, get them merged, get the latest branch and try again.\n" +
|
|
"Continue with packaging? (y=continue, n=abort)",
|
|
addproperty: "sanity-check-2",
|
|
validargs: "y,n")
|
|
if (ant.properties['sanity-check-2'] == 'n') {
|
|
ant.fail('Aborting')
|
|
}
|
|
|
|
// TODO Evtl check programmatically in gradle (i.e. fail if below v11)
|
|
executeCmd("java --version")
|
|
ant.input(message: "Above you see the installed java version, which will be used to compile and build Haveno.\n" +
|
|
"Is this java version ok for that? (y=continue, n=abort)",
|
|
addproperty: "sanity-check-3",
|
|
validargs: "y,n")
|
|
if (ant.properties['sanity-check-3'] == 'n') {
|
|
ant.fail('Aborting')
|
|
}
|
|
} else {
|
|
println "CI environment detected, skipping interactive sanity checks"
|
|
executeCmd("git --no-pager log -5 --oneline")
|
|
executeCmd("git status --short --branch")
|
|
executeCmd("java --version")
|
|
}
|
|
}
|
|
}
|
|
|
|
task getJavaBinariesDownloadURLs {
|
|
description 'Find out which JDK will be used for jpackage and prepare to download it'
|
|
dependsOn 'jpackageSanityChecks'
|
|
|
|
doLast {
|
|
// The build directory will be deleted next time the clean task runs
|
|
// Therefore, we can use it to store any temp files (separate JDK for jpackage, etc) and resulting build artefacts
|
|
// We create a temp folder in the build directory which holds all jpackage-related artefacts (not just the final installers)
|
|
String tempRootDirName = 'temp-' + LocalDateTime.now().format('yyyy.MM.dd-HHmmssSSS')
|
|
File tempRootDir = new File(project.buildDir, tempRootDirName)
|
|
tempRootDir.mkdirs()
|
|
ext.tempRootDir = tempRootDir
|
|
println "Created temp root folder " + tempRootDir
|
|
|
|
File binariesFolderPath = new File(tempRootDir, "binaries")
|
|
binariesFolderPath.mkdirs()
|
|
ext.binariesFolderPath = binariesFolderPath
|
|
|
|
// Define the download URLs (and associated binary hashes) for the JDK used to package the installers
|
|
// These JDKs are independent of what is installed on the building system
|
|
//
|
|
// If these specific versions are not hosted by AdoptOpenJDK anymore, or if different versions are desired,
|
|
// simply update the links and associated hashes below
|
|
//
|
|
// See https://adoptopenjdk.net/releases.html?variant=openjdk15&jvmVariant=hotspot for latest download URLs
|
|
// On the download page linked above, filter as follows to get the binary URL + associated SHA256:
|
|
// - architecture: x64
|
|
// - operating system:
|
|
// -- linux ( -> use the tar.gz JDK link)
|
|
// -- macOS ( -> use the tar.gz JDK link)
|
|
// -- windows ( -> use the .zip JDK link)
|
|
Map jdk21Binaries = [
|
|
'linux' : 'https://download.bell-sw.com/java/21.0.2+14/bellsoft-jdk21.0.2+14-linux-amd64-full.tar.gz',
|
|
'linux-sha256' : '7eda80851fba1da023e03446c77100f19e7c770491b0d5bc9f893044e1b2b69b',
|
|
'linux-aarch64' : 'https://download.bell-sw.com/java/21.0.2+14/bellsoft-jdk21.0.2+14-linux-aarch64-full.tar.gz',
|
|
'linux-aarch64-sha256' : 'a477fc72085f30b03bf71fbed47923cea3b6f33b5b6a5a74718623b772a3a043',
|
|
'mac' : 'https://download.bell-sw.com/java/21.0.2+14/bellsoft-jdk21.0.2+14-macos-amd64-full.tar.gz',
|
|
'mac-sha256' : '42b528206595e559803b6f9f6bdbbf236ec6d10684058f46bc5261f5498d345c',
|
|
'mac-aarch64' : 'https://download.bell-sw.com/java/21.0.2+14/bellsoft-jdk21.0.2+14-macos-aarch64-full.tar.gz',
|
|
'mac-aarch64-sha256' : 'eba73a9bff7234220dc9a1da7f44b3d7ed2a562663eadc1c53bd74b355839a55',
|
|
'windows' : 'https://download.bell-sw.com/java/21.0.2+14/bellsoft-jdk21.0.2+14-windows-amd64-full.zip',
|
|
'windows-sha256' : 'f823eff0234af5bef095e53e5431191dbee8c2e42ca321eda23148a15cbf8d5b',
|
|
'windows-aarch64' : 'https://download.bell-sw.com/java/21.0.2+14/bellsoft-jdk21.0.2+14-windows-aarch64-full.zip',
|
|
'windows-aarch64-sha256': 'a2e9edecaf9637f83ef1cddab3a74f39ac55f8e1a479f10f3584ad939dfadd0a'
|
|
]
|
|
|
|
String osKey
|
|
String architecture = System.getProperty("os.arch").toLowerCase()
|
|
|
|
if (Os.isFamily(Os.FAMILY_WINDOWS)) {
|
|
if (architecture.contains("aarch64") || architecture.contains("arm")) {
|
|
osKey = "windows-aarch64"
|
|
} else {
|
|
osKey = "windows"
|
|
}
|
|
} else if (Os.isFamily(Os.FAMILY_MAC)) {
|
|
if (architecture.contains("aarch64") || architecture.contains("arm")) {
|
|
osKey = "mac-aarch64"
|
|
} else {
|
|
osKey = "mac"
|
|
}
|
|
} else {
|
|
if (architecture.contains("aarch64") || architecture.contains("arm")) {
|
|
osKey = "linux-aarch64"
|
|
} else {
|
|
osKey = "linux"
|
|
}
|
|
}
|
|
|
|
ext.osKey = osKey
|
|
|
|
ext.jdk21Binary_DownloadURL = jdk21Binaries[osKey]
|
|
ext.jdk21Binary_SHA256Hash = jdk21Binaries[osKey + '-sha256']
|
|
}
|
|
}
|
|
|
|
task retrieveAndExtractJavaBinaries {
|
|
description 'Retrieve necessary Java binaries and extract them'
|
|
dependsOn 'getJavaBinariesDownloadURLs'
|
|
|
|
doLast {
|
|
File tempRootDir = getJavaBinariesDownloadURLs.property("tempRootDir") as File
|
|
|
|
// Folder where the jpackage JDK archive will be downloaded and extracted
|
|
String jdkForJpackageDirName = "jdk-jpackage"
|
|
File jdkForJpackageDir = new File(tempRootDir, jdkForJpackageDirName)
|
|
jdkForJpackageDir.mkdirs()
|
|
|
|
String jdkForJpackageArchiveURL = getJavaBinariesDownloadURLs.property('jdk21Binary_DownloadURL')
|
|
String jdkForJpackageArchiveHash = getJavaBinariesDownloadURLs.property('jdk21Binary_SHA256Hash')
|
|
String jdkForJpackageArchiveFileName = jdkForJpackageArchiveURL.tokenize('/').last()
|
|
File jdkForJpackageFile = new File(jdkForJpackageDir, jdkForJpackageArchiveFileName)
|
|
|
|
// Download necessary JDK binaries + verify hash
|
|
ext.downloadAndVerifyArchive(jdkForJpackageArchiveURL, jdkForJpackageArchiveHash, jdkForJpackageFile)
|
|
|
|
// Extract them
|
|
String jpackageBinaryFileName
|
|
if (Os.isFamily(Os.FAMILY_WINDOWS)) {
|
|
ext.extractArchiveZip(jdkForJpackageFile, jdkForJpackageDir)
|
|
jpackageBinaryFileName = 'jpackage.exe'
|
|
} else {
|
|
ext.extractArchiveTarGz(jdkForJpackageFile, jdkForJpackageDir)
|
|
jpackageBinaryFileName = 'jpackage'
|
|
}
|
|
|
|
// Find jpackage in the newly extracted JDK
|
|
// Don't rely on hardcoded paths to reach it, because the path depends on the version and platform
|
|
jdkForJpackageDir.traverse(type: groovy.io.FileType.FILES, nameFilter: jpackageBinaryFileName) {
|
|
println 'Using jpackage binary from ' + it
|
|
ext.jpackageFilePath = it.path
|
|
}
|
|
}
|
|
|
|
ext.downloadAndVerifyArchive = { String archiveURL, String archiveSHA256, File destinationArchiveFile ->
|
|
println "Downloading ${archiveURL}"
|
|
ant.get(src: archiveURL, dest: destinationArchiveFile)
|
|
println 'Download saved to ' + destinationArchiveFile
|
|
|
|
println 'Verifying checksum for downloaded binary ...'
|
|
ant.jdkHash = archiveSHA256
|
|
ant.checksum(file: destinationArchiveFile, algorithm: 'SHA-256', property: '${jdkHash}', verifyProperty: 'hashMatches')
|
|
if (ant.properties['hashMatches'] != 'true') {
|
|
ant.fail('Checksum mismatch: Downloaded JDK binary has a different checksum than expected')
|
|
}
|
|
println 'Checksum verified'
|
|
}
|
|
|
|
ext.extractArchiveTarGz = { File tarGzFile, File destinationDir ->
|
|
println "Extracting tar.gz ${tarGzFile}"
|
|
// Gradle's tar extraction preserves permissions (crucial for jpackage to function correctly)
|
|
copy {
|
|
from tarTree(resources.gzip(tarGzFile))
|
|
into destinationDir
|
|
}
|
|
println "Extracted to ${destinationDir}"
|
|
}
|
|
|
|
ext.extractArchiveZip = { File zipFile, File destinationDir ->
|
|
println "Extracting zip ${zipFile}..."
|
|
ant.unzip(src: zipFile, dest: destinationDir)
|
|
println "Extracted to ${destinationDir}"
|
|
}
|
|
}
|
|
|
|
task packageInstallers {
|
|
description 'Call jpackage to prepare platform-specific binaries for this platform'
|
|
dependsOn 'retrieveAndExtractJavaBinaries'
|
|
// Clean all previous artifacts and create a fresh shadowJar for the installers
|
|
dependsOn rootProject.clean
|
|
dependsOn ':core:havenoDeps'
|
|
dependsOn ':desktop:shadowJar'
|
|
|
|
doLast {
|
|
String jPackageFilePath = retrieveAndExtractJavaBinaries.property('jpackageFilePath')
|
|
File binariesFolderPath = file(getJavaBinariesDownloadURLs.property('binariesFolderPath'))
|
|
|
|
File tempRootDir = getJavaBinariesDownloadURLs.property("tempRootDir") as File
|
|
// The jpackageTempDir stores temp files used by jpackage for building the installers
|
|
// It can be inspected in order to troubleshoot the packaging process
|
|
File jpackageTempDir = new File(tempRootDir, "jpackage-temp")
|
|
jpackageTempDir.mkdirs()
|
|
|
|
// ALL contents of this folder will be included in the resulting installers
|
|
// However, the fat jar is the only one we need
|
|
// Therefore, this location should point to a folder that ONLY contains the fat jar
|
|
// If later we will need to include other non-jar resources, we can do that by adding --resource-dir to the jpackage opts
|
|
String fatJarFolderPath = "${project(':desktop').buildDir}/libs/fatJar"
|
|
String mainJarName = shadowJar.getArchiveFileName().get()
|
|
|
|
delete(fatJarFolderPath)
|
|
mkdir(fatJarFolderPath)
|
|
copy {
|
|
from "${project(':desktop').buildDir}/libs/${mainJarName}"
|
|
into fatJarFolderPath
|
|
}
|
|
|
|
// We convert the fat jar into a deterministic one by stripping out comments with date, etc.
|
|
// jar file created from https://github.com/ManfredKarrer/tools
|
|
executeCmd("java -jar \"${project(':desktop').projectDir}/package/tools-1.0.jar\" ${fatJarFolderPath}/${mainJarName}")
|
|
|
|
// Store deterministic jar SHA-256
|
|
ant.checksum(file: "${fatJarFolderPath}/${mainJarName}", algorithm: 'SHA-256')
|
|
copy {
|
|
from "${fatJarFolderPath}/${mainJarName}.SHA-256"
|
|
into binariesFolderPath
|
|
}
|
|
|
|
// TODO For non-modular applications: use jlink to create a custom runtime containing only the modules required
|
|
|
|
// See jpackager argument documentation:
|
|
// https://docs.oracle.com/en/java/javase/15/docs/specs/man/jpackage.html
|
|
|
|
// Remove the -SNAPSHOT suffix from the version string (originally defined in build.gradle)
|
|
// Having it in would have resulted in an invalid version property for several platforms (mac, linux/rpm)
|
|
String appVersion = version.replaceAll("-SNAPSHOT", "")
|
|
println "Packaging Haveno version ${appVersion}"
|
|
|
|
// zip jar lib for Raspberry Pi only on macOS as there are path issues on Windows and it is only needed once
|
|
// for the release
|
|
if (Os.isFamily(Os.FAMILY_MAC)) {
|
|
println "Zipping jar lib for raspberry pi"
|
|
ant.zip(basedir: "${project(':desktop').buildDir}/app/lib",
|
|
destfile: "${binariesFolderPath}/jar-lib-for-raspberry-pi-${appVersion}.zip")
|
|
}
|
|
|
|
//String appDescription = 'A decentralized monero exchange network.'
|
|
String appCopyright = '© 2024 Haveno'
|
|
String appNameAndVendor = 'Haveno'
|
|
|
|
String commonOpts = new String(
|
|
// Generic options
|
|
" --dest \"${binariesFolderPath}\"" +
|
|
" --name ${appNameAndVendor}" +
|
|
//" --description \"${appDescription}\"" + // TODO: task managers show app description instead of name, so we disable it
|
|
" --app-version ${appVersion}" +
|
|
" --copyright \"${appCopyright}\"" +
|
|
" --vendor ${appNameAndVendor}" +
|
|
" --temp \"${jpackageTempDir}\"" +
|
|
|
|
// Options for creating the application image
|
|
" --input ${fatJarFolderPath}" +
|
|
|
|
// Options for creating the application launcher
|
|
" --main-jar ${mainJarName}" +
|
|
" --main-class haveno.desktop.app.HavenoAppMain" +
|
|
" --java-options -Xss1280k" +
|
|
" --java-options -XX:MaxRAM=4g" +
|
|
" --java-options --add-opens=javafx.controls/com.sun.javafx.scene.control.behavior=ALL-UNNAMED" +
|
|
" --java-options --add-opens=javafx.controls/com.sun.javafx.scene.control=ALL-UNNAMED" +
|
|
" --java-options --add-opens=java.base/java.lang.reflect=ALL-UNNAMED" +
|
|
" --java-options --add-opens=javafx.graphics/com.sun.javafx.scene=ALL-UNNAMED" +
|
|
" --java-options -Djava.net.preferIPv4Stack=true" +
|
|
" --arguments --baseCurrencyNetwork=XMR_STAGENET"
|
|
// Warning: this will cause guice reflection exceptions and lead to issues with the guice internal cache
|
|
// resulting in the UI not loading
|
|
// " --java-options -Djdk.module.illegalAccess=deny" +
|
|
)
|
|
|
|
if (Os.isFamily(Os.FAMILY_WINDOWS)) {
|
|
String windowsOpts = new String(
|
|
" --icon \"${project(':desktop').projectDir}/package/windows/Haveno.ico\"" +
|
|
" --resource-dir \"${project(':desktop').projectDir}/package/windows\"" +
|
|
" --win-dir-chooser" +
|
|
" --win-per-user-install" +
|
|
" --win-menu" +
|
|
" --win-shortcut"
|
|
)
|
|
|
|
executeCmd(jPackageFilePath + commonOpts + windowsOpts + " --verbose > desktop/build/output.txt --type exe")
|
|
} else if (Os.isFamily(Os.FAMILY_MAC)) {
|
|
// See https://docs.oracle.com/en/java/javase/14/jpackage/override-jpackage-resources.html
|
|
// for details of "--resource-dir"
|
|
|
|
String macOpts = new String(
|
|
" --resource-dir \"${project(':desktop').projectDir}/package/macosx\""
|
|
)
|
|
|
|
executeCmd(jPackageFilePath + commonOpts + macOpts + " --type dmg")
|
|
} else {
|
|
String linuxOpts = new String(
|
|
" --icon ${project(':desktop').projectDir}/package/linux/icon.png" +
|
|
// This defines the first part of the resulting packages (the application name)
|
|
// deb requires lowercase letters, therefore the application name is written in lowercase
|
|
" --linux-package-name haveno" +
|
|
|
|
// This represents the linux package version (revision)
|
|
// By convention, this is part of the deb/rpm package names, in addition to the software version
|
|
" --linux-app-release 1" +
|
|
|
|
" --linux-menu-group Network" +
|
|
" --linux-shortcut"
|
|
)
|
|
|
|
// Package deb
|
|
executeCmd(jPackageFilePath + commonOpts + linuxOpts +
|
|
" --linux-deb-maintainer noreply@haveno.exchange" +
|
|
" --type deb")
|
|
|
|
// Clean jpackage temp folder, needs to be empty for the next packaging step (AppImage)
|
|
jpackageTempDir.deleteDir()
|
|
jpackageTempDir.mkdirs()
|
|
|
|
executeCmd(jPackageFilePath + commonOpts +
|
|
" --dest \"${jpackageTempDir}\"" +
|
|
" --type app-image")
|
|
|
|
// Path to the app-image directory: THIS IS NOT THE ACTUAL .AppImage FILE.
|
|
// See JPackage documentation on --type app-image for more.
|
|
String appImagePath = new String(
|
|
"\"${binariesFolderPath}/${appNameAndVendor}\""
|
|
)
|
|
|
|
// Which version of AppImageTool to use
|
|
String AppImageToolVersion = "13";
|
|
|
|
// Download AppImageTool
|
|
Map AppImageToolBinaries = [
|
|
'linux' : "https://github.com/AppImage/AppImageKit/releases/download/${AppImageToolVersion}/appimagetool-x86_64.AppImage",
|
|
'linux-aarch64' : "https://github.com/AppImage/AppImageKit/releases/download/${AppImageToolVersion}/appimagetool-aarch64.AppImage",
|
|
]
|
|
|
|
String osKey = getJavaBinariesDownloadURLs.property('osKey')
|
|
|
|
File appDir = new File("${jpackageTempDir}/Haveno")
|
|
File templateAppDir = new File("${project(':desktop').projectDir}/package/linux/Haveno.AppDir")
|
|
File jpackDir = appDir
|
|
|
|
appDir.mkdirs()
|
|
|
|
File AppImageToolBinary = new File("${jpackageTempDir}/appimagetool.AppImage")
|
|
|
|
// Adding a platform to the AppImageToolBinaries essentially adds it to the "supported" list of platforms able to make AppImages
|
|
// However, be warned that any platform that doesn't support unix `ln` and `chmod` will not work with the current method.
|
|
if (AppImageToolBinaries.containsKey(osKey)) {
|
|
println "Downloading ${AppImageToolBinaries[osKey]}"
|
|
ant.get(src: AppImageToolBinaries[osKey], dest: AppImageToolBinary)
|
|
println 'Download saved to ' + jpackageTempDir
|
|
|
|
project.exec {
|
|
commandLine('chmod', '+x', AppImageToolBinary)
|
|
}
|
|
|
|
copy {
|
|
from templateAppDir
|
|
into appDir
|
|
boolean includeEmptyDirs = true
|
|
}
|
|
|
|
project.exec {
|
|
workingDir appDir
|
|
commandLine 'ln', '-s', 'bin/Haveno', 'AppRun'
|
|
}
|
|
|
|
project.exec {
|
|
commandLine "${AppImageToolBinary}", appDir, "${binariesFolderPath}/haveno_${appVersion}.AppImage"
|
|
}
|
|
} else {
|
|
println "Your platform does not support AppImageTool ${AppImageToolVersion}"
|
|
}
|
|
|
|
|
|
// Clean jpackage temp folder, needs to be empty for the next packaging step (rpm)
|
|
jpackageTempDir.deleteDir()
|
|
jpackageTempDir.mkdirs()
|
|
|
|
// Package rpm
|
|
executeCmd(jPackageFilePath + commonOpts + linuxOpts +
|
|
" --linux-rpm-license-type AGPLv3" + // https://fedoraproject.org/wiki/Licensing:Main?rd=Licensing#Good_Licenses
|
|
" --type rpm")
|
|
|
|
|
|
|
|
// Define Flatpak-related properties
|
|
String flatpakManifestFile = 'package/linux/exchange.haveno.Haveno.yml'
|
|
String linuxDir = 'package/linux'
|
|
String flatpakOutputDir = 'package/linux/build'
|
|
String flatpakExportDir = "${binariesFolderPath}/fpexport"
|
|
String flatpakBundleFile = "${binariesFolderPath}/haveno.flatpak"
|
|
|
|
// Read the default app name from the HavenoExecutable.java file
|
|
def filer = file('../core/src/main/java/haveno/core/app/HavenoExecutable.java')
|
|
def content = filer.text
|
|
def matcher = Pattern.compile(/public static final String DEFAULT_APP_NAME = "(.*?)";/).matcher(content)
|
|
def defaultAppName = "Haveno"
|
|
if (matcher.find()) {
|
|
defaultAppName = matcher.group(1)
|
|
} else {
|
|
throw new GradleException("DEFAULT_APP_NAME not found in HavenoExecutable.java")
|
|
}
|
|
|
|
// Copy the manifest to a new tmp one in the same place
|
|
// and add a --filesystem=.local/share/${name} to the flatpak manifest
|
|
def manifest = file(flatpakManifestFile)
|
|
def newManifest = file('exchange.haveno.Haveno.yaml')
|
|
newManifest.write(manifest.text.replace("- --share=network", "- --share=network\n - --filesystem=~/.local/share/${defaultAppName}:create"))
|
|
flatpakManifestFile = 'exchange.haveno.Haveno.yaml'
|
|
|
|
// Command to build the Flatpak
|
|
exec {
|
|
commandLine 'flatpak-builder', '--force-clean', flatpakOutputDir, flatpakManifestFile, '--user', '--install-deps-from=flathub'
|
|
}
|
|
|
|
// Command to export the Flatpak
|
|
exec {
|
|
commandLine 'flatpak', 'build-export', flatpakExportDir, flatpakOutputDir
|
|
}
|
|
|
|
// Command to create the Flatpak bundle
|
|
exec {
|
|
commandLine 'flatpak', 'build-bundle', flatpakExportDir, flatpakBundleFile, 'exchange.haveno.Haveno', '--runtime-repo=https://flathub.org/repo/flathub.flatpakrepo'
|
|
}
|
|
|
|
// delete the flatpak build directory
|
|
delete(flatpakOutputDir)
|
|
delete(flatpakExportDir)
|
|
delete(flatpakManifestFile)
|
|
|
|
println "Flatpak package created at ${flatpakBundleFile}"
|
|
}
|
|
|
|
// Env variable can be set by calling "export HAVENO_SHARED_FOLDER='Some value'"
|
|
// This is to copy the final binary/ies to a shared folder for further processing if a VM is used.
|
|
String envVariableSharedFolder = "$System.env.HAVENO_SHARED_FOLDER"
|
|
println "Environment variable HAVENO_SHARED_FOLDER is: ${envVariableSharedFolder}"
|
|
|
|
if (envVariableSharedFolder != "null") {
|
|
ant.input(message: "Copy the created binary to a shared folder? (y=yes, n=no)",
|
|
addproperty: "copy-to-shared-folder",
|
|
validargs: "y,n")
|
|
if (ant.properties['copy-to-shared-folder'] == 'y') {
|
|
copy {
|
|
from binariesFolderPath
|
|
into envVariableSharedFolder
|
|
}
|
|
|
|
executeCmd("open " + envVariableSharedFolder)
|
|
}
|
|
}
|
|
|
|
println "The binaries are ready:"
|
|
binariesFolderPath.traverse {
|
|
println it.path
|
|
}
|
|
}
|
|
}
|
|
|
|
def executeCmd(String cmd) {
|
|
String shell
|
|
String shellArg
|
|
if (Os.isFamily(Os.FAMILY_WINDOWS)) {
|
|
shell = 'cmd'
|
|
shellArg = '/c'
|
|
} else {
|
|
shell = 'bash'
|
|
shellArg = '-c'
|
|
}
|
|
|
|
println "Executing command:\n${cmd}\n"
|
|
// See "Executing External Processes" section of
|
|
// http://docs.groovy-lang.org/next/html/documentation/
|
|
def commands = [shell, shellArg, cmd]
|
|
def process = commands.execute(null, project.rootDir)
|
|
def result
|
|
if (process.waitFor() == 0) {
|
|
result = process.text
|
|
println "Command output (stdout):\n${result}"
|
|
} else {
|
|
result = process.err.text
|
|
println "Command output (stderr):\n${result}"
|
|
}
|
|
return result
|
|
}
|