322 lines
15 KiB
Groovy
322 lines
15 KiB
Groovy
def lnpubuildinfo = null
|
|
|
|
/* Example expected JSON
|
|
{
|
|
"Artifact info": {
|
|
"Location": "Jenkins job artifact",
|
|
"Job": "LNPU_master/LNPU_master_build",
|
|
"Job selector": "<StatusBuildSelector plugin=\"copyartifact@1.46.2\"><stable>true</stable></StatusBuildSelector>",
|
|
"Release repo": "git@hydra:local-network-package-updater-releases/local-network-package-updater-whole.git",
|
|
"Release repo revision": ""
|
|
}
|
|
}
|
|
*/
|
|
|
|
def String asJsonText() {
|
|
return writeJSON(returnText: true, json: lnpubuildinfo, pretty: 1)
|
|
}
|
|
|
|
def boolean exists() {
|
|
return (lnpubuildinfo != null)
|
|
}
|
|
|
|
def set(String jsontext) {
|
|
lnpubuildinfo = readJSON(text: jsontext)
|
|
echo "LNPU build info:\n${asJsonText()}"
|
|
}
|
|
|
|
def get() {
|
|
return lnpubuildinfo
|
|
}
|
|
|
|
pipeline {
|
|
agent { label AGENT_LABEL }
|
|
stages {
|
|
stage('Initial setup') {
|
|
steps {
|
|
script {
|
|
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startbuild(this, PRODUCT_NAME, SUBCOMPONENT_NAME, RELEASE_REPO)
|
|
|
|
set(LNPU_BINARIES_INFO)
|
|
lnpubuildjobartifactinfo = get()['Artifact info']
|
|
|
|
if (INSTALLSHIELD2020_CMD == "" || DOTNET_FRAMEWORK64_PATH == "" || WINDOWS_DRIVER_KIT_8_1 == "" || WINDOWS_DRIVER_KIT_10 == "") {
|
|
echo "Either INSTALLSHIELD2020_CMD, DOTNET_FRAMEWORK64_PATH, WINDOWS_DRIVER_KIT_8_1 or WINDOWS_DRIVER_KIT_10 environment variables have not been defined"
|
|
currentBuild.result = 'FAILED'
|
|
exit(1)
|
|
}
|
|
|
|
toBuild = ['LNPU']
|
|
}
|
|
}
|
|
}
|
|
stage('Checkout dependencies') {
|
|
steps {
|
|
script {
|
|
configurationhelper = autobuilder.configurationhelper()
|
|
|
|
PYTHONURL = 'git@hydra:tools/python.git'
|
|
PYTHONBRANCH = 'origin/3.6.3_windows'
|
|
PYTHONDIR = "${WORKSPACE}/python"
|
|
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR)
|
|
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
|
|
|
|
SUPPORTURL = 'git@hydra:gis/gissupport.git'
|
|
SUPPORTBRANCH = SUPPORT_REVISION.trim()
|
|
SUPPORTDIR = "${WORKSPACE}\\gissupport"
|
|
configurationhelper.gitCheckoutAndRegister(meta, 'gissupport', SUPPORTURL, SUPPORTBRANCH, SUPPORTDIR)
|
|
env.INST_SUPPORT = SUPPORTDIR
|
|
|
|
EULAURL = 'git@hydra:gis/giseula.git'
|
|
EULABRANCH = EULA_REVISION.trim()
|
|
EULADIR = "${WORKSPACE}\\giseula"
|
|
configurationhelper.gitCheckoutAndRegister(meta, 'giseula', EULAURL, EULABRANCH, EULADIR)
|
|
env.INST_EULA = EULADIR
|
|
|
|
PREREQURL = 'git@hydra:gis/installerprerequisites.git'
|
|
PREREQBRANCH = PREREQUISITE_REVISION.trim()
|
|
PREREQDIR = "${WORKSPACE}\\prereq"
|
|
configurationhelper.gitCheckoutAndRegister(meta, 'installerprerequisites', PREREQURL, PREREQBRANCH, PREREQDIR)
|
|
env.INST_PREQ = PREREQDIR
|
|
|
|
DIGSIGURL = 'git@hydra:gis/digitalsignature.git'
|
|
DIGSIGBRANCH = DIGITALSIGNATURE_REVISION.trim()
|
|
DIGSIGDIR = "${WORKSPACE}\\certificates"
|
|
configurationhelper.gitCheckoutAndRegister(meta, 'digitalsignature', DIGSIGURL, DIGSIGBRANCH, DIGSIGDIR)
|
|
env.PATH_TO_CERTIFICATE_PFX = "${DIGSIGDIR}\\GIS"
|
|
}
|
|
}
|
|
}
|
|
stage('Checkout source') {
|
|
steps {
|
|
script {
|
|
SOURCEURL = 'git@hydra:core-presto/pc-utilities/local-network-package-updater.git'
|
|
SOURCEREVISION = SOURCE_REVISION.trim()
|
|
SOURCEDIR = "${WORKSPACE}\\lnpu"
|
|
configurationhelper.gitCheckoutAndRegister(meta, 'lnpu', SOURCEURL, SOURCEREVISION, SOURCEDIR, '', 0, false)
|
|
env.SOURCE_PATH = SOURCEDIR
|
|
env.INST_SRC = "${SOURCE_PATH}\\src"
|
|
}
|
|
}
|
|
}
|
|
stage("Clean exports") {
|
|
steps {
|
|
script {
|
|
env.IMPORTSPATH = "${WORKSPACE}\\imports"
|
|
env.APPPACKAGEIMPORTPATH = "${IMPORTSPATH}\\build\\apppackage"
|
|
env.CONTROLPACKAGEIMPORTPATH = "${IMPORTSPATH}\\build\\controlpackage"
|
|
env.INTERMEDIATEEXPORTSPATH = "${WORKSPACE}\\info"
|
|
env.EXPORTSPATH = 'installers'
|
|
env.VERSIONINFO = "${WORKSPACE}\\versioninfo"
|
|
LNPUBUILDIMPORT = 'lnpubuild'
|
|
env.LNPUBUILD = "${WORKSPACE}\\${LNPUBUILDIMPORT}"
|
|
cleanfolders = [
|
|
IMPORTSPATH,
|
|
INTERMEDIATEEXPORTSPATH,
|
|
EXPORTSPATH,
|
|
VERSIONINFO,
|
|
LNPUBUILDIMPORT,
|
|
]
|
|
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
|
|
cleaner.clean(cleanfolders)
|
|
}
|
|
}
|
|
}
|
|
stage('Generating version info') {
|
|
steps {
|
|
script {
|
|
version = load("${autobuilder.commonscripts()}/versionnumbering/generate.groovy")
|
|
version.generate(meta, SOURCE_REVISION, SOURCE_PATH)
|
|
}
|
|
}
|
|
}
|
|
stage("Import binaries") {
|
|
steps {
|
|
script {
|
|
def importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
|
|
|
|
def lnpubuildimportoptions = importer.getNewImportOptions()
|
|
lnpubuildimportoptions.source(lnpubuildjobartifactinfo['Location'],
|
|
lnpubuildjobartifactinfo['Job'],
|
|
lnpubuildjobartifactinfo['Job selector'],
|
|
lnpubuildjobartifactinfo['Release repo'],
|
|
lnpubuildjobartifactinfo['Release repo revision'])
|
|
lnpubuildimportoptions.setincrementversionnumber(false)
|
|
lnpubuildimportoptions.setexcludes( '**/*.pdb,**/*.lib')
|
|
lnpubuildmeta = importer.artifactimport(meta, lnpubuildimportoptions, LNPUBUILDIMPORT)
|
|
|
|
def apppackageimportoptions = importer.getNewImportOptions()
|
|
apppackageimportoptions.jenkinsjob(PACKAGE_CREATE_JOB,
|
|
PACKAGE_CREATE_JOB_SELECTOR)
|
|
apppackageimportoptions.setincrementversionnumber(false)
|
|
apppackagemeta = importer.artifactimport(meta, apppackageimportoptions, APPPACKAGEIMPORTPATH)
|
|
|
|
def controlpackageimportoptions = importer.getNewImportOptions()
|
|
controlpackageimportoptions.jenkinsjob(CONTROL_PACKAGE_CREATE_JOB,
|
|
CONTROL_PACKAGE_CREATE_JOB_SELECTOR)
|
|
controlpackageimportoptions.setincrementversionnumber(false)
|
|
controlpackagemeta = importer.artifactimport(meta, controlpackageimportoptions, CONTROLPACKAGEIMPORTPATH)
|
|
|
|
BUILD_STAMP = apppackagemeta.buildstampinfo.buildstamp
|
|
PRODUCT_NAME = apppackagemeta.productinfo.productname
|
|
EXE_NAME_PREFIX = "GIS ${PRODUCT_NAME} ${BUILD_STAMP} LNP Updater"
|
|
|
|
artifactDetails = [
|
|
// Key, Artifacts Source project Artifacts source selector, Destination folder Increment Version Number Artifacts to copy Artifacts to not copy Binaries Folders
|
|
]
|
|
installerDetails = [
|
|
// Key, Installer command artifactSet Target folder Execution path ISM project file Variant Intermediate output path Component base folder Final filename
|
|
LNPU: [INSTALLSHIELD2020_CMD, [], 'install_core', "${SOURCE_PATH}\\installer\\build\\core", 'Core.ism', '', "${INTERMEDIATEEXPORTSPATH}/install_core/x64/ALL/DiskImages/DISK1/LNPU.exe", "${EXPORTSPATH}/ALL", "${EXE_NAME_PREFIX}.exe" ],
|
|
]
|
|
installerhelper = load("${autobuilder.commonscripts()}/install/installhelper.groovy")
|
|
artifactFetched = installerhelper.artifactsImporter(meta, importer, toBuild, artifactDetails, installerDetails)
|
|
}
|
|
}
|
|
}
|
|
stage('Generate version info folder for installer') {
|
|
steps {
|
|
script {
|
|
def metamap = [
|
|
[ VERSIONINFO, meta ], // Incomplete until this job ends
|
|
]
|
|
for (metaitem in metamap) {
|
|
(destfolder, componentmeta) = metaitem
|
|
dir(destfolder) {
|
|
componentmeta.saveJsonSerialised("meta.json")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
stage("Build installers") {
|
|
steps {
|
|
script {
|
|
fileOperations([folderCreateOperation(INTERMEDIATEEXPORTSPATH)])
|
|
installerpublishlist = []
|
|
(installcmd, artifactKeySet, processingFolder, EXECUTIONPATH, ISMPROJECT, VARIANT, pathToIntermediate, FINALBASEFOLDER, FINALFILENAME) = installerDetails.get(toBuild[0])
|
|
|
|
def INST_ISVERSION = BUILD_STAMP
|
|
echo "Build stamp is: ${INST_ISVERSION}"
|
|
|
|
def APP_PACKAGE_BIN = APPPACKAGEIMPORTPATH
|
|
|
|
def CONTROL_PACKAGE_BIN = CONTROLPACKAGEIMPORTPATH
|
|
|
|
def LNPU_BIN = LNPUBUILD
|
|
|
|
def INST_VERBOSE = ''
|
|
if (VERBOSE == "true") {
|
|
INST_VERBOSE = '-v'
|
|
}
|
|
|
|
def INST_OUT = "${INTERMEDIATEEXPORTSPATH}\\${processingFolder}"
|
|
fileOperations([folderCreateOperation(INST_OUT)])
|
|
|
|
def INST_VARIANT = ''
|
|
if (VARIANT != "" ) {
|
|
INST_VARIANT = '-r ' + VARIANT
|
|
}
|
|
|
|
def ISM_PROJECT_FILE_PATH = "${EXECUTIONPATH}\\${ISMPROJECT}"
|
|
convertdetails = [
|
|
// File to convert Pattern to replace New string
|
|
[ ISM_PROJECT_FILE_PATH, "-INSTALLER PRODUCT NAME-", EXE_NAME_PREFIX ],
|
|
]
|
|
versionnumbering = load("${autobuilder.commonscripts()}/versionnumbering/do.groovy")
|
|
//versionnumbering.stamp(convertdetails)
|
|
|
|
installerhelper.checkISMfile(ISM_PROJECT_FILE_PATH)
|
|
installerhelper.selectSigningCertificate(NODE_NAME, ISM_PROJECT_FILE_PATH)
|
|
|
|
// Fill settings file
|
|
//-i <.ini file path>
|
|
def IS_INI_CONTENT = [
|
|
"[Project]",
|
|
"Name=\"${ISMPROJECT}\"",
|
|
"BuildLabel=x64",
|
|
"Product=\"${EXE_NAME_PREFIX}\"",
|
|
"",
|
|
"[Release]",
|
|
"Name=${VARIANT}",
|
|
"",
|
|
"[Mode]",
|
|
"Verbose=${(VERBOSE == "true")?'yes':'no'}",
|
|
"DotNetPath=\"${DOTNET_FRAMEWORK64_PATH}\"",
|
|
"PrerequisitePath=\"${INST_PREQ}\"",
|
|
].join('\n')
|
|
|
|
dir(EXECUTIONPATH) {
|
|
def IS_INI_FILE = 'is.ini'
|
|
echo "Writing:\n${IS_INI_CONTENT}\nto: ${IS_INI_FILE}"
|
|
writeFile(file: IS_INI_FILE, text: IS_INI_CONTENT)
|
|
bat """
|
|
"${installcmd}" ^
|
|
-i "${IS_INI_FILE}" ^
|
|
-y "${INST_ISVERSION}" ^
|
|
-l "WORKSPACE=${WORKSPACE}" ^
|
|
-l "APP_PACKAGE_BIN=${APP_PACKAGE_BIN}" ^
|
|
-l "CONTROL_PACKAGE_BIN=${CONTROL_PACKAGE_BIN}" ^
|
|
-l "LNPU_BIN=${LNPU_BIN}" ^
|
|
-l "INST_OUT=${INST_OUT}" ^
|
|
-l "INST_EULA=${INST_EULA}" ^
|
|
-l "INST_SUPPORT=${INST_SUPPORT}" ^
|
|
-l "INST_VERSIONINFO=${VERSIONINFO}" ^
|
|
-z "ProductName=${EXE_NAME_PREFIX}"
|
|
"""
|
|
}
|
|
//-z <property name=property value>
|
|
|
|
installerhelper.copyToFinalPosition(pathToIntermediate, FINALBASEFOLDER, FINALFILENAME)
|
|
|
|
def EXPORT_OUT_GLOB = "${FINALBASEFOLDER}/**"
|
|
echo "Adding ${EXPORT_OUT_GLOB} to installer publish list"
|
|
installerpublishlist.add(EXPORT_OUT_GLOB)
|
|
}
|
|
}
|
|
}
|
|
stage('Classifying publishable artifacts') {
|
|
steps {
|
|
script {
|
|
def publishable = installerpublishlist
|
|
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
|
|
publishutils.generatelist(meta, publishable)
|
|
}
|
|
}
|
|
}
|
|
stage('Archiving artifacts') {
|
|
steps {
|
|
script {
|
|
ArrayList<String> itemsForRelease = ["info/**", "installers/**"]
|
|
def artifactlist = meta.generateartifacts(itemsForRelease)
|
|
artifactarchiver = load("${autobuilder.commonscripts()}/artifacts/archiver.groovy")
|
|
artifactarchiver.archive(meta, artifactlist)
|
|
}
|
|
}
|
|
}
|
|
stage('Check for unstable build') {
|
|
steps {
|
|
script {
|
|
def installersToBuild = installerDetails.size()
|
|
if (installersToBuild != toBuild.size()) {
|
|
echo "Not building the complete set of installers (${installersToBuild}) therefore marking building unstable"
|
|
currentBuild.result = 'UNSTABLE'
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
post {
|
|
always {
|
|
echo 'Post-build'
|
|
}
|
|
failure {
|
|
echo 'Failed build'
|
|
}
|
|
unstable {
|
|
echo 'Unstable build'
|
|
}
|
|
success {
|
|
echo 'Succeeded build'
|
|
}
|
|
}
|
|
}
|