Copy from Atlas Autobuild scripts as a starting point
This commit is contained in:
parent
b9a22c1989
commit
2d66e342df
92 changed files with 11897 additions and 0 deletions
17
Common_scripts/.project
Normal file
17
Common_scripts/.project
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<projectDescription>
|
||||
<name>Common Build Scripts</name>
|
||||
<comment></comment>
|
||||
<projects>
|
||||
</projects>
|
||||
<buildSpec>
|
||||
<buildCommand>
|
||||
<name>org.python.pydev.PyDevBuilder</name>
|
||||
<arguments>
|
||||
</arguments>
|
||||
</buildCommand>
|
||||
</buildSpec>
|
||||
<natures>
|
||||
<nature>org.python.pydev.pythonNature</nature>
|
||||
</natures>
|
||||
</projectDescription>
|
||||
8
Common_scripts/.pydevproject
Normal file
8
Common_scripts/.pydevproject
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
|
||||
<?eclipse-pydev version="1.0"?><pydev_project>
|
||||
<pydev_pathproperty name="org.python.pydev.PROJECT_SOURCE_PATH">
|
||||
<path>/${PROJECT_DIR_NAME}</path>
|
||||
</pydev_pathproperty>
|
||||
<pydev_property name="org.python.pydev.PYTHON_PROJECT_VERSION">python 2.7</pydev_property>
|
||||
<pydev_property name="org.python.pydev.PYTHON_PROJECT_INTERPRETER">python35</pydev_property>
|
||||
</pydev_project>
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
eclipse.preferences.version=1
|
||||
encoding//versionnumbering/versioninfo.py=utf-8
|
||||
22
Common_scripts/artifacts/metaexport.groovy
Normal file
22
Common_scripts/artifacts/metaexport.groovy
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
|
||||
// Take a list of Sub-job descriptors and output folder pairs, copy the artifacts, while filling in a string of artifact folders
|
||||
def combineSubjobArtifacts(meta, importer, subJobs) {
|
||||
def ArrayList<String> artifactFolders = new ArrayList<String>()
|
||||
for (subJob in subJobs) {
|
||||
def subJobObject = subJob[0]
|
||||
if (subJobObject != null) {
|
||||
def subJobName = subJobObject.getProjectName()
|
||||
def subJobNumber = subJobObject.getNumber()
|
||||
def destFolder = subJob[1]
|
||||
def boolean incrementversionnumber = subJob[2]
|
||||
dir(destFolder) {
|
||||
deleteDir()
|
||||
}
|
||||
importer.artifactimport(meta, subJobName, subJobNumber, destFolder, incrementversionnumber)
|
||||
artifactFolders.add("${destFolder}/**")
|
||||
}
|
||||
}
|
||||
return artifactFolders
|
||||
}
|
||||
|
||||
return this;
|
||||
98
Common_scripts/autobuilder.groovy
Normal file
98
Common_scripts/autobuilder.groovy
Normal file
|
|
@ -0,0 +1,98 @@
|
|||
// Assume that WORKSPACE environment variable is set
|
||||
|
||||
autobuildroot = 'autobuild'
|
||||
commonscriptsroot = "${autobuildroot}/Common_scripts"
|
||||
metafolderscript = null
|
||||
|
||||
def conditionalclean(doclean = "${CLEAN_WORKSPACE}" == "true") {
|
||||
if (doclean) {
|
||||
echo "Cleaning workspace"
|
||||
// Save any script files that were loaded into the workspace at first and are required after cleaning the workspace
|
||||
def stashname = 'Clean workspace stash'
|
||||
stash(allowEmpty: true,
|
||||
includes: "${autobuildroot}/**,${autobuildroot}/.git/**",
|
||||
name: stashname,
|
||||
useDefaultExcludes: false
|
||||
)
|
||||
cleanWs()
|
||||
unstash name: stashname
|
||||
}
|
||||
else {
|
||||
echo "Not cleaning workspace"
|
||||
}
|
||||
}
|
||||
|
||||
def commonscripts() {
|
||||
return commonscriptsroot
|
||||
}
|
||||
|
||||
def getautobuildpath() {
|
||||
return autobuildroot
|
||||
}
|
||||
|
||||
def getmetafolderscript() {
|
||||
return metafolderscript
|
||||
}
|
||||
|
||||
// Start up boilderplate
|
||||
def startbuild(script, String productname = PRODUCT_NAME, String subcomponentname = SUBCOMPONENT_NAME, String releaserepo = RELEASE_REPO, String autobuildpath = autobuildroot, String commonscriptspath = commonscriptsroot) {
|
||||
echo "Starting...."
|
||||
|
||||
autobuildroot = autobuildpath
|
||||
commonscriptsroot = commonscriptspath
|
||||
metafolderscript = load("${commonscripts()}/meta/folder.groovy")
|
||||
|
||||
conditionalclean()
|
||||
|
||||
def meta = getmetafolderscript().metareset(script)
|
||||
echo "Product name: ${productname} Subcomponent name: ${subcomponentname}"
|
||||
meta.productinfo.set(productname, subcomponentname)
|
||||
def now = new Date()
|
||||
now.format("yyMMdd.HHmm", TimeZone.getTimeZone('UTC'))
|
||||
meta.jenkinsbuildinfo.set(JOB_NAME, BUILD_ID.toInteger(), NODE_NAME, now.toString())
|
||||
|
||||
def rr = load("${commonscripts()}/release/registerrepo.groovy")
|
||||
echo "Release repo: ${releaserepo}"
|
||||
rr.registerrepo(meta, releaserepo)
|
||||
|
||||
def ch = load("${commonscripts()}/configuration/configuration.groovy")
|
||||
ch.registerPipelineScriptConfiguration(meta)
|
||||
|
||||
return meta
|
||||
}
|
||||
|
||||
def start(script, String productname = PRODUCT_NAME, String subcomponentname = SUBCOMPONENT_NAME, String jirakey = JIRA_KEY, String releaserepo = RELEASE_REPO, String repoRootSuffix = "", String autobuildpath = autobuildroot, String commonscriptspath = commonscriptsroot) {
|
||||
echo "DEPRECATED method: start(script, String productname = PRODUCT_NAME, subcomponentname = SUBCOMPONENT_NAME, jirakey = JIRA_KEY, ...)"
|
||||
return startbuild(script, productname, subcomponentname, releaserepo, autobuildpath, commonscriptspath)
|
||||
}
|
||||
|
||||
// Start up boilderplate
|
||||
def startnonbuild(script, autobuildpath = autobuildroot, commonscriptspath = commonscriptsroot) {
|
||||
echo "Starting non-build job...."
|
||||
|
||||
autobuildroot = autobuildpath
|
||||
commonscriptsroot = commonscriptspath
|
||||
metafolderscript = load("${commonscripts()}/meta/folder.groovy")
|
||||
|
||||
conditionalclean()
|
||||
|
||||
def meta = getmetafolderscript().metareset(script)
|
||||
meta.productinfo.set("Non-build-product", "Non-build-subcomponent")
|
||||
def now = new Date()
|
||||
now.format("yyMMdd.HHmm", TimeZone.getTimeZone('UTC'))
|
||||
meta.jenkinsbuildinfo.set(JOB_NAME, BUILD_ID.toInteger(), NODE_NAME, now.toString())
|
||||
|
||||
def ch = load("${commonscripts()}/configuration/configuration.groovy")
|
||||
ch.registerPipelineScriptConfiguration(meta)
|
||||
|
||||
return meta
|
||||
}
|
||||
|
||||
def configurationhelper() {
|
||||
return load("${commonscripts()}/configuration/configuration.groovy")
|
||||
}
|
||||
|
||||
// Everyone wants to know this
|
||||
autobuilder = this
|
||||
|
||||
return this;
|
||||
86
Common_scripts/check/build_meta.groovy
Normal file
86
Common_scripts/check/build_meta.groovy
Normal file
|
|
@ -0,0 +1,86 @@
|
|||
pipeline {
|
||||
agent { label "${AGENT_LABEL}" }
|
||||
stages {
|
||||
stage('Initial setup') {
|
||||
steps {
|
||||
script {
|
||||
autobuilderscript = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy")
|
||||
meta = autobuilderscript.startnonbuild(this)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Clean exports') {
|
||||
steps {
|
||||
script {
|
||||
cleanfolders = [
|
||||
"${WORKSPACE}/build_artifacts",
|
||||
]
|
||||
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
|
||||
cleaner.clean(cleanfolders)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Get build artifact meta') {
|
||||
steps {
|
||||
script {
|
||||
BUILD_ARTIFACTS = "${WORKSPACE}/build_artifacts"
|
||||
copyArtifacts(
|
||||
projectName: BUILD_JOB,
|
||||
selector: [
|
||||
$class: 'ParameterizedBuildSelector',
|
||||
parameterName: BUILD_JOB_SELECTOR
|
||||
],
|
||||
target: BUILD_ARTIFACTS
|
||||
)
|
||||
def mfs = autobuilderscript.getmetafolderscript()
|
||||
buildmeta = mfs.metafromfolder(BUILD_ARTIFACTS)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Check components') {
|
||||
steps {
|
||||
script {
|
||||
def checker = load("${autobuilder.commonscripts()}/check/do_meta.groovy")
|
||||
(summarystring, markunstable, unstablereason) = checker.checkhierarchy(buildmeta, MAX_META_DEPTH, BUILD_ARTIFACTS)
|
||||
if (markunstable) {
|
||||
env.unstablereason = unstablereason
|
||||
currentBuild.result = 'UNSTABLE'
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Archiving artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def artifactlist = meta.generateartifacts()
|
||||
archiveArtifacts "summary/**,${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Summarise') {
|
||||
steps {
|
||||
script {
|
||||
echo "Summary:\n${summarystring}\n"
|
||||
if (env.unstablereason) {
|
||||
echo "Instability reason: ${env.unstablereason}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
77
Common_scripts/check/do_meta.groovy
Normal file
77
Common_scripts/check/do_meta.groovy
Normal file
|
|
@ -0,0 +1,77 @@
|
|||
markunstable = false
|
||||
unstablereason = ""
|
||||
|
||||
summaryfolder = "${WORKSPACE}/summary"
|
||||
summaryfile = "${summaryfolder}/summary.txt"
|
||||
summarystring = ""
|
||||
releaserepofolder = "${WORKSPACE}/releaserepos"
|
||||
sourcerepofolder = "${WORKSPACE}/sourcerepos"
|
||||
tempfolder = "${WORKSPACE}/temp"
|
||||
gitrevparseoutputfile = "${tempfolder}/gitrevparse.out"
|
||||
|
||||
metascript = autobuilder.getmetafolderscript()
|
||||
|
||||
def resetfolders() {
|
||||
dir(summaryfolder) {
|
||||
deleteDir()
|
||||
}
|
||||
dir(releaserepofolder) {
|
||||
deleteDir()
|
||||
}
|
||||
dir(tempfolder) {
|
||||
deleteDir()
|
||||
}
|
||||
}
|
||||
|
||||
def preconditions() {
|
||||
markunstable = false
|
||||
unstablereason = ""
|
||||
summarystring = ""
|
||||
writeFile(file: summaryfile, text: "Release summary: \n")
|
||||
}
|
||||
|
||||
def setunstable(String reason) {
|
||||
markunstable = true
|
||||
unstablereason += reason + "\n"
|
||||
echo "Marked build as unstable: Reason: ${reason}"
|
||||
}
|
||||
|
||||
def summaryappend(String summary) {
|
||||
def String currentsummarycontents = readFile(file: summaryfile)
|
||||
writeFile(file: summaryfile, text: currentsummarycontents + summary)
|
||||
summarystring += summary
|
||||
}
|
||||
|
||||
def checkhierarchy(buildmeta, String maxdepth, String buildpathroot) {
|
||||
int md = maxdepth.toInteger()
|
||||
resetfolders()
|
||||
preconditions()
|
||||
|
||||
// Walk the meta information to a max depth
|
||||
def buildinfo = buildmeta.releasewalker(md)
|
||||
echo "All components:"
|
||||
def String componentinfo = ""
|
||||
for (entry in buildinfo) {
|
||||
def name = entry.meta.componentversionuniqueidentifier()
|
||||
def offsetpath = entry.offsetpath
|
||||
def abspath = "${buildpathroot}/${offsetpath}"
|
||||
componentinfo += "Name: ${name} \t\t\t\tPath: ${offsetpath} \t\t\t\tFile exists in import: ${fileExists(abspath)}\n"
|
||||
}
|
||||
echo componentinfo
|
||||
|
||||
// Walk the meta information to a max depth
|
||||
def componentReleaseInfo = buildmeta.releasewalkerunique(md)
|
||||
echo "Unique components:"
|
||||
def String versioncomponent = ""
|
||||
for (key in componentReleaseInfo.keySet()) {
|
||||
def buildinfo2 = componentReleaseInfo[key]
|
||||
def offsetpath = buildinfo2.offsetpath
|
||||
def abspath = "${buildpathroot}/${offsetpath}"
|
||||
versioncomponent += "Key: ${key} \t\t\tPath: ${offsetpath} \t\t\tFile exists in import: ${fileExists(abspath)}\n"
|
||||
}
|
||||
echo versioncomponent
|
||||
|
||||
return [summarystring, markunstable, unstablereason]
|
||||
}
|
||||
|
||||
return this;
|
||||
14
Common_scripts/checksum/utils.groovy
Normal file
14
Common_scripts/checksum/utils.groovy
Normal file
|
|
@ -0,0 +1,14 @@
|
|||
|
||||
// Generate a checksum file of from a list of files/directories relative to workspace
|
||||
def generatelist(meta, checksummable) {
|
||||
for (filepath in checksummable) {
|
||||
def checksumset = meta.checksuminfo.addChecksumSet(filepath)
|
||||
def files = findFiles(glob: filepath)
|
||||
for (file in files) {
|
||||
def sum = sha1(file: file.path).trim()
|
||||
checksumset.addChecksumPair(file.path, sum)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return this;
|
||||
10
Common_scripts/clean/clean.groovy
Normal file
10
Common_scripts/clean/clean.groovy
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
|
||||
def clean(folderlist) {
|
||||
for (folder in folderlist) {
|
||||
dir(folder) {
|
||||
deleteDir()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return this;
|
||||
13
Common_scripts/commandline/commandline.groovy
Normal file
13
Common_scripts/commandline/commandline.groovy
Normal file
|
|
@ -0,0 +1,13 @@
|
|||
String getCommandOutput(String cmd) {
|
||||
if (isUnix()) {
|
||||
return sh(returnStdout: true, script: '#!/bin/sh -e\n' + cmd).trim()
|
||||
} else {
|
||||
return bat(returnStdout: true, script: """
|
||||
@echo off
|
||||
${cmd}
|
||||
"""
|
||||
).trim()
|
||||
}
|
||||
}
|
||||
|
||||
return this
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
|
||||
// Disable parallel make builds - which may be causing autobuild issues
|
||||
def doDisableParallelMake(rootSearchFolder = "${WORKSPACE}") {
|
||||
if (isUnix()) {
|
||||
sh """
|
||||
# Looks for "<builder*parallelBuildOn="true"* in all .cproject files and replaces the "true" with "false"
|
||||
find "${rootSearchFolder}" -iname ".cproject" | xargs -iXX sed -i "s@\\(<builder.*parallelBuildOn=\\"\\)true\\(\\"\\)@\\1false\\2@g" XX
|
||||
"""
|
||||
}
|
||||
}
|
||||
|
||||
return this;
|
||||
172
Common_scripts/compile/eclipsebuild/eclipseSTM8build.groovy
Normal file
172
Common_scripts/compile/eclipsebuild/eclipseSTM8build.groovy
Normal file
|
|
@ -0,0 +1,172 @@
|
|||
def doDisplayLeftovers() {
|
||||
}
|
||||
|
||||
def doKillLeftovers() {
|
||||
}
|
||||
|
||||
def doCheck(checkpathlist, build_variant = "") {
|
||||
def result = 0
|
||||
for (checkpath in checkpathlist) {
|
||||
echo "Checking file at: ${checkpath}"
|
||||
script {
|
||||
echo "Build variant is ${build_variant}"
|
||||
if (build_variant) {
|
||||
def srcFile = "${WORKSPACE}\${checkpath}"
|
||||
def srcFileExpanded = srcFile.replace("-BUILDVARIANT-", "${build_variant}")
|
||||
// Print out dependencies of the built file
|
||||
echo "Showing dependencies of ${srcFileExpanded}"
|
||||
if (srcFileExpanded.endsWith(".elf")) {
|
||||
result = bat ( script: """
|
||||
${CYGWINDIR}/bin/readelf -hS ${srcFileExpanded}
|
||||
if errorlevel 1 EXIT /b 1
|
||||
""",
|
||||
returnStatus: true
|
||||
)
|
||||
}
|
||||
if (result != 0) {
|
||||
return result
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
def doExport(exportfolder, exportpathlist, partdest = "", build_variant = "") {
|
||||
def result = 0
|
||||
def destFolder = ""
|
||||
def srcFile = ""
|
||||
def srcFileExpanded = ""
|
||||
for (exportpath in exportpathlist) {
|
||||
echo "Export path at: ${exportpath}"
|
||||
script {
|
||||
if (build_variant) {
|
||||
echo "Build variant is ${build_variant}"
|
||||
srcFile = "${WORKSPACE}\\${exportpath}"
|
||||
srcFileExpanded = srcFile.replace("-BUILDVARIANT-", "${build_variant}")
|
||||
}
|
||||
else {
|
||||
echo "No build variant"
|
||||
srcFileExpanded = "${WORKSPACE}\\${exportpath}"
|
||||
}
|
||||
destFolder = "${exportfolder}"
|
||||
if (partdest) {
|
||||
destFolder += "\\" + partdest
|
||||
}
|
||||
}
|
||||
def destFolderExpanded = destFolder.replace("-BUILDVARIANT-", "${build_variant}")
|
||||
dir (destFolderExpanded) {
|
||||
echo "Copy \"${srcFileExpanded}\" to \"${destFolderExpanded}\""
|
||||
result = bat( script: """
|
||||
copy "${srcFileExpanded}" "${destFolderExpanded}"
|
||||
if errorlevel 1 EXIT /b 1
|
||||
""",
|
||||
returnStatus: true
|
||||
)
|
||||
if (result != 0) {
|
||||
return result
|
||||
}
|
||||
}
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// Import all eclipse projects in a given folder
|
||||
def doImportProjects(ds5folder, ds5shellcommand, buildcommand, sourcefolder) {
|
||||
bat """
|
||||
"${ds5shellcommand}" ${buildcommand} -no-indexer -importAll "${sourcefolder}"
|
||||
"""
|
||||
}
|
||||
|
||||
def doBuildAndExportProject(String ds5folder, String ds5shellcommand, String buildcommand, String project, Boolean doexport, variants, String exportfolder, exportpathlist, String destpart) {
|
||||
echo "Doing build and export project: ${project} : ${doexport}"
|
||||
for (build_variant in variants) {
|
||||
retry(maxprojectbuildretries) { // Eclipse occasionally raises exceptions (rather than the builds failing)
|
||||
try {
|
||||
if (toBuild.contains(build_variant)) {
|
||||
doDisplayLeftovers()
|
||||
echo "Build command: ${ds5shellcommand} \'${buildcommand} -no-indexer -build ${project}/${build_variant}\'"
|
||||
timeout(time: 20, unit: 'MINUTES') {
|
||||
bat """
|
||||
"${ds5shellcommand}" ${buildcommand} -no-indexer -build ${project}/${build_variant}
|
||||
"""
|
||||
}
|
||||
result = doCheck(exportpathlist, build_variant)
|
||||
if (result != 0) {
|
||||
error "Failed to check files...."
|
||||
}
|
||||
echo "Doing export: ${doexport}"
|
||||
if (doexport) {
|
||||
result = doExport(exportfolder, exportpathlist, destpart, build_variant)
|
||||
if (result != 0) {
|
||||
error "Failed to copy...."
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
echo "Not building ${build_variant} variant of project: ${project}"
|
||||
}
|
||||
} catch (Exception e) {
|
||||
echo "Exception: ${e.getMessage()}\nBuild failed - Waiting for a while"
|
||||
sleep(time: 4, unit: 'SECONDS')
|
||||
error "Build failed..."
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
def doExportOnlyProject(String project, Boolean doexport, variants, String exportfolder, exportpathlist, String destpart) {
|
||||
echo "Doing export only project: ${project} : ${doexport}"
|
||||
if (doexport) {
|
||||
if (!variants) {
|
||||
result = doExport(exportfolder, exportpathlist, destpart)
|
||||
if (result != 0) {
|
||||
error "Failed to copy...."
|
||||
}
|
||||
} else {
|
||||
for (build_variant in variants) {
|
||||
if (toBuild.contains(build_variant)) {
|
||||
result = doExport(exportfolder, exportpathlist, destpart, build_variant)
|
||||
if (result != 0) {
|
||||
error "Failed to copy...."
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Build and export files
|
||||
def doBuild(apps, ds5folder, ds5shellcommand, buildcommand, sourcefolder, variantstobuild, exportfolder = "${WORKSPACE}") {
|
||||
toBuild = []
|
||||
if (variantstobuild) {
|
||||
toBuildUntrimmed = variantstobuild.split(',')
|
||||
toBuildUntrimmed.each {
|
||||
toBuild.add(it.trim())
|
||||
}
|
||||
}
|
||||
// The lock is being used because it was being found that the doKillLeftovers was affecting other builds
|
||||
lock(resource: "eclipsebuild_${env.NODE_NAME}") {
|
||||
try {
|
||||
timeout(time: 5, unit: 'MINUTES') {
|
||||
doImportProjects(ds5folder, ds5shellcommand, buildcommand, sourcefolder)
|
||||
}
|
||||
for (appInfo in apps) {
|
||||
def Boolean build
|
||||
def Boolean doexport
|
||||
(build, doexport, project, variants, exportpathlist, destpart) = appInfo
|
||||
if (build) {
|
||||
doBuildAndExportProject(ds5folder, ds5shellcommand, buildcommand, project, doexport, variants, exportfolder, exportpathlist, destpart)
|
||||
}
|
||||
else {
|
||||
doExportOnlyProject(project, doexport, variants, exportfolder, exportpathlist, destpart)
|
||||
}
|
||||
}
|
||||
} catch (Exception e) {
|
||||
// doKillLeftovers()
|
||||
error "Exception: ${e.getMessage()}\nBuild failed - Killing leftovers"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return this;
|
||||
252
Common_scripts/compile/eclipsebuild/eclipseds5build.groovy
Normal file
252
Common_scripts/compile/eclipsebuild/eclipseds5build.groovy
Normal file
|
|
@ -0,0 +1,252 @@
|
|||
def doDisplayLeftovers() {
|
||||
if (isUnix()) {
|
||||
sh """
|
||||
# Killing any processes that may interfere with the next build
|
||||
# The build system must be setup to do more than one eclipse build concurrently
|
||||
# Don't return an error if the processes don't exist
|
||||
USER=`whoami`
|
||||
ps aux | grep "eclipse"
|
||||
ps aux | grep "make"
|
||||
ps aux | grep "arm-linux"
|
||||
# ps aux | grep "sh"
|
||||
"""
|
||||
}
|
||||
}
|
||||
|
||||
def doKillLeftovers() {
|
||||
if (isUnix()) {
|
||||
doDisplayLeftovers()
|
||||
sh """
|
||||
# Killing any processes that may interfere with the next build
|
||||
# The build system must be setup to do more than one eclipse build concurrently
|
||||
# Don't return an error if the processes don't exist
|
||||
USER=`whoami`
|
||||
pkill -U "${USER}" -9 eclipse || true
|
||||
pkill -U "${USER}" -9 make || true
|
||||
pkill -U "${USER}" -9 ".*arm-linux.*" || true
|
||||
"""
|
||||
}
|
||||
}
|
||||
|
||||
def doCheck(checkpathlist, build_variant = "") {
|
||||
def result = 0
|
||||
for (checkpath in checkpathlist) {
|
||||
echo "Checking file at: ${checkpath}"
|
||||
script {
|
||||
echo "Build variant is ${build_variant}"
|
||||
if (build_variant) {
|
||||
def srcFile = "${WORKSPACE}/${checkpath}"
|
||||
def srcFileExpanded = srcFile.replace("-BUILDVARIANT-", "${build_variant}")
|
||||
// Print out dependencies of the built file
|
||||
echo "Showing dependencies of ${srcFileExpanded}"
|
||||
result = sh( script: """
|
||||
readelf -d "${srcFileExpanded}"
|
||||
if [ \$? -ne 0 ]; then exit 1; fi
|
||||
""",
|
||||
returnStatus: true
|
||||
)
|
||||
if (result != 0) {
|
||||
return result
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
def doExport(exportfolder, exportpathlist, partdest = "", build_variant = "") {
|
||||
def result = 0
|
||||
def destFolder = ""
|
||||
def srcFile = ""
|
||||
def srcFileExpanded = ""
|
||||
for (exportpath in exportpathlist) {
|
||||
echo "Export path at: ${exportpath}"
|
||||
script {
|
||||
if (build_variant) {
|
||||
echo "Build variant is ${build_variant}"
|
||||
srcFile = "${WORKSPACE}/${exportpath}"
|
||||
srcFileExpanded = srcFile.replace("-BUILDVARIANT-", "${build_variant}")
|
||||
}
|
||||
else {
|
||||
echo "No build variant"
|
||||
srcFileExpanded = "${WORKSPACE}/${exportpath}"
|
||||
}
|
||||
destFolder = "${exportfolder}"
|
||||
if (partdest) {
|
||||
destFolder += "/" + partdest
|
||||
}
|
||||
}
|
||||
def destFolderExpanded = destFolder.replace("-BUILDVARIANT-", "${build_variant}")
|
||||
dir (destFolderExpanded) {
|
||||
echo "Copy \"${srcFileExpanded}\" to \"${destFolderExpanded}\""
|
||||
if (isUnix()) {
|
||||
result = sh( script: """
|
||||
cp -v --no-dereference --preserve=links -r "${srcFileExpanded}" "${destFolderExpanded}"
|
||||
if [ \$? -ne 0 ]; then exit 1; fi
|
||||
""",
|
||||
returnStatus: true
|
||||
)
|
||||
if (result != 0) {
|
||||
return result
|
||||
}
|
||||
}
|
||||
else {
|
||||
result = bat( script: """
|
||||
copy "${srcFileExpanded}" "${destFolderExpanded}"
|
||||
if errorlevel 1 EXIT /b 1
|
||||
""",
|
||||
returnStatus: true
|
||||
)
|
||||
if (result != 0) {
|
||||
return result
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// Register toolchain
|
||||
def doRegisterToolchain(ds5folder, toolchainfolder) {
|
||||
// Register toolchain (if it is not already)
|
||||
if (isUnix()) {
|
||||
sh """
|
||||
"${ds5folder}/bin/add_toolchain" --non-interactive "${toolchainfolder}"
|
||||
"""
|
||||
}
|
||||
else {
|
||||
bat """
|
||||
"%ds5folder%\\bin\\add_toolchain" --non-interactive "%toolchainfolder%"
|
||||
"""
|
||||
}
|
||||
echo "Path is: ${PATH}"
|
||||
}
|
||||
|
||||
// Add toolchain to path
|
||||
def addToolchainPath(toolchainfolder) {
|
||||
// Register toolchain (if it is not already)
|
||||
if (isUnix()) {
|
||||
env.PATH = toolchainfolder + ":" + env.PATH
|
||||
}
|
||||
else {
|
||||
env.PATH = toolchainfolder + ";" + env.PATH
|
||||
}
|
||||
echo "Path is: ${PATH}"
|
||||
}
|
||||
|
||||
// Import all eclipse projects in a given folder
|
||||
def doImportProjects(ds5folder, toolchainfolder, ds5shellcommand, buildcommand, sourcefolder) {
|
||||
doRegisterToolchain(ds5folder, toolchainfolder)
|
||||
if (isUnix()) {
|
||||
sh """
|
||||
${ds5shellcommand} \'${buildcommand} -no-indexer -importAll "${sourcefolder}"\'
|
||||
"""
|
||||
}
|
||||
else {
|
||||
bat '%ds5shellcommand% %buildcommand% -no-indexer -importAll "%sourcefolder%"'
|
||||
}
|
||||
}
|
||||
|
||||
def doBuildAndExportProject(String ds5folder, String toolchainfolder, String ds5shellcommand, String buildcommand, String project, Boolean doexport, variants, String exportfolder, exportpathlist, String destpart) {
|
||||
echo "Doing build and export project: ${project} : ${doexport}"
|
||||
for (build_variant in variants) {
|
||||
retry(maxprojectbuildretries) { // Eclipse occasionally raises exceptions (rather than the builds failing)
|
||||
try {
|
||||
if (toBuild.contains(build_variant)) {
|
||||
doDisplayLeftovers()
|
||||
doRegisterToolchain(ds5folder, toolchainfolder)
|
||||
echo "Build command: ${ds5shellcommand} \'${buildcommand} -no-indexer -build \"${project}/${build_variant}\"\'"
|
||||
timeout(time: 20, unit: 'MINUTES') {
|
||||
if (isUnix()) {
|
||||
sh """
|
||||
echo Start time: `date`
|
||||
${ds5shellcommand} \'${buildcommand} -no-indexer -build \"${project}/${build_variant}\"\'
|
||||
echo End time: `date`
|
||||
"""
|
||||
}
|
||||
else {
|
||||
bat """
|
||||
"%ds5shellcommand%" "%buildcommand%" -no-indexer -build "${project}\\${build_variant}"
|
||||
"""
|
||||
}
|
||||
}
|
||||
result = doCheck(exportpathlist, build_variant)
|
||||
if (result != 0) {
|
||||
error "Failed to check files...."
|
||||
}
|
||||
echo "Doing export: ${doexport}"
|
||||
if (doexport) {
|
||||
result = doExport(exportfolder, exportpathlist, destpart, build_variant)
|
||||
if (result != 0) {
|
||||
error "Failed to copy...."
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
echo "Not building ${build_variant} variant of project: ${project}"
|
||||
}
|
||||
} catch (Exception e) {
|
||||
echo "Exception: ${e.getMessage()}\nBuild failed - Waiting for a while"
|
||||
sleep(time: 4, unit: 'SECONDS')
|
||||
error "Build failed..."
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
def doExportOnlyProject(String project, Boolean doexport, variants, String exportfolder, exportpathlist, String destpart) {
|
||||
echo "Doing export only project: ${project} : ${doexport}"
|
||||
if (doexport) {
|
||||
if (!variants) {
|
||||
result = doExport(exportfolder, exportpathlist, destpart)
|
||||
if (result != 0) {
|
||||
error "Failed to copy...."
|
||||
}
|
||||
} else {
|
||||
for (build_variant in variants) {
|
||||
if (toBuild.contains(build_variant)) {
|
||||
result = doExport(exportfolder, exportpathlist, destpart, build_variant)
|
||||
if (result != 0) {
|
||||
error "Failed to copy...."
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Build and export files
|
||||
def doBuild(apps, ds5folder, toolchainfolder, ds5shellcommand, buildcommand, sourcefolder, variantstobuild, exportfolder = "${WORKSPACE}/export") {
|
||||
toBuild = []
|
||||
if (variantstobuild) {
|
||||
toBuildUntrimmed = variantstobuild.split(',')
|
||||
toBuildUntrimmed.each {
|
||||
toBuild.add(it.trim())
|
||||
}
|
||||
}
|
||||
// The lock is being used because it was being found that the doKillLeftovers was affecting other builds
|
||||
lock(resource: "eclipsebuild_${env.NODE_NAME}") {
|
||||
try {
|
||||
timeout(time: 10, unit: 'MINUTES') {
|
||||
addToolchainPath(toolchainfolder)
|
||||
doImportProjects(ds5folder, toolchainfolder, ds5shellcommand, buildcommand, sourcefolder)
|
||||
}
|
||||
for (appInfo in apps) {
|
||||
def Boolean build
|
||||
def Boolean doexport
|
||||
(build, doexport, project, variants, exportpathlist, destpart) = appInfo
|
||||
if (build) {
|
||||
doBuildAndExportProject(ds5folder, toolchainfolder, ds5shellcommand, buildcommand, project, doexport, variants, exportfolder, exportpathlist, destpart)
|
||||
}
|
||||
else {
|
||||
doExportOnlyProject(project, doexport, variants, exportfolder, exportpathlist, destpart)
|
||||
}
|
||||
}
|
||||
} catch (Exception e) {
|
||||
// doKillLeftovers()
|
||||
error "Exception: ${e.getMessage()}\nBuild failed - Killing leftovers"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return this;
|
||||
116
Common_scripts/compile/eclipsebuild/eclipseniosbuild.groovy
Normal file
116
Common_scripts/compile/eclipsebuild/eclipseniosbuild.groovy
Normal file
|
|
@ -0,0 +1,116 @@
|
|||
// Gets the debug and optimization flags.
|
||||
// Arg1 is "app" or "lib". Returns flags.
|
||||
// Restore the debug and optimization levels, in case this is a dev machine.
|
||||
// Arg1 is "app" or "lib". Arg2-3 is flags from getFlags. Returns nothing.
|
||||
def setFlagsToRelease(NIOSEDS, project, wdir) {
|
||||
if ( project == "app" ) {
|
||||
if (isUnix()) {
|
||||
sh """#!/bin/bash
|
||||
set -x
|
||||
cd "${wdir}"
|
||||
|
||||
"${NIOSEDS}/nios2_command_shell.sh" nios2-app-update-makefile --app-dir=. --set-optimization=-O2 --set-debug-level=
|
||||
"""
|
||||
}
|
||||
}
|
||||
else if ( project == "lib" ) {
|
||||
if (isUnix()) {
|
||||
sh """#!/bin/bash
|
||||
set -x
|
||||
cd "${wdir}"
|
||||
|
||||
"${NIOSEDS}/nios2_command_shell.sh" nios2-lib-update-makefile --lib-dir=. --set-optimization=-O2 --set-debug-level=
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
def remake_and_check(NIOSEDS, wdir) {
|
||||
if (isUnix()) {
|
||||
sh """#!/bin/bash
|
||||
set -x
|
||||
cd "${wdir}"
|
||||
|
||||
# Use the makefile to clean and build
|
||||
"${NIOSEDS}/nios2_command_shell.sh" make clean
|
||||
if [ \$? -ne 0 ]; then exit 1; fi
|
||||
|
||||
# Set the debug and optimization levels to production values
|
||||
"${NIOSEDS}/nios2_command_shell.sh" make -j12 all
|
||||
if [ \$? -ne 0 ]; then exit 1; fi
|
||||
"""
|
||||
}
|
||||
}
|
||||
|
||||
def generate_bsp(NIOSEDS, bspfolder) {
|
||||
if (isUnix()) {
|
||||
sh """#!/bin/bash
|
||||
set -x
|
||||
|
||||
"${NIOSEDS}/nios2_command_shell.sh" nios2-bsp-generate-files --bsp-dir "${bspfolder}" --log "${bspfolder}/bsp.log" --settings "${bspfolder}/settings.bsp"
|
||||
"""
|
||||
}
|
||||
}
|
||||
|
||||
def modifylib(NIOSEDS, bspfolder, buildconfig, wdir) {
|
||||
if (isUnix()) {
|
||||
sh """#!/bin/bash
|
||||
set -x
|
||||
|
||||
cd "${wdir}"
|
||||
|
||||
"${NIOSEDS}/nios2_command_shell.sh" nios2-lib-update-makefile --lib-dir=. --set-bsp-dir "${bspfolder}" --set-active-build-config "${buildconfig}"
|
||||
"""
|
||||
}
|
||||
}
|
||||
|
||||
def modifyapp(NIOSEDS, bspfolder, wdir) {
|
||||
if (isUnix()) {
|
||||
sh """#!/bin/bash
|
||||
set -x
|
||||
|
||||
cd "${wdir}"
|
||||
|
||||
"${NIOSEDS}/nios2_command_shell.sh" nios2-app-update-makefile --app-dir=. --set-bsp-dir "${bspfolder}"
|
||||
"""
|
||||
}
|
||||
}
|
||||
|
||||
def dump_elf_info(NIOSEDS, elffile, meta, custominfokeyprefix) {
|
||||
if (isUnix()) {
|
||||
def cpu_name = sh(script: """#!/bin/bash
|
||||
"${NIOSEDS}/nios2_command_shell.sh" nios2-elf-query "${elffile}" --cpu_name
|
||||
""",
|
||||
returnStdout: true
|
||||
).trim()
|
||||
meta.addCustomInfo("${custominfokeyprefix}_cpu_name", cpu_name)
|
||||
def sidp = sh(script: """#!/bin/bash
|
||||
"${NIOSEDS}/nios2_command_shell.sh" nios2-elf-query "${elffile}" --sidp
|
||||
""",
|
||||
returnStdout: true
|
||||
).trim()
|
||||
meta.addCustomInfo("${custominfokeyprefix}_sidp", sidp)
|
||||
def id = sh(script: """#!/bin/bash
|
||||
"${NIOSEDS}/nios2_command_shell.sh" nios2-elf-query "${elffile}" --id
|
||||
""",
|
||||
returnStdout: true
|
||||
).trim()
|
||||
meta.addCustomInfo("${custominfokeyprefix}_id", id)
|
||||
def timestamp = sh(script: """#!/bin/bash
|
||||
"${NIOSEDS}/nios2_command_shell.sh" nios2-elf-query "${elffile}" --timestamp
|
||||
""",
|
||||
returnStdout: true
|
||||
).trim()
|
||||
meta.addCustomInfo("${custominfokeyprefix}_timestamp", timestamp)
|
||||
/*
|
||||
def sopcinfo = sh(script: """#!/bin/bash
|
||||
"${NIOSEDS}/nios2_command_shell.sh" nios2-elf-query "${elffile}" --sopcinfo
|
||||
""",
|
||||
returnStdout: true
|
||||
).trim()
|
||||
meta.addCustomInfo("${custominfokeyprefix}_sopcinfo", sopcinfo)
|
||||
*/
|
||||
}
|
||||
}
|
||||
|
||||
return this;
|
||||
18
Common_scripts/configuration/configuration.groovy
Normal file
18
Common_scripts/configuration/configuration.groovy
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
gh = load("${autobuilder.commonscripts()}/versioncontrol/git.groovy")
|
||||
|
||||
def registerConfigurationInfo(meta, String configurationName, String configurationURL, String configurationVersion, String configurationSHA) {
|
||||
meta.addConfigurationInfo(configurationName, configurationURL, configurationVersion, configurationSHA)
|
||||
}
|
||||
|
||||
def registerPipelineScriptConfiguration(meta) {
|
||||
registerConfigurationInfo(meta, 'pipeline script', '-', '-', gh.getGitInfo(autobuilder.getautobuildpath()))
|
||||
}
|
||||
|
||||
def gitCheckoutAndRegister(meta, String tool, String gitURL, String revision, String targetDir, String repoRoot = "", int cloneDepth = 1, boolean shallowClone = true, String filter = '') {
|
||||
def ArrayList<String> sparseitemlist = gh.convertSparseItemsString(filter)
|
||||
gh.gitCheckoutAlt(gitURL, revision, targetDir, repoRoot, cloneDepth, shallowClone)
|
||||
|
||||
registerConfigurationInfo(meta, tool, gitURL, revision, gh.getGitInfo(targetDir))
|
||||
}
|
||||
|
||||
return this
|
||||
86
Common_scripts/copy/all.groovy
Normal file
86
Common_scripts/copy/all.groovy
Normal file
|
|
@ -0,0 +1,86 @@
|
|||
pipeline {
|
||||
agent { label "${AGENT_LABEL}" }
|
||||
stages {
|
||||
stage('Initial setup') {
|
||||
steps {
|
||||
script {
|
||||
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Clean exports') {
|
||||
steps {
|
||||
script {
|
||||
IMPORTS = 'imports'
|
||||
cleanfolders = [
|
||||
IMPORTS,
|
||||
]
|
||||
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
|
||||
cleaner.clean(cleanfolders)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import source artifacts') {
|
||||
steps {
|
||||
script {
|
||||
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
|
||||
def copyoptions = importer.getNewImportOptions()
|
||||
copyoptions.source(
|
||||
SOURCE_ARTIFACT_LOCATION,
|
||||
SOURCE_ARTIFACT_BUILD_JOB,
|
||||
SOURCE_ARTIFACT_BUILD_SELECTOR,
|
||||
SOURCE_ARTIFACT_RELEASE_REPO,
|
||||
SOURCE_ARTIFACT_RELEASE_REVISION)
|
||||
echo "Nested: ${NESTED_COPY}"
|
||||
copyoptions.setnested(NESTED_COPY == 'true')
|
||||
importer.artifactimport(meta, copyoptions, IMPORTS)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Copy source artifacts') {
|
||||
steps {
|
||||
script {
|
||||
dir(IMPORTS) {
|
||||
fileOperations([
|
||||
fileCopyOperation(excludes: '',
|
||||
flattenFiles: false,
|
||||
includes: '**/*',
|
||||
targetLocation: WORKSPACE)
|
||||
])
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Archiving artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def includes = '**/*'
|
||||
def excludes = "${IMPORTS}/*"
|
||||
echo "Archiving artifacts: Includes: ${includes} Excludes: ${excludes}"
|
||||
// This does not work: archiveArtifacts artifacts: includes, excludes: excludes
|
||||
// so
|
||||
cleanfolders = [
|
||||
IMPORTS,
|
||||
'autobuild',
|
||||
]
|
||||
cleaner.clean(cleanfolders)
|
||||
archiveArtifacts artifacts: includes
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
63
Common_scripts/copy/esw.groovy
Normal file
63
Common_scripts/copy/esw.groovy
Normal file
|
|
@ -0,0 +1,63 @@
|
|||
pipeline {
|
||||
agent { label "${AGENT_LABEL}" }
|
||||
stages {
|
||||
stage('Initial setup') {
|
||||
steps {
|
||||
script {
|
||||
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
|
||||
|
||||
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Clean exports') {
|
||||
steps {
|
||||
script {
|
||||
env.ESW = 'esw'
|
||||
env.ESWDEST = "${WORKSPACE}/${ESW}"
|
||||
env.ESWEXPORT = 'embedded_software'
|
||||
cleanfolders = [
|
||||
ESWDEST,
|
||||
ESWEXPORT,
|
||||
]
|
||||
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
|
||||
cleaner.clean(cleanfolders)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Copying embedded software artifacts') {
|
||||
steps {
|
||||
script {
|
||||
importer.artifactimport(meta, ESW_ARTIFACT_LOCATION, ESW_ARTIFACT_BUILD_JOB, ESW_ARTIFACT_BUILD_SELECTOR, ESW_ARTIFACT_RELEASE_REPO, ESW_ARTIFACT_RELEASE_REVISION, ESWDEST)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Archiving artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def artifactlist = meta.generateartifacts(["${ESWEXPORT}/**"])
|
||||
sh """
|
||||
rm -v -rf diff
|
||||
rm -v -rf meta
|
||||
mv -v "${ESW}"/* .
|
||||
"""
|
||||
archiveArtifacts "${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
70
Common_scripts/copy/filtered.groovy
Normal file
70
Common_scripts/copy/filtered.groovy
Normal file
|
|
@ -0,0 +1,70 @@
|
|||
pipeline {
|
||||
agent { label AGENT_LABEL }
|
||||
stages {
|
||||
stage('Initial setup') {
|
||||
steps {
|
||||
script {
|
||||
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
|
||||
|
||||
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Clean') {
|
||||
steps {
|
||||
script {
|
||||
env.IMPORT = "${WORKSPACE}/import"
|
||||
env.FILTEREDDEST = "${WORKSPACE}/filtered"
|
||||
cleanfolders = [
|
||||
FILTEREDDEST,
|
||||
IMPORT,
|
||||
]
|
||||
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
|
||||
cleaner.clean(cleanfolders)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import artifacts') {
|
||||
steps {
|
||||
script {
|
||||
importer.artifactimport(meta, ARTIFACT_LOCATION, ARTIFACT_PROJECT, ARTIFACT_BUILD_SELECTOR, RELEASE_REPO, RELEASE_REVISION, IMPORT)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Filtered copy') {
|
||||
steps {
|
||||
script {
|
||||
dir(IMPORT) {
|
||||
fileOperations([
|
||||
fileCopyOperation(excludes: EXCLUDES,
|
||||
flattenFiles: FLATTENOUTPUT,
|
||||
includes: INCLUDES,
|
||||
targetLocation: FILTEREDDEST)])
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Archiving artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def artifactlist = meta.generateartifacts(["filtered/**"])
|
||||
archiveArtifacts "${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
62
Common_scripts/copy/logic.groovy
Normal file
62
Common_scripts/copy/logic.groovy
Normal file
|
|
@ -0,0 +1,62 @@
|
|||
pipeline {
|
||||
agent { label "${AGENT_LABEL}" }
|
||||
stages {
|
||||
stage('Initial setup') {
|
||||
steps {
|
||||
script {
|
||||
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
|
||||
|
||||
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Clean exports') {
|
||||
steps {
|
||||
script {
|
||||
env.LOGICDEST = "${WORKSPACE}/logic"
|
||||
cleanfolders = [
|
||||
LOGICDEST,
|
||||
"${WORKSPACE}/embedded_logic",
|
||||
]
|
||||
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
|
||||
cleaner.clean(cleanfolders)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Copying logic artifacts') {
|
||||
steps {
|
||||
script {
|
||||
importer.artifactimport(meta, LOGIC_ARTIFACT_LOCATION, LOGIC_ARTIFACT_PROJECT, LOGIC_ARTIFACT_BUILD_SELECTOR, LOGIC_RELEASE_REPO, LOGIC_RELEASE_REVISION, LOGICDEST)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Archiving artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def artifactlist = meta.generateartifacts(["embedded_logic/**"])
|
||||
sh """
|
||||
rm -v -rf meta
|
||||
# The following is removing a deprecated folder
|
||||
rm -v -rf diff
|
||||
mv -v "logic"/* .
|
||||
"""
|
||||
archiveArtifacts "${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
17
Common_scripts/differences/.project
Normal file
17
Common_scripts/differences/.project
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<projectDescription>
|
||||
<name>Release_difference</name>
|
||||
<comment></comment>
|
||||
<projects>
|
||||
</projects>
|
||||
<buildSpec>
|
||||
<buildCommand>
|
||||
<name>org.python.pydev.PyDevBuilder</name>
|
||||
<arguments>
|
||||
</arguments>
|
||||
</buildCommand>
|
||||
</buildSpec>
|
||||
<natures>
|
||||
<nature>org.python.pydev.pythonNature</nature>
|
||||
</natures>
|
||||
</projectDescription>
|
||||
8
Common_scripts/differences/.pydevproject
Normal file
8
Common_scripts/differences/.pydevproject
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
|
||||
<?eclipse-pydev version="1.0"?><pydev_project>
|
||||
<pydev_pathproperty name="org.python.pydev.PROJECT_SOURCE_PATH">
|
||||
<path>/${PROJECT_DIR_NAME}</path>
|
||||
</pydev_pathproperty>
|
||||
<pydev_property name="org.python.pydev.PYTHON_PROJECT_VERSION">python 3.0</pydev_property>
|
||||
<pydev_property name="org.python.pydev.PYTHON_PROJECT_INTERPRETER">Default</pydev_property>
|
||||
</pydev_project>
|
||||
836
Common_scripts/differences/dometahierarchy.groovy
Normal file
836
Common_scripts/differences/dometahierarchy.groovy
Normal file
|
|
@ -0,0 +1,836 @@
|
|||
import groovy.json.JsonSlurper
|
||||
|
||||
markunstable = false
|
||||
unstablereason = ""
|
||||
|
||||
summaryfolder = "${WORKSPACE}/summary"
|
||||
summaryfile = "${summaryfolder}/summary.txt"
|
||||
summarystring = ""
|
||||
|
||||
sourcerepofolder = "${WORKSPACE}/sourcerepos"
|
||||
tempfolder = "${WORKSPACE}/temp"
|
||||
|
||||
reportfolder = "${WORKSPACE}/reports"
|
||||
|
||||
class JiraTicketInfo {
|
||||
String jiranumber
|
||||
String uri
|
||||
|
||||
JiraTicketInfo() {
|
||||
jiranumber = ''
|
||||
uri = ''
|
||||
}
|
||||
|
||||
def String dump() {
|
||||
return "jiranumber: ${jiranumber} uri: ${uri}"
|
||||
}
|
||||
}
|
||||
|
||||
class DifferenceRecord {
|
||||
String productname
|
||||
String subcomponentname
|
||||
|
||||
String rawdifferencetext
|
||||
String sha
|
||||
String type
|
||||
String mergeinfo
|
||||
String squashinfo
|
||||
List<JiraTicketInfo> jiraticketinfo
|
||||
String comment
|
||||
|
||||
DifferenceRecord() {
|
||||
productname = ""
|
||||
subcomponentname = ""
|
||||
|
||||
rawdifferencetext = ""
|
||||
sha = ""
|
||||
type = ""
|
||||
mergeinfo = ""
|
||||
squashinfo = ""
|
||||
jiraticketinfo = []
|
||||
comment = ""
|
||||
}
|
||||
|
||||
def String dump() {
|
||||
String jiraticketstring = ''
|
||||
for (j in jiraticketinfo) {
|
||||
jiraticketstring += j.dump() + " "
|
||||
}
|
||||
return "Difference Record:\nproductname: ${productname}\nsubcomponentname: ${subcomponentname}\nrawdifferencetext: ${rawdifferencetext}\nsha: ${sha}\ntype: ${type}\nmergeinfo: ${mergeinfo}\njiraticketinfo: ${jiraticketstring}\ncomment: ${comment}"
|
||||
}
|
||||
}
|
||||
|
||||
def resetfolders() {
|
||||
dir(summaryfolder) {
|
||||
deleteDir()
|
||||
}
|
||||
dir(tempfolder) {
|
||||
deleteDir()
|
||||
}
|
||||
dir(reportfolder) {
|
||||
deleteDir()
|
||||
}
|
||||
}
|
||||
|
||||
def preconditions() {
|
||||
markunstable = false
|
||||
unstablereason = ""
|
||||
summarystring = ""
|
||||
writeFile(file: summaryfile, text: "Release summary: \n")
|
||||
}
|
||||
|
||||
def setunstable(String reason) {
|
||||
markunstable = true
|
||||
unstablereason += reason + "\n"
|
||||
echo "Marked build as unstable: Reason: ${reason}"
|
||||
}
|
||||
|
||||
def summaryappend(String summary) {
|
||||
def String currentsummarycontents = readFile(file: summaryfile)
|
||||
writeFile(file: summaryfile, text: currentsummarycontents + summary)
|
||||
summarystring += summary
|
||||
}
|
||||
|
||||
def showmetaitems(metaitems) {
|
||||
String info = ''
|
||||
for (key in metaitems.keySet()) {
|
||||
def relatedmetainfo = metaitems[key]
|
||||
def offsetpath = relatedmetainfo.offsetpath
|
||||
info += "Name: ${key}\t\t\t\tPath: ${offsetpath}\n"
|
||||
}
|
||||
echo info
|
||||
}
|
||||
|
||||
def boolean checkoutsourcerepo(buildmeta, String checkoutfolder) {
|
||||
boolean checkedout = false
|
||||
def String sourcerepo = buildmeta.gitinfo.remoteurl
|
||||
if (sourcerepo?.trim()) {
|
||||
echo "Updating source repo: ${sourcerepo} in folder: ${checkoutfolder}"
|
||||
if (sourcerepo) {
|
||||
// Get the latest revision of the source repo without checking out working copy; Check out to a folder unique to component
|
||||
if (fileExists(checkoutfolder)) {
|
||||
dir(checkoutfolder) {
|
||||
sh("""
|
||||
git reset --hard
|
||||
git clean -fdx
|
||||
git pull
|
||||
"""
|
||||
)
|
||||
}
|
||||
}
|
||||
else {
|
||||
dir(sourcerepofolder) {
|
||||
sh("git clone ${sourcerepo} ${checkoutfolder}")
|
||||
}
|
||||
}
|
||||
}
|
||||
checkedout = true
|
||||
}
|
||||
return checkedout
|
||||
}
|
||||
|
||||
def String getcomponent(meta) {
|
||||
def String uniquefolder = "${meta.productinfo.productname}_${meta.productinfo.subcomponentname}"
|
||||
def String uniquefoldertemp = "${tempfolder}/${uniquefolder}"
|
||||
def String uniquefolderforsourcerepo = "${sourcerepofolder}/${uniquefolder}"
|
||||
|
||||
boolean checkedout = checkoutsourcerepo(meta, uniquefolderforsourcerepo)
|
||||
|
||||
return [checkedout, uniquefolderforsourcerepo]
|
||||
}
|
||||
|
||||
def getgitlogdifferences(String gitrootfolder, String earlyrevision, String laterrevision, boolean tripledot = false) {
|
||||
def String releaseexpression
|
||||
if (tripledot) {
|
||||
releaseexpression = earlyrevision + "..." + laterrevision
|
||||
} else {
|
||||
releaseexpression = earlyrevision + ".." + laterrevision
|
||||
}
|
||||
def String differencetext
|
||||
dir(gitrootfolder) {
|
||||
differencetext = sh(returnStdout: true, script: "git --no-pager log --oneline ${releaseexpression}").trim()
|
||||
}
|
||||
return differencetext
|
||||
}
|
||||
|
||||
def extractsha(String line) {
|
||||
def pattern = ~"^(\\p{XDigit}*) (.*)"
|
||||
def match = (line =~ pattern)
|
||||
match.find()
|
||||
|
||||
def sha = match.group(1)
|
||||
def restofline = match.group(2)
|
||||
|
||||
//echo "Sha filtering: line: ${line} sha: ${sha} therest: ${restofline}"
|
||||
|
||||
return [sha.trim(), restofline.trim()]
|
||||
}
|
||||
|
||||
def extractsquashes(String line) {
|
||||
def pattern1 = "^(.*)(Squashed .*)"
|
||||
def match1 = (line =~ pattern1)
|
||||
if (match1.find()) {
|
||||
return [true, match1.group(2)]
|
||||
}
|
||||
|
||||
return [false, line]
|
||||
}
|
||||
|
||||
def extractmerges(String line) {
|
||||
def pattern1 = "^(.*)(Merge branch .*)"
|
||||
def match1 = (line =~ pattern1)
|
||||
if (match1.find()) {
|
||||
return [true, match1.group(2)]
|
||||
}
|
||||
|
||||
def pattern2 = "^(.*)(Merge remote-tracking branch .*)"
|
||||
def match2 = (line =~ pattern2)
|
||||
if (match2.find()) {
|
||||
return [true, match2.group(2)]
|
||||
}
|
||||
|
||||
def pattern3 = "^(.*)(Merge commit .*)"
|
||||
def match3 = (line =~ pattern3)
|
||||
if (match3.find()) {
|
||||
return [true, match3.group(2)]
|
||||
}
|
||||
|
||||
def pattern4 = "^(.*)(Add .* from commit .*)"
|
||||
def match4 = (line =~ pattern4)
|
||||
if (match4.find()) {
|
||||
return [true, match4.group(2)]
|
||||
}
|
||||
|
||||
return [false, line]
|
||||
}
|
||||
|
||||
def jiraticketexists(String jiraticket) {
|
||||
def String URI = "${JIRA_URI}/browse/${jiraticket}"
|
||||
def String RestfulURI = "${JIRA_URI}/rest/api/latest/issue/${jiraticket}?fields=summary"
|
||||
def get = new URL(RestfulURI).openConnection();
|
||||
get.setRequestProperty( 'X-AUSERNAME', "${JIRA_USERNAME}" )
|
||||
get.setRequestProperty( 'Authorization', "Basic ${JIRA_ENCODED_PASSWORD}" )
|
||||
get.setRequestProperty( 'User-Agent', 'groovy-2.4.4' )
|
||||
get.setRequestProperty( 'Accept', 'application/json' )
|
||||
def getRC = get.getResponseCode();
|
||||
|
||||
def String redirectedjiraticket = jiraticket
|
||||
if(!getRC.equals(200)) {
|
||||
return [false, '', jiraticket]
|
||||
} else {
|
||||
def jsonresponse = new JsonSlurper().parseText(get.inputStream.getText('UTF-8'))
|
||||
redirectedjiraticket = jsonresponse['key']
|
||||
}
|
||||
return [true, URI, redirectedjiraticket]
|
||||
}
|
||||
|
||||
def extractjiraticketinfo(String line) {
|
||||
def List jiratickets = []
|
||||
boolean exists = false
|
||||
String URI = ''
|
||||
|
||||
while (true) {
|
||||
line = line.trim()
|
||||
def commapattern = '^\\s*,(.*)' // Consume separating commas at the beginning of the line
|
||||
def commamatch = (line =~ commapattern)
|
||||
if (commamatch.find()) {
|
||||
line = commamatch.group(1).trim()
|
||||
}
|
||||
def pattern1 = '^(\\w+-\\d+)(.*)' //GIS-1234 hmbxr5601-1234
|
||||
def match1 = (line =~ pattern1)
|
||||
if (match1.find()) {
|
||||
jiraticket = match1.group(1)
|
||||
(exists, URI, jiraticket) = jiraticketexists(jiraticket)
|
||||
if (exists) {
|
||||
def JiraTicketInfo j = new JiraTicketInfo()
|
||||
j.jiranumber = jiraticket
|
||||
j.uri = URI
|
||||
jiratickets.add(j)
|
||||
line = match1.group(2)
|
||||
} else {
|
||||
break
|
||||
}
|
||||
} else {
|
||||
def pattern2 = '^(\\w+)(\\d+)(.*)' //GIS1234 smb1234
|
||||
def match2 = (line =~ pattern2)
|
||||
if (match2.find()) {
|
||||
jiraticket = match2.group(1) + "-" + match2.group(2)
|
||||
(exists, URI, jiraticket) = jiraticketexists(jiraticket)
|
||||
if (exists) {
|
||||
def JiraTicketInfo j = new JiraTicketInfo()
|
||||
j.jiranumber = jiraticket
|
||||
j.uri = URI
|
||||
jiratickets.add(j)
|
||||
line = match2.group(3)
|
||||
} else {
|
||||
break
|
||||
}
|
||||
} else {
|
||||
def pattern3 = '^(\\w+)\\s(\\d+)(.*)' //GIS 1234 smb 1234
|
||||
def match3 = (line =~ pattern3)
|
||||
if (match3.find()) {
|
||||
jiraticket = match3.group(1) + "-" + match3.group(2)
|
||||
(exists, URI, jiraticket) = jiraticketexists(jiraticket)
|
||||
if (exists) {
|
||||
def JiraTicketInfo j = new JiraTicketInfo()
|
||||
j.jiranumber = jiraticket
|
||||
j.uri = URI
|
||||
jiratickets.add(j)
|
||||
line = match3.group(3)
|
||||
} else {
|
||||
break
|
||||
}
|
||||
} else {
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
boolean result = jiratickets.size() > 0
|
||||
return [result, jiratickets, line]
|
||||
}
|
||||
|
||||
def extractreverts(String line) {
|
||||
boolean result = true
|
||||
|
||||
def pattern1 = '^(.*)Revert \"(.*)\"'
|
||||
def match1 = (line =~ pattern1)
|
||||
if (match1.find()) {
|
||||
def line2 = match1.group(2)
|
||||
(result, originaljiraticketinfo, originalcomment) = extractjiraticketinfo(line2)
|
||||
return [true, originaljiraticketinfo, originalcomment]
|
||||
}
|
||||
|
||||
def pattern2 = '^(.*)Partial Revert \"(.*)\"'
|
||||
def match2 = (line =~ pattern2)
|
||||
if (match2.find()) {
|
||||
def line2 = match2.group(2)
|
||||
(result, originaljiraticketinfo, originalcomment) = extractjiraticketinfo(line2)
|
||||
return [true, originaljiraticketinfo, originalcomment]
|
||||
}
|
||||
|
||||
return [false, [], line]
|
||||
}
|
||||
|
||||
def getgitlogdifferencesfromsquash(String gitrootfolder, String squashedrevision) {
|
||||
def String differencetext
|
||||
dir(gitrootfolder) {
|
||||
differencetext = sh(returnStdout: true, script: "git --no-pager log --oneline ${squashedrevision}").trim()
|
||||
}
|
||||
return differencetext
|
||||
}
|
||||
|
||||
def List fillsquashrecords(String sourcepath, String sha) {
|
||||
def List differencerecords = []
|
||||
|
||||
String squashloglines = getgitlogdifferencesfromsquash(sourcepath, sha)
|
||||
int count = 0
|
||||
squashloglines.split('\n').each {
|
||||
if (count > 0) { // Ignore first line
|
||||
def line = it
|
||||
if (line?.trim()) {
|
||||
def List drs = fillrecord(meta, line.trim(), sourcepath)
|
||||
differencerecords.addAll(drs)
|
||||
//echo "${dr.dump()}"
|
||||
}
|
||||
}
|
||||
count += 1
|
||||
}
|
||||
return differencerecords
|
||||
}
|
||||
|
||||
def List fillrecord(meta, line, String sourcepath) {
|
||||
def List differencerecords = []
|
||||
def DifferenceRecord dr = new DifferenceRecord()
|
||||
|
||||
dr.productname = meta.productinfo.productname
|
||||
dr.subcomponentname = meta.productinfo.subcomponentname
|
||||
|
||||
dr.rawdifferencetext = line
|
||||
|
||||
// Example of raw text to process:
|
||||
// 76056562e4 GIS-1621 - Removing redundant lines and effects of this - Restore nuget_version_edit.py
|
||||
|
||||
(sha, line2) = extractsha(line)
|
||||
dr.sha = sha
|
||||
|
||||
(result, squashinfo) = extractsquashes(line2)
|
||||
if (result) {
|
||||
dr.type = "Squash"
|
||||
dr.squashinfo = squashinfo
|
||||
squashrecords = fillsquashrecords(sourcepath, sha)
|
||||
differencerecords.addAll(squashrecords)
|
||||
} else {
|
||||
(result, mergeinfo) = extractmerges(line2)
|
||||
if (result) {
|
||||
dr.type = "Merge"
|
||||
dr.mergeinfo = mergeinfo
|
||||
} else {
|
||||
(result, jiraticketinfo, comment) = extractreverts(line2)
|
||||
if (result) {
|
||||
dr.type = "Revert"
|
||||
dr.jiraticketinfo = jiraticketinfo
|
||||
dr.comment = comment
|
||||
} else {
|
||||
(result, jiraticketinfo, comment) = extractjiraticketinfo(line2)
|
||||
if (result) {
|
||||
dr.type = "Ticketed"
|
||||
dr.jiraticketinfo = jiraticketinfo
|
||||
dr.comment = comment
|
||||
} else {
|
||||
dr.type = "Unticketed"
|
||||
dr.comment = line2
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
differencerecords.add(dr)
|
||||
return differencerecords
|
||||
}
|
||||
|
||||
def List processtext(meta, String text, String sourcepath) {
|
||||
def List differencerecords = []
|
||||
|
||||
text.split('\n').each {
|
||||
def line = it
|
||||
if (line?.trim()) {
|
||||
def List drs = fillrecord(meta, line.trim(), sourcepath)
|
||||
differencerecords.addAll(drs)
|
||||
//echo "${dr.dump()}"
|
||||
}
|
||||
}
|
||||
return differencerecords
|
||||
}
|
||||
|
||||
def getdifferencerecords(earlymeta, latermeta, String sourcepath) {
|
||||
boolean result = true;
|
||||
def List differencerecords = []
|
||||
|
||||
def earlygitinfo = earlymeta.gitinfo
|
||||
def latergitinfo = latermeta.gitinfo
|
||||
|
||||
if (earlygitinfo.remoteurl == latergitinfo.remoteurl) {
|
||||
def earlyrevision = earlygitinfo.gitrevision
|
||||
def laterrevision = latergitinfo.gitrevision
|
||||
echo "Comparing early revision: ${earlyrevision} with: ${laterrevision} Working copy path: ${sourcepath}"
|
||||
summaryappend("Early revision: ${earlyrevision} Later revision: ${laterrevision}")
|
||||
def String differencetext = getgitlogdifferences(sourcepath, earlyrevision, laterrevision)
|
||||
differencerecords = processtext(earlymeta, differencetext, sourcepath)
|
||||
if (earlyrevision == laterrevision) {
|
||||
summaryappend(" No change")
|
||||
}
|
||||
} else {
|
||||
summaryappend("The early and later git urls don't match")
|
||||
echo "The early and later git urls don't match"
|
||||
result = false;
|
||||
setunstable("The early and later git urls don't match in: ${earlymeta.componentidentifier()}")
|
||||
}
|
||||
|
||||
return [result, differencerecords]
|
||||
}
|
||||
|
||||
def deletedcomponent(earlymetaitems, key) {
|
||||
echo "Component ${key} has been deleted in later version"
|
||||
summaryappend("Deleted ")
|
||||
}
|
||||
|
||||
def addedcomponent(latermetaitems, key) {
|
||||
echo "Component ${key} has been added in later version"
|
||||
summaryappend("Added ")
|
||||
}
|
||||
|
||||
class SquashReportRecord {
|
||||
String comment
|
||||
int duplicates
|
||||
|
||||
SquashReportRecord() {
|
||||
comment = ''
|
||||
duplicates = 0
|
||||
}
|
||||
}
|
||||
|
||||
def squashreport(String reportsubfolder, String title, LinkedHashMap<String, SquashReportRecord> squashes, boolean iscomponent = true) {
|
||||
dir(reportsubfolder) {
|
||||
def String squashlist = "${title}\nSquash list:\n"
|
||||
def squashessorted = squashes.sort()
|
||||
for (asquash in squashessorted) {
|
||||
def SquashReportRecord s = asquash.value
|
||||
squashlist += "${s.comment} (${s.duplicates})\n"
|
||||
}
|
||||
writeFile(file: "squashlist.txt", text: squashlist)
|
||||
}
|
||||
}
|
||||
|
||||
class MergeReportRecord {
|
||||
String comment
|
||||
int duplicates
|
||||
|
||||
MergeReportRecord() {
|
||||
comment = ''
|
||||
duplicates = 0
|
||||
}
|
||||
}
|
||||
|
||||
def mergereport(String reportsubfolder, String title, LinkedHashMap<String, MergeReportRecord> merges, boolean iscomponent = true) {
|
||||
dir(reportsubfolder) {
|
||||
def String mergelist = "${title}\nMerge list:\n"
|
||||
def mergessorted = merges.sort()
|
||||
for (amerge in mergessorted) {
|
||||
def MergeReportRecord m = amerge.value
|
||||
mergelist += "${m.comment} (${m.duplicates})\n"
|
||||
}
|
||||
writeFile(file: "mergelist.txt", text: mergelist)
|
||||
}
|
||||
}
|
||||
|
||||
class CommentsRecord {
|
||||
String comment
|
||||
int duplicates
|
||||
|
||||
CommentsRecord() {
|
||||
comment = ''
|
||||
duplicates = 0
|
||||
}
|
||||
}
|
||||
|
||||
class RevertsReportRecord {
|
||||
String jiraticket
|
||||
String ticketURI
|
||||
LinkedHashMap<String, CommentsRecord> commentscollection
|
||||
|
||||
RevertsReportRecord() {
|
||||
jiraticket = ''
|
||||
ticketURI = ''
|
||||
commentscollection = new LinkedHashMap<String, CommentsRecord>()
|
||||
}
|
||||
}
|
||||
|
||||
def revertsreport(String reportsubfolder, String title, LinkedHashMap<String, RevertsReportRecord> reverts, boolean iscomponent = true) {
|
||||
dir(reportsubfolder) {
|
||||
def String revertlist = "${title}\nRevert list:\n"
|
||||
def revertssorted = reverts.sort()
|
||||
for (arevert in revertssorted) {
|
||||
def RevertsReportRecord r = arevert.value
|
||||
revertlist += "${r.jiraticket} (${r.ticketURI}):\n"
|
||||
def commentscollection = r.commentscollection
|
||||
def sortedcommentscollection = commentscollection.sort()
|
||||
for (commentrecord in sortedcommentscollection) {
|
||||
def CommentsRecord c = commentrecord.value
|
||||
revertlist += "${c.comment} (${c.duplicates})\n"
|
||||
}
|
||||
revertlist += "\n"
|
||||
}
|
||||
writeFile(file: "revertlist.txt", text: revertlist)
|
||||
}
|
||||
}
|
||||
|
||||
class TicketedReportRecord {
|
||||
String jiraticket
|
||||
String ticketURI
|
||||
LinkedHashMap<String, CommentsRecord> commentscollection
|
||||
|
||||
TicketedReportRecord() {
|
||||
jiraticket = ''
|
||||
ticketURI = ''
|
||||
commentscollection = new LinkedHashMap<String, CommentsRecord>()
|
||||
}
|
||||
}
|
||||
|
||||
def ticketedreport(String reportsubfolder, String title, LinkedHashMap<String, TicketedReportRecord> ticketed, boolean iscomponent = true) {
|
||||
dir(reportsubfolder) {
|
||||
def String ticketedlist = "${title}\nTicketed list:\n"
|
||||
def ticketedsorted = ticketed.sort()
|
||||
for (aticketed in ticketedsorted) {
|
||||
def TicketedReportRecord r = aticketed.value
|
||||
ticketedlist += "${r.jiraticket} (${r.ticketURI}):\n"
|
||||
def commentscollection = r.commentscollection
|
||||
def sortedcommentscollection = commentscollection.sort()
|
||||
for (commentrecord in sortedcommentscollection) {
|
||||
def CommentsRecord c = commentrecord.value
|
||||
ticketedlist += "${c.comment} (${c.duplicates})\n"
|
||||
}
|
||||
ticketedlist += "\n"
|
||||
}
|
||||
writeFile(file: "ticketedlist.txt", text: ticketedlist)
|
||||
}
|
||||
}
|
||||
|
||||
class UnticketedReportRecord {
|
||||
String comment
|
||||
int duplicates
|
||||
|
||||
UnticketedReportRecord() {
|
||||
comment = ''
|
||||
duplicates = 0
|
||||
}
|
||||
}
|
||||
|
||||
def unticketedreport(String reportsubfolder, String title, LinkedHashMap<String, UnticketedReportRecord> unticketed, boolean iscomponent = true) {
|
||||
dir(reportsubfolder) {
|
||||
def String unticketedlist = "${title}\nUnticketed list:\n"
|
||||
def unticketedsorted = unticketed.sort()
|
||||
for (anunticketed in unticketedsorted) {
|
||||
UnticketedReportRecord u = anunticketed.value
|
||||
unticketedlist += "${u.comment} (${u.duplicates})\n"
|
||||
}
|
||||
writeFile(file: "unticketedlist.txt", text: unticketedlist)
|
||||
}
|
||||
}
|
||||
|
||||
class TicketsReportRecord {
|
||||
String jiraticket
|
||||
String ticketURI
|
||||
int duplicates
|
||||
|
||||
TicketsReportRecord() {
|
||||
jiraticket = ''
|
||||
ticketURI = ''
|
||||
duplicates = 0
|
||||
}
|
||||
}
|
||||
|
||||
def ticketsreport(String reportsubfolder, String title, tickets, boolean iscomponent = true) {
|
||||
dir(reportsubfolder) {
|
||||
String ticketlist = "${title}\nTicket list:\n"
|
||||
ticketssorted = tickets.sort()
|
||||
for (ticketnumber in ticketssorted) {
|
||||
TicketsReportRecord t = ticketnumber.value
|
||||
ticketlist += "${t.jiraticket} (${t.ticketURI}) (${t.duplicates})\n"
|
||||
}
|
||||
writeFile(file: "ticketlist.txt", text: ticketlist)
|
||||
}
|
||||
}
|
||||
|
||||
def differencerecordsreport(String reportsubfolder, String title, differencerecords, boolean iscomponent = true) {
|
||||
dir(reportsubfolder) {
|
||||
String recordlist = "${title}\n"
|
||||
for (dr in differencerecords) {
|
||||
recordlist += dr.dump() + "\n\n"
|
||||
}
|
||||
writeFile(file: "recordlist.txt", text: recordlist)
|
||||
}
|
||||
}
|
||||
|
||||
def boolean report(meta, title, differencerecords, boolean iscomponent = true) {
|
||||
def Map ticketed = [:]
|
||||
def Map squashes = [:]
|
||||
def Map merges = [:]
|
||||
def Map reverts = [:]
|
||||
def Map unticketed = [:]
|
||||
def Map tickets = [:]
|
||||
|
||||
for (dr in differencerecords) {
|
||||
if (dr.type == "Squash") {
|
||||
def SquashReportRecord s
|
||||
if (!squashes.containsKey(dr.mergeinfo)) {
|
||||
s = new SquashReportRecord()
|
||||
s.comment = dr.squashinfo
|
||||
s.duplicates = 1
|
||||
} else {
|
||||
s = squashes[dr.squashinfo]
|
||||
s.duplicates += 1
|
||||
}
|
||||
squashes[dr.squashinfo] = s
|
||||
}
|
||||
if (dr.type == "Merge") {
|
||||
def MergeReportRecord m
|
||||
if (!merges.containsKey(dr.mergeinfo)) {
|
||||
m = new MergeReportRecord()
|
||||
m.comment = dr.mergeinfo
|
||||
m.duplicates = 1
|
||||
} else {
|
||||
m = merges[dr.mergeinfo]
|
||||
m.duplicates += 1
|
||||
}
|
||||
merges[dr.mergeinfo] = m
|
||||
}
|
||||
if (dr.type == "Revert") {
|
||||
def RevertsReportRecord r
|
||||
for (ticket in dr.jiraticketinfo) {
|
||||
JiraTicketInfo j = ticket
|
||||
if (!reverts.containsKey(j.jiranumber)) {
|
||||
r = new RevertsReportRecord()
|
||||
r.jiraticket = j.jiranumber
|
||||
r.ticketURI = j.uri
|
||||
CommentsRecord c = new CommentsRecord()
|
||||
c.comment = dr.comment
|
||||
c.duplicates = 1
|
||||
r.commentscollection[dr.comment] = c
|
||||
} else {
|
||||
r = reverts[j.jiranumber]
|
||||
def CommentsRecord c
|
||||
if (!r.commentscollection.containsKey(dr.comment)) {
|
||||
c = new CommentsRecord()
|
||||
c.comment = dr.comment
|
||||
c.duplicates = 1
|
||||
r.commentscollection[dr.comment] = c
|
||||
} else {
|
||||
c = r.commentscollection[dr.comment]
|
||||
c.duplicates += 1
|
||||
}
|
||||
r.commentscollection[dr.comment] = c
|
||||
}
|
||||
reverts[j.jiranumber] = r
|
||||
def TicketsReportRecord t
|
||||
if (!tickets.containsKey(j.jiranumber)) {
|
||||
t = new TicketsReportRecord()
|
||||
t.jiraticket = j.jiranumber
|
||||
t.ticketURI = j.uri
|
||||
t.duplicates = 1
|
||||
} else {
|
||||
t = tickets[j.jiranumber]
|
||||
t.duplicates += 1
|
||||
}
|
||||
tickets[j.jiranumber] = t
|
||||
}
|
||||
}
|
||||
if (dr.type == "Ticketed") {
|
||||
def TicketedReportRecord t
|
||||
for (ticket in dr.jiraticketinfo) {
|
||||
JiraTicketInfo j = ticket
|
||||
if (!ticketed.containsKey(j.jiranumber)) {
|
||||
t = new TicketedReportRecord()
|
||||
t.jiraticket = j.jiranumber
|
||||
t.ticketURI = j.uri
|
||||
CommentsRecord c = new CommentsRecord()
|
||||
c.comment = dr.comment
|
||||
c.duplicates = 1
|
||||
t.commentscollection[dr.comment] = c
|
||||
} else {
|
||||
t = ticketed[j.jiranumber]
|
||||
def CommentsRecord c
|
||||
if (!t.commentscollection.containsKey(dr.comment)) {
|
||||
c = new CommentsRecord()
|
||||
c.comment = dr.comment
|
||||
c.duplicates = 1
|
||||
t.commentscollection[dr.comment] = c
|
||||
} else {
|
||||
c = t.commentscollection[dr.comment]
|
||||
c.duplicates += 1
|
||||
}
|
||||
t.commentscollection[dr.comment] = c
|
||||
}
|
||||
ticketed[j.jiranumber] = t
|
||||
def TicketsReportRecord ti
|
||||
if (!tickets.containsKey(j.jiranumber)) {
|
||||
ti = new TicketsReportRecord()
|
||||
ti.jiraticket = j.jiranumber
|
||||
ti.ticketURI = j.uri
|
||||
ti.duplicates = 1
|
||||
} else {
|
||||
ti = tickets[j.jiranumber]
|
||||
ti.duplicates += 1
|
||||
}
|
||||
tickets[j.jiranumber] = ti
|
||||
}
|
||||
}
|
||||
if (dr.type == "Unticketed") {
|
||||
UnticketedReportRecord u
|
||||
if (!unticketed.containsKey(dr.comment)) {
|
||||
u = new UnticketedReportRecord()
|
||||
u.comment = dr.comment
|
||||
u.duplicates = 1
|
||||
} else {
|
||||
u = unticketed[dr.comment]
|
||||
u.duplicates += 1
|
||||
}
|
||||
unticketed[dr.comment] = u
|
||||
}
|
||||
}
|
||||
String reportsubfolder = ""
|
||||
if (iscomponent) {
|
||||
reportsubfolder = "${reportfolder}/${meta.componentidentifier()}"
|
||||
} else {
|
||||
reportsubfolder = "${reportfolder}/Combined"
|
||||
}
|
||||
mergereport(reportsubfolder, title, merges, iscomponent)
|
||||
squashreport(reportsubfolder, title, squashes, iscomponent)
|
||||
revertsreport(reportsubfolder, title, reverts, iscomponent)
|
||||
ticketedreport(reportsubfolder, title, ticketed, iscomponent)
|
||||
unticketedreport(reportsubfolder, title, unticketed, iscomponent)
|
||||
ticketsreport(reportsubfolder, title, tickets, iscomponent)
|
||||
differencerecordsreport(reportsubfolder, title, differencerecords, iscomponent)
|
||||
}
|
||||
|
||||
def title(earlymeta, latermeta) {
|
||||
return """
|
||||
Differences in:
|
||||
Product: ${earlymeta.productinfo.productname} Subcomponent: ${earlymeta.productinfo.subcomponentname}
|
||||
between:
|
||||
then:
|
||||
Build date: ${earlymeta.jenkinsbuildinfo.builddate} Build stamp: ${earlymeta.buildstampinfo.buildstamp} Git revision: ${earlymeta.gitinfo.gitrevision}
|
||||
now:
|
||||
Build date: ${latermeta.jenkinsbuildinfo.builddate} Build stamp: ${latermeta.buildstampinfo.buildstamp} Git revision: ${latermeta.gitinfo.gitrevision}
|
||||
"""
|
||||
}
|
||||
|
||||
def compare(earlymetaitems, latermetaitems, key) {
|
||||
boolean result = true;
|
||||
echo "Collecting changes between early and later versions of component: ${key}"
|
||||
|
||||
def earlymeta = earlymetaitems[key].meta
|
||||
def latermeta = latermetaitems[key].meta
|
||||
|
||||
summaryappend("${earlymeta.productinfo.productname} ${earlymeta.productinfo.subcomponentname}: Changed: ")
|
||||
|
||||
def boolean repoavailable
|
||||
def String uniquefolderforsourcerepo
|
||||
(repoavailable, uniquefolderforsourcerepo) = getcomponent(earlymeta)
|
||||
|
||||
List differencerecords = []
|
||||
if (repoavailable) {
|
||||
(result, differencerecords) = getdifferencerecords(earlymeta, latermeta, uniquefolderforsourcerepo)
|
||||
|
||||
summaryappend(" Items: ${differencerecords.size()} ")
|
||||
report(earlymeta, title(earlymeta, latermeta), differencerecords)
|
||||
} else {
|
||||
summaryappend(" No source repo ")
|
||||
}
|
||||
summaryappend("\n")
|
||||
|
||||
return [result, differencerecords];
|
||||
}
|
||||
|
||||
def comparehierarchy(meta, String earlymetafolder, String latermetafolder, String maxdepth, String summaryfolder) {
|
||||
def List differencerecords = []
|
||||
|
||||
def int md = maxdepth.toInteger()
|
||||
resetfolders()
|
||||
preconditions()
|
||||
|
||||
echo "Comparing product meta hierarchy from folders: ${earlymetafolder} and ${latermetafolder} to a depth of ${md}. Exporting summary to ${summaryfolder}"
|
||||
|
||||
def earlymeta = meta.importrelated(true, earlymetafolder)
|
||||
def latermeta = meta.importrelated(true, latermetafolder)
|
||||
|
||||
def earlymetaitems = earlymeta.releasewalkerunique(md)
|
||||
def latermetaitems = latermeta.releasewalkerunique(md)
|
||||
|
||||
echo "Early items:"
|
||||
showmetaitems(earlymetaitems)
|
||||
|
||||
echo "Later items:"
|
||||
showmetaitems(latermetaitems)
|
||||
|
||||
for (key in earlymetaitems.keySet()) {
|
||||
if (latermetaitems.containsKey(key)) {
|
||||
(result, componentdifferencerecords) = compare(earlymetaitems, latermetaitems, key)
|
||||
differencerecords = differencerecords + componentdifferencerecords
|
||||
} else {
|
||||
summaryappend("${earlymeta.productinfo.productname} ${earlymeta.productinfo.subcomponentname}: ")
|
||||
deletedcomponent(earlymetaitems, key)
|
||||
summaryappend("\n")
|
||||
}
|
||||
}
|
||||
for (key in latermetaitems.keySet()) {
|
||||
if (!earlymetaitems.containsKey(key)) {
|
||||
summaryappend("${latermeta.productinfo.productname} ${latermeta.productinfo.subcomponentname}: ")
|
||||
addedcomponent(latermetaitems, key)
|
||||
summaryappend("\n")
|
||||
}
|
||||
}
|
||||
report(meta, title(earlymeta, latermeta), differencerecords, false)
|
||||
return [summarystring, markunstable, unstablereason]
|
||||
}
|
||||
|
||||
return this;
|
||||
16
Common_scripts/differences/file.groovy
Normal file
16
Common_scripts/differences/file.groovy
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
def comparefiles(importedfile, currentfile, boolean ignorewhitespace = true) {
|
||||
if (isUnix()) {
|
||||
def wsparameter = "-w"
|
||||
if (!ignorewhitespace) {
|
||||
wsparameter = ""
|
||||
}
|
||||
sh """
|
||||
diff -c ${wsparameter} "${importedfile}" "${currentfile}"
|
||||
"""
|
||||
}
|
||||
else {
|
||||
error "Windows not currently supporting file comparison"
|
||||
}
|
||||
}
|
||||
|
||||
return this;
|
||||
15
Common_scripts/differences/json.groovy
Normal file
15
Common_scripts/differences/json.groovy
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
def comparefiles(importedjsonfile, currentjsonfile) {
|
||||
if (isUnix()) {
|
||||
sh """
|
||||
which jq
|
||||
if [ \$? -ne 0 ]; then exit 1; fi
|
||||
# jq -S sorts json output
|
||||
diff -c <(jq -S . "${importedjsonfile}") <(jq -S . "${currentjsonfile}")
|
||||
"""
|
||||
}
|
||||
else {
|
||||
error "Windows not currently supporting json file comparison"
|
||||
}
|
||||
}
|
||||
|
||||
return this;
|
||||
91
Common_scripts/differences/metahierarchy.groovy
Normal file
91
Common_scripts/differences/metahierarchy.groovy
Normal file
|
|
@ -0,0 +1,91 @@
|
|||
pipeline {
|
||||
agent { label "${AGENT_LABEL}" }
|
||||
stages {
|
||||
stage('Initial setup') {
|
||||
steps {
|
||||
script {
|
||||
autobuilderscript = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy")
|
||||
meta = autobuilderscript.startnonbuild(this)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Clean exports') {
|
||||
steps {
|
||||
script {
|
||||
SUMMARYDIR = "${WORKSPACE}/summary"
|
||||
REPORTDIR = "${WORKSPACE}/reports"
|
||||
EARLYROOTDIR = 'early'
|
||||
EARLYDIR = "${WORKSPACE}/${EARLYROOTDIR}"
|
||||
LATERROOTDIR = 'later'
|
||||
LATERDIR = "${WORKSPACE}/${LATERROOTDIR}"
|
||||
|
||||
cleanfolders = [
|
||||
"${WORKSPACE}/build_artifacts",
|
||||
"${EARLYDIR}",
|
||||
"${LATERDIR}",
|
||||
"${SUMMARYDIR}",
|
||||
"${REPORTDIR}",
|
||||
]
|
||||
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
|
||||
cleaner.clean(cleanfolders)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Obtain top level meta') {
|
||||
steps {
|
||||
script {
|
||||
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
|
||||
|
||||
SOURCEURL = TOP_LEVEL_META_REPOSITORY.trim()
|
||||
importer.artifactimport(meta, EARLY_SOURCE, EARLY_BUILD_JOB, EARLY_BUILD_SELECTOR, SOURCEURL, RELEASE_EARLY_REVISION, EARLYROOTDIR, false, 'meta/**')
|
||||
importer.artifactimport(meta, LATER_SOURCE, LATER_BUILD_JOB, LATER_BUILD_SELECTOR, SOURCEURL, RELEASE_LATER_REVISION, LATERROOTDIR, false, 'meta/**')
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Diff components') {
|
||||
steps {
|
||||
script {
|
||||
def comparator = load("${autobuilder.commonscripts()}/differences/dometahierarchy.groovy")
|
||||
(summarystring, markunstable, unstablereason) = comparator.comparehierarchy(meta, EARLYDIR, LATERDIR, MAX_META_DEPTH, SUMMARYDIR)
|
||||
if (markunstable) {
|
||||
env.unstablereason = unstablereason
|
||||
currentBuild.result = 'UNSTABLE'
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Archiving artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def artifactlist = meta.generateartifacts()
|
||||
archiveArtifacts "summary/**,reports/**,${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Summarise') {
|
||||
steps {
|
||||
script {
|
||||
echo "Summary:\n${summarystring}\n"
|
||||
if (env.unstablereason) {
|
||||
echo "Instability reason: ${env.unstablereason}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
80
Common_scripts/documentation/doxygen_deploy.groovy
Normal file
80
Common_scripts/documentation/doxygen_deploy.groovy
Normal file
|
|
@ -0,0 +1,80 @@
|
|||
pipeline {
|
||||
agent { label "${AGENT_LABEL}" }
|
||||
stages {
|
||||
stage('Initial setup') {
|
||||
steps {
|
||||
script {
|
||||
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Clean imports') {
|
||||
steps {
|
||||
script {
|
||||
env.DOXYGEN = "doxygen"
|
||||
cleanfolders = [
|
||||
DOXYGEN,
|
||||
]
|
||||
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
|
||||
cleaner.clean(cleanfolders)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import doxygen artifacts') {
|
||||
steps {
|
||||
script {
|
||||
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
|
||||
def importoptions = importer.getNewImportOptions()
|
||||
|
||||
importoptions.jenkinsjob(BUILD_JOB_WITH_DOXYGEN_ARTIFACTS, BUILD_JOB_WITH_DOXYGEN_ARTIFACTS_SELECTOR)
|
||||
importoptions.setfilter(ARTIFACT_PATH_TO_DOXYGEN_ROOT + '/**')
|
||||
doxygenmeta = importer.artifactimportfrombuildjob(meta, importoptions, DOXYGEN)
|
||||
|
||||
productname = doxygenmeta.productinfo.productname
|
||||
buildstampprefix = doxygenmeta.buildstampinfo.buildstampprefix
|
||||
|
||||
echo "Doyxgen imported for product: ${productname} and build stamp prefix: ${buildstampprefix}"
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Copy doxygen to server') {
|
||||
steps {
|
||||
script {
|
||||
doxygensource = "${DOXYGEN}/${ARTIFACT_PATH_TO_DOXYGEN_ROOT}"
|
||||
pathonserver = "${ROOT_PATH_ON_SERVER.trim()}/${productname}/${buildstampprefix}"
|
||||
echo "Copying from ${doxygensource} to ${pathonserver}"
|
||||
if (isUnix()) {
|
||||
sh """#!/bin/bash
|
||||
rm -rfv "${pathonserver}"
|
||||
if [ \$? -ne 0 ]; then exit 1; fi
|
||||
|
||||
mkdir -pv "${pathonserver}"
|
||||
if [ \$? -ne 0 ]; then exit 1; fi
|
||||
|
||||
echo mv -v "${doxygensource}"/ "${pathonserver}"
|
||||
mv -v "${doxygensource}"/ "${pathonserver}"
|
||||
if [ \$? -ne 0 ]; then exit 1; fi
|
||||
"""
|
||||
} else {
|
||||
error("This job does not run on Windows at the moment")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
333
Common_scripts/import/importer.groovy
Normal file
333
Common_scripts/import/importer.groovy
Normal file
|
|
@ -0,0 +1,333 @@
|
|||
gh = load("${autobuilder.commonscripts()}/versioncontrol/git.groovy")
|
||||
versiongenerator = load("${autobuilder.commonscripts()}/versionnumbering/generate.groovy")
|
||||
|
||||
class ImportOptions {
|
||||
def m_script // Script to use if wanting to execute script commands (eg. echo -> script.echo)
|
||||
|
||||
boolean m_incrementversionnumber // If true, increment the parent's (4th) version number with the (4th) version number of this object being imported
|
||||
String m_filter // Only import files/paths/folders that match the filter
|
||||
String m_excludes // Exclude files/paths/folders that match the exclude filter
|
||||
boolean m_fingerprint // Do Jenkins fingerprinting on imported artifacts
|
||||
boolean m_nested // Import all child artifacts too (identified in the related meta info
|
||||
boolean m_flatten // Flatten files and folders imported
|
||||
boolean m_includemetainfilter // Make sure meta is also included in filter
|
||||
boolean m_clean // Clean import folder before obtaining artifacts
|
||||
boolean m_appendtoparentmeta // Append to parent meta
|
||||
String m_sourceselect // Where are the artifacts coming from
|
||||
|
||||
String m_jobname
|
||||
def m_buildnumberorselector
|
||||
|
||||
String m_repo
|
||||
String m_revision
|
||||
|
||||
ImportOptions(script,
|
||||
String sourceselect = 'Jenkins job artifact',
|
||||
boolean incrementversionnumber = true,
|
||||
String filter = '',
|
||||
String excludes = '',
|
||||
boolean fingerprint = false,
|
||||
boolean nested = false,
|
||||
boolean flatten = false,
|
||||
boolean includemetainfilter = true,
|
||||
boolean clean = true,
|
||||
appendtoparentmeta = true) {
|
||||
m_script = script
|
||||
m_sourceselect = sourceselect.trim()
|
||||
m_incrementversionnumber = incrementversionnumber
|
||||
m_filter = filter.trim()
|
||||
m_excludes = excludes.trim()
|
||||
m_fingerprint = fingerprint
|
||||
m_nested = nested
|
||||
m_flatten = flatten
|
||||
m_includemetainfilter = includemetainfilter
|
||||
m_clean = clean
|
||||
m_appendtoparentmeta = appendtoparentmeta
|
||||
}
|
||||
|
||||
void setsourceselect(String sourceselect) {
|
||||
sourceselect = sourceselect.trim()
|
||||
switch (sourceselect) {
|
||||
case 'Jenkins job artefact':
|
||||
m_sourceselect = 'Jenkins job artifact'
|
||||
break
|
||||
case 'Jenkins job artifact':
|
||||
case 'Release repository':
|
||||
m_sourceselect = sourceselect
|
||||
break
|
||||
default:
|
||||
error("Unknown type of artifact source select: ${m_sourceselect}")
|
||||
}
|
||||
}
|
||||
|
||||
void setincrementversionnumber(boolean incrementversionnumber = true) {
|
||||
m_incrementversionnumber = incrementversionnumber
|
||||
}
|
||||
|
||||
void setfilter(String filter) {
|
||||
m_filter = filter.trim()
|
||||
}
|
||||
|
||||
void setexcludes(String excludes) {
|
||||
m_excludes = excludes.trim()
|
||||
}
|
||||
|
||||
void setfingerprint(boolean fingerprint = true) {
|
||||
m_fingerprint = fingerprint
|
||||
}
|
||||
|
||||
void setnested(boolean nested = true) {
|
||||
m_nested = nested
|
||||
}
|
||||
|
||||
void flattenimports(boolean flatten = true) {
|
||||
m_flatten = flatten
|
||||
}
|
||||
|
||||
void includemetainfilter(boolean includemetainfilter = true) {
|
||||
m_includemetainfilter = includemetainfilter
|
||||
}
|
||||
|
||||
void clean(boolean clean = true) {
|
||||
m_clean = clean
|
||||
}
|
||||
|
||||
void setappendtoparentmeta(boolean appendtoparentmeta) {
|
||||
m_appendtoparentmeta = appendtoparentmeta
|
||||
}
|
||||
|
||||
void jenkinsjob(String jobname, String buildnumberorselector) {
|
||||
m_jobname = jobname.trim()
|
||||
m_buildnumberorselector = buildnumberorselector.trim()
|
||||
setsourceselect('Jenkins job artifact')
|
||||
}
|
||||
|
||||
void releaserepo(String repo, String revision) {
|
||||
m_repo = repo.trim()
|
||||
m_revision = revision.trim()
|
||||
setsourceselect('Release repository')
|
||||
}
|
||||
|
||||
void source(String sourceselect, String jobname, String buildnumberorselector, String repo, String revision) {
|
||||
jenkinsjob(jobname, buildnumberorselector)
|
||||
releaserepo(repo, revision)
|
||||
setsourceselect(sourceselect)
|
||||
}
|
||||
}
|
||||
|
||||
ImportOptions getNewImportOptions() {
|
||||
return new ImportOptions(this)
|
||||
}
|
||||
|
||||
def formFilter(ImportOptions importoptions) {
|
||||
def String filter = importoptions.m_filter
|
||||
if (filter != '') {
|
||||
if (importoptions.m_includemetainfilter) {
|
||||
filter = 'meta/**,' + filter
|
||||
}
|
||||
}
|
||||
echo "Import options filter is: ${filter}"
|
||||
return filter
|
||||
}
|
||||
|
||||
def conditionalClean(ImportOptions importoptions, String destpath) {
|
||||
if (importoptions.m_clean) {
|
||||
echo "Cleaning ${destpath}"
|
||||
dir(destpath) {
|
||||
deleteDir()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
def artifactimportfrombuildjob(meta, importoptions, String destpath) {
|
||||
if (importoptions.m_sourceselect != 'Jenkins job artifact') {
|
||||
error("Import options settings have not been set for: Jenkins job artifact")
|
||||
return
|
||||
}
|
||||
|
||||
conditionalClean(importoptions, destpath)
|
||||
|
||||
copyArtifacts(
|
||||
filter: formFilter(importoptions),
|
||||
excludes: importoptions.m_excludes,
|
||||
fingerprintArtifacts: importoptions.m_fingerprint,
|
||||
projectName: importoptions.m_jobname,
|
||||
selector: [
|
||||
$class: 'ParameterizedBuildSelector',
|
||||
parameterName: importoptions.m_buildnumberorselector
|
||||
],
|
||||
flatten: importoptions.m_flatten,
|
||||
target: destpath
|
||||
)
|
||||
def importedmeta = meta.importrelated(importoptions.m_appendtoparentmeta, destpath)
|
||||
if (importoptions.m_incrementversionnumber) {
|
||||
meta.buildstampinfo.changerevision(versiongenerator.incrementrevision(meta.buildstampinfo.revision, importedmeta.buildstampinfo.revision))
|
||||
}
|
||||
return importedmeta
|
||||
}
|
||||
|
||||
def rewritemetafileasreleased(meta, String filepath) {
|
||||
// Modify the meta info to say that is has already been released
|
||||
meta.markreleased()
|
||||
meta.saveJsonSerialised(filepath)
|
||||
}
|
||||
|
||||
def hierarchyartifactimportfromrepo(meta, importoptions, String destpath) {
|
||||
if (importoptions.m_sourceselect != 'Release repository') {
|
||||
error("Import options settings have not been set for: Release repository")
|
||||
return
|
||||
}
|
||||
|
||||
def rooturl = importoptions.m_repo
|
||||
def rootrevision = importoptions.m_revision
|
||||
echo "Cloning root release repo: ${rooturl}, revision: ${rootrevision} at folder: ${destpath}"
|
||||
|
||||
conditionalClean(importoptions, destpath)
|
||||
|
||||
def ArrayList<String> sparseitemlist = gh.convertSparseItemsString(formFilter(importoptions))
|
||||
gh.gitCheckoutAlt(rooturl, rootrevision, destpath, "", 1, true, sparseitemlist)
|
||||
|
||||
def importedmeta = meta.importrelated(importoptions.m_appendtoparentmeta, destpath, rooturl, rootrevision, gh.getGitInfo(destpath))
|
||||
|
||||
relatedimportinfo = importedmeta.getassociated()
|
||||
echo "Cloning associated repos"
|
||||
for(relatedmetainfo in relatedimportinfo) {
|
||||
def relatedmeta = relatedmetainfo.meta
|
||||
def relatedoffsetpath = relatedmetainfo.offsetpath
|
||||
def cloneurl = relatedmeta.releaseinfo.releaserepoURL
|
||||
def clonerevision = "refs/tags/${relatedmeta.releasetag()}"
|
||||
def clonepath = "${destpath}/${relatedoffsetpath}"
|
||||
echo "Cloning release repo: ${cloneurl}, revision: ${clonerevision} at folder: ${clonepath}"
|
||||
|
||||
gh.gitCheckoutAlt(cloneurl, clonerevision, clonepath, "", 1, true, [])
|
||||
|
||||
gh.stripgithistory(clonepath)
|
||||
|
||||
def metafilepath = "${clonepath}/${relatedmeta.metafilepath()}"
|
||||
echo "Marking related meta as released and rewriting meta file: ${metafilepath}"
|
||||
rewritemetafileasreleased(relatedmeta, metafilepath)
|
||||
}
|
||||
gh.stripgithistory(destpath)
|
||||
def metafilepath = "${destpath}/${meta.metafilepath()}"
|
||||
echo "Marking root meta as released and rewriting meta file: ${metafilepath}"
|
||||
rewritemetafileasreleased(importedmeta, metafilepath)
|
||||
|
||||
if (importoptions.m_incrementversionnumber) {
|
||||
meta.buildstampinfo.changerevision(versiongenerator.incrementrevision(meta.buildstampinfo.revision, importedmeta.buildstampinfo.revision))
|
||||
}
|
||||
return importedmeta
|
||||
}
|
||||
|
||||
def artifactimportfromrepo(meta, importoptions, String destpath) {
|
||||
if (importoptions.m_sourceselect != 'Release repository') {
|
||||
error("Import options settings have not been set for: Release repository")
|
||||
return
|
||||
}
|
||||
|
||||
conditionalClean(importoptions, destpath)
|
||||
|
||||
def rooturl = importoptions.m_repo
|
||||
def rootrevision = importoptions.m_revision
|
||||
echo "Cloning release repo: ${rooturl}, revision: ${rootrevision} at folder: ${destpath}"
|
||||
|
||||
def ArrayList<String> sparseitemlist = gh.convertSparseItemsString(formFilter(importoptions))
|
||||
gh.gitCheckoutAlt(rooturl, rootrevision, destpath, "", 1, true, sparseitemlist)
|
||||
|
||||
def importedmeta = meta.importrelated(importoptions.m_appendtoparentmeta, destpath, rooturl, rootrevision, gh.getGitInfo(destpath))
|
||||
|
||||
gh.stripgithistory(destpath)
|
||||
def metafilepath = "${destpath}/${meta.metafilepath()}"
|
||||
echo "Marking meta as released and rewriting meta file: ${metafilepath}"
|
||||
rewritemetafileasreleased(importedmeta, metafilepath)
|
||||
|
||||
if (importoptions.m_incrementversionnumber) {
|
||||
meta.buildstampinfo.changerevision(versiongenerator.incrementrevision(meta.buildstampinfo.revision, importedmeta.buildstampinfo.revision))
|
||||
}
|
||||
return importedmeta
|
||||
}
|
||||
|
||||
def artifactimport(meta, importoptions, String destpath) {
|
||||
switch (importoptions.m_sourceselect) {
|
||||
case 'Jenkins job artifact':
|
||||
case 'Jenkins job artefact':
|
||||
return artifactimportfrombuildjob(meta, importoptions, destpath)
|
||||
case 'Release repository':
|
||||
if (importoptions.m_nested) {
|
||||
return hierarchyartifactimportfromrepo(meta, importoptions, destpath)
|
||||
}
|
||||
return artifactimportfromrepo(meta, importoptions, destpath)
|
||||
default:
|
||||
error("Unknown type of artifact source: ${source}")
|
||||
}
|
||||
return meta
|
||||
}
|
||||
|
||||
// Deprecated (use above)
|
||||
def artifactimport(meta,
|
||||
String sourceselect,
|
||||
String jenkinsjob,
|
||||
buildnumberorselector,
|
||||
String repo,
|
||||
String revision,
|
||||
String destpath,
|
||||
boolean incrementversionnumber = true,
|
||||
String filter = '',
|
||||
String excludes = '',
|
||||
boolean fingerprint = false,
|
||||
boolean nested = false) {
|
||||
echo "DEPRECATED method: artifactimport(meta, String source, String jenkinsjob, buildnumberorselector, String repo, String revision, String destpath ...)"
|
||||
def importoptions = getNewImportOptions()
|
||||
|
||||
importoptions.source(sourceselect, jenkinsjob, buildnumberorselector, repo, revision)
|
||||
importoptions.setincrementversionnumber(incrementversionnumber)
|
||||
importoptions.setfilter(filter)
|
||||
importoptions.setexcludes(excludes)
|
||||
importoptions.setfingerprint(fingerprint)
|
||||
importoptions.setnested(nested)
|
||||
|
||||
return artifactimport(meta, importoptions, destpath)
|
||||
}
|
||||
|
||||
// Deprecated (use above)
|
||||
def artifactimport(meta,
|
||||
String buildjob,
|
||||
int buildnumber,
|
||||
String destpath,
|
||||
boolean incrementversionnumber = true,
|
||||
String filter = '**',
|
||||
String excludes = '',
|
||||
boolean fingerprint = false) {
|
||||
echo "DEPRECATED method: artifactimport(meta, String buildjob, int buildnumber, String destpath, ...)"
|
||||
def importoptions = getNewImportOptions()
|
||||
|
||||
importoptions.jenkinsjob(buildjob, "<SpecificBuildSelector plugin='copyartifact@1.41'> <buildNumber>${buildnumber}</buildNumber></SpecificBuildSelector>")
|
||||
importoptions.setincrementversionnumber(incrementversionnumber)
|
||||
importoptions.setfilter(filter)
|
||||
importoptions.setexcludes(excludes)
|
||||
importoptions.setfingerprint(fingerprint)
|
||||
|
||||
return artifactimport(meta, importoptions, destpath)
|
||||
}
|
||||
|
||||
// Deprecated (use above)
|
||||
def artifactimport(meta,
|
||||
String buildjob,
|
||||
buildnumberorselector,
|
||||
String destpath,
|
||||
boolean incrementversionnumber = true,
|
||||
String filter = '',
|
||||
String excludes = '',
|
||||
boolean fingerprint = false) {
|
||||
echo "DEPRECATED method: artifactimport(meta, String buildjob, buildnumberorselector, String destpath, ...)"
|
||||
def importoptions = getNewImportOptions()
|
||||
|
||||
importoptions.jenkinsjob(buildjob, buildnumberorselector)
|
||||
importoptions.setincrementversionnumber(incrementversionnumber)
|
||||
importoptions.setfilter(filter)
|
||||
importoptions.setexcludes(excludes)
|
||||
importoptions.setfingerprint(fingerprint)
|
||||
|
||||
return artifactimport(meta, importoptions, destpath)
|
||||
}
|
||||
|
||||
return this;
|
||||
117
Common_scripts/install/installhelper.groovy
Normal file
117
Common_scripts/install/installhelper.groovy
Normal file
|
|
@ -0,0 +1,117 @@
|
|||
import hudson.FilePath
|
||||
|
||||
// Transfer file from intermediate position to final position;
|
||||
// creating necessary folders on the way;
|
||||
// deleting intermediate file
|
||||
def copyToFinalPosition(String pathToIntermediate, String finalBaseFolder, String finalFilename) {
|
||||
def channel = Jenkins.getInstance().getComputer(env['NODE_NAME']).getChannel()
|
||||
|
||||
def String abs_exports_root_path = "${WORKSPACE}/${finalBaseFolder}"
|
||||
def String abs_export_out = "${abs_exports_root_path}/${finalFilename}"
|
||||
def export_filepath = new hudson.FilePath(channel, abs_export_out)
|
||||
def export_out_folder = export_filepath.getParent()
|
||||
def export_out_folder_string = export_out_folder.toString()
|
||||
def export_out_file = export_filepath.getName()
|
||||
|
||||
echo "Creating folder ${export_out_folder_string}"
|
||||
export_out_folder.mkdirs()
|
||||
|
||||
echo "Copying from ${pathToIntermediate} to ${abs_export_out}"
|
||||
def intermediate_filepath = new hudson.FilePath(channel, pathToIntermediate)
|
||||
intermediate_filepath.copyTo(export_filepath)
|
||||
intermediate_filepath.delete()
|
||||
}
|
||||
|
||||
// Given details about artifacts to import and details of installers to build, import artifacts that are required
|
||||
def Map artifactsImporter(meta, importer, artifactDetails, installerDetails) {
|
||||
artifactFetched = [:]
|
||||
|
||||
def importoptions = importer.getNewImportOptions()
|
||||
for (installer in toBuild) {
|
||||
def artifactKeys = installerDetails.get(installer)[1]
|
||||
if (artifactKeys instanceof java.lang.String) {
|
||||
artifactKeys = [ artifactKeys ]
|
||||
}
|
||||
for (artifactKey in artifactKeys) {
|
||||
(sourceProject, sourceselector, destFolder, incrementversionnumber, toCopy, notToCopy, binariesFolders) = artifactDetails.get(artifactKey)
|
||||
if (artifactFetched.get(artifactKey) == null) {
|
||||
importoptions.jenkinsjob(sourceProject, sourceselector)
|
||||
importoptions.setincrementversionnumber(incrementversionnumber)
|
||||
importoptions.setfilter(toCopy)
|
||||
importoptions.setexcludes(notToCopy)
|
||||
|
||||
def importmeta = importer.artifactimport(meta, importoptions, destFolder)
|
||||
artifactFetched.put(artifactKey, importmeta)
|
||||
}
|
||||
}
|
||||
}
|
||||
return artifactFetched
|
||||
}
|
||||
|
||||
@NonCPS
|
||||
def checkISMfilebackend(String xml) {
|
||||
def String message = ""
|
||||
|
||||
def parsedxml = new XmlParser(true, true, true).parseText(xml)
|
||||
def pathvariableinfo = [:]
|
||||
def exitcode = 0
|
||||
// Load up a map of path variable and path pairs
|
||||
// Ignore blank path definitions
|
||||
// Ignore the workspace definition which should have the only absolute path
|
||||
parsedxml.each{ table ->
|
||||
if (table.@name == "ISPathVariable") {
|
||||
table['row'].each{ row ->
|
||||
def pathname = row['td'][0].value()[0]
|
||||
def path = row['td'][1].value()[0]
|
||||
if (path && pathname != 'WORKSPACE') {
|
||||
pathvariableinfo[pathname] = path
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// Check that each path variable is defined beginning with a path variable or the WORKSPACE one
|
||||
pathvariableinfo.each{ pair ->
|
||||
message += "pair key: ${pair.key} value: ${pair.value}\n"
|
||||
def path = pair.value
|
||||
def pathvarmatcher = path =~ /<(.*)>.*/
|
||||
if (pathvarmatcher.matches()) {
|
||||
def pathvarfound = pathvarmatcher.group(1)
|
||||
if (pathvarfound != 'WORKSPACE') {
|
||||
if (!pathvariableinfo.containsKey(pathvarfound)) {
|
||||
message += "Undefined path variable ${pathvarfound} found\n"
|
||||
exitcode = 1
|
||||
}
|
||||
}
|
||||
} else {
|
||||
message += "Path: ${path} does not begin with a path variable\n"
|
||||
exitcode = 1
|
||||
}
|
||||
}
|
||||
return [exitcode, message]
|
||||
}
|
||||
|
||||
def checkISMfile(String ISMfile) {
|
||||
echo "Checking ISM file: ${ISMfile}"
|
||||
def xml = readFile(ISMfile)
|
||||
(exitcode, message) = checkISMfilebackend(xml)
|
||||
echo message
|
||||
if (exitcode > 0) {
|
||||
error "ISM file errors found"
|
||||
} else {
|
||||
echo "Checked ISM file - ok"
|
||||
}
|
||||
}
|
||||
|
||||
certificatethumbprints = [:]
|
||||
certificatethumbprints['floreana'] = '0FDEB0A227982C877146CA595091173AC9655479' // Authoring takes place on this machine - so this is what should be in the ISM file already
|
||||
certificatethumbprints['hawaii'] = '49FD1B361CFF35014B81940C5B046543045DD34B'
|
||||
|
||||
def selectSigningCertificate(String nodeName, String ISMfile) {
|
||||
def masterpattern = '0FDEB0A227982C877146CA595091173AC9655479'
|
||||
echo "Substituting occurrences of ${masterpattern} with ${certificatethumbprints[nodeName]} in ISM file: ${ISMfile}"
|
||||
|
||||
textutils_subst = load("${autobuilder.commonscripts()}/textutils/subst.groovy")
|
||||
textutils_subst.substitute(ISMfile, masterpattern, certificatethumbprints[nodeName])
|
||||
}
|
||||
|
||||
return this;
|
||||
772
Common_scripts/meta/folder.groovy
Normal file
772
Common_scripts/meta/folder.groovy
Normal file
|
|
@ -0,0 +1,772 @@
|
|||
import java.nio.file.Paths
|
||||
import java.nio.file.Path
|
||||
import groovy.json.JsonSlurperClassic
|
||||
|
||||
abstract class GISJsonSerialised implements Serializable {
|
||||
def script
|
||||
|
||||
GISJsonSerialised(script) {
|
||||
this.script = script
|
||||
}
|
||||
|
||||
abstract LinkedHashMap serialisationdata()
|
||||
|
||||
abstract void deserialiseJson(rawmeta)
|
||||
|
||||
def saveJsonSerialised(String outputfile, int prettylevel = 4) {
|
||||
def outJson = script.readJSON text: groovy.json.JsonOutput.toJson(serialisationdata())
|
||||
script.writeJSON(file: outputfile, json: outJson, pretty: prettylevel)
|
||||
}
|
||||
}
|
||||
|
||||
class ProductInfo extends GISJsonSerialised {
|
||||
String productname
|
||||
String subcomponentname
|
||||
|
||||
ProductInfo(script, productname = "", subcomponentname = "") {
|
||||
super(script)
|
||||
this.productname = productname
|
||||
this.subcomponentname = subcomponentname
|
||||
}
|
||||
|
||||
void set(String productname, String subcomponentname) {
|
||||
// Make sure the fields can be used in git tags
|
||||
def int pstatus = 0
|
||||
if (script.isUnix()) {
|
||||
pstatus = script.sh(script: "git check-ref-format --normalize \"refs/tags/${productname}\" >/dev/null 2>/dev/null", , returnStatus: true)
|
||||
}
|
||||
else {
|
||||
pstatus = script.bat(script: "@git check-ref-format --normalize \"refs/tags/${productname}\" > NUL 2> NUL", , returnStatus: true)
|
||||
}
|
||||
if (pstatus > 0) {
|
||||
script.error("The product name: ${productname} needs to be renamed as it cannot be used in a git tag name")
|
||||
}
|
||||
def int sstatus = 0
|
||||
if (script.isUnix()) {
|
||||
sstatus = script.sh(script: "git check-ref-format --normalize \"refs/tags/${subcomponentname}\" >/dev/null 2>/dev/null", , returnStatus: true)
|
||||
}
|
||||
else {
|
||||
sstatus = script.bat(script: "@git check-ref-format --normalize \"refs/tags/${subcomponentname}\" > NUL 2> NUL", , returnStatus: true)
|
||||
}
|
||||
if (sstatus > 0) {
|
||||
script.error("The subcomponent name: ${subcomponentname} needs to be renamed as it cannot be used in a git tag name")
|
||||
}
|
||||
this.productname = productname
|
||||
this.subcomponentname = subcomponentname
|
||||
}
|
||||
|
||||
void deserialiseJson(rawmeta) {
|
||||
productname = rawmeta['productname']
|
||||
subcomponentname = rawmeta['subcomponentname']
|
||||
}
|
||||
|
||||
LinkedHashMap serialisationdata() {
|
||||
def data = [
|
||||
'productname' : productname,
|
||||
'subcomponentname' : subcomponentname,
|
||||
]
|
||||
return data
|
||||
}
|
||||
}
|
||||
|
||||
class GitInfo extends GISJsonSerialised {
|
||||
private String sourcepath
|
||||
private String sourcerevision
|
||||
private String gitrevision
|
||||
private String remoteurl
|
||||
private String remoteinfo
|
||||
|
||||
GitInfo(script, sourcepath = "", sourcerevision = "", gitrevision = "", remoteurl = "", remoteinfo = "") {
|
||||
super(script)
|
||||
this.sourcepath = sourcepath
|
||||
this.sourcerevision = sourcerevision
|
||||
this.gitrevision = gitrevision
|
||||
this.remoteurl = remoteurl
|
||||
this.remoteinfo = remoteinfo
|
||||
}
|
||||
|
||||
void set(String sourcepath, String sourcerevision, String gitrevision, String remoteurl, String remoteinfo) {
|
||||
this.sourcepath = sourcepath
|
||||
this.sourcerevision = sourcerevision
|
||||
this.gitrevision = gitrevision
|
||||
this.remoteurl = remoteurl
|
||||
this.remoteinfo = remoteinfo
|
||||
}
|
||||
|
||||
void deserialiseJson(rawmeta) {
|
||||
sourcepath = rawmeta['sourcepath']
|
||||
sourcerevision = rawmeta['sourcerevision']
|
||||
gitrevision = rawmeta['gitrevision']
|
||||
remoteurl = rawmeta['remoteurl']
|
||||
remoteinfo = rawmeta['remoteinfo']
|
||||
}
|
||||
|
||||
LinkedHashMap serialisationdata() {
|
||||
def data = [
|
||||
'sourcepath' : sourcepath,
|
||||
'sourcerevision' : sourcerevision,
|
||||
'gitrevision' : gitrevision,
|
||||
'remoteurl' : remoteurl,
|
||||
'remoteinfo' : remoteinfo,
|
||||
]
|
||||
return data
|
||||
}
|
||||
}
|
||||
|
||||
class JenkinsBuildInfo extends GISJsonSerialised {
|
||||
String buildjobname
|
||||
int buildnumber
|
||||
private String buildmachine
|
||||
private String builddate
|
||||
|
||||
JenkinsBuildInfo(script, String buildjobname = "", int buildnumber = 0, String buildmachine = "", String builddate = "") {
|
||||
super(script)
|
||||
this.buildjobname = buildjobname
|
||||
this.buildnumber = buildnumber
|
||||
this.buildmachine = buildmachine
|
||||
this.builddate = builddate
|
||||
}
|
||||
|
||||
void set(String buildjobname, int buildnumber, String buildmachine, String builddate) {
|
||||
this.buildjobname = buildjobname
|
||||
this.buildnumber = buildnumber
|
||||
this.buildmachine = buildmachine
|
||||
this.builddate = builddate
|
||||
}
|
||||
|
||||
void deserialiseJson(rawmeta) {
|
||||
buildjobname = rawmeta['buildjobname']
|
||||
buildnumber = rawmeta['buildnumber']
|
||||
buildmachine = rawmeta['buildmachine']
|
||||
builddate = rawmeta['builddate']
|
||||
}
|
||||
|
||||
LinkedHashMap serialisationdata() {
|
||||
def data = [
|
||||
'buildjobname' : buildjobname,
|
||||
'buildnumber' : buildnumber,
|
||||
'buildmachine' : buildmachine,
|
||||
'builddate' : builddate,
|
||||
]
|
||||
return data
|
||||
}
|
||||
}
|
||||
|
||||
class BuildStampInfo extends GISJsonSerialised {
|
||||
String buildstampprefix
|
||||
int revision
|
||||
String buildstamp
|
||||
|
||||
BuildStampInfo(script, buildstampprefix = "0.30000.0.", revision = 0, buildstamp = "0.30000.0.0") {
|
||||
super(script)
|
||||
this.buildstampprefix = buildstampprefix
|
||||
this.revision = revision
|
||||
this.buildstamp = buildstamp
|
||||
}
|
||||
|
||||
void set(String buildstampprefix, int revision, String buildstamp) {
|
||||
this.buildstampprefix = buildstampprefix
|
||||
this.revision = revision
|
||||
this.buildstamp = buildstamp
|
||||
}
|
||||
|
||||
String buildstampcommasep() {
|
||||
def String buildstampcommasep = buildstamp.replace(".", ",")
|
||||
return buildstampcommasep
|
||||
}
|
||||
|
||||
void changerevision(int newrevision) {
|
||||
script.echo("Build stamp currently ${buildstamp}")
|
||||
revision = newrevision
|
||||
def List buildstampsplit = buildstamp.split('\\.')
|
||||
buildstampsplit[-1] = newrevision.toString()
|
||||
buildstamp = buildstampsplit.join('.')
|
||||
script.echo("Build stamp now ${buildstamp}")
|
||||
}
|
||||
|
||||
void set(String buildstampprefix, int revision) {
|
||||
buildstampprefix += buildstampprefix.endsWith('.') ? '' : '.'
|
||||
this.buildstampprefix = buildstampprefix
|
||||
this.buildstamp = buildstampprefix + "0"
|
||||
changerevision(revision)
|
||||
}
|
||||
|
||||
void set(String buildstampprefix, String revision = '0') {
|
||||
set(buildstampprefix, revision.toInteger())
|
||||
}
|
||||
|
||||
void deserialiseJson(rawmeta) {
|
||||
buildstampprefix = rawmeta['buildstampprefix']
|
||||
revision = rawmeta['revision']
|
||||
buildstamp = rawmeta['buildstamp']
|
||||
}
|
||||
|
||||
LinkedHashMap serialisationdata() {
|
||||
def data = [
|
||||
'buildstampprefix' : buildstampprefix,
|
||||
'revision' : revision,
|
||||
'buildstamp' : buildstamp,
|
||||
]
|
||||
return data
|
||||
}
|
||||
}
|
||||
|
||||
class ReleaseInfo extends GISJsonSerialised {
|
||||
String releaserepoURL
|
||||
ArrayList<String> releaseitems
|
||||
boolean released
|
||||
|
||||
ReleaseInfo(script, String releaserepoURL = "", boolean released = false) {
|
||||
super(script)
|
||||
this.releaserepoURL = releaserepoURL
|
||||
this.releaseitems = new ArrayList<String>()
|
||||
this.released = released
|
||||
}
|
||||
|
||||
void set(String releaserepoURL = "") {
|
||||
this.releaserepoURL = releaserepoURL
|
||||
}
|
||||
|
||||
void addReleaseItem(String releaseitem) {
|
||||
script.echo("Adding release item: ${releaseitem} to release items")
|
||||
releaseitems.add(releaseitem)
|
||||
}
|
||||
|
||||
void markreleased() {
|
||||
this.released = true
|
||||
}
|
||||
|
||||
List releaseitemssserialised() {
|
||||
def items = []
|
||||
for (ri in releaseitems) {
|
||||
items.add(ri)
|
||||
}
|
||||
return items
|
||||
}
|
||||
|
||||
void deserialiseJson(rawmeta) {
|
||||
releaserepoURL = rawmeta['releaserepoURL']
|
||||
releaseitems = new ArrayList<String>()
|
||||
for (rawreleaseitem in rawmeta['releaseitems']) {
|
||||
releaseitems.add(rawreleaseitem)
|
||||
}
|
||||
released = rawmeta['released'] ?: false
|
||||
}
|
||||
|
||||
LinkedHashMap serialisationdata() {
|
||||
def data = [
|
||||
'releaserepoURL' : releaserepoURL,
|
||||
'releaseitems' : releaseitemssserialised(),
|
||||
'released' : released
|
||||
]
|
||||
return data
|
||||
}
|
||||
}
|
||||
|
||||
class ConfigurationInfo extends GISJsonSerialised {
|
||||
private String configurationname
|
||||
private String configurationURL
|
||||
private String configurationversion
|
||||
private String configurationSHA
|
||||
|
||||
ConfigurationInfo(script, configurationname = "", configurationURL = "", configurationversion = "", configurationSHA = "") {
|
||||
super(script)
|
||||
this.configurationname = configurationname
|
||||
this.configurationURL = configurationURL
|
||||
this.configurationversion = configurationversion
|
||||
this.configurationSHA = configurationSHA
|
||||
}
|
||||
|
||||
void deserialiseJson(rawmeta) {
|
||||
configurationname = rawmeta['configurationname']
|
||||
configurationURL = rawmeta['configurationURL']
|
||||
configurationversion = rawmeta['configurationversion']
|
||||
configurationSHA = rawmeta['configurationSHA']
|
||||
}
|
||||
|
||||
LinkedHashMap serialisationdata() {
|
||||
def data = [
|
||||
'configurationname' : configurationname,
|
||||
'configurationURL' : configurationURL,
|
||||
'configurationversion' : configurationversion,
|
||||
'configurationSHA' : configurationSHA,
|
||||
]
|
||||
return data
|
||||
}
|
||||
}
|
||||
|
||||
class ChecksumPair extends GISJsonSerialised {
|
||||
private String filepath
|
||||
private String sum
|
||||
|
||||
ChecksumPair(script, String filepath = "", String sum = "") {
|
||||
super(script)
|
||||
this.filepath = filepath
|
||||
this.sum = sum
|
||||
}
|
||||
|
||||
void deserialiseJson(rawmeta) {
|
||||
filepath = rawmeta['filepath']
|
||||
sum = rawmeta['sum']
|
||||
}
|
||||
|
||||
LinkedHashMap serialisationdata() {
|
||||
def data = [
|
||||
'filepath' : filepath,
|
||||
'sum' : sum,
|
||||
]
|
||||
return data
|
||||
}
|
||||
}
|
||||
|
||||
class ChecksumSet extends GISJsonSerialised {
|
||||
private String artifactpath
|
||||
private ArrayList<ChecksumPair> checksumpairs
|
||||
|
||||
ChecksumSet(script, artifactpath = "") {
|
||||
super(script)
|
||||
this.artifactpath = artifactpath
|
||||
checksumpairs = new ArrayList<ChecksumPair>()
|
||||
}
|
||||
|
||||
ChecksumPair addChecksumPair(String filepath, String sum) {
|
||||
def cp = new ChecksumPair(script, filepath, sum)
|
||||
checksumpairs.add(cp)
|
||||
return cp
|
||||
}
|
||||
|
||||
List checksumpairsserialised() {
|
||||
def associated = []
|
||||
for (cp in checksumpairs) {
|
||||
associated.add(cp.serialisationdata())
|
||||
}
|
||||
return associated
|
||||
}
|
||||
|
||||
void deserialiseJson(rawmeta) {
|
||||
artifactpath = rawmeta['artifactpath']
|
||||
checksumpairs = new ArrayList<ChecksumPair>()
|
||||
for (rawchecksumpair in rawmeta['checksumpairs']) {
|
||||
def csp = new ChecksumPair(script)
|
||||
csp.deserialiseJson(rawchecksumpair)
|
||||
checksumpairs.add(csp)
|
||||
}
|
||||
}
|
||||
|
||||
LinkedHashMap serialisationdata() {
|
||||
def data = [
|
||||
'artifactpath' : artifactpath,
|
||||
'checksumpairs' : checksumpairsserialised(),
|
||||
]
|
||||
return data
|
||||
}
|
||||
}
|
||||
|
||||
class ChecksumInfo extends GISJsonSerialised {
|
||||
private ArrayList<ChecksumSet> checksumsets
|
||||
|
||||
ChecksumInfo(script) {
|
||||
super(script)
|
||||
checksumsets = new ArrayList<ChecksumSet>()
|
||||
}
|
||||
|
||||
ChecksumSet addChecksumSet(String artifactpath) {
|
||||
def cs = new ChecksumSet(script, artifactpath)
|
||||
checksumsets.add(cs)
|
||||
return cs
|
||||
}
|
||||
|
||||
List checksumsetsserialised() {
|
||||
def associated = []
|
||||
for (cs in checksumsets) {
|
||||
associated.add(cs.serialisationdata())
|
||||
}
|
||||
return associated
|
||||
}
|
||||
|
||||
void deserialiseJson(rawmeta) {
|
||||
checksumsets = new ArrayList<ChecksumSet>()
|
||||
for (rawchecksumset in rawmeta['checksumsets']) {
|
||||
def cs = new ChecksumSet(script)
|
||||
cs.deserialiseJson(rawchecksumset)
|
||||
checksumsets.add(cs)
|
||||
}
|
||||
}
|
||||
|
||||
LinkedHashMap serialisationdata() {
|
||||
def data = [
|
||||
'checksumsets' : checksumsetsserialised(),
|
||||
]
|
||||
return data
|
||||
}
|
||||
}
|
||||
|
||||
class PublishableInfo extends GISJsonSerialised {
|
||||
private String filepath
|
||||
|
||||
PublishableInfo(script, String filepath = "") {
|
||||
super(script)
|
||||
this.filepath = filepath
|
||||
}
|
||||
|
||||
void deserialiseJson(rawmeta) {
|
||||
filepath = rawmeta['filepath']
|
||||
}
|
||||
|
||||
LinkedHashMap serialisationdata() {
|
||||
def data = [
|
||||
'filepath' : filepath,
|
||||
]
|
||||
return data
|
||||
}
|
||||
}
|
||||
|
||||
class MetaInfo extends GISJsonSerialised {
|
||||
private static String FORMAT = "0.1"
|
||||
private static String METAFOLDERNAME = "meta"
|
||||
private static String METAFILENAME = "info.json"
|
||||
private static String METAARTIFACTS = "${METAFOLDERNAME}/**"
|
||||
|
||||
class RelatedMetaInfo extends GISJsonSerialised {
|
||||
String offsetpath
|
||||
MetaInfo meta
|
||||
|
||||
RelatedMetaInfo(script, offsetpath = "", MetaInfo meta = null) {
|
||||
super(script)
|
||||
this.offsetpath = offsetpath
|
||||
this.meta = meta
|
||||
}
|
||||
|
||||
void deserialiseJson(rawmeta) {
|
||||
offsetpath = rawmeta['offsetpath']
|
||||
meta = new MetaInfo(script)
|
||||
meta.deserialiseJson(rawmeta['meta'])
|
||||
}
|
||||
|
||||
LinkedHashMap serialisationdata() {
|
||||
def data = [
|
||||
'offsetpath' : offsetpath,
|
||||
'meta' : meta.serialisationdata(),
|
||||
]
|
||||
return data
|
||||
}
|
||||
}
|
||||
|
||||
private String format = FORMAT
|
||||
ProductInfo productinfo
|
||||
GitInfo gitinfo
|
||||
JenkinsBuildInfo jenkinsbuildinfo
|
||||
BuildStampInfo buildstampinfo
|
||||
ReleaseInfo releaseinfo
|
||||
ChecksumInfo checksuminfo
|
||||
private ArrayList<ConfigurationInfo> configurationinfo
|
||||
private ArrayList<PublishableInfo> publishableinfo
|
||||
private LinkedHashMap<String, String> custominfo
|
||||
private ArrayList<RelatedMetaInfo> associatedmeta
|
||||
|
||||
MetaInfo(script) {
|
||||
super(script)
|
||||
productinfo = new ProductInfo(script)
|
||||
gitinfo = new GitInfo(script)
|
||||
jenkinsbuildinfo = new JenkinsBuildInfo(script)
|
||||
buildstampinfo = new BuildStampInfo(script)
|
||||
releaseinfo = new ReleaseInfo(script)
|
||||
checksuminfo = new ChecksumInfo(script)
|
||||
configurationinfo = new ArrayList<ConfigurationInfo>()
|
||||
publishableinfo = new ArrayList<PublishableInfo>()
|
||||
custominfo = new LinkedHashMap<String, String>()
|
||||
associatedmeta = new ArrayList<RelatedMetaInfo>()
|
||||
}
|
||||
|
||||
List getassociated() {
|
||||
return associatedmeta
|
||||
}
|
||||
|
||||
void markreleased() {
|
||||
script.echo("Marking product: ${productinfo.productname} component: ${productinfo.subcomponentname} as released")
|
||||
releaseinfo.markreleased()
|
||||
for (associated in associatedmeta) {
|
||||
associated.meta.releaseinfo.markreleased()
|
||||
}
|
||||
}
|
||||
|
||||
List configurationinfoserialised() {
|
||||
def configuration = []
|
||||
for (configurationitem in configurationinfo) {
|
||||
configuration.add(configurationitem.serialisationdata())
|
||||
}
|
||||
return configuration
|
||||
}
|
||||
|
||||
void addPublishable(String filepath) {
|
||||
def PublishableInfo pi = new PublishableInfo(script, filepath)
|
||||
script.echo("Adding ${filepath} to publishable list")
|
||||
publishableinfo.add(pi)
|
||||
}
|
||||
|
||||
void addConfigurationInfo(String configurationname, String configurationURL, String configurationversion, String configurationSHA) {
|
||||
def ConfigurationInfo ci = new ConfigurationInfo(script, configurationname, configurationURL, configurationversion, configurationSHA)
|
||||
script.echo("Adding configuration info: name: ${configurationname} url: ${configurationURL} version: ${configurationversion} sha: ${configurationSHA}")
|
||||
configurationinfo.add(ci)
|
||||
}
|
||||
|
||||
void addCustomInfo(String customId, String customValue) {
|
||||
custominfo.put(customId.trim(), customValue)
|
||||
}
|
||||
|
||||
String getCustomInfo(String customId) {
|
||||
return custominfo.getAt(customId.trim())
|
||||
}
|
||||
|
||||
List publishableinfoserialised() {
|
||||
def publishable = []
|
||||
for (publishableitem in publishableinfo) {
|
||||
publishable.add(publishableitem.serialisationdata())
|
||||
}
|
||||
return publishable
|
||||
}
|
||||
|
||||
List associatedmetaserialised() {
|
||||
def associated = []
|
||||
for (metaitem in associatedmeta) {
|
||||
associated.add(metaitem.serialisationdata())
|
||||
}
|
||||
return associated
|
||||
}
|
||||
|
||||
void deserialiseJson(rawmeta) {
|
||||
if (rawmeta['format'] != FORMAT) {
|
||||
script.error("Unsupported meta format found at ${filepath}")
|
||||
return
|
||||
}
|
||||
productinfo.deserialiseJson(rawmeta['productinfo'])
|
||||
gitinfo.deserialiseJson(rawmeta['gitinfo'])
|
||||
jenkinsbuildinfo.deserialiseJson(rawmeta['jenkinsbuildinfo'])
|
||||
buildstampinfo.deserialiseJson(rawmeta['buildstampinfo'])
|
||||
releaseinfo.deserialiseJson(rawmeta['releaseinfo'])
|
||||
checksuminfo.deserialiseJson(rawmeta['checksuminfo'])
|
||||
for (rawconfig in rawmeta['configuration']) {
|
||||
def cf = new ConfigurationInfo(script)
|
||||
cf.deserialiseJson(rawconfig)
|
||||
configurationinfo.add(cf)
|
||||
}
|
||||
for (rawpublishable in rawmeta['publishableinfo']) {
|
||||
def pb = new PublishableInfo(script)
|
||||
pb.deserialiseJson(rawpublishable)
|
||||
publishableinfo.add(pb)
|
||||
}
|
||||
custominfo = rawmeta['custominfo']
|
||||
for (rawrelatedmeta in rawmeta['associatedmeta']) {
|
||||
def rm = new RelatedMetaInfo(script)
|
||||
rm.deserialiseJson(rawrelatedmeta)
|
||||
associatedmeta.add(rm)
|
||||
}
|
||||
}
|
||||
|
||||
def deserialiseJson(String filepath) {
|
||||
script.echo("Deserialising JSON at file: ${filepath}")
|
||||
def rawmeta = script.readJSON(file: filepath)
|
||||
deserialiseJson(rawmeta)
|
||||
}
|
||||
|
||||
def deserialiseJsonSlurper(String filepath) {
|
||||
File jsonfile = new File(filepath)
|
||||
def jsonfiletext = jsonfile.getText()
|
||||
def rawmeta = new JsonSlurperClassic().parseText(jsonfiletext)
|
||||
deserialiseJson(rawmeta)
|
||||
}
|
||||
|
||||
String relativize(String mypath) {
|
||||
String pathRelative
|
||||
script.echo("Seeing if ${mypath} begins with ${script.WORKSPACE}")
|
||||
if (mypath.startsWith(script.WORKSPACE)) {
|
||||
pathRelative = mypath.minus(script.WORKSPACE)
|
||||
script.echo("Extracted ${pathRelative} from ${script.WORKSPACE} and ${mypath}")
|
||||
} else {
|
||||
pathRelative = mypath
|
||||
script.echo("Path relative is unchanged: ${pathRelative}")
|
||||
}
|
||||
// Convert \ with /
|
||||
pathRelative = pathRelative.tokenize('\\').join('/')
|
||||
// Strip leading / if any
|
||||
pathRelative = pathRelative.replaceAll('^/+', '')
|
||||
|
||||
script.echo("Path relative is ${pathRelative}")
|
||||
|
||||
return pathRelative
|
||||
}
|
||||
|
||||
static String metafilepath() {
|
||||
return METAFOLDERNAME + "/" + METAFILENAME
|
||||
}
|
||||
|
||||
MetaInfo importrelated(boolean appendtoparentmeta, String destpath, String givenRepo = 'Unknown', String givenRevision = 'Unknown', String givenSHA = 'Unknown') {
|
||||
MetaInfo mi = new MetaInfo(script)
|
||||
|
||||
def String adjustedpath = relativize(destpath)
|
||||
def importedmetafile = adjustedpath + "/" + metafilepath()
|
||||
if (script.fileExists(importedmetafile)) {
|
||||
mi.deserialiseJson(importedmetafile)
|
||||
} else {
|
||||
script.echo("Could not deserialise meta at file: ${importedmetafile} (destpath: ${destpath})- Does not exist")
|
||||
mi.addConfigurationInfo('', givenRepo, givenRevision, givenSHA)
|
||||
}
|
||||
|
||||
RelatedMetaInfo rmi = new RelatedMetaInfo(script, adjustedpath, mi)
|
||||
if (appendtoparentmeta) {
|
||||
associatedmeta.add(rmi)
|
||||
}
|
||||
|
||||
return mi
|
||||
}
|
||||
|
||||
LinkedHashMap serialisationdata() {
|
||||
def data = [
|
||||
'format' : format,
|
||||
'productinfo' : productinfo.serialisationdata(),
|
||||
'gitinfo' : gitinfo.serialisationdata(),
|
||||
'jenkinsbuildinfo' : jenkinsbuildinfo.serialisationdata(),
|
||||
'buildstampinfo' : buildstampinfo.serialisationdata(),
|
||||
'releaseinfo' : releaseinfo.serialisationdata(),
|
||||
'configuration' : configurationinfoserialised(),
|
||||
'checksuminfo' : checksuminfo.serialisationdata(),
|
||||
'publishableinfo' : publishableinfoserialised(),
|
||||
'custominfo' : custominfo,
|
||||
'associatedmeta' : associatedmetaserialised(),
|
||||
]
|
||||
return data
|
||||
}
|
||||
|
||||
static String folder() {
|
||||
return METAFOLDERNAME
|
||||
}
|
||||
|
||||
String generateartifacts(ArrayList<String> releasedfromhere = new ArrayList<String>(), // These items are recorded in meta as released from here
|
||||
ArrayList<String> releasedfromsubmeta = new ArrayList<String>(), // These items are not recorded in meta as released from here
|
||||
String metafilepath ="${METAFOLDERNAME}/${METAFILENAME}"
|
||||
) {
|
||||
def String artifactlist = METAARTIFACTS
|
||||
releaseinfo.addReleaseItem(METAARTIFACTS)
|
||||
for (releaseitem in releasedfromhere) {
|
||||
artifactlist += "," + releaseitem
|
||||
releaseinfo.addReleaseItem(releaseitem)
|
||||
}
|
||||
for (releaseitem in releasedfromsubmeta) {
|
||||
artifactlist += "," + releaseitem
|
||||
}
|
||||
saveJsonSerialised(metafilepath)
|
||||
return artifactlist
|
||||
}
|
||||
|
||||
// Recurse tree of meta looking for release info and accumulate path - Pass by reference unavailable in Groovy/Java
|
||||
private ArrayList<RelatedMetaInfo> releasewalkerp(int maxdepth, ArrayList<RelatedMetaInfo> releasemetacollection, String pathsofar) {
|
||||
if (maxdepth > 0) {
|
||||
if (releaseinfo.releaserepoURL) {
|
||||
RelatedMetaInfo rmi = new RelatedMetaInfo(script, pathsofar, this)
|
||||
releasemetacollection.add(rmi)
|
||||
}
|
||||
if (pathsofar) {
|
||||
pathsofar += "/"
|
||||
}
|
||||
for (relatedmetainfo in associatedmeta) {
|
||||
MetaInfo othermeta = relatedmetainfo.meta
|
||||
String newpathsofar = pathsofar + relatedmetainfo.offsetpath
|
||||
releasemetacollection = othermeta.releasewalkerp(maxdepth - 1, releasemetacollection, newpathsofar)
|
||||
}
|
||||
}
|
||||
return releasemetacollection
|
||||
}
|
||||
|
||||
ArrayList<RelatedMetaInfo> releasewalker(int maxdepth, String startpath = "") {
|
||||
ArrayList<RelatedMetaInfo> releasemetacollection = new ArrayList<RelatedMetaInfo>()
|
||||
releasemetacollection = releasewalkerp(maxdepth, releasemetacollection, startpath)
|
||||
return releasemetacollection
|
||||
}
|
||||
|
||||
String componentidentifier() {
|
||||
return productinfo.productname + "_" + productinfo.subcomponentname
|
||||
}
|
||||
|
||||
String componentversionuniqueidentifier() {
|
||||
return componentidentifier() + "_" + buildstampinfo.buildstamp
|
||||
}
|
||||
|
||||
String globalreleasetag() {
|
||||
return componentversionuniqueidentifier() + "_" + jenkinsbuildinfo.buildnumber
|
||||
}
|
||||
|
||||
String releasetag() {
|
||||
return buildstampinfo.buildstamp + "_" + jenkinsbuildinfo.buildnumber
|
||||
}
|
||||
|
||||
String releasetagfordebpackage() {
|
||||
return buildstampinfo.buildstamp + "-" + jenkinsbuildinfo.buildnumber
|
||||
}
|
||||
|
||||
Map<String, RelatedMetaInfo> putwithshortestoffsetpath(Map<String, RelatedMetaInfo> releasemetacollection, String uniquestring, RelatedMetaInfo relatedmetainfo) {
|
||||
if (releasemetacollection.containsKey(uniquestring)) {
|
||||
def existingentry = releasemetacollection[uniquestring]
|
||||
if (existingentry.offsetpath.size() > relatedmetainfo.offsetpath.size()) {
|
||||
releasemetacollection.put(uniquestring, relatedmetainfo)
|
||||
}
|
||||
} else {
|
||||
releasemetacollection.put(uniquestring, relatedmetainfo)
|
||||
}
|
||||
return releasemetacollection
|
||||
}
|
||||
|
||||
Map<String, RelatedMetaInfo> releasewalkerunique(int maxdepth, String startpath = "") {
|
||||
def ArrayList<RelatedMetaInfo> releasemetacollection = new ArrayList<RelatedMetaInfo>()
|
||||
releasemetacollection = releasewalkerp(maxdepth, releasemetacollection, startpath)
|
||||
|
||||
def Map<String, RelatedMetaInfo> releasemetauniquecollection = new LinkedHashMap<String, RelatedMetaInfo>()
|
||||
for (relatedmetainfo in releasemetacollection) {
|
||||
def String uniquestring = relatedmetainfo.meta.componentidentifier()
|
||||
releasemetauniquecollection = putwithshortestoffsetpath(releasemetauniquecollection, uniquestring, relatedmetainfo)
|
||||
}
|
||||
|
||||
return releasemetauniquecollection
|
||||
}
|
||||
|
||||
Map<String, RelatedMetaInfo> releasewalkerversionunique(int maxdepth, String startpath = "") {
|
||||
ArrayList<RelatedMetaInfo> releasemetacollection = new ArrayList<RelatedMetaInfo>()
|
||||
releasemetacollection = releasewalkerp(maxdepth, releasemetacollection, startpath)
|
||||
|
||||
def Map<String, RelatedMetaInfo> releasemetaversionuniquecollection = new LinkedHashMap<String, RelatedMetaInfo>()
|
||||
for (relatedmetainfo in releasemetacollection) {
|
||||
def String uniquestring = relatedmetainfo.meta.componentversionuniqueidentifier()
|
||||
releasemetaversionuniquecollection = putwithshortestoffsetpath(releasemetaversionuniquecollection, uniquestring, relatedmetainfo)
|
||||
}
|
||||
|
||||
return releasemetaversionuniquecollection
|
||||
}
|
||||
|
||||
MetaInfo getNewMetaObject(script) {
|
||||
return new MetaInfo(script)
|
||||
}
|
||||
}
|
||||
|
||||
MetaInfo metareset(script) {
|
||||
echo "Resetting meta folder"
|
||||
def mi = new MetaInfo(script)
|
||||
|
||||
dir(mi.folder()) {
|
||||
deleteDir()
|
||||
}
|
||||
|
||||
return mi
|
||||
}
|
||||
|
||||
MetaInfo metafromfolder(String folder = "") {
|
||||
MetaInfo buildmeta = new MetaInfo(this)
|
||||
buildmeta.deserialiseJson("${folder}/${MetaInfo.metafilepath()}")
|
||||
return buildmeta
|
||||
}
|
||||
|
||||
MetaInfo metafromfolderSlurper(String folder = "") {
|
||||
MetaInfo buildmeta = new MetaInfo(this)
|
||||
buildmeta.deserialiseJsonSlurper("${folder}/${MetaInfo.metafilepath()}")
|
||||
return buildmeta
|
||||
}
|
||||
|
||||
return this;
|
||||
106
Common_scripts/packaging/debian.groovy
Normal file
106
Common_scripts/packaging/debian.groovy
Normal file
|
|
@ -0,0 +1,106 @@
|
|||
class DebRootDefinition {
|
||||
String ROOTPATH
|
||||
String PACKAGE_PREFIX
|
||||
String PACKAGE_FOLDER_NAME
|
||||
String PACKAGE_NAME
|
||||
String UNIQUE_PACKAGE_NAME
|
||||
|
||||
String PACKAGE_SOURCE_ROOT
|
||||
String PACKAGE_SOURCE_FOLDER_NAME
|
||||
String DEBPATH
|
||||
|
||||
String ETC
|
||||
String GIS_OPT_BIN
|
||||
String GIS_OPT_LIB
|
||||
String GIS_OPT_SCRIPTS_APP
|
||||
String GIS_OPT_SCRIPTS_EL
|
||||
String GIS_OPT_SCRIPTS_CONTROL
|
||||
String GIS_OPT_WWW
|
||||
String GIS_OPT_OTHER
|
||||
String GIS_OPT_LOGIC
|
||||
String GIS_OPT_PRINTHEAD
|
||||
|
||||
String USR_BIN
|
||||
String USR_LIB_ARCH
|
||||
String LIB_FIRMWARE
|
||||
String HTTP_DEV_DIV
|
||||
String LIB_SYSTEMD
|
||||
|
||||
DebRootDefinition(String rootpath, String packagesourceroot, String packageprefix, String buildstamp) {
|
||||
ROOTPATH = rootpath
|
||||
PACKAGE_PREFIX = packageprefix
|
||||
PACKAGE_FOLDER_NAME = packageprefix
|
||||
PACKAGE_NAME = packageprefix + "_armhf.deb"
|
||||
UNIQUE_PACKAGE_NAME = packageprefix + "_" + buildstamp + "_armhf.deb"
|
||||
|
||||
PACKAGE_SOURCE_ROOT = packagesourceroot
|
||||
PACKAGE_SOURCE_FOLDER_NAME = "${ROOTPATH}/${PACKAGE_PREFIX}"
|
||||
DEBPATH = "${ROOTPATH}/${PACKAGE_FOLDER_NAME}"
|
||||
|
||||
ETC = "${DEBPATH}/etc"
|
||||
GIS_OPT_BIN = "${DEBPATH}/opt/gis/bin"
|
||||
GIS_OPT_LIB = "${DEBPATH}/opt/gis/lib"
|
||||
GIS_OPT_SCRIPTS_APP = "${DEBPATH}/opt/gis/scripts/app"
|
||||
GIS_OPT_SCRIPTS_EL = "${DEBPATH}/opt/gis/scripts/el"
|
||||
GIS_OPT_SCRIPTS_CONTROL = "${DEBPATH}/opt/gis/scripts/control"
|
||||
GIS_OPT_WWW = "${DEBPATH}/opt/gis/www"
|
||||
GIS_OPT_OTHER = "${DEBPATH}/opt/gis/other"
|
||||
GIS_OPT_LOGIC = "${DEBPATH}/opt/gis/logic"
|
||||
GIS_OPT_PRINTHEAD = "${DEBPATH}/opt/gis/printhead"
|
||||
|
||||
USR_BIN = "${DEBPATH}/usr/bin"
|
||||
USR_LIB_ARCH = "${DEBPATH}/usr/lib/arm-linux-gnueabihf"
|
||||
LIB_FIRMWARE = "${DEBPATH}/lib/firmware"
|
||||
HTTP_DEV_DIV = "${DEBPATH}/var/www/gis_dev"
|
||||
LIB_SYSTEMD = "${DEBPATH}/lib/systemd"
|
||||
}
|
||||
}
|
||||
|
||||
def DebRootDefinition debDefinition(String rootpath, String packagesourceroot, String packageprefix, String buildstamp) {
|
||||
return new DebRootDefinition(rootpath, packagesourceroot, packageprefix, buildstamp)
|
||||
}
|
||||
|
||||
def buildPackage(String packageout, String uniquepackageout, DebRootDefinition packagedefs, String password) {
|
||||
try {
|
||||
sh """#!/bin/bash
|
||||
# Exit if any command fails
|
||||
set -xe
|
||||
|
||||
echo "${password}" | sudo -S echo
|
||||
|
||||
cp -v -r "${packagedefs.PACKAGE_SOURCE_ROOT}/${packagedefs.PACKAGE_SOURCE_FOLDER_NAME}"/* "${packagedefs.DEBPATH}"
|
||||
|
||||
sudo chmod -v -R 755 "${packagedefs.DEBPATH}"
|
||||
sudo chown -v -R root: "${packagedefs.DEBPATH}"
|
||||
|
||||
mkdir -v -p "${packageout}"
|
||||
echo "Building package:"
|
||||
dpkg-deb -v --build "${packagedefs.DEBPATH}" "${packageout}/${packagedefs.PACKAGE_NAME}"
|
||||
|
||||
mkdir -v -p "${uniquepackageout}"
|
||||
cp "${packageout}/${packagedefs.PACKAGE_NAME}" "${uniquepackageout}/${packagedefs.UNIQUE_PACKAGE_NAME}"
|
||||
|
||||
echo "Showing package:"
|
||||
dpkg-deb --show "${packageout}/${packagedefs.PACKAGE_NAME}"
|
||||
echo "Showing package contents:"
|
||||
dpkg-deb --contents "${packageout}/${packagedefs.PACKAGE_NAME}"
|
||||
|
||||
echo "Showing package lintian output:"
|
||||
lintian --suppress-tags dir-or-file-in-opt "${packageout}/${packagedefs.PACKAGE_NAME}" || true
|
||||
|
||||
sudo chown -R ${USER}: "${packagedefs.DEBPATH}"
|
||||
"""
|
||||
}
|
||||
catch (Exception e) {
|
||||
echo "Exception occurred"
|
||||
sh """#!/bin/bash -v
|
||||
echo "${password}" | sudo -S echo
|
||||
|
||||
sudo chown -R ${USER}: "${packagedefs.DEBPATH}"
|
||||
|
||||
exit 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
|
||||
return this;
|
||||
5
Common_scripts/platform/lineendings.groovy
Normal file
5
Common_scripts/platform/lineendings.groovy
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
|
||||
// Put ${nl} into strings when wanting a newline
|
||||
nl = System.properties['line.separator']
|
||||
|
||||
return this;
|
||||
9
Common_scripts/publish/.classpath
Normal file
9
Common_scripts/publish/.classpath
Normal file
|
|
@ -0,0 +1,9 @@
|
|||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<classpath>
|
||||
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
|
||||
<classpathentry excluding="publish.groovy" kind="src" path=""/>
|
||||
<classpathentry exported="true" kind="con" path="GROOVY_SUPPORT"/>
|
||||
<classpathentry exported="true" kind="con" path="GROOVY_DSL_SUPPORT"/>
|
||||
<classpathentry kind="lib" path="/home/dan/.sdkman/candidates/groovy/2.5.6/lib/groovy-json-2.5.6.jar"/>
|
||||
<classpathentry kind="output" path=""/>
|
||||
</classpath>
|
||||
7
Common_scripts/publish/.gitignore
vendored
Normal file
7
Common_scripts/publish/.gitignore
vendored
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
/do$_publish_closure4.class
|
||||
/do$_resetfolders_closure1.class
|
||||
/do$_resetfolders_closure2.class
|
||||
/do$_resetfolders_closure3.class
|
||||
/do$_stripgithistory_closure5.class
|
||||
/do.class
|
||||
/publish_item_select.class
|
||||
18
Common_scripts/publish/.project
Normal file
18
Common_scripts/publish/.project
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<projectDescription>
|
||||
<name>publish_item_select</name>
|
||||
<comment></comment>
|
||||
<projects>
|
||||
</projects>
|
||||
<buildSpec>
|
||||
<buildCommand>
|
||||
<name>org.eclipse.jdt.core.javabuilder</name>
|
||||
<arguments>
|
||||
</arguments>
|
||||
</buildCommand>
|
||||
</buildSpec>
|
||||
<natures>
|
||||
<nature>org.eclipse.jdt.groovy.core.groovyNature</nature>
|
||||
<nature>org.eclipse.jdt.core.javanature</nature>
|
||||
</natures>
|
||||
</projectDescription>
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
eclipse.preferences.version=1
|
||||
groovy.compiler.level=25
|
||||
groovy.script.filters=**/*.dsld,y,**/*.gradle,n
|
||||
174
Common_scripts/publish/do.groovy
Normal file
174
Common_scripts/publish/do.groovy
Normal file
|
|
@ -0,0 +1,174 @@
|
|||
import groovy.io.FileType
|
||||
|
||||
markunstable = false
|
||||
unstablereason = ""
|
||||
|
||||
summaryfolder = "${WORKSPACE}/summary"
|
||||
summaryfile = "${summaryfolder}/summary.txt"
|
||||
summarystring = ""
|
||||
releaserepofolder = "${WORKSPACE}/releaserepos"
|
||||
filteredreleaserepofolder = "${WORKSPACE}/filteredreleaserepos"
|
||||
|
||||
def resetfolders() {
|
||||
dir(summaryfolder) {
|
||||
deleteDir()
|
||||
}
|
||||
dir(releaserepofolder) {
|
||||
deleteDir()
|
||||
}
|
||||
dir(filteredreleaserepofolder) {
|
||||
deleteDir()
|
||||
}
|
||||
}
|
||||
|
||||
def productuniquefolder(releasemeta) {
|
||||
return "${releasemeta.productinfo.productname}_${releasemeta.productinfo.subcomponentname}"
|
||||
}
|
||||
|
||||
def uniquereleasefolder(String productline, String softwarerelease, releasemeta) {
|
||||
return "Software/${productline} ${softwarerelease}/${productuniquefolder(releasemeta)}"
|
||||
}
|
||||
|
||||
def uniqueabsoluterreleasefolder(String productline, String releaserepofolder, String softwarerelease, releasemeta) {
|
||||
return "${releaserepofolder}/${uniquereleasefolder(productline, softwarerelease, releasemeta)}"
|
||||
}
|
||||
|
||||
def preconditions() {
|
||||
markunstable = false
|
||||
unstablereason = ""
|
||||
summarystring = ""
|
||||
writeFile(file: summaryfile, text: "Publish summary: \n")
|
||||
}
|
||||
|
||||
def setunstable(String reason) {
|
||||
markunstable = true
|
||||
unstablereason = reason
|
||||
}
|
||||
|
||||
def summaryappend(String summary) {
|
||||
def String currentsummarycontents = readFile(file: summaryfile)
|
||||
writeFile(file: summaryfile, text: currentsummarycontents + summary)
|
||||
summarystring += summary
|
||||
}
|
||||
|
||||
def guessreporootsuffix(componentURL) {
|
||||
def guess = componentURL.replaceFirst(/.*\/(.*).git/, '$1')
|
||||
return guess
|
||||
}
|
||||
|
||||
gh = load("${autobuilder.commonscripts()}/versioncontrol/git.groovy")
|
||||
def getcomponentartifacts(releaseinfo, String repofolder, itempathstopublish) {
|
||||
summaryappend("Artifacts: ")
|
||||
|
||||
def releasemeta = releaseinfo.meta
|
||||
def String componentURL = releasemeta.releaseinfo.releaserepoURL
|
||||
def String revision = "refs/tags/${releasemeta.buildstampinfo.buildstamp}_${releasemeta.jenkinsbuildinfo.buildnumber}"
|
||||
def publishableitems = releasemeta.publishableinfo
|
||||
|
||||
def ArrayList<String> publishablepaths = new ArrayList<String>()
|
||||
if (publishableitems.size() > 0) {
|
||||
for (publishableitem in publishableitems) {
|
||||
def String productuniquepublishableitem = "${productuniquefolder(releasemeta)}/${publishableitem.filepath}"
|
||||
echo "publishableitem: ${productuniquepublishableitem}"
|
||||
if (itempathstopublish.size() == 0 || productuniquepublishableitem in itempathstopublish) {
|
||||
publishablepaths.add(publishableitem.filepath)
|
||||
summaryappend("${publishableitem.filepath},")
|
||||
}
|
||||
}
|
||||
}
|
||||
if (publishablepaths.size() > 0) {
|
||||
def reporootsuffix = guessreporootsuffix(componentURL)
|
||||
gh.gitCheckoutAlt(componentURL, revision, repofolder, reporootsuffix, 1, true, publishablepaths) // Shallow clone
|
||||
}
|
||||
else {
|
||||
summaryappend("None ")
|
||||
}
|
||||
}
|
||||
|
||||
def publish(hostedftpsiteinfo, String customer, String finalreleaserepofolder = releaserepofolder) {
|
||||
summaryappend(" FTP operations: ")
|
||||
|
||||
def String ftproot = "${hostedftpsiteinfo.workingdirectory}${customer}"
|
||||
dir(finalreleaserepofolder) {
|
||||
summaryappend("FTP operations: Transferring to ${ftproot}")
|
||||
sh """#!/bin/bash
|
||||
ncftpput -u ${hostedftpsiteinfo.username} -p ${hostedftpsiteinfo.password} -R ${hostedftpsiteinfo.url} "${ftproot}" .
|
||||
"""
|
||||
summaryappend(", Transferred ")
|
||||
}
|
||||
}
|
||||
|
||||
def copydirectory(File dirFrom, File dirTo) {
|
||||
if (!dirTo.exists()) {
|
||||
dirTo.mkdirs();
|
||||
}
|
||||
dirFrom.eachFile(FileType.FILES) { File source ->
|
||||
File target = new File(dirTo, source.getName())
|
||||
target.bytes = source.bytes
|
||||
}
|
||||
dirFrom.eachFile(FileType.DIRECTORIES) { File source ->
|
||||
File target = new File(dirTo, source.getName())
|
||||
copyLargeDir(source, target)
|
||||
}
|
||||
}
|
||||
|
||||
def recallcomponent(String productline, releaseinfo, String softwarerelease, itempathstopublish) {
|
||||
def releasemeta = releaseinfo.meta
|
||||
def String uniquefolderforrepo = uniqueabsoluterreleasefolder(productline, releaserepofolder, softwarerelease, releasemeta)
|
||||
|
||||
summaryappend("${releasemeta.productinfo.productname} ${releasemeta.productinfo.subcomponentname}: ")
|
||||
|
||||
getcomponentartifacts(releaseinfo, uniquefolderforrepo, itempathstopublish)
|
||||
|
||||
summaryappend("\n")
|
||||
}
|
||||
|
||||
def convertitemstopublish(String itemstopublishstring) {
|
||||
def List paths = []
|
||||
|
||||
def String[] items = itemstopublishstring.split(',')
|
||||
def String allpaths = ""
|
||||
for(String item : items) {
|
||||
def String[] pathitems = item.split('#')
|
||||
def String path = "${pathitems[0]}_${pathitems[1]}/${pathitems[2]}"
|
||||
paths.add(path)
|
||||
allpaths += "${path}\n"
|
||||
}
|
||||
echo "Selected item to publish:\n${allpaths}"
|
||||
return paths
|
||||
}
|
||||
|
||||
// Publish selected items from a release to the customer folder on the ftp site
|
||||
// itemstopublishstring is a comma-seperated set of strings in this format <ProductName>#<ComponentName>#<PathToPublishableItem>
|
||||
def publishhierarchy(hostedftpsiteinfo, releasemeta, String itemstopublishstring, String customer, String softwarerelease, String maxdepth) {
|
||||
int md = maxdepth.toInteger()
|
||||
resetfolders()
|
||||
preconditions()
|
||||
|
||||
def productline = releasemeta.productinfo.productname
|
||||
// Walk the meta information to a max depth, looking for artifacts to publish
|
||||
def componentReleaseInfoVersionUnique = releasemeta.releasewalkerversionunique(md)
|
||||
|
||||
echo "Version unique components:"
|
||||
def String versionuniquecomponent = ""
|
||||
for (key in componentReleaseInfoVersionUnique.keySet()) {
|
||||
versionuniquecomponent += "${key}\n"
|
||||
}
|
||||
echo versionuniquecomponent
|
||||
|
||||
def itempathstopublish = convertitemstopublish(itemstopublishstring)
|
||||
for (key in componentReleaseInfoVersionUnique.keySet()) {
|
||||
def releaseinfo = componentReleaseInfoVersionUnique[key]
|
||||
recallcomponent(productline, releaseinfo, softwarerelease, itempathstopublish)
|
||||
}
|
||||
gh.stripgithistory(releaserepofolder)
|
||||
publish(hostedftpsiteinfo, customer)
|
||||
|
||||
return [summarystring, markunstable, unstablereason]
|
||||
}
|
||||
|
||||
def publishhierarchy(hostedftpsiteinfo, releasemeta, String customer, String softwarerelease, String maxdepth) {
|
||||
return publishhierarchy(hostedftpsiteinfo, releasemeta, "", customer, softwarerelease, maxdepth)
|
||||
}
|
||||
|
||||
return this;
|
||||
176
Common_scripts/publish/package.groovy
Normal file
176
Common_scripts/publish/package.groovy
Normal file
|
|
@ -0,0 +1,176 @@
|
|||
pipeline {
|
||||
agent { label "${AGENT_LABEL}" }
|
||||
stages {
|
||||
stage('Initial setup') {
|
||||
steps {
|
||||
script {
|
||||
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout dependencies') {
|
||||
steps {
|
||||
script {
|
||||
configurationhelper = autobuilder.configurationhelper()
|
||||
|
||||
PYTHONURL = 'git@hydra:tools/python.git'
|
||||
if (isUnix()) {
|
||||
PYTHONBRANCH = "origin/3.6.3_linux"
|
||||
}
|
||||
else {
|
||||
PYTHONBRANCH = "origin/3.6.3_windows"
|
||||
}
|
||||
PYTHONDIR = "${WORKSPACE}/python"
|
||||
PYTHONROOTDIR = 'python'
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR, PYTHONROOTDIR)
|
||||
if (isUnix()) {
|
||||
env.PYTHON = "${PYTHONDIR}/usr/local/bin/python3"
|
||||
}
|
||||
else {
|
||||
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Clean exports') {
|
||||
steps {
|
||||
script {
|
||||
PACKAGEDEST = "${WORKSPACE}/package"
|
||||
cleanfolders = [
|
||||
PACKAGEDEST,
|
||||
]
|
||||
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
|
||||
cleaner.clean(cleanfolders)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Copying package artifacts') {
|
||||
steps {
|
||||
script {
|
||||
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
|
||||
packagemeta = importer.artifactimport(meta, PACKAGE_CREATE_JOB, PACKAGE_CREATE_JOB_SELECTOR, PACKAGEDEST)
|
||||
PACKAGE_FOLDER = "${PACKAGEDEST}/package"
|
||||
UNIQUE_PACKAGE_FOLDER = "${PACKAGEDEST}/uniquepackage"
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Aptly environment') {
|
||||
steps {
|
||||
script {
|
||||
echo "Aptly config file is ${APTLY_CONFIG_FILE}"
|
||||
sh """#!/bin/bash -v
|
||||
aptly config show
|
||||
if [ \$? -ne 0 ]; then exit 1; fi
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Create repo - if not already there') {
|
||||
steps {
|
||||
script {
|
||||
echo "Repo name is ${REPO_NAME}"
|
||||
sh """#!/bin/bash -v
|
||||
aptly repo -config="${APTLY_CONFIG_FILE}" -with-packages show "${REPO_NAME}"
|
||||
if [ \$? -ne 0 ]; then
|
||||
echo "aptly repo ${REPO_NAME} does not exist; Creating it"
|
||||
aptly repo -config="${APTLY_CONFIG_FILE}" create "${REPO_NAME}"
|
||||
if [ \$? -ne 0 ]; then exit 1; fi
|
||||
fi
|
||||
aptly repo -config="${APTLY_CONFIG_FILE}" -with-packages show "${REPO_NAME}"
|
||||
if [ \$? -ne 0 ]; then exit 1; fi
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Drop published repo - if any') {
|
||||
steps {
|
||||
script {
|
||||
sh """#!/bin/bash -v
|
||||
# This errors if the published repo exists already; Ignore it
|
||||
aptly publish -config="${APTLY_CONFIG_FILE}" drop "${DISTRIBUTION}" "${PUBLISH_PATH_PREFIX}"
|
||||
aptly publish -config="${APTLY_CONFIG_FILE}" list
|
||||
if [ \$? -ne 0 ]; then exit 1; fi
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
stage('Add/update package in repo') {
|
||||
steps {
|
||||
script {
|
||||
echo "Unique package folder is ${UNIQUE_PACKAGE_FOLDER}"
|
||||
sh """#!/bin/bash -v
|
||||
aptly repo -config="${APTLY_CONFIG_FILE}" add "${REPO_NAME}" "${UNIQUE_PACKAGE_FOLDER}"
|
||||
if [ \$? -ne 0 ]; then exit 1; fi
|
||||
aptly repo -config="${APTLY_CONFIG_FILE}" show -with-packages "${REPO_NAME}"
|
||||
if [ \$? -ne 0 ]; then exit 1; fi
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Create snapshot') {
|
||||
steps {
|
||||
script {
|
||||
echo "Snapshot name is ${SNAPSHOT_NAME}"
|
||||
FULL_SNAPSHOT_NAME = "${REPO_NAME}_${SNAPSHOT_NAME}"
|
||||
PACKAGE_VERSION_PREFIX = packagemeta.buildstampinfo.buildstampprefix
|
||||
echo "Full Snapshot name is ${FULL_SNAPSHOT_NAME} containing packages of versions beginning with: ${PACKAGE_VERSION_PREFIX}"
|
||||
// Convert prefix to regular expression
|
||||
PACKAGE_VERSION_PREFIX_SPLIT = PACKAGE_VERSION_PREFIX.split("[.]")
|
||||
PACKAGE_VERSION_REGEX = ''
|
||||
i = 0
|
||||
while(true) {
|
||||
if (i == PACKAGE_VERSION_PREFIX_SPLIT.size() - 1) {
|
||||
PACKAGE_VERSION_REGEX += PACKAGE_VERSION_PREFIX_SPLIT[i]
|
||||
break;
|
||||
}
|
||||
PACKAGE_VERSION_REGEX += PACKAGE_VERSION_PREFIX_SPLIT[i]
|
||||
PACKAGE_VERSION_REGEX += '\\.'
|
||||
i++
|
||||
}
|
||||
sh """#!/bin/bash -v
|
||||
# This errors if the snapshot exists already; Ignore it
|
||||
aptly snapshot -config="${APTLY_CONFIG_FILE}" drop "${FULL_SNAPSHOT_NAME}"
|
||||
aptly snapshot -config="${APTLY_CONFIG_FILE}" drop "All_${FULL_SNAPSHOT_NAME}"
|
||||
aptly snapshot -config="${APTLY_CONFIG_FILE}" create "All_${FULL_SNAPSHOT_NAME}" from repo "${REPO_NAME}"
|
||||
if [ \$? -ne 0 ]; then exit 1; fi
|
||||
|
||||
aptly snapshot filter -config="/home/repos/gis-aptly-config/gis.conf" "All_${FULL_SNAPSHOT_NAME}" "${FULL_SNAPSHOT_NAME}" 'Version (~ .*${PACKAGE_VERSION_REGEX}.*)'
|
||||
if [ \$? -ne 0 ]; then exit 1; fi
|
||||
aptly snapshot -config="${APTLY_CONFIG_FILE}" -with-packages show "${FULL_SNAPSHOT_NAME}"
|
||||
if [ \$? -ne 0 ]; then exit 1; fi
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Publish snapshot') {
|
||||
steps {
|
||||
script {
|
||||
sh """#!/bin/bash -v
|
||||
aptly publish -config="${APTLY_CONFIG_FILE}" -distribution="${DISTRIBUTION}" -component="${COMPONENT}" -gpg-key="${GPG_KEY_ID}" snapshot "${FULL_SNAPSHOT_NAME}" "${PUBLISH_PATH_PREFIX}"
|
||||
if [ \$? -ne 0 ]; then exit 1; fi
|
||||
aptly publish -config="${APTLY_CONFIG_FILE}" list
|
||||
if [ \$? -ne 0 ]; then exit 1; fi
|
||||
aptly publish -config="${APTLY_CONFIG_FILE}" show "${DISTRIBUTION}" "${PUBLISH_PATH_PREFIX}"
|
||||
if [ \$? -ne 0 ]; then exit 1; fi
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
179
Common_scripts/publish/promptingpublish.groovy
Normal file
179
Common_scripts/publish/promptingpublish.groovy
Normal file
|
|
@ -0,0 +1,179 @@
|
|||
pipeline {
|
||||
agent { label "${AGENT_LABEL}" }
|
||||
stages {
|
||||
stage('Initial setup') {
|
||||
steps {
|
||||
script {
|
||||
autobuilderscript = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy")
|
||||
meta = autobuilderscript.startnonbuild(this)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Clean folders') {
|
||||
steps {
|
||||
script {
|
||||
cleanfolders = [
|
||||
]
|
||||
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
|
||||
cleaner.clean(cleanfolders)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout release repo') {
|
||||
steps {
|
||||
script {
|
||||
configurationhelper = autobuilder.configurationhelper()
|
||||
|
||||
SOURCEURL = RELEASE_REPO
|
||||
SOURCEREVISION = "origin/master"
|
||||
SOURCEDIR = "${WORKSPACE}/whole"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'whole', SOURCEURL, SOURCEREVISION, SOURCEDIR, '', 0, false)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Identify customer to publish to') {
|
||||
steps {
|
||||
script {
|
||||
hostedftb = load("${autobuilder.commonscripts()}/remoteaccess/hostedftp.groovy")
|
||||
def List<String> customers = hostedftb.getCustomerList()
|
||||
timeout(time: 10, unit: 'MINUTES') {
|
||||
customer = input(
|
||||
message: 'Please select customer to publish to',
|
||||
ok: 'Ok',
|
||||
parameters: [
|
||||
choice(name: 'customer', choices: customers, description: 'Which customer?')
|
||||
]
|
||||
)
|
||||
echo "Chosen customer is: ${customer}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Identify software release to publish') {
|
||||
steps {
|
||||
script {
|
||||
gh = load("${autobuilder.commonscripts()}/versioncontrol/git.groovy")
|
||||
def allreleases = gh.gettaglist(SOURCEDIR)
|
||||
def releases = new ArrayList<String>()
|
||||
if (FILTER_REDUNDANT_RELEASES == 'false') {
|
||||
echo("Showing all releases")
|
||||
releases = allreleases
|
||||
} else {
|
||||
echo("Showing filtered releases")
|
||||
for (release in allreleases) {
|
||||
if (!release.toLowerCase().startsWith("superceded") &&
|
||||
!release.toLowerCase().startsWith("erroneous") &&
|
||||
!release.toLowerCase().startsWith("faulty") &&
|
||||
!release.toLowerCase().startsWith("ignore") &&
|
||||
!release.toLowerCase().startsWith("inmainline")) {
|
||||
echo("Showing release: ${release}")
|
||||
releases.add(release)
|
||||
} else {
|
||||
echo("Not showing release: ${release}")
|
||||
}
|
||||
}
|
||||
}
|
||||
timeout(time: 10, unit: 'MINUTES') {
|
||||
release = input(
|
||||
message: 'Please select the software version',
|
||||
ok: 'Ok',
|
||||
parameters: [
|
||||
choice(name: 'release', choices: releases, description: 'Which software release?')
|
||||
]
|
||||
)
|
||||
echo "Chosen software version is: ${release}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout release repo at selected software version') {
|
||||
steps {
|
||||
script {
|
||||
SOURCEURL = RELEASE_REPO
|
||||
SOURCEREVISION = "refs/tags/${release}"
|
||||
SOURCEDIR = "${WORKSPACE}/whole"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'whole', SOURCEURL, SOURCEREVISION, SOURCEDIR, '', 0, false)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Get release artifact info') {
|
||||
steps {
|
||||
script {
|
||||
def mfs = autobuilderscript.getmetafolderscript()
|
||||
releasemeta = mfs.metafromfolder(SOURCEDIR)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Select which items from software release to publish') {
|
||||
steps {
|
||||
script {
|
||||
publishitems = load("${autobuilder.commonscripts()}/publish/publishitems.groovy")
|
||||
timeout(time: 10, unit: 'MINUTES') {
|
||||
def itemsobject = publishitems.createItemSelector(
|
||||
'Select software items',
|
||||
'Software items',
|
||||
releasemeta,
|
||||
ITEMSDEFAULTLIST,
|
||||
MAX_META_DEPTH,
|
||||
'20',
|
||||
'PT_MULTI_SELECT')
|
||||
selecteditems = input(
|
||||
message: 'Select which items from the release are to be published',
|
||||
ok: 'Ok',
|
||||
parameters: [
|
||||
itemsobject.multiSelect()
|
||||
]
|
||||
)
|
||||
echo "Chosen items are: ${selecteditems}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Publish components') {
|
||||
steps {
|
||||
script {
|
||||
def publisher = load("${autobuilder.commonscripts()}/publish/do.groovy")
|
||||
def hostedftpsiteinfo = hostedftb.getHostedFTPSiteInfo()
|
||||
(summarystring, markunstable, unstablereason) = publisher.publishhierarchy(hostedftpsiteinfo, releasemeta, selecteditems, customer, release, MAX_META_DEPTH)
|
||||
if (markunstable) {
|
||||
env.unstablereason = unstablereason
|
||||
currentBuild.result = 'UNSTABLE'
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Archiving artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def artifactlist = meta.generateartifacts()
|
||||
archiveArtifacts "summary/**,${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Summarise') {
|
||||
steps {
|
||||
script {
|
||||
echo "Summary:\n${summarystring}\n"
|
||||
if (env.unstablereason) {
|
||||
echo "Instability reason: ${env.unstablereason}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
91
Common_scripts/publish/publish.groovy
Normal file
91
Common_scripts/publish/publish.groovy
Normal file
|
|
@ -0,0 +1,91 @@
|
|||
pipeline {
|
||||
agent { label "${AGENT_LABEL}" }
|
||||
stages {
|
||||
stage('Initial setup') {
|
||||
steps {
|
||||
script {
|
||||
autobuilderscript = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy")
|
||||
meta = autobuilderscript.startbuild(this, PRODUCT_NAME, SUBCOMPONENT_NAME, RELEASE_REPO)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Clean folders') {
|
||||
steps {
|
||||
script {
|
||||
cleanfolders = [
|
||||
]
|
||||
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
|
||||
cleaner.clean(cleanfolders)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout release repo') {
|
||||
steps {
|
||||
script {
|
||||
configurationhelper = autobuilder.configurationhelper()
|
||||
|
||||
SOURCEURL = RELEASE_REPO
|
||||
SOURCEREVISION = "refs/tags/${SOFTWARE_RELEASE}"
|
||||
SOURCEDIR = "${WORKSPACE}/whole"
|
||||
SOURCEROOTDIR = 'whole'
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'whole', SOURCEURL, SOURCEREVISION, SOURCEDIR, SOURCEROOTDIR, 0, false)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Get release artifact meta') {
|
||||
steps {
|
||||
script {
|
||||
def mfs = autobuilderscript.getmetafolderscript()
|
||||
releasemeta = mfs.metafromfolder(SOURCEDIR)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Publish components') {
|
||||
steps {
|
||||
script {
|
||||
def publisher = load("${autobuilder.commonscripts()}/publish/do.groovy")
|
||||
def hostedftb = load("${autobuilder.commonscripts()}/remoteaccess/hostedftp.groovy")
|
||||
def hostedftpsiteinfo = hostedftb.getHostedFTPSiteInfo()
|
||||
(summarystring, markunstable, unstablereason) = publisher.publishhierarchy(hostedftpsiteinfo, releasemeta, ITEMS_TO_PUBLISH, CUSTOMER, SOFTWARE_RELEASE, MAX_META_DEPTH)
|
||||
if (markunstable) {
|
||||
env.unstablereason = unstablereason
|
||||
currentBuild.result = 'UNSTABLE'
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Archiving artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def artifactlist = meta.generateartifacts()
|
||||
archiveArtifacts "summary/**,${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Summarise') {
|
||||
steps {
|
||||
script {
|
||||
echo "Summary:\n${summarystring}\n"
|
||||
if (env.unstablereason) {
|
||||
echo "Instability reason: ${env.unstablereason}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
127
Common_scripts/publish/publishitems.groovy
Normal file
127
Common_scripts/publish/publishitems.groovy
Normal file
|
|
@ -0,0 +1,127 @@
|
|||
import com.cwctravel.hudson.plugins.extended_choice_parameter.ExtendedChoiceParameterDefinition
|
||||
|
||||
class PublishableItemsSelection {
|
||||
def script
|
||||
def ArrayList<String> preselectedmenuitems
|
||||
def ArrayList<String> menuitemdescriptions
|
||||
def ArrayList<String> menuitemsfull
|
||||
def ExtendedChoiceParameterDefinition multiselect
|
||||
|
||||
PublishableItemsSelection(script) {
|
||||
this.script = script
|
||||
preselectedmenuitems = new ArrayList<String>()
|
||||
menuitemdescriptions = new ArrayList<String>()
|
||||
menuitemsfull = new ArrayList<String>()
|
||||
}
|
||||
|
||||
def init(
|
||||
String name,
|
||||
String description,
|
||||
releasemeta,
|
||||
String preselectedext,
|
||||
String metalevelsstringext,
|
||||
String visibleItemCountExt,
|
||||
String controltype) {
|
||||
outputSelectionfromPreselect(preselectedmenuitems, preselectedext)
|
||||
def Integer metalevelsext = metalevelsstringext.toInteger()
|
||||
def Integer visibleItemCount = visibleItemCountExt.toInteger()
|
||||
def metaitems = releasemeta.releasewalkerunique(metalevelsext)
|
||||
for (key in metaitems.keySet()) {
|
||||
def releaseinfo = metaitems[key]
|
||||
outputDescription(menuitemdescriptions, releaseinfo)
|
||||
outputSelection(menuitemsfull, releaseinfo)
|
||||
}
|
||||
|
||||
script.echo("name is: ${name}")
|
||||
script.echo("description is: ${description}")
|
||||
script.echo("menuitemsfull is: ${menuitemsfull}")
|
||||
script.echo("preselectedmenuitems is: ${preselectedmenuitems}")
|
||||
script.echo("menuitemdescriptions is: ${menuitemdescriptions}")
|
||||
script.echo("visibleItemCount is: ${visibleItemCount}")
|
||||
script.echo("controltype is: ${controltype}")
|
||||
|
||||
def seperator = ","
|
||||
visibleItemCount = Math.min(visibleItemCount, menuitemsfull.size())
|
||||
script.echo("visibleItemCount is now: ${visibleItemCount}")
|
||||
|
||||
multiselect = new ExtendedChoiceParameterDefinition(
|
||||
name, // String name
|
||||
controltype, // String type
|
||||
menuitemsfull.join(seperator), // String value
|
||||
"project name", // String projectName
|
||||
"", // String propertyFile
|
||||
"", // String groovyScript
|
||||
"", // String groovyScriptFile
|
||||
"", // String bindings
|
||||
"", // String groovyClasspath
|
||||
"", // String propertyKey
|
||||
preselectedmenuitems.join(seperator),// String defaultValue
|
||||
"", // String defaultPropertyFile
|
||||
"", // String defaultGroovyScript
|
||||
"", // String defaultGroovyScriptFile
|
||||
"", // String defaultBindings
|
||||
"", // String defaultGroovyClasspath
|
||||
"", // String defaultPropertyKey
|
||||
menuitemdescriptions.join(seperator),// String descriptionPropertyValue
|
||||
"", // String descriptionPropertyFile
|
||||
"", // String descriptionGroovyScript
|
||||
"", // String descriptionGroovyScriptFile
|
||||
"", // String descriptionBindings
|
||||
"", // String descriptionGroovyClasspath
|
||||
"", // String descriptionPropertyKey
|
||||
"", // String javascriptFile
|
||||
"", // String javascript
|
||||
false, // boolean saveJSONParameterToFile
|
||||
false, // boolean quoteValue
|
||||
visibleItemCount, // int visibleItemCount
|
||||
description, // String description
|
||||
seperator) // String multiSelectDelimiter
|
||||
}
|
||||
|
||||
def outputSelectionfromPreselect(menuitems, preselectedext) {
|
||||
script.echo ("preselectext: ${preselectedext}")
|
||||
def menuitemstemp = preselectedext.split(',')
|
||||
script.echo ("Menuitemstemp: ${menuitemstemp}")
|
||||
|
||||
for (menuitem in menuitemstemp) {
|
||||
menuitems.add(menuitem.trim())
|
||||
}
|
||||
}
|
||||
|
||||
def outputDescription(menuitems, releaseinfo) {
|
||||
def meta = releaseinfo.meta
|
||||
|
||||
for (publishableitem in meta.publishableinfo) {
|
||||
menuitems.add("${meta.productinfo.productname} ${meta.productinfo.subcomponentname} ${publishableitem.filepath}")
|
||||
}
|
||||
}
|
||||
|
||||
def outputSelection(menuitems, releaseinfo) {
|
||||
def meta = releaseinfo.meta
|
||||
|
||||
for (publishableitem in meta.publishableinfo) {
|
||||
menuitems.add("${meta.productinfo.productname}#${meta.productinfo.subcomponentname}#${publishableitem.filepath}")
|
||||
}
|
||||
}
|
||||
|
||||
def multiSelect() {
|
||||
return multiselect
|
||||
}
|
||||
}
|
||||
|
||||
PublishableItemsSelection createItemSelector(
|
||||
String name,
|
||||
String description,
|
||||
releasemeta,
|
||||
String preselectedext,
|
||||
String metalevelsstringext,
|
||||
String visibleItemCountExt = '20',
|
||||
String type = 'PT_CHECKBOX') { // Could also be "PT_MULTI_SELECT"
|
||||
PublishableItemsSelection pis = new PublishableItemsSelection(this)
|
||||
|
||||
pis.init(name, description, releasemeta, preselectedext, metalevelsstringext, visibleItemCountExt, type)
|
||||
|
||||
return pis
|
||||
}
|
||||
|
||||
return this;
|
||||
27
Common_scripts/publishing/utils.groovy
Normal file
27
Common_scripts/publishing/utils.groovy
Normal file
|
|
@ -0,0 +1,27 @@
|
|||
|
||||
|
||||
// The filepath must end in "<folder>/**" or "<folder>/" - Glob wildcard - as a git sparse checkout
|
||||
def allowed(String filepath) {
|
||||
if (filepath.endsWith('/**') || filepath.endsWith('/')) {
|
||||
def files = findFiles glob: filepath
|
||||
if (files.length > 0) {
|
||||
return
|
||||
} else {
|
||||
error "There are no files/folders under the publishable item: ${filepath}"
|
||||
}
|
||||
}
|
||||
error "The publishable item: ${filepath} does not end in <folder>/** or <folder>/ (for git sparse checkouts)"
|
||||
}
|
||||
|
||||
// Generate a list of artifact files that are publishable to outside parties
|
||||
def generatelist(meta, publishable) {
|
||||
filelist = []
|
||||
for (filepath in publishable) {
|
||||
if (filepath != meta.METAARTIFACTS) {
|
||||
allowed(filepath)
|
||||
}
|
||||
meta.addPublishable(filepath)
|
||||
}
|
||||
}
|
||||
|
||||
return this;
|
||||
439
Common_scripts/release/do.groovy
Normal file
439
Common_scripts/release/do.groovy
Normal file
|
|
@ -0,0 +1,439 @@
|
|||
markunstable = false
|
||||
unstablereason = ""
|
||||
|
||||
summaryfolder = "${WORKSPACE}/summary"
|
||||
summaryfile = "${summaryfolder}/summary.txt"
|
||||
summarystring = ""
|
||||
repoandtagsfile = "${summaryfolder}/repoandtags.txt"
|
||||
repoandtagsstring = ""
|
||||
releaserepofolder = "${WORKSPACE}/releaserepos"
|
||||
sourcerepofolder = "${WORKSPACE}/sourcerepos"
|
||||
tempfolder = "${WORKSPACE}/temp"
|
||||
gitrevparseoutputfile = "${tempfolder}/gitrevparse.out"
|
||||
|
||||
metascript = autobuilder.getmetafolderscript()
|
||||
|
||||
def resetfolders() {
|
||||
dir(summaryfolder) {
|
||||
deleteDir()
|
||||
}
|
||||
dir(releaserepofolder) {
|
||||
deleteDir()
|
||||
}
|
||||
dir(tempfolder) {
|
||||
deleteDir()
|
||||
}
|
||||
}
|
||||
|
||||
def preconditions() {
|
||||
markunstable = false
|
||||
unstablereason = ""
|
||||
summarystring = ""
|
||||
writeFile(file: summaryfile, text: "Release summary: \n")
|
||||
repoandtagsstring = ""
|
||||
writeFile(file: repoandtagsfile, text: "Repository summary: \n")
|
||||
}
|
||||
|
||||
def setunstable(String reason) {
|
||||
markunstable = true
|
||||
unstablereason += reason + "\n"
|
||||
echo "Marked build as unstable: Reason: ${reason}"
|
||||
}
|
||||
|
||||
def summaryappend(String summary) {
|
||||
def String currentsummarycontents = readFile(file: summaryfile)
|
||||
writeFile(file: summaryfile, text: currentsummarycontents + summary)
|
||||
summarystring += summary
|
||||
}
|
||||
|
||||
def repoandtagsappend(String summary) {
|
||||
def String repoandtagscontents = readFile(file: repoandtagsfile)
|
||||
writeFile(file: repoandtagsfile, text: repoandtagscontents + summary)
|
||||
repoandtagsstring += summary
|
||||
}
|
||||
|
||||
def getpreviousreleasemeta(buildmeta, String checkoutfolder) {
|
||||
def previousreleasemeta = buildmeta.getNewMetaObject(this)
|
||||
// See if there is meta data file from the current release
|
||||
def String releasemetafolderpath = "${checkoutfolder}/${buildmeta.folder()}"
|
||||
if (fileExists(releasemetafolderpath)) {
|
||||
previousreleasemeta = metascript.metafromfolder(checkoutfolder)
|
||||
}
|
||||
return previousreleasemeta
|
||||
}
|
||||
|
||||
def checkoutreleaserepo(buildmeta, String checkoutfolder) {
|
||||
def String releaserepo = buildmeta.releaseinfo.releaserepoURL
|
||||
// Get the latest head revision of the release repo without checking out working copy; Check out to a folder unique to component; Extract any meta
|
||||
repoandtagsappend(" Release repo: ${releaserepo}")
|
||||
def previousreleasemeta = buildmeta.getNewMetaObject(this)
|
||||
dir(releaserepofolder) {
|
||||
sh("git clone ${releaserepo} ${checkoutfolder}")
|
||||
}
|
||||
previousreleasemeta = getpreviousreleasemeta(buildmeta, checkoutfolder)
|
||||
dir(checkoutfolder) {
|
||||
// Clear all existing files - Note that this does not remove .git*
|
||||
sh("git rm -r *")
|
||||
}
|
||||
return previousreleasemeta
|
||||
}
|
||||
|
||||
def checkoutsourcerepo(buildmeta, String checkoutfolder) {
|
||||
def String sourcerepo = buildmeta.gitinfo.remoteurl
|
||||
if (sourcerepo) {
|
||||
repoandtagsappend(" Source repo: ${sourcerepo}")
|
||||
// Get the latest revision of the source repo without checking out working copy; Check out to a folder unique to component
|
||||
if (fileExists(checkoutfolder)) {
|
||||
dir(checkoutfolder) {
|
||||
sh("""
|
||||
git reset --hard
|
||||
git clean -fdx
|
||||
git pull
|
||||
# Remove all tags that are not already on the remote
|
||||
git tag -l | xargs git tag -d >/dev/null
|
||||
git fetch -t >/dev/null
|
||||
"""
|
||||
)
|
||||
}
|
||||
}
|
||||
else {
|
||||
dir(sourcerepofolder) {
|
||||
sh("git clone ${sourcerepo} ${checkoutfolder}")
|
||||
}
|
||||
}
|
||||
} else {
|
||||
repoandtagsappend(" Source repo: None")
|
||||
}
|
||||
}
|
||||
|
||||
def boolean getcomponentartifacts(toplevelbuildmeta, buildinfo, String repofolder, String tempfolder) {
|
||||
// Copy relevant artifacts to temp folder
|
||||
summaryappend("Artifacts: ")
|
||||
def boolean result = true
|
||||
for (artifactfilter in buildinfo.meta.releaseinfo.releaseitems) {
|
||||
def filterpath = artifactfilter
|
||||
if (buildinfo.offsetpath) {
|
||||
filterpath = buildinfo.offsetpath + '/' + artifactfilter
|
||||
}
|
||||
// Copy relevant artifacts to temp folder
|
||||
echo "Copying artifacts: ${filterpath} to ${tempfolder}"
|
||||
try {
|
||||
copyArtifacts(
|
||||
filter: filterpath,
|
||||
projectName: toplevelbuildmeta.jenkinsbuildinfo.buildjobname,
|
||||
selector: [
|
||||
$class: 'ParameterizedBuildSelector',
|
||||
parameterName: "<SpecificBuildSelector plugin='copyartifact@1.41'><buildNumber>${toplevelbuildmeta.jenkinsbuildinfo.buildnumber}</buildNumber></SpecificBuildSelector>"
|
||||
],
|
||||
target: tempfolder
|
||||
)
|
||||
} catch (Exception e) {
|
||||
echo "Exception occurred while copying artifacts from ${toplevelbuildmeta.jenkinsbuildinfo.buildjobname}: ${e.getMessage()}"
|
||||
result = false
|
||||
summaryappend("Does not exist:")
|
||||
}
|
||||
if (result) {
|
||||
// Move relevant artifacts from temp folder to release position
|
||||
def originalrootdir = tempfolder + "/" + buildinfo.offsetpath
|
||||
dir(originalrootdir) {
|
||||
sh("mv * ${repofolder}")
|
||||
}
|
||||
}
|
||||
summaryappend("${artifactfilter},")
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
def releasegitadd() {
|
||||
// Add anything new
|
||||
sh("git add .")
|
||||
summaryappend("Add,")
|
||||
}
|
||||
|
||||
def releasegitreset() {
|
||||
// Add anything new
|
||||
sh("git reset --hard")
|
||||
sh("git clean -fdx")
|
||||
summaryappend("Reset,")
|
||||
}
|
||||
|
||||
def releasegitcommit(String buildstamp) {
|
||||
sh("git commit -a -m ${buildstamp}")
|
||||
summaryappend("Commit,")
|
||||
}
|
||||
|
||||
// Determine if there has been a change by comparing the sha code in previous release meta and the build meta
|
||||
def boolean checkforchange(buildmeta, previousreleasemeta) {
|
||||
String buildsha = buildmeta.gitinfo.gitrevision
|
||||
String previoussha = previousreleasemeta.gitinfo.gitrevision
|
||||
|
||||
def boolean shachanged = (buildsha != previoussha)
|
||||
echo "buildsha: ${buildsha} previoussha: ${previoussha} changed: ${shachanged}"
|
||||
|
||||
String buildstamp = buildmeta.buildstampinfo.buildstamp
|
||||
String previousbuildstamp = previousreleasemeta.buildstampinfo.buildstamp
|
||||
|
||||
def boolean buildstampchanged = (buildstamp != previousbuildstamp)
|
||||
echo "buildstamp: ${buildstamp} previousbuildstamp: ${previousbuildstamp} changed: ${buildstampchanged}"
|
||||
|
||||
def boolean changed = (shachanged | buildstampchanged)
|
||||
echo "changed: ${changed}"
|
||||
|
||||
return changed
|
||||
}
|
||||
|
||||
def ArrayList<String> maketaglist(buildmeta, String buildstamp, String otherreleasetags) {
|
||||
def ArrayList<String> taglist = new ArrayList<String>()
|
||||
taglist.add(buildstamp)
|
||||
|
||||
def ArrayList<String> othertaglist = otherreleasetags.split(',')
|
||||
for (othertagitem in othertaglist) {
|
||||
if (othertagitem?.trim()) {
|
||||
def componentothertagitem = "${othertagitem.trim()}_${buildmeta.productinfo.productname}_${buildmeta.productinfo.subcomponentname}"
|
||||
taglist.add(componentothertagitem)
|
||||
}
|
||||
}
|
||||
return taglist
|
||||
}
|
||||
|
||||
def String releasegitgetshacode(String tag) {
|
||||
def existingshacode = ""
|
||||
// Check if tag exists already
|
||||
def int gitrevparsestatus = sh(script: "git rev-parse \"${tag}\" >\"${gitrevparseoutputfile}\" 2>/dev/null", returnStatus: true)
|
||||
if (gitrevparsestatus == 0) { // Tag exists
|
||||
existingshacode = readFile(file: gitrevparseoutputfile).trim()
|
||||
}
|
||||
return existingshacode
|
||||
}
|
||||
|
||||
def boolean releasegittag(String postcommitshacode, String tag) {
|
||||
def boolean tagadded = false
|
||||
// Check if tag exists already
|
||||
def String existingshacode = releasegitgetshacode(tag)
|
||||
if (existingshacode) { // Tag exists
|
||||
if (existingshacode != postcommitshacode) { // If the existing tag is not associated with the one expected
|
||||
// This is a problem - The tag is already at another position in git repo
|
||||
setunstable("The release tag ${tag} has been used at another commit other than one expected - You must decide what to do with it - Not good practice to delete it or move it (Existing sha code: ${existingshacode} Post commit sha code: ${postcommitshacode})")
|
||||
summaryappend("(${tag} - Could not add!)")
|
||||
} else {
|
||||
summaryappend("(${tag} - Already added)")
|
||||
}
|
||||
} else { // If tag does not exist already
|
||||
// Tag
|
||||
sh("git tag \"${tag}\"")
|
||||
summaryappend("(${tag})")
|
||||
tagadded = true
|
||||
}
|
||||
return tagadded
|
||||
}
|
||||
|
||||
def boolean releasegittags(String postcommitshacode, ArrayList<String> taglist) {
|
||||
boolean tagadded = false
|
||||
|
||||
summaryappend("Rel Tag ")
|
||||
for (tag in taglist) {
|
||||
if (releasegittag(postcommitshacode, tag)) {
|
||||
tagadded = true
|
||||
}
|
||||
}
|
||||
return tagadded
|
||||
}
|
||||
|
||||
def boolean sourcegittag(String shacode, String tag) {
|
||||
def boolean tagadded = false
|
||||
// Check if tag exists already
|
||||
def int gitrevparsestatus = sh(script: "git rev-parse \"${tag}\" >\"${gitrevparseoutputfile}\" 2>/dev/null", returnStatus: true)
|
||||
if (gitrevparsestatus == 0) { // Tag exists
|
||||
def existingshacode = readFile(file: gitrevparseoutputfile).trim()
|
||||
if (existingshacode != shacode) { // If the existing tag is not associated with HEAD
|
||||
// This is a problem - The tag is already at another position in git repo
|
||||
setunstable("The source tag ${tag} has been used at another commit (${existingshacode}) - You must decide what to do with it - Not good practice to delete it or move it (Existing sha code: ${existingshacode} Post commit sha code: ${shacode})")
|
||||
summaryappend("(${tag} - Could not add!)")
|
||||
}
|
||||
else {
|
||||
summaryappend("(${tag} - Already added)")
|
||||
}
|
||||
}
|
||||
else { // If tag does not exist already
|
||||
// Tag
|
||||
sh("git tag \"${tag}\" ${shacode}")
|
||||
summaryappend("(${tag})")
|
||||
tagadded = true
|
||||
}
|
||||
return tagadded
|
||||
}
|
||||
|
||||
def sourcegittags(String buildsha, List taglist) {
|
||||
boolean tagadded = false
|
||||
|
||||
summaryappend(",Src Tag ")
|
||||
for (tag in taglist) {
|
||||
if (sourcegittag(buildsha, tag)) {
|
||||
tagadded = true
|
||||
}
|
||||
}
|
||||
return tagadded
|
||||
}
|
||||
|
||||
def releasegitpush(String dryrunpush ) {
|
||||
sh("git remote -v")
|
||||
if (dryrunpush == "true") {
|
||||
sh("git push -n --tags origin master")
|
||||
summaryappend(",Dry-Run-Push")
|
||||
setunstable("The artifact(s) have not been pushed/saved (\"Dry run push\" parameter/option is selected)")
|
||||
}
|
||||
else {
|
||||
sh("git push --tags origin master")
|
||||
summaryappend(",Push")
|
||||
}
|
||||
}
|
||||
|
||||
def sourcegitpush(String dryrunpush ) {
|
||||
sh("git remote -v")
|
||||
if (dryrunpush == "true") {
|
||||
sh("git push -n --tags")
|
||||
summaryappend(",Src-Dry-Run-Push")
|
||||
setunstable("The source tag(s) have not been pushed/saved (\"Dry run push\" parameter/option is selected)")
|
||||
}
|
||||
else {
|
||||
sh("git push --tags")
|
||||
summaryappend(",Src Push")
|
||||
}
|
||||
}
|
||||
|
||||
def boolean isalreadyreleased(buildmeta, tag) {
|
||||
def boolean alreadyreleased = buildmeta.releaseinfo.released
|
||||
if (alreadyreleased) {
|
||||
echo "Component is already marked as released: ${alreadyreleased}"
|
||||
} else {
|
||||
String commitshacode = releasegitgetshacode(tag)
|
||||
if (commitshacode) {
|
||||
echo "Tag: ${tag} already exists in this repo therefore marking as already released"
|
||||
alreadyreleased = true
|
||||
} else {
|
||||
alreadyreleased = false
|
||||
}
|
||||
}
|
||||
return alreadyreleased
|
||||
}
|
||||
|
||||
def gitrelease(buildmeta, previousreleasemeta, String releaserepo, String sourcerepo, String otherreleasetags, String dryrunpush) {
|
||||
summaryappend(" Git operations: ")
|
||||
def String buildstamptag = buildmeta.releasetag()
|
||||
|
||||
dir(releaserepo) {
|
||||
def String precommitshacode = sh(script: "git rev-parse --verify HEAD", returnStdout: true).trim()
|
||||
echo "Pre commit sha code: ${precommitshacode}"
|
||||
|
||||
def boolean alreadyreleased = isalreadyreleased(buildmeta, buildstamptag)
|
||||
|
||||
def String postcommitshacode
|
||||
def boolean changed = false
|
||||
if (alreadyreleased) {
|
||||
summaryappend("Already-released,")
|
||||
postcommitshacode = releasegitgetshacode(buildstamptag)
|
||||
echo "Previous release sha code: ${postcommitshacode}"
|
||||
} else {
|
||||
releasegitadd()
|
||||
|
||||
changed = checkforchange(buildmeta, previousreleasemeta)
|
||||
if (changed) {
|
||||
releasegitcommit(buildstamptag)
|
||||
} else {
|
||||
releasegitreset()
|
||||
summaryappend("No-commit,")
|
||||
}
|
||||
|
||||
postcommitshacode = sh(script: "git rev-parse --verify HEAD", returnStdout: true).trim()
|
||||
echo "Post commit sha code: ${postcommitshacode}"
|
||||
}
|
||||
|
||||
ArrayList<String> taglist = maketaglist(buildmeta, buildstamptag, otherreleasetags)
|
||||
def tagadded = releasegittags(postcommitshacode, taglist)
|
||||
|
||||
if (changed || tagadded) {
|
||||
releasegitpush(dryrunpush)
|
||||
}
|
||||
}
|
||||
dir(sourcerepo) {
|
||||
def String srcbuildstamptag = buildmeta.globalreleasetag()
|
||||
def String buildsha = buildmeta.gitinfo.gitrevision
|
||||
|
||||
if (buildsha) {
|
||||
def ArrayList<String> srctaglist = maketaglist(buildmeta, srcbuildstamptag, otherreleasetags)
|
||||
def tagadded = sourcegittags(buildsha, srctaglist)
|
||||
if (tagadded) {
|
||||
sourcegitpush(dryrunpush)
|
||||
}
|
||||
} else {
|
||||
summaryappend(",No Src ")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
def releasecomponent(toplevelbuildmeta, buildinfo, String otherreleasetags, String dryrunpush) {
|
||||
def buildmeta = buildinfo.meta
|
||||
def String uniquefolder = "${buildmeta.productinfo.productname}_${buildmeta.productinfo.subcomponentname}"
|
||||
def String uniquefolderforrepo = "${releaserepofolder}/${uniquefolder}"
|
||||
def String uniquefoldertemp = "${tempfolder}/${uniquefolder}"
|
||||
def String uniquefolderforsourcerepo = "${sourcerepofolder}/${uniquefolder}"
|
||||
|
||||
summaryappend("${buildmeta.productinfo.productname} ${buildmeta.productinfo.subcomponentname}: ")
|
||||
repoandtagsappend("${buildmeta.productinfo.productname} ${buildmeta.productinfo.subcomponentname}: ")
|
||||
def previousreleasemeta = checkoutreleaserepo(buildmeta, uniquefolderforrepo)
|
||||
|
||||
checkoutsourcerepo(buildmeta, uniquefolderforsourcerepo)
|
||||
|
||||
if (getcomponentartifacts(toplevelbuildmeta, buildinfo, uniquefolderforrepo, uniquefoldertemp)) {
|
||||
gitrelease(buildmeta, previousreleasemeta, uniquefolderforrepo, uniquefolderforsourcerepo, otherreleasetags, dryrunpush)
|
||||
}
|
||||
|
||||
summaryappend("\n")
|
||||
repoandtagsappend("\n")
|
||||
}
|
||||
|
||||
def releasehierarchy(buildmeta, String maxdepth, String otherreleasetags, String dryrunpush) {
|
||||
def int md = maxdepth.toInteger()
|
||||
resetfolders()
|
||||
preconditions()
|
||||
|
||||
// Walk the meta information to a max depth, looking for components to release
|
||||
def componentReleaseInfo = buildmeta.releasewalkerunique(md)
|
||||
echo "Unique components:"
|
||||
def String versioncomponent = ""
|
||||
for (key in componentReleaseInfo.keySet()) {
|
||||
versioncomponent += "${key}\n"
|
||||
}
|
||||
echo versioncomponent
|
||||
|
||||
// Walk the meta information to a max depth, looking for components to release
|
||||
def componentReleaseInfoVersionUnique = buildmeta.releasewalkerversionunique(md)
|
||||
echo "Version unique components:"
|
||||
def String versionuniquecomponent = ""
|
||||
for (key in componentReleaseInfoVersionUnique.keySet()) {
|
||||
versionuniquecomponent += "${key}\n"
|
||||
}
|
||||
echo versionuniquecomponent
|
||||
|
||||
if (DO_INTEGRITY_CHECK == "true") {
|
||||
if (componentReleaseInfo.size() != componentReleaseInfoVersionUnique.size()) {
|
||||
error "There are 2 or more versions of the same component being used in this hierarchy: Is this correct?"
|
||||
}
|
||||
}
|
||||
|
||||
def toplevelid = buildmeta.componentidentifier()
|
||||
// For each component
|
||||
for (key in componentReleaseInfo.keySet()) {
|
||||
def buildinfo = componentReleaseInfo[key]
|
||||
if (toplevelid != key) {
|
||||
releasecomponent(buildmeta, buildinfo, otherreleasetags, dryrunpush)
|
||||
}
|
||||
}
|
||||
// Do the top level last
|
||||
def toplevelbuildinfo = componentReleaseInfo[toplevelid]
|
||||
releasecomponent(buildmeta, toplevelbuildinfo, otherreleasetags, dryrunpush)
|
||||
|
||||
return [summarystring, markunstable, unstablereason]
|
||||
}
|
||||
|
||||
return this;
|
||||
12
Common_scripts/release/registerrepo.groovy
Normal file
12
Common_scripts/release/registerrepo.groovy
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
|
||||
vc = load("${autobuilder.commonscripts()}/versioncontrol/git.groovy")
|
||||
|
||||
// Prove the existence of the release repo - otherwise there is a large wait to cycle the build to correct the meta data
|
||||
def registerrepo(meta, String releaserepo) {
|
||||
if (releaserepo?.trim()) {
|
||||
vc.checkRepoExists(releaserepo)
|
||||
}
|
||||
meta.releaseinfo.set(releaserepo)
|
||||
}
|
||||
|
||||
return this;
|
||||
88
Common_scripts/release/release.groovy
Normal file
88
Common_scripts/release/release.groovy
Normal file
|
|
@ -0,0 +1,88 @@
|
|||
pipeline {
|
||||
agent { label "${AGENT_LABEL}" }
|
||||
stages {
|
||||
stage('Initial setup') {
|
||||
steps {
|
||||
script {
|
||||
autobuilderscript = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy")
|
||||
meta = autobuilderscript.startbuild(this, PRODUCT_NAME, SUBCOMPONENT_NAME, RELEASE_REPO)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Clean exports') {
|
||||
steps {
|
||||
script {
|
||||
cleanfolders = [
|
||||
"${WORKSPACE}/build_artifacts",
|
||||
]
|
||||
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
|
||||
cleaner.clean(cleanfolders)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Get build artifact meta') {
|
||||
steps {
|
||||
script {
|
||||
BUILD_ARTIFACTS = "${WORKSPACE}/build_artifacts"
|
||||
copyArtifacts(
|
||||
filter: 'meta/**',
|
||||
projectName: BUILD_JOB,
|
||||
selector: [
|
||||
$class: 'ParameterizedBuildSelector',
|
||||
parameterName: BUILD_JOB_SELECTOR
|
||||
],
|
||||
target: BUILD_ARTIFACTS
|
||||
)
|
||||
def mfs = autobuilderscript.getmetafolderscript()
|
||||
buildmeta = mfs.metafromfolder(BUILD_ARTIFACTS)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Release components') {
|
||||
steps {
|
||||
script {
|
||||
def releaser = load("${autobuilder.commonscripts()}/release/do.groovy")
|
||||
// Place the top level build stamp on all
|
||||
OTHER_RELEASE_TAGS = "${buildmeta.globalreleasetag()},${OTHER_RELEASE_TAGS}"
|
||||
(summarystring, markunstable, unstablereason) = releaser.releasehierarchy(buildmeta, MAX_META_DEPTH, OTHER_RELEASE_TAGS, DRY_RUN_PUSH)
|
||||
if (markunstable) {
|
||||
env.unstablereason = unstablereason
|
||||
currentBuild.result = 'UNSTABLE'
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Archiving artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def artifactlist = meta.generateartifacts()
|
||||
archiveArtifacts "summary/**,${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Summarise') {
|
||||
steps {
|
||||
script {
|
||||
echo "Summary:\n${summarystring}\n"
|
||||
if (env.unstablereason) {
|
||||
echo "Instability reason: ${env.unstablereason}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
32
Common_scripts/remoteaccess/ftp.groovy
Normal file
32
Common_scripts/remoteaccess/ftp.groovy
Normal file
|
|
@ -0,0 +1,32 @@
|
|||
import org.apache.commons.net.ftp.FTPClient
|
||||
|
||||
class FTPSiteInfo {
|
||||
String url
|
||||
String username
|
||||
String password
|
||||
String workingdirectory
|
||||
|
||||
FTPSiteInfo(String url, String username, String password, String workingdirectory) {
|
||||
this.url = url
|
||||
this.username = username
|
||||
this.password = password
|
||||
this.workingdirectory = workingdirectory
|
||||
}
|
||||
}
|
||||
|
||||
FTPSiteInfo createFTPSiteInfo(String url, String username, String password, String workingdirectory) {
|
||||
FTPSiteInfo ftpsiteinfo = new FTPSiteInfo(url, username, password, workingdirectory)
|
||||
return ftpsiteinfo
|
||||
}
|
||||
|
||||
FTPClient createFTPClient(FTPSiteInfo ftpsiteinfo) {
|
||||
FTPClient ftpclient = new FTPClient()
|
||||
ftpclient.connect(ftpsiteinfo.url)
|
||||
ftpclient.enterLocalPassiveMode()
|
||||
ftpclient.login(ftpsiteinfo.username, ftpsiteinfo.password)
|
||||
ftpclient.changeWorkingDirectory(ftpsiteinfo.workingdirectory)
|
||||
|
||||
return ftpclient
|
||||
}
|
||||
|
||||
return this;
|
||||
28
Common_scripts/remoteaccess/hostedftp.groovy
Normal file
28
Common_scripts/remoteaccess/hostedftp.groovy
Normal file
|
|
@ -0,0 +1,28 @@
|
|||
ftpremote = load("${autobuilder.commonscripts()}/remoteaccess/ftp.groovy")
|
||||
|
||||
def getHostedFTPSiteInfo() {
|
||||
hostedftpsiteinfo =
|
||||
ftpremote.createFTPSiteInfo("ftp.hostedftp.com",
|
||||
"ftp@globalinkjetsystems.com",
|
||||
"ramshorn42",
|
||||
"/Customers/")
|
||||
return hostedftpsiteinfo
|
||||
}
|
||||
|
||||
def getCustomerList() {
|
||||
def List<String> customerfilenames = new ArrayList<String>()
|
||||
def List<String> customers = new ArrayList<String>()
|
||||
|
||||
def ftpsiteinfo = getHostedFTPSiteInfo()
|
||||
def ftpclient = ftpremote.createFTPClient(ftpsiteinfo)
|
||||
|
||||
customerfilenames = ftpclient.listNames()
|
||||
for(customer in customerfilenames) {
|
||||
def String converted = new String(customer.getBytes("ISO-8859-1"), "UTF-8")
|
||||
customers.add(converted)
|
||||
}
|
||||
ftpclient.disconnect()
|
||||
return customers
|
||||
}
|
||||
|
||||
return this;
|
||||
119
Common_scripts/staticanalysis/ccm.groovy
Normal file
119
Common_scripts/staticanalysis/ccm.groovy
Normal file
|
|
@ -0,0 +1,119 @@
|
|||
pipeline {
|
||||
agent { label "${AGENT_LABEL}" }
|
||||
stages {
|
||||
stage('Initial setup') {
|
||||
steps {
|
||||
script {
|
||||
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
|
||||
}
|
||||
}
|
||||
}
|
||||
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"
|
||||
|
||||
CCMURL = 'git@hydra:tools/ccm.git'
|
||||
CCMBRANCH = 'origin/master'
|
||||
CCMDIR = "${WORKSPACE}/ccm"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'ccm', CCMURL, CCMBRANCH, CCMDIR)
|
||||
CCM = "${CCMDIR}/bin/CCM.exe"
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout source') {
|
||||
steps {
|
||||
script {
|
||||
SOURCEREVISION = "${SOURCE_REVISION}"
|
||||
SOURCEDIR = "${WORKSPACE}/source"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'source', SOURCEURL, SOURCEREVISION, SOURCEDIR, '', 0, false)
|
||||
SOURCE_PATH = "${SOURCEDIR}"
|
||||
env.SRC = "${SOURCE_PATH}/${SOURCE_OFFSET_PATH}"
|
||||
}
|
||||
}
|
||||
}
|
||||
stage("Clean exports") {
|
||||
steps {
|
||||
script {
|
||||
STATICANALYSIS = 'staticanalysis'
|
||||
cleanfolders = [
|
||||
STATICANALYSIS,
|
||||
]
|
||||
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('Static analysis') {
|
||||
steps {
|
||||
script {
|
||||
def CCMOLDER = "${STATICANALYSIS}/ccm"
|
||||
dir(CCMOLDER) {
|
||||
echo "Executing: ${CCM} ${SRC} /xml /nummetrics=100 > ccm.xml"
|
||||
if (isUnix()) {
|
||||
sh """#!/bin/bash
|
||||
find "${SRC}" -type f ! -name "*.cpp" -a ! -name "*.h" -a ! -name "*.hpp" -a ! -name "*.c" -exec rm -r {} \\;
|
||||
# Uses mono
|
||||
"${CCM}" "${SRC}" /xml /nummetrics=100 > ccm.xml
|
||||
"""
|
||||
} else {
|
||||
bat """
|
||||
"${CCM}" "${SRC}" /xml /nummetrics=100 > ccm.xml
|
||||
"""
|
||||
}
|
||||
}
|
||||
recordIssues(tools: [
|
||||
ccm(pattern: "**/ccm.xml", reportEncoding: 'UTF-8'),
|
||||
])
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Classifying publishable artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def publishable = [
|
||||
]
|
||||
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
|
||||
publishutils.generatelist(meta, publishable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Archiving artifacts') {
|
||||
steps {
|
||||
script {
|
||||
ArrayList<String> itemsForRelease = ["${STATICANALYSIS}/**"]
|
||||
def artifactlist = meta.generateartifacts(itemsForRelease)
|
||||
archiveArtifacts "${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
151
Common_scripts/staticanalysis/cpd.groovy
Normal file
151
Common_scripts/staticanalysis/cpd.groovy
Normal file
|
|
@ -0,0 +1,151 @@
|
|||
pipeline {
|
||||
agent { label AGENT_LABEL }
|
||||
stages {
|
||||
stage('Initial setup') {
|
||||
steps {
|
||||
script {
|
||||
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout dependencies') {
|
||||
steps {
|
||||
script {
|
||||
configurationhelper = autobuilder.configurationhelper()
|
||||
|
||||
PYTHONURL = 'git@hydra:tools/python.git'
|
||||
if (isUnix()) {
|
||||
PYTHONBRANCH = 'origin/3.6.3_linux'
|
||||
} else {
|
||||
PYTHONBRANCH = 'origin/3.6.3_windows'
|
||||
}
|
||||
PYTHONDIR = "${WORKSPACE}/python"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR)
|
||||
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
|
||||
|
||||
JAVAURL = 'git@hydra:tools/openjdk.git'
|
||||
if (isUnix()) {
|
||||
JAVABRANCH = 'origin/openjdk-11.0.2_linux-x64_bin'
|
||||
} else {
|
||||
JAVABRANCH = 'origin/openjdk-11.0.2_windows-x64_bin'
|
||||
}
|
||||
JAVADIR = "${WORKSPACE}/java"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'java', JAVAURL, JAVABRANCH, JAVADIR)
|
||||
JAVA = "${JAVADIR}/ver/bin"
|
||||
if (isUnix()) {
|
||||
env.PATH = JAVA + ':' + PATH
|
||||
} else {
|
||||
env.PATH = JAVA + ';' + PATH
|
||||
}
|
||||
|
||||
PPDURL = 'git@hydra:tools/pmd.git'
|
||||
PPDBRANCH = 'origin/master'
|
||||
PPDDIR = "${WORKSPACE}/ppd"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'ppd', PPDURL, PPDBRANCH, PPDDIR)
|
||||
PPD = "${PPDDIR}/bin"
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout source') {
|
||||
steps {
|
||||
script {
|
||||
SOURCEREVISION = "${SOURCE_REVISION}"
|
||||
SOURCEDIR = "${WORKSPACE}/source"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'source', SOURCEURL, SOURCEREVISION, SOURCEDIR, '', 0, false)
|
||||
SOURCE_PATH = "${SOURCEDIR}"
|
||||
SRC = "${SOURCE_PATH}"
|
||||
if (SOURCE_OFFSET_PATH) {
|
||||
SRC += "/${SOURCE_OFFSET_PATH}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage("Clean exports") {
|
||||
steps {
|
||||
script {
|
||||
STATICANALYSIS = 'staticanalysis'
|
||||
cleanfolders = [
|
||||
STATICANALYSIS,
|
||||
]
|
||||
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('Static analysis') {
|
||||
steps {
|
||||
script {
|
||||
def PPDFOLDER = "${STATICANALYSIS}/ppd"
|
||||
def EXCLUDE_PARAM = ''
|
||||
if (EXCLUDE_PATHS) {
|
||||
EXCLUDE_PARAM = '--exclude "'
|
||||
def exclude_path_list = EXCLUDE_PATHS.split(',')
|
||||
for (exclude_path in exclude_path_list) {
|
||||
EXCLUDE_PARAM += "${SRC}/${exclude_path.trim()},"
|
||||
}
|
||||
EXCLUDE_PARAM += '"'
|
||||
}
|
||||
if (isUnix()) {
|
||||
sh """#!/bin/bash
|
||||
set -ev
|
||||
|
||||
mkdir -p "${PPDFOLDER}"
|
||||
export PMD_JAVA_OPTS=-Xmx65536m
|
||||
"${PPD}/run.sh" cpd --minimum-tokens 100 --files "${SRC}" --language cpp --format xml ${EXCLUDE_PARAM} --failOnViolation false > "${PPDFOLDER}/cpd.xml"
|
||||
"""
|
||||
} else {
|
||||
bat """
|
||||
mkdir -p "${PPDFOLDER}"
|
||||
set PMD_JAVA_OPTS=-Xmx2048m
|
||||
"${PPD}/cpd.bat" --minimum-tokens 100 --files "${SRC}" --language cpp --format xml ${EXCLUDE_PARAM} --failOnViolation false > "${PPDFOLDER}/cpd.xml"
|
||||
"""
|
||||
}
|
||||
recordIssues(tools: [
|
||||
cpd(pattern: "**/cpd.xml", reportEncoding: 'UTF-8'),
|
||||
])
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Classifying publishable artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def publishable = [
|
||||
]
|
||||
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
|
||||
publishutils.generatelist(meta, publishable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Archiving artifacts') {
|
||||
steps {
|
||||
script {
|
||||
ArrayList<String> itemsForRelease = ["${STATICANALYSIS}/**"]
|
||||
def artifactlist = meta.generateartifacts(itemsForRelease)
|
||||
archiveArtifacts "${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
113
Common_scripts/staticanalysis/cppcheck.groovy
Normal file
113
Common_scripts/staticanalysis/cppcheck.groovy
Normal file
|
|
@ -0,0 +1,113 @@
|
|||
pipeline {
|
||||
agent { label "${AGENT_LABEL}" }
|
||||
stages {
|
||||
stage('Initial setup') {
|
||||
steps {
|
||||
script {
|
||||
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
|
||||
}
|
||||
}
|
||||
}
|
||||
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"
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout source') {
|
||||
steps {
|
||||
script {
|
||||
SOURCEREVISION = "${SOURCE_REVISION}"
|
||||
SOURCEDIR = "${WORKSPACE}/source"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'source', SOURCEURL, SOURCEREVISION, SOURCEDIR, '', 0, false)
|
||||
SOURCE_PATH = "${SOURCEDIR}"
|
||||
env.SRC = "${SOURCE_PATH}/${SOURCE_OFFSET_PATH}"
|
||||
}
|
||||
}
|
||||
}
|
||||
stage("Clean exports") {
|
||||
steps {
|
||||
script {
|
||||
STATICANALYSIS = 'staticanalysis'
|
||||
cleanfolders = [
|
||||
STATICANALYSIS,
|
||||
]
|
||||
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('Static analysis') {
|
||||
steps {
|
||||
script {
|
||||
def CPPCHECKFOLDER = "${STATICANALYSIS}/cppcheck"
|
||||
dir(CPPCHECKFOLDER) {
|
||||
echo "Executing: ${CPPCHECK} --xml --xml-version=2 ${SRC} 2> cppcheck.xml"
|
||||
if (isUnix()) {
|
||||
sh """#!/bin/bash
|
||||
set -e
|
||||
|
||||
"${CPPCHECK}" --xml --xml-version=2 "${SRC}" 2> cppcheck.xml
|
||||
"""
|
||||
} else {
|
||||
bat """
|
||||
"${CPPCHECK}" --xml --xml-version=2 "${SRC}" 2> cppcheck.xml
|
||||
"""
|
||||
}
|
||||
}
|
||||
recordIssues(tools: [
|
||||
cppCheck(pattern: "**/cppcheck.xml", reportEncoding: 'UTF-8'),
|
||||
])
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Classifying publishable artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def publishable = [
|
||||
]
|
||||
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
|
||||
publishutils.generatelist(meta, publishable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Archiving artifacts') {
|
||||
steps {
|
||||
script {
|
||||
ArrayList<String> itemsForRelease = ["${STATICANALYSIS}/**"]
|
||||
def artifactlist = meta.generateartifacts(itemsForRelease)
|
||||
archiveArtifacts "${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
8
Common_scripts/textutils/subst.groovy
Normal file
8
Common_scripts/textutils/subst.groovy
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
|
||||
def substitute(String filepath, pattern, String subst) {
|
||||
fileText = readFile(file: filepath, encoding: 'UTF-8')
|
||||
def converted = fileText.replaceAll(pattern, subst)
|
||||
writeFile(file: filepath, text: converted, encoding: 'UTF-8')
|
||||
}
|
||||
|
||||
return this;
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
{
|
||||
"version": "1.0",
|
||||
"components": [
|
||||
"Microsoft.VisualStudio.Workload.ManagedDesktop",
|
||||
"Microsoft.VisualStudio.Workload.NativeDesktop",
|
||||
"Microsoft.VisualStudio.Workload.NetWeb",
|
||||
"Microsoft.VisualStudio.Workload.NetCoreTools",
|
||||
"microsoft.net.componentgroup.targetingpacks.common",
|
||||
"microsoft.componentgroup.blend",
|
||||
"microsoft.visualstudio.component.entityframework",
|
||||
"microsoft.visualstudio.component.debugger.justintime",
|
||||
"microsoft.visualstudio.component.wcf.tooling",
|
||||
"microsoft.visualstudio.component.vc.diagnostictools",
|
||||
"microsoft.visualstudio.component.vc.cmake.project",
|
||||
"microsoft.visualstudio.component.vc.testadapterforboosttest",
|
||||
"microsoft.visualstudio.component.vc.testadapterforgoogletest",
|
||||
"microsoft.visualstudio.component.vc.atlmfc",
|
||||
"microsoft.visualstudio.component.appinsights.tools",
|
||||
"microsoft.visualstudio.component.diagnostictools",
|
||||
"microsoft.visualstudio.componentgroup.web.cloudtools",
|
||||
"microsoft.visualstudio.component.aspnet45",
|
||||
"microsoft.visualstudio.component.webdeploy",
|
||||
"microsoft.visualstudio.component.nuget.buildtools"
|
||||
]
|
||||
}
|
||||
376
Common_scripts/versioncontrol/git.groovy
Normal file
376
Common_scripts/versioncontrol/git.groovy
Normal file
|
|
@ -0,0 +1,376 @@
|
|||
import hudson.plugins.git.*
|
||||
import hudson.plugins.git.extensions.*
|
||||
import hudson.plugins.git.extensions.impl.*
|
||||
|
||||
clh = load("${autobuilder.commonscripts()}/commandline/commandline.groovy")
|
||||
|
||||
def boolean isShallowClonedRepo(String gitrootpath) {
|
||||
def boolean isshallowclone = true
|
||||
|
||||
dir( gitrootpath) {
|
||||
if (isUnix()) {
|
||||
isshallowclone = sh(returnStdout: true, script: "git rev-parse --is-shallow-repository").trim().toBoolean()
|
||||
}
|
||||
else {
|
||||
isshallowclone = bat(returnStdout: true, script: "@git rev-parse --is-shallow-repository").trim().toBoolean()
|
||||
}
|
||||
echo "Repo at ${gitrootpath} is shallow cloned: ${isshallowclone}"
|
||||
}
|
||||
return isshallowclone
|
||||
}
|
||||
|
||||
String getGitInfo(String workingSetRootPath) {
|
||||
dir(workingSetRootPath) {
|
||||
return clh.getCommandOutput('git rev-parse HEAD')
|
||||
}
|
||||
}
|
||||
|
||||
ArrayList<String> gettaglist(String workingSetRootPath) {
|
||||
ArrayList<String> taglist = new ArrayList<String>()
|
||||
dir(workingSetRootPath) {
|
||||
def tagliststring = clh.getCommandOutput('git tag --sort=-version:refname')
|
||||
taglist = tagliststring.split('\\n')
|
||||
}
|
||||
return taglist
|
||||
}
|
||||
|
||||
@NonCPS
|
||||
def ArrayList<SparseCheckoutPath> sparsecheckoutconfig(ArrayList<String> paths) {
|
||||
ArrayList<SparseCheckoutPath> sparsecheckoutpaths = new ArrayList<SparseCheckoutPath>()
|
||||
for (path in paths) {
|
||||
sparsecheckoutpaths.add(new SparseCheckoutPath(path))
|
||||
}
|
||||
return sparsecheckoutpaths
|
||||
}
|
||||
|
||||
def String uniquereporootname(String gitURL) {
|
||||
def uniquename = gitURL.replaceAll("[^A-Za-z0-9]", "_")
|
||||
echo "Unique reporoot name for URL: ${gitURL} is: ${uniquename}"
|
||||
return uniquename
|
||||
}
|
||||
|
||||
// The REPO_ROOT is a folder where a cache of git checkouts can be kept - each subfolder name is unique to a particular git repo
|
||||
def String checkouttoreporoot(String gitURL) {
|
||||
def String reporootsubfolder
|
||||
def String reporootenv = env.REPO_ROOT
|
||||
if (!reporootenv) {
|
||||
reporootsubfolder = ""
|
||||
echo "To improve Git performance: Define the REPO_ROOT enviroment to a path where a cache of git repositories can be placed on this slave"
|
||||
} else {
|
||||
def reporootname = uniquereporootname(gitURL)
|
||||
reporootsubfolder = "${reporootenv}/${reporootname}"
|
||||
|
||||
if (!fileExists(reporootsubfolder)) {
|
||||
echo "Checking out ${gitURL} to ${reporootsubfolder}"
|
||||
checkout([
|
||||
$class: 'GitSCM',
|
||||
userRemoteConfigs: [
|
||||
[url: gitURL]
|
||||
],
|
||||
branches: [
|
||||
[name: 'origin/master']
|
||||
],
|
||||
doGenerateSubmoduleConfigurations: false,
|
||||
extensions: [
|
||||
[$class: 'GitLFSPull'],
|
||||
[$class: 'CleanBeforeCheckout'],
|
||||
[$class: 'CheckoutOption', timeout: 180],
|
||||
[$class: 'RelativeTargetDirectory', relativeTargetDir: reporootsubfolder],
|
||||
],
|
||||
submoduleCfg: [],
|
||||
])
|
||||
} else {
|
||||
echo "Found ${gitURL} checked out at ${reporootsubfolder}"
|
||||
/*
|
||||
dir(reporootsubfolder) {
|
||||
if (isUnix()) {
|
||||
sh """
|
||||
git status
|
||||
if [ \$? -ne 0 ]; then exit 1; fi
|
||||
"""
|
||||
} else {
|
||||
bat """
|
||||
git status
|
||||
if errorlevel 1 EXIT /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
*/
|
||||
}
|
||||
}
|
||||
return reporootsubfolder
|
||||
}
|
||||
|
||||
def checkgitlfsinstall() {
|
||||
if (isUnix()) {
|
||||
sh """
|
||||
git lfs install
|
||||
if [ \$? -ne 0 ]; then exit 1; fi
|
||||
"""
|
||||
|
||||
} else {
|
||||
bat """
|
||||
git lfs install
|
||||
if errorlevel 1 EXIT /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
|
||||
//No credentials specified
|
||||
//Cloning the remote Git repository
|
||||
//Cloning repository git@hydra:print-server-releases/print_server_whole.git
|
||||
//> git init /home/jenkins_user/jenkins/jobs/Print_Server_publish_to_customer/ws/whole # timeout=10
|
||||
//Using reference repository: /home/jenkins_user/reporoot/git_hydra_print_server_releases_print_server_whole_git
|
||||
//Fetching upstream changes from git@hydra:print-server-releases/print_server_whole.git
|
||||
// > git --version # timeout=10
|
||||
// > git fetch --tags --progress git@hydra:print-server-releases/print_server_whole.git +refs/heads/*:refs/remotes/origin/* # timeout=120
|
||||
// > git config remote.origin.url git@hydra:print-server-releases/print_server_whole.git # timeout=10
|
||||
// > git config --add remote.origin.fetch +refs/heads/*:refs/remotes/origin/* # timeout=10
|
||||
// > git config remote.origin.url git@hydra:print-server-releases/print_server_whole.git # timeout=10
|
||||
// Cleaning workspace
|
||||
// > git rev-parse --verify HEAD # timeout=10
|
||||
// No valid HEAD. Skipping the resetting
|
||||
// > git clean -fdx # timeout=10
|
||||
// Fetching upstream changes from git@hydra:print-server-releases/print_server_whole.git
|
||||
// > git fetch --tags --progress git@hydra:print-server-releases/print_server_whole.git +refs/heads/*:refs/remotes/origin/* # timeout=120
|
||||
// > git rev-parse refs/tags/2.10180.7389.21125_7^{commit} # timeout=10
|
||||
// > git rev-parse refs/remotes/origin/refs/tags/2.10180.7389.21125_7^{commit} # timeout=10
|
||||
// Checking out Revision 64cac35e9a7603c060135f61f91b3f809bbdf160 (refs/tags/2.10180.7389.21125_7)
|
||||
// Enabling Git LFS pull
|
||||
// > git config core.sparsecheckout # timeout=10
|
||||
// > git checkout -f 64cac35e9a7603c060135f61f91b3f809bbdf160 # timeout=120
|
||||
// > git config --get remote.origin.url # timeout=10
|
||||
// > git lfs pull origin # timeout=120
|
||||
// Commit message: "2.10180.7389.21125_7"
|
||||
// > git rev-list --no-walk 64cac35e9a7603c060135f61f91b3f809bbdf160 # timeout=10
|
||||
|
||||
|
||||
// > git rev-parse --is-inside-work-tree # timeout=10
|
||||
// Fetching changes from the remote Git repository
|
||||
// > git config remote.origin.url git@hydra:releases/print-server-installer.git # timeout=10
|
||||
// Cleaning workspace
|
||||
// > git rev-parse --verify HEAD # timeout=10
|
||||
// Resetting working tree
|
||||
// > git reset --hard # timeout=10
|
||||
// > git clean -fdx # timeout=10
|
||||
// Using shallow fetch with depth 1
|
||||
// Fetching upstream changes from git@hydra:releases/print-server-installer.git
|
||||
// > git --version # timeout=10
|
||||
// > git fetch --tags --progress git@hydra:releases/print-server-installer.git +refs/heads/*:refs/remotes/origin/* --depth=1 # timeout=120
|
||||
// > git rev-parse refs/remotes/origin/master^{commit} # timeout=10
|
||||
// > git rev-parse refs/remotes/origin/origin/master^{commit} # timeout=10
|
||||
// Checking out Revision d0788d22622862e441c5995a22629846573c39f3 (refs/remotes/origin/master)
|
||||
// Enabling Git LFS pull
|
||||
// > git config core.sparsecheckout # timeout=10
|
||||
// > git read-tree -mu HEAD # timeout=10
|
||||
// > git checkout -f d0788d22622862e441c5995a22629846573c39f3 # timeout=120
|
||||
// > git config --get remote.origin.url # timeout=10
|
||||
// > git lfs pull origin # timeout=120
|
||||
// Commit message: "2.10180.7389.21125_3"
|
||||
// > git rev-list --no-walk d0788d22622862e441c5995a22629846573c39f3 # timeout=10
|
||||
|
||||
def String lfsinstallandreporoot(String gitURL) {
|
||||
checkgitlfsinstall()
|
||||
return checkouttoreporoot(gitURL)
|
||||
}
|
||||
|
||||
def showsparseitemlist(ArrayList<String> sparseitemlist = new ArrayList<String>()) {
|
||||
if (!sparseitemlist.isEmpty()) {
|
||||
def itemstring = "Items in sparse item list:\n"
|
||||
for (item in sparseitemlist) {
|
||||
itemstring += item + "\n"
|
||||
}
|
||||
echo itemstring
|
||||
}
|
||||
}
|
||||
|
||||
def docheckout(String gitURL, String revision, int cloneDepth, String reporootpath, boolean shallowClone, String targetDir, sparseitemlist) {
|
||||
checkout([
|
||||
$class: 'GitSCM',
|
||||
userRemoteConfigs: [
|
||||
[url: gitURL]
|
||||
],
|
||||
branches: [
|
||||
[name: revision]
|
||||
],
|
||||
doGenerateSubmoduleConfigurations: false,
|
||||
extensions: [
|
||||
[$class: 'GitLFSPull'],
|
||||
[$class: 'CleanBeforeCheckout'],
|
||||
[$class: 'CloneOption', depth: cloneDepth, noTags: false, reference: reporootpath, shallow: shallowClone, timeout: 120],
|
||||
[$class: 'CheckoutOption', timeout: 120],
|
||||
[$class: 'RelativeTargetDirectory', relativeTargetDir: targetDir],
|
||||
[$class: 'SparseCheckoutPaths', sparseCheckoutPaths: sparsecheckoutconfig(sparseitemlist)],
|
||||
],
|
||||
submoduleCfg: [],
|
||||
])
|
||||
}
|
||||
|
||||
// gitCheckout (below) cannot handle sparse checkout and lfs at the moment - see https://issues.jenkins-ci.org/browse/JENKINS-43427 - see gitCheckoutAlt()
|
||||
def gitCheckout(String gitURL, String revision, String targetDir, String repoRootSuffix = "", int cloneDepth = 1, boolean shallowClone = true, ArrayList<String> sparseitemlist = new ArrayList<String>()) {
|
||||
def String reporootpath = lfsinstallandreporoot(gitURL)
|
||||
showsparseitemlist(sparseitemlist)
|
||||
docheckout(gitURL, revision, cloneDepth, reporootpath, shallowClone, targetDir, sparseitemlist)
|
||||
}
|
||||
|
||||
def gitinit(String targetDir, String reporootpath) {
|
||||
if (!fileExists("${targetDir}/.git")) { // Git folder does not already exist
|
||||
echo "git init ${targetDir}"
|
||||
if (isUnix()) {
|
||||
sh """
|
||||
git init "${targetDir}"
|
||||
"""
|
||||
} else {
|
||||
bat """
|
||||
git init "${targetDir}"
|
||||
"""
|
||||
}
|
||||
}
|
||||
echo "Writing ${reporootpath}/.git/objects to ${targetDir}/.git/objects/info/alternates"
|
||||
dir("${targetDir}/.git/objects/info") {
|
||||
writeFile(file: 'alternates', text: "${reporootpath}/.git/objects")
|
||||
}
|
||||
}
|
||||
|
||||
def setlfsfetchinclude(String targetDir, ArrayList<String> sparseitemlist) {
|
||||
def String sparseitemliststring = ""
|
||||
if (!sparseitemlist.isEmpty()) {
|
||||
for (item in sparseitemlist) {
|
||||
sparseitemliststring += "${item},"
|
||||
}
|
||||
echo "git config lfs.fetchinclude ${sparseitemliststring}"
|
||||
dir(targetDir) {
|
||||
if (isUnix()) {
|
||||
sh """
|
||||
git config lfs.fetchinclude "${sparseitemliststring}"
|
||||
"""
|
||||
} else {
|
||||
bat """
|
||||
git config lfs.fetchinclude "${sparseitemliststring}"
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
def gitsparserestore(String targetDir) {
|
||||
echo "Clean out full fetch; Force a sparse fetch"
|
||||
dir(targetDir) {
|
||||
if (isUnix()) {
|
||||
sh """
|
||||
git rm -rf . > /dev/null
|
||||
git clean -fxd > /dev/null
|
||||
git reset --hard > /dev/null
|
||||
"""
|
||||
} else {
|
||||
bat """
|
||||
git rm -rf . 2> nul
|
||||
git clean -fxd 2> nul
|
||||
git reset --hard 2> nul
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
def List convertSparseItemsString(String itemstopublish) {
|
||||
def List sparsepaths = []
|
||||
|
||||
boolean nonempty = itemstopublish?.trim()
|
||||
if (nonempty) {
|
||||
def String[] items = itemstopublish.trim().split(',')
|
||||
def String allpaths = ""
|
||||
for(String item : items) {
|
||||
sparsepaths.add(item)
|
||||
allpaths += "${item}\n"
|
||||
}
|
||||
echo "Selected item to publish:\n${allpaths}"
|
||||
}
|
||||
return sparsepaths
|
||||
}
|
||||
|
||||
def gitCheckoutAlt(String gitURL, String revision, String targetDir, String repoRootSuffix = "", int cloneDepth = 1, boolean shallowClone = true, ArrayList<String> sparseitemlist = new ArrayList<String>()) {
|
||||
echo "Performing alternative checkout"
|
||||
def String reporootpath = lfsinstallandreporoot(gitURL)
|
||||
showsparseitemlist(sparseitemlist)
|
||||
if (!sparseitemlist.isEmpty()) {
|
||||
gitinit(targetDir, reporootpath)
|
||||
setlfsfetchinclude(targetDir, sparseitemlist)
|
||||
}
|
||||
docheckout(gitURL, revision, cloneDepth, reporootpath, shallowClone, targetDir, sparseitemlist)
|
||||
if (!sparseitemlist.isEmpty()) {
|
||||
gitsparserestore(targetDir)
|
||||
}
|
||||
}
|
||||
|
||||
def checkRepoExists(String gitURL) {
|
||||
def int result = 0
|
||||
if (isUnix()) {
|
||||
result = sh( script: """
|
||||
git ls-remote "${gitURL}" CHECK_GIT_REMOTE_URL_REACHABILITY
|
||||
""",
|
||||
returnStatus: true
|
||||
)
|
||||
} else {
|
||||
result = bat( script: """
|
||||
@git ls-remote "${gitURL}" CHECK_GIT_REMOTE_URL_REACHABILITY
|
||||
""",
|
||||
returnStatus: true
|
||||
)
|
||||
}
|
||||
echo "git ls-remote return result: ${result}"
|
||||
if (result > 0) {
|
||||
error("The release repo: ${gitURL} cannot be found. Please ensure this exists before building")
|
||||
} else {
|
||||
echo "The release repo: ${gitURL} exists"
|
||||
}
|
||||
}
|
||||
|
||||
String getSHAFromVersion(String versionFolder) {
|
||||
dir (versionFolder) {
|
||||
srcRevision = readFile("gitrevision.txt").trim()
|
||||
}
|
||||
return srcRevision
|
||||
}
|
||||
|
||||
boolean checkAllVersionsAgree(java.util.LinkedHashMap versions) {
|
||||
def keys = versions.keySet()
|
||||
if (keys.size() < 1) {
|
||||
return false
|
||||
}
|
||||
if (keys.size() == 1) {
|
||||
return true
|
||||
}
|
||||
else {
|
||||
version = ""
|
||||
for (key in keys) {
|
||||
nextversion = versions.get(key)
|
||||
if (version == "") {
|
||||
version = nextversion
|
||||
}
|
||||
if (nextversion != version) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
def stripgithistory(String rootfolder) {
|
||||
echo "Stripping git history out of ${rootfolder}"
|
||||
dir(rootfolder) {
|
||||
if (isUnix()) {
|
||||
sh """#!/bin/bash
|
||||
pwd
|
||||
find . -type d -name ".git" | xargs -iXX rm -rf XX
|
||||
find . -name ".gitignore" | xargs -iXX rm -rf XX
|
||||
find . -name ".gitmodules" | xargs -iXX rm -rf XX
|
||||
find . -iname ".gitattributes" | xargs -iXX rm -rf XX
|
||||
find . -iname "*@tmp" | xargs -iXX rm -rf XX
|
||||
"""
|
||||
} else {
|
||||
echo "Not supporting git stripping in Windows at the moment"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return this
|
||||
23
Common_scripts/versionnumbering/do.groovy
Normal file
23
Common_scripts/versionnumbering/do.groovy
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
|
||||
def stamp(convertdetails) {
|
||||
for (convertdetail in convertdetails) {
|
||||
def filetoconvert = convertdetail[0]
|
||||
def pattern = convertdetail[1]
|
||||
def replacement = convertdetail[2]
|
||||
//echo "Converting any instances of pattern: ${pattern} with replacement: ${replacement} in file: ${filetoconvert}"
|
||||
def stampscript = "${autobuilder.commonscripts()}/versionstamping/versionstamper.py"
|
||||
//echo "Using python: ${PYTHON} and script: ${stampscript}"
|
||||
if (isUnix()) {
|
||||
sh """
|
||||
"${PYTHON}" -u "${stampscript}" -f "${filetoconvert}" -p "${pattern}" -s "${replacement}"
|
||||
"""
|
||||
}
|
||||
else {
|
||||
bat """
|
||||
"${PYTHON}" -u "${stampscript}" -f "${filetoconvert}" -p "${pattern}" -s "${replacement}"
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return this;
|
||||
169
Common_scripts/versionnumbering/generate.groovy
Normal file
169
Common_scripts/versionnumbering/generate.groovy
Normal file
|
|
@ -0,0 +1,169 @@
|
|||
gh = load("${autobuilder.commonscripts()}/versioncontrol/git.groovy")
|
||||
|
||||
def int maxversionnumber() {
|
||||
def int MAXVERSIONNUMBER = 65535
|
||||
return MAXVERSIONNUMBER
|
||||
}
|
||||
|
||||
int incrementrevision(int current, int increment) {
|
||||
def int newrevision = (current + increment) % (maxversionnumber() + 1)
|
||||
echo "Current revision: ${current} Increment: ${increment} New revision: ${newrevision}"
|
||||
return newrevision
|
||||
}
|
||||
|
||||
def getGitRevision(String gitrootpath, int basebuildnumber) {
|
||||
def int adjustedchangecount
|
||||
def String gitrevision
|
||||
def String remoteinfo
|
||||
def String remoteurl
|
||||
|
||||
def boolean isShallowCloned = gh.isShallowClonedRepo(gitrootpath)
|
||||
if (isShallowCloned) {
|
||||
error("Cannot generate a version number from a shallow cloned repo at ${gitrootpath}")
|
||||
}
|
||||
|
||||
dir( gitrootpath) {
|
||||
def int changecount = 0
|
||||
if (isUnix()) {
|
||||
changecount = sh(returnStdout: true, script: "git rev-list HEAD --count").trim().toInteger()
|
||||
}
|
||||
else {
|
||||
changecount = bat(returnStdout: true, script: "@git rev-list HEAD --count").trim().toInteger()
|
||||
}
|
||||
echo "Change count: ${changecount}"
|
||||
def int mvnp1 = maxversionnumber() + 1
|
||||
basebuildnumber = (basebuildnumber < 0) ? mvnp1 - (basebuildnumber.abs() % mvnp1) : basebuildnumber
|
||||
adjustedchangecount = incrementrevision(changecount, basebuildnumber)
|
||||
echo "Adjusted change count: ${adjustedchangecount}"
|
||||
if (isUnix()) {
|
||||
gitrevision = sh(returnStdout: true, script: "git rev-parse HEAD").trim()
|
||||
}
|
||||
else {
|
||||
gitrevision = bat(returnStdout: true, script: "@git rev-parse HEAD").trim()
|
||||
}
|
||||
echo "Revision: ${gitrevision}"
|
||||
if (isUnix()) {
|
||||
remoteinfo = sh(returnStdout: true, script: "git remote show origin").trim()
|
||||
}
|
||||
else {
|
||||
remoteinfo = bat(returnStdout: true, script: "@git remote show origin").trim()
|
||||
}
|
||||
echo "Remote info: ${remoteinfo}"
|
||||
if (isUnix()) {
|
||||
remoteurl = sh(returnStdout: true, script: "git config --get remote.origin.url").trim()
|
||||
}
|
||||
else {
|
||||
remoteurl = bat(returnStdout: true, script: "@git config --get remote.origin.url").trim()
|
||||
}
|
||||
echo "Remote URL: ${remoteurl}"
|
||||
}
|
||||
return [adjustedchangecount, gitrevision, remoteinfo, remoteurl]
|
||||
}
|
||||
|
||||
// Handle:
|
||||
// origin/master
|
||||
// origin/2.0.x
|
||||
def getVersionPrefix(String sourcebranch, boolean droptrailingdot = false) {
|
||||
echo "Determining version number prefix from source branch name: ${sourcebranch}"
|
||||
sourcebranch = sourcebranch.toLowerCase()
|
||||
|
||||
def defaultversionprefix = "0.30000.0."
|
||||
def splits = sourcebranch.split('/')
|
||||
if (splits.size() < 1) {
|
||||
echo "Source branch name is invalid. Defaulting to: ${defaultversionprefix}"
|
||||
return defaultversionprefix
|
||||
}
|
||||
|
||||
def mastertypeversionprefix = "0.20000.0."
|
||||
sourcebranch = splits.last()
|
||||
if (sourcebranch.toLowerCase().find("master") != null) {
|
||||
echo "Source branch name has 'master' in it. Defaulting to: ${mastertypeversionprefix}"
|
||||
return mastertypeversionprefix
|
||||
}
|
||||
|
||||
def splits2 = sourcebranch.split('\\.')
|
||||
if (splits2.size() < 1) {
|
||||
def thirdpartyversionprefix = "0.25000.0."
|
||||
echo "Source branch name has no dots in it (eg. 1.9.2). Defaulting to: ${thirdpartyversionprefix}"
|
||||
return thirdpartyversionprefix
|
||||
}
|
||||
|
||||
for (split in splits2) {
|
||||
if (split == "x") {
|
||||
echo "Source branch name has '.x' or 'x.' in it. Defaulting to: ${mastertypeversionprefix}"
|
||||
return mastertypeversionprefix
|
||||
}
|
||||
}
|
||||
|
||||
def integerstrings = sourcebranch.findAll(/\d+/)
|
||||
def integers = []
|
||||
for (integerstring in integerstrings) {
|
||||
int integer = integerstring.toInteger()
|
||||
integer = integer % (maxversionnumber() + 1)
|
||||
integers.add(integer)
|
||||
}
|
||||
|
||||
def versionprefix = ""
|
||||
if (integers.size() < 1) {
|
||||
echo "This source branch name has no numbers in its name so defaulting to: ${defaultversionprefix}"
|
||||
versionprefix = defaultversionprefix
|
||||
}
|
||||
else {
|
||||
def int integernumbercount = 0
|
||||
for (integer in integers) {
|
||||
versionprefix += integer + "."
|
||||
integernumbercount += 1
|
||||
if (integernumbercount > 2) {
|
||||
break
|
||||
}
|
||||
}
|
||||
if (integernumbercount == 0) {
|
||||
echo "No leading numbers were found in source branch name so defaulting to: ${defaultversionprefix}"
|
||||
versionprefix = defaultversionprefix
|
||||
}
|
||||
else if (integernumbercount == 1) {
|
||||
versionprefix += "0.0."
|
||||
}
|
||||
else if (integernumbercount == 2) {
|
||||
versionprefix += "0."
|
||||
}
|
||||
}
|
||||
if (droptrailingdot == true) {
|
||||
versionprefix = versionprefix.substring(0, versionprefix.length() - 1);
|
||||
}
|
||||
echo "Determined version prefix to be: ${versionprefix}"
|
||||
return versionprefix
|
||||
}
|
||||
|
||||
String generate(meta, String sourcerevision, String sourcepath, int basebuildnumber = 1000) {
|
||||
def int gitrevisioncount
|
||||
def String gitrevision
|
||||
def String remoteinfo
|
||||
def String remoteurl
|
||||
|
||||
(gitrevisioncount, gitrevision, remoteinfo, remoteurl) = getGitRevision(sourcepath, basebuildnumber)
|
||||
|
||||
def versionprefix = getVersionPrefix(sourcerevision)
|
||||
|
||||
def buildstamp = versionprefix + gitrevisioncount.toString()
|
||||
echo "Build stamp is: ${buildstamp}"
|
||||
|
||||
meta.gitinfo.set(sourcepath, sourcerevision, gitrevision, remoteurl, remoteinfo)
|
||||
meta.buildstampinfo.set(versionprefix, gitrevisioncount, buildstamp)
|
||||
|
||||
return buildstamp
|
||||
}
|
||||
|
||||
String generate(meta, String sourcerevision, String sourcepath, String basebuildnumber) {
|
||||
def int bbn = basebuildnumber.trim().toInteger()
|
||||
return generate(meta, sourcerevision, sourcepath, bbn)
|
||||
}
|
||||
|
||||
String copyfrom(meta, othermeta) {
|
||||
meta.gitinfo = othermeta.gitinfo
|
||||
meta.buildstampinfo = othermeta.buildstampinfo
|
||||
|
||||
return meta.buildstampinfo.buildstamp
|
||||
}
|
||||
|
||||
return this;
|
||||
17
Common_scripts/versionstamping/.project
Normal file
17
Common_scripts/versionstamping/.project
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<projectDescription>
|
||||
<name>versionstamping</name>
|
||||
<comment></comment>
|
||||
<projects>
|
||||
</projects>
|
||||
<buildSpec>
|
||||
<buildCommand>
|
||||
<name>org.python.pydev.PyDevBuilder</name>
|
||||
<arguments>
|
||||
</arguments>
|
||||
</buildCommand>
|
||||
</buildSpec>
|
||||
<natures>
|
||||
<nature>org.python.pydev.pythonNature</nature>
|
||||
</natures>
|
||||
</projectDescription>
|
||||
8
Common_scripts/versionstamping/.pydevproject
Normal file
8
Common_scripts/versionstamping/.pydevproject
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
|
||||
<?eclipse-pydev version="1.0"?><pydev_project>
|
||||
<pydev_pathproperty name="org.python.pydev.PROJECT_SOURCE_PATH">
|
||||
<path>/${PROJECT_DIR_NAME}</path>
|
||||
</pydev_pathproperty>
|
||||
<pydev_property name="org.python.pydev.PYTHON_PROJECT_VERSION">python 3.0</pydev_property>
|
||||
<pydev_property name="org.python.pydev.PYTHON_PROJECT_INTERPRETER">python35</pydev_property>
|
||||
</pydev_project>
|
||||
38
Common_scripts/versionstamping/versionstamper.py
Normal file
38
Common_scripts/versionstamping/versionstamper.py
Normal file
|
|
@ -0,0 +1,38 @@
|
|||
import argparse
|
||||
import sys
|
||||
import shutil
|
||||
from builtins import FileNotFoundError
|
||||
|
||||
def main(argv):
|
||||
parser = argparse.ArgumentParser(description="Look for version number pattern in file and replace with autobuild version number")
|
||||
|
||||
# Call once arguments to allow or disallow something
|
||||
parser.add_argument('-f', '--filetoconvert', help='The file to convert')
|
||||
parser.add_argument('-p', '--pattern', default='0.30000.0.0', help='The pattern to search for and replace')
|
||||
parser.add_argument('-s', '--substitute', help='The new version number that will substitute the pattern')
|
||||
|
||||
args = parser.parse_args(argv)
|
||||
|
||||
filetoconvert = args.filetoconvert
|
||||
pattern = args.pattern
|
||||
substitute = args.substitute
|
||||
|
||||
print("Converting incidences of {0} with {1} in file: {2}\n".format(pattern, substitute, filetoconvert))
|
||||
|
||||
with open(filetoconvert,'r') as c:
|
||||
fileread = c.read()
|
||||
|
||||
count = 0
|
||||
with open(filetoconvert, 'w') as f:
|
||||
print("Detected %s instances of %s pre-conversion"%(fileread.count(pattern),pattern))
|
||||
converted = fileread.replace(pattern, substitute)
|
||||
count = converted.count(substitute)
|
||||
print("Confirmed %s instances of %s post-conversion"%(count,substitute))
|
||||
f.write(converted)
|
||||
|
||||
if count == 0:
|
||||
return 1
|
||||
return 0
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main(sys.argv[1:]))
|
||||
326
build/build_all.groovy
Normal file
326
build/build_all.groovy
Normal file
|
|
@ -0,0 +1,326 @@
|
|||
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)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout dependencies') {
|
||||
steps {
|
||||
script {
|
||||
configurationhelper = autobuilder.configurationhelper()
|
||||
|
||||
SOURCEURL = 'git@hydra:gis/atlas_ui.git'
|
||||
SOURCEREVISION = "${SOURCE_REVISION}".trim()
|
||||
SOURCEROOTDIR = 'atlas_ui'
|
||||
SOURCEDIR = "${WORKSPACE}/atlas_ui"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, SOURCEROOTDIR, SOURCEURL, SOURCEREVISION, SOURCEDIR, SOURCEROOTDIR, 0, false)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Generating version info') {
|
||||
steps {
|
||||
script {
|
||||
version = load("${autobuilder.commonscripts()}/versionnumbering/generate.groovy")
|
||||
version.generate(meta, SOURCEREVISION, SOURCEDIR, BASEBUILDNUMBER)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Print server to adjust version number') {
|
||||
steps {
|
||||
script {
|
||||
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
|
||||
|
||||
def importoptions = importer.getNewImportOptions()
|
||||
importoptions.source(PRINT_SERVER_ARTIFACT_LOCATION,
|
||||
PRINT_SERVER_COMPILE_JOB,
|
||||
PRINT_SERVER_BUILD_SELECTOR,
|
||||
PRINT_SERVER_RELEASE_REPO,
|
||||
PRINT_SERVER_RELEASE_REVISION)
|
||||
importoptions.setincrementversionnumber(true)
|
||||
importoptions.setfilter('meta/**');
|
||||
importoptions.setappendtoparentmeta(false)
|
||||
importer.artifactimport(meta, importoptions, 'ps_bin')
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Atlas services to adjust version number') {
|
||||
steps {
|
||||
script {
|
||||
def importoptions = importer.getNewImportOptions()
|
||||
importoptions.source(ATLAS_SERVICES_ARTIFACT_LOCATION,
|
||||
ATLAS_SERVICES_COMPILE_JOB,
|
||||
ATLAS_SERVICES_BUILD_SELECTOR,
|
||||
ATLAS_SERVICES_RELEASE_REPO,
|
||||
ATLAS_SERVICES_RELEASE_REVISION)
|
||||
importoptions.setincrementversionnumber(true)
|
||||
importoptions.setfilter('meta/**');
|
||||
importoptions.setappendtoparentmeta(false)
|
||||
importer.artifactimport(meta, importoptions, 'as_bin')
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Compile') {
|
||||
steps {
|
||||
script {
|
||||
atlas_compile_job = build job: ATLAS_COMPILE_JOB,
|
||||
parameters: [
|
||||
string(name: 'SOURCE_REVISION', value: SOURCEREVISION),
|
||||
string(name: 'PRINT_SERVER_ARTIFACT_LOCATION', value: PRINT_SERVER_ARTIFACT_LOCATION),
|
||||
string(name: 'PRINT_SERVER_COMPILE_JOB', value: PRINT_SERVER_COMPILE_JOB),
|
||||
string(name: 'PRINT_SERVER_BUILD_SELECTOR', value: PRINT_SERVER_BUILD_SELECTOR),
|
||||
string(name: 'PRINT_SERVER_RELEASE_REPO', value: PRINT_SERVER_RELEASE_REPO),
|
||||
string(name: 'PRINT_SERVER_RELEASE_REVISION', value: PRINT_SERVER_RELEASE_REVISION),
|
||||
string(name: 'ATLAS_SERVICES_ARTIFACT_LOCATION', value: ATLAS_SERVICES_ARTIFACT_LOCATION),
|
||||
string(name: 'ATLAS_SERVICES_COMPILE_JOB', value: ATLAS_SERVICES_COMPILE_JOB),
|
||||
string(name: 'ATLAS_SERVICES_BUILD_SELECTOR', value: ATLAS_SERVICES_BUILD_SELECTOR),
|
||||
string(name: 'ATLAS_SERVICES_RELEASE_REPO', value: ATLAS_SERVICES_RELEASE_REPO),
|
||||
string(name: 'ATLAS_SERVICES_RELEASE_REVISION', value: ATLAS_SERVICES_RELEASE_REVISION),
|
||||
booleanParam(name: 'CLEAN_WORKSPACE', value: CLEAN_WORKSPACE),
|
||||
]
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Compile Atlas Ink UI') {
|
||||
steps {
|
||||
script {
|
||||
ink_ui_compile_job = build job: INK_UI_COMPILE_JOB,
|
||||
parameters: [
|
||||
string(name: 'SOURCE_REVISION', value: SOURCEREVISION),
|
||||
string(name: 'ATLAS_UI_COMPILE_JOB', value: atlas_compile_job.getProjectName()),
|
||||
string(name: 'ATLAS_UI_COMPILE_BUILD_SELECTOR', value: "<SpecificBuildSelector plugin='copyartifact@1.41'> <buildNumber>${atlas_compile_job.getNumber()}</buildNumber></SpecificBuildSelector>"),
|
||||
string(name: 'PRINT_SERVER_ARTIFACT_LOCATION', value: PRINT_SERVER_ARTIFACT_LOCATION),
|
||||
string(name: 'PRINT_SERVER_COMPILE_JOB', value: PRINT_SERVER_COMPILE_JOB),
|
||||
string(name: 'PRINT_SERVER_BUILD_SELECTOR', value: PRINT_SERVER_BUILD_SELECTOR),
|
||||
string(name: 'PRINT_SERVER_RELEASE_REPO', value: PRINT_SERVER_RELEASE_REPO),
|
||||
string(name: 'PRINT_SERVER_RELEASE_REVISION', value: PRINT_SERVER_RELEASE_REVISION),
|
||||
string(name: 'ATLAS_SERVICES_ARTIFACT_LOCATION', value: ATLAS_SERVICES_ARTIFACT_LOCATION),
|
||||
string(name: 'ATLAS_SERVICES_COMPILE_JOB', value: ATLAS_SERVICES_COMPILE_JOB),
|
||||
string(name: 'ATLAS_SERVICES_BUILD_SELECTOR', value: ATLAS_SERVICES_BUILD_SELECTOR),
|
||||
string(name: 'ATLAS_SERVICES_RELEASE_REPO', value: ATLAS_SERVICES_RELEASE_REPO),
|
||||
string(name: 'ATLAS_SERVICES_RELEASE_REVISION', value: ATLAS_SERVICES_RELEASE_REVISION),
|
||||
booleanParam(name: 'CLEAN_WORKSPACE', value: CLEAN_WORKSPACE),
|
||||
]
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Second stage') {
|
||||
failFast true
|
||||
parallel {
|
||||
stage('Check localisations') {
|
||||
steps {
|
||||
script {
|
||||
localisation_check_job = build job: ATLAS_LOCALISATION_CHECK_JOB,
|
||||
parameters: [
|
||||
string(name: 'SOURCE_REVISION', value: SOURCEREVISION),
|
||||
string(name: 'ATLAS_UI_COMPILE_JOB', value: atlas_compile_job.getProjectName()),
|
||||
string(name: 'ATLAS_UI_COMPILE_BUILD_SELECTOR', value: "<SpecificBuildSelector plugin='copyartifact@1.41'> <buildNumber>${atlas_compile_job.getNumber()}</buildNumber></SpecificBuildSelector>"),
|
||||
booleanParam(name: 'CLEAN_WORKSPACE', value: CLEAN_WORKSPACE),
|
||||
]
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Build Atlas Professional installers') {
|
||||
steps {
|
||||
script {
|
||||
atlas_pro_installer_job = build job: ATLAS_PROFESSIONAL_INSTALLER_BUILD_JOB
|
||||
parameters: [
|
||||
string(name: 'SOURCE_REVISION', value: SOURCEREVISION),
|
||||
string(name: 'ATLAS_UI_COMPILE_JOB', value: atlas_compile_job.getProjectName()),
|
||||
string(name: 'ATLAS_UI_COMPILE_BUILD_SELECTOR', value: "<SpecificBuildSelector plugin='copyartifact@1.41'> <buildNumber>${atlas_compile_job.getNumber()}</buildNumber></SpecificBuildSelector>"),
|
||||
string(name: 'PRINT_SERVER_ARTIFACT_LOCATION', value: PRINT_SERVER_ARTIFACT_LOCATION),
|
||||
string(name: 'PRINT_SERVER_COMPILE_JOB', value: PRINT_SERVER_COMPILE_JOB),
|
||||
string(name: 'PRINT_SERVER_BUILD_SELECTOR', value: PRINT_SERVER_BUILD_SELECTOR),
|
||||
string(name: 'PRINT_SERVER_RELEASE_REPO', value: PRINT_SERVER_RELEASE_REPO),
|
||||
string(name: 'PRINT_SERVER_RELEASE_REVISION', value: PRINT_SERVER_RELEASE_REVISION),
|
||||
string(name: 'ATLAS_SERVICES_ARTIFACT_LOCATION', value: ATLAS_SERVICES_ARTIFACT_LOCATION),
|
||||
string(name: 'ATLAS_SERVICES_COMPILE_JOB', value: ATLAS_SERVICES_COMPILE_JOB),
|
||||
string(name: 'ATLAS_SERVICES_BUILD_SELECTOR', value: ATLAS_SERVICES_BUILD_SELECTOR),
|
||||
string(name: 'ATLAS_SERVICES_RELEASE_REPO', value: ATLAS_SERVICES_RELEASE_REPO),
|
||||
string(name: 'ATLAS_SERVICES_RELEASE_REVISION', value: ATLAS_SERVICES_RELEASE_REVISION),
|
||||
booleanParam(name: 'CLEAN_WORKSPACE', value: CLEAN_WORKSPACE),
|
||||
]
|
||||
|
||||
if(atlas_pro_installer_job.result.equals("UNSTABLE") || atlas_pro_installer_job.result.equals("FAILURE"))
|
||||
{
|
||||
currentBuild.result = atlas_pro_installer_job.result
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Build Atlas SDK installers') {
|
||||
steps {
|
||||
script {
|
||||
atlas_sdk_installer_job = build job: ATLAS_SDK_INSTALLER_BUILD_JOB
|
||||
parameters: [
|
||||
string(name: 'SOURCE_REVISION', value: SOURCEREVISION),
|
||||
string(name: 'ATLAS_UI_COMPILE_JOB', value: atlas_compile_job.getProjectName()),
|
||||
string(name: 'ATLAS_UI_COMPILE_BUILD_SELECTOR', value: "<SpecificBuildSelector plugin='copyartifact@1.41'> <buildNumber>${atlas_compile_job.getNumber()}</buildNumber></SpecificBuildSelector>"),
|
||||
string(name: 'PRINT_SERVER_ARTIFACT_LOCATION', value: PRINT_SERVER_ARTIFACT_LOCATION),
|
||||
string(name: 'PRINT_SERVER_COMPILE_JOB', value: PRINT_SERVER_COMPILE_JOB),
|
||||
string(name: 'PRINT_SERVER_BUILD_SELECTOR', value: PRINT_SERVER_BUILD_SELECTOR),
|
||||
string(name: 'PRINT_SERVER_RELEASE_REPO', value: PRINT_SERVER_RELEASE_REPO),
|
||||
string(name: 'PRINT_SERVER_RELEASE_REVISION', value: PRINT_SERVER_RELEASE_REVISION),
|
||||
string(name: 'ATLAS_SERVICES_ARTIFACT_LOCATION', value: ATLAS_SERVICES_ARTIFACT_LOCATION),
|
||||
string(name: 'ATLAS_SERVICES_COMPILE_JOB', value: ATLAS_SERVICES_COMPILE_JOB),
|
||||
string(name: 'ATLAS_SERVICES_BUILD_SELECTOR', value: ATLAS_SERVICES_BUILD_SELECTOR),
|
||||
string(name: 'ATLAS_SERVICES_RELEASE_REPO', value: ATLAS_SERVICES_RELEASE_REPO),
|
||||
string(name: 'ATLAS_SERVICES_RELEASE_REVISION', value: ATLAS_SERVICES_RELEASE_REVISION),
|
||||
booleanParam(name: 'CLEAN_WORKSPACE', value: CLEAN_WORKSPACE),
|
||||
]
|
||||
|
||||
if(atlas_sdk_installer_job.result.equals("UNSTABLE") || atlas_sdk_installer_job.result.equals("FAILURE"))
|
||||
{
|
||||
currentBuild.result = atlas_sdk_installer_job.result
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Build Ink UI installers') {
|
||||
steps {
|
||||
script {
|
||||
ink_ui_installer_job = build job: INK_UI_INSTALLER_BUILD_JOB
|
||||
parameters: [
|
||||
string(name: 'SOURCE_REVISION', value: SOURCEREVISION),
|
||||
string(name: 'ATLAS_UI_COMPILE_JOB', value: atlas_compile_job.getProjectName()),
|
||||
string(name: 'ATLAS_UI_COMPILE_BUILD_SELECTOR', value: "<SpecificBuildSelector plugin='copyartifact@1.41'> <buildNumber>${atlas_compile_job.getNumber()}</buildNumber></SpecificBuildSelector>"),
|
||||
string(name: 'INK_UI_COMPILE_JOB', value: ink_ui_compile_job.getProjectName()),
|
||||
string(name: 'INK_UI_COMPILE_BUILD_SELECTOR', value: "<SpecificBuildSelector plugin='copyartifact@1.41'> <buildNumber>${ink_ui_compile_job.getNumber()}</buildNumber></SpecificBuildSelector>"),
|
||||
string(name: 'PRINT_SERVER_ARTIFACT_LOCATION', value: PRINT_SERVER_ARTIFACT_LOCATION),
|
||||
string(name: 'PRINT_SERVER_COMPILE_JOB', value: PRINT_SERVER_COMPILE_JOB),
|
||||
string(name: 'PRINT_SERVER_BUILD_SELECTOR', value: PRINT_SERVER_BUILD_SELECTOR),
|
||||
string(name: 'PRINT_SERVER_RELEASE_REPO', value: PRINT_SERVER_RELEASE_REPO),
|
||||
string(name: 'PRINT_SERVER_RELEASE_REVISION', value: PRINT_SERVER_RELEASE_REVISION),
|
||||
string(name: 'ATLAS_SERVICES_ARTIFACT_LOCATION', value: ATLAS_SERVICES_ARTIFACT_LOCATION),
|
||||
string(name: 'ATLAS_SERVICES_COMPILE_JOB', value: ATLAS_SERVICES_COMPILE_JOB),
|
||||
string(name: 'ATLAS_SERVICES_BUILD_SELECTOR', value: ATLAS_SERVICES_BUILD_SELECTOR),
|
||||
string(name: 'ATLAS_SERVICES_RELEASE_REPO', value: ATLAS_SERVICES_RELEASE_REPO),
|
||||
string(name: 'ATLAS_SERVICES_RELEASE_REVISION', value: ATLAS_SERVICES_RELEASE_REVISION),
|
||||
booleanParam(name: 'CLEAN_WORKSPACE', value: CLEAN_WORKSPACE),
|
||||
]
|
||||
|
||||
if(ink_ui_installer_job.result.equals("UNSTABLE") || ink_ui_installer_job.result.equals("FAILURE"))
|
||||
{
|
||||
currentBuild.result = ink_ui_installer_job.result
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Release Documentation') {
|
||||
steps {
|
||||
script {
|
||||
release_notes_job = build job: RELEASE_NOTES_JOB,
|
||||
parameters: [
|
||||
string(name: 'SOURCE_REVISION', value: SOURCEREVISION),
|
||||
string(name: 'PRINT_SERVER_ARTIFACT_LOCATION', value: PRINT_SERVER_ARTIFACT_LOCATION),
|
||||
string(name: 'PRINT_SERVER_COMPILE_JOB', value: PRINT_SERVER_COMPILE_JOB),
|
||||
string(name: 'PRINT_SERVER_BUILD_SELECTOR', value: PRINT_SERVER_BUILD_SELECTOR),
|
||||
string(name: 'PRINT_SERVER_RELEASE_REPO', value: PRINT_SERVER_RELEASE_REPO),
|
||||
string(name: 'PRINT_SERVER_RELEASE_REVISION', value: PRINT_SERVER_RELEASE_REVISION),
|
||||
string(name: 'ATLAS_SERVICES_ARTIFACT_LOCATION', value: ATLAS_SERVICES_ARTIFACT_LOCATION),
|
||||
string(name: 'ATLAS_SERVICES_COMPILE_JOB', value: ATLAS_SERVICES_COMPILE_JOB),
|
||||
string(name: 'ATLAS_SERVICES_BUILD_SELECTOR', value: ATLAS_SERVICES_BUILD_SELECTOR),
|
||||
string(name: 'ATLAS_SERVICES_RELEASE_REPO', value: ATLAS_SERVICES_RELEASE_REPO),
|
||||
string(name: 'ATLAS_SERVICES_RELEASE_REVISION', value: ATLAS_SERVICES_RELEASE_REVISION),
|
||||
booleanParam(name: 'CLEAN_WORKSPACE', value: CLEAN_WORKSPACE),
|
||||
]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Accumulate artifacts') {
|
||||
steps {
|
||||
script {
|
||||
artifacthelper = load("${autobuilder.commonscripts()}/artifacts/metaexport.groovy")
|
||||
subJobs = [
|
||||
// Sub-job variable, Artifact folder Increment Version Number
|
||||
[ atlas_compile_job, "atlas_binaries", false, ],
|
||||
[ ink_ui_compile_job, "ink_ui_binaries", false, ],
|
||||
[ atlas_pro_installer_job, "atlas_pro_installers", false, ],
|
||||
[ atlas_sdk_installer_job, "atlas_sdk_installer", false, ],
|
||||
[ ink_ui_installer_job, "ink_ui_installers", false, ],
|
||||
[ release_notes_job, "release_notes", false, ],
|
||||
]
|
||||
artifactFolders = artifacthelper.combineSubjobArtifacts(meta, importer, subJobs)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Check installers for consistency') {
|
||||
steps {
|
||||
script {
|
||||
def mfs = autobuilder.getmetafolderscript()
|
||||
|
||||
echo "Checking meta data for version consistency."
|
||||
|
||||
def atlasmeta = mfs.metafromfolder("atlas_binaries")
|
||||
def atlasrevision = atlasmeta.buildstampinfo.revision
|
||||
echo "Atlas meta has revision ${atlasrevision}."
|
||||
|
||||
def proinstallmeta = mfs.metafromfolder("atlas_pro_installers")
|
||||
def proinstallrevision = proinstallmeta.buildstampinfo.revision
|
||||
echo "Pro installer meta has revision ${proinstallrevision}."
|
||||
|
||||
def sdkinstallmeta = mfs.metafromfolder("atlas_sdk_installer")
|
||||
def sdkinstallrevision = sdkinstallmeta.buildstampinfo.revision
|
||||
echo "SDK installer meta has revision ${sdkinstallrevision}."
|
||||
|
||||
def inkinstallmeta = mfs.metafromfolder("ink_ui_installers")
|
||||
def inkinstallrevision = inkinstallmeta.buildstampinfo.revision
|
||||
echo "Ink installer meta has revision ${inkinstallrevision}."
|
||||
|
||||
if(atlasrevision != proinstallrevision) {
|
||||
echo "A git check-in has been made during the pipeline (Atlas compile revision: ${atlasrevision} does not equal Professional Installer revison: ${proinstallrevision}) so marking build UNSTABLE"
|
||||
currentBuild.result = 'UNSTABLE'
|
||||
}
|
||||
|
||||
if(atlasrevision != sdkinstallrevision) {
|
||||
echo "A git check-in has been made during the pipeline (Atlas compile revision: ${atlasrevision} does not equal SDK Installer revison: ${sdkinstallrevision}) so marking build UNSTABLE"
|
||||
currentBuild.result = 'UNSTABLE'
|
||||
}
|
||||
|
||||
if(atlasrevision != inkinstallrevision) {
|
||||
echo "A git check-in has been made during the pipeline (Atlas compile revision: ${atlasrevision} does not equal Ink Installer revison: ${inkinstallrevision}) so marking build UNSTABLE"
|
||||
currentBuild.result = 'UNSTABLE'
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Classifying publishable artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def publishable = [
|
||||
'meta/**',
|
||||
]
|
||||
def publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
|
||||
publishutils.generatelist(meta, publishable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Archiving artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def artifactlist = meta.generateartifacts([], artifactFolders)
|
||||
archiveArtifacts "${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
212
cloning/cloning.groovy
Normal file
212
cloning/cloning.groovy
Normal file
|
|
@ -0,0 +1,212 @@
|
|||
pipeline {
|
||||
agent { label "${AGENT_LABEL}" }
|
||||
stages {
|
||||
stage('Initial setup') {
|
||||
steps {
|
||||
script {
|
||||
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout dependencies') {
|
||||
steps {
|
||||
script {
|
||||
configurationhelper = autobuilder.configurationhelper()
|
||||
|
||||
PYTHONURL = 'git@hydra:tools/python.git'
|
||||
PYTHONBRANCH = 'origin/3.6.3_windows'
|
||||
PYTHONDIR = "${WORKSPACE}/python"
|
||||
PYTHONROOTDIR = 'python'
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR, PYTHONROOTDIR)
|
||||
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
|
||||
}
|
||||
}
|
||||
}
|
||||
stage("Clean exports") {
|
||||
steps {
|
||||
script {
|
||||
cleanfolders = [
|
||||
]
|
||||
def cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
|
||||
cleaner.clean(cleanfolders)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Generate new job name prefix') {
|
||||
steps {
|
||||
script {
|
||||
def version = load("${autobuilder.commonscripts()}/versionnumbering/generate.groovy")
|
||||
versionprefix = version.getVersionPrefix("origin/${BRANCH_TO_BUILD}", true)
|
||||
echo "From revision: ${BRANCH_TO_BUILD} creating prefix: ${versionprefix}"
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Clone jobs') {
|
||||
steps {
|
||||
script {
|
||||
def templates = []
|
||||
def stringreplace = []
|
||||
|
||||
def defaultMCSJob = "MCS_master_compile"
|
||||
def defaultMCSTag = "refs/tags/1.0.1.40053_35"
|
||||
def defaultPrintServerJob = "Print_Server_master_compile"
|
||||
def defaultPrintServerTag = "refs/tags/2.0.31.21210_34"
|
||||
|
||||
if (BRANCH_TO_COPY == "3.0.x") {
|
||||
templates = [ // Build jobs
|
||||
"Atlas_3.0.x_build",
|
||||
"Atlas_3.0.x_CCM_analysis",
|
||||
"Atlas_3.0.x_compile",
|
||||
"Atlas_3.0.x_documentation_build",
|
||||
"Atlas_3.0.x_documentation_ink_ui_build",
|
||||
"Atlas_3.0.x_ink_ui_compile",
|
||||
"Atlas_3.0.x_ink_ui_installer_build",
|
||||
"Atlas_3.0.x_ink_ui_resharper_code_analysis",
|
||||
"Atlas_3.0.x_localisation_check",
|
||||
"Atlas_3.0.x_professional_installer_build",
|
||||
"Atlas_3.0.x_release_notes",
|
||||
"Atlas_3.0.x_resharper_code_analysis",
|
||||
"Atlas_3.0.x_sdk_installer_build",
|
||||
"Atlas_3.0.x_sdk_resharper_code_analysis",
|
||||
"Atlas_3.0.x_static_analysis",
|
||||
// Test jobs
|
||||
]
|
||||
stringreplace = [ "3.0.x" ]
|
||||
}
|
||||
for (gisjobname in templates) {
|
||||
def job = hudson.model.Hudson.instance.getItem(gisjobname)
|
||||
def newjobname = gisjobname.replaceAll(BRANCH_TO_COPY, versionprefix)
|
||||
echo "Creating new job name: ${newjobname} from: ${gisjobname}"
|
||||
|
||||
def alreadyexistingjob = hudson.model.Hudson.instance.getItem(newjobname)
|
||||
if (!alreadyexistingjob) {
|
||||
def configXMLFile = job.getConfigFile()
|
||||
//def file = configXMLFile.getFile()
|
||||
|
||||
def configXMLString = configXMLFile.asString()
|
||||
echo "XML is: ${configXMLString}"
|
||||
|
||||
echo "Changing instances of: origin/${BRANCH_TO_COPY} with: origin/${BRANCH_TO_BUILD}"
|
||||
configXMLString = configXMLString.replaceAll("origin/${BRANCH_TO_COPY}", "origin/${BRANCH_TO_BUILD}")
|
||||
|
||||
echo "Changing instances of: <defaultValue>${BRANCH_TO_COPY}</defaultValue> with: <defaultValue>${BRANCH_TO_BUILD}</defaultValue>"
|
||||
configXMLString = configXMLString.replaceAll("<defaultValue>${BRANCH_TO_COPY}</defaultValue>", "<defaultValue>${BRANCH_TO_BUILD}</defaultValue>")
|
||||
|
||||
echo "Changing instances of: <defaultValue>${defaultMCSJob}</defaultValue> with: <defaultValue>${ATLAS_SERVICES_BUILD_JOB}</defaultValue>"
|
||||
configXMLString = configXMLString.replaceAll("<defaultValue>${defaultMCSJob}</defaultValue>", "<defaultValue>${ATLAS_SERVICES_BUILD_JOB}</defaultValue>")
|
||||
|
||||
echo "Changing instances of: <defaultValue>${defaultMCSTag}</defaultValue> with: <defaultValue>${ATLAS_SERVICES_RELEASE_REVISION}</defaultValue>"
|
||||
configXMLString = configXMLString.replaceAll("<defaultValue>${defaultMCSTag}</defaultValue>", "<defaultValue>${ATLAS_SERVICES_RELEASE_REVISION}</defaultValue>")
|
||||
|
||||
echo "Changing instances of: <defaultValue>${defaultPrintServerJob}</defaultValue> with: <defaultValue>${PRINT_SERVER_COMPILE_JOB}</defaultValue>"
|
||||
configXMLString = configXMLString.replaceAll("<defaultValue>${defaultPrintServerJob}</defaultValue>", "<defaultValue>${PRINT_SERVER_COMPILE_JOB}</defaultValue>")
|
||||
|
||||
echo "Changing instances of: <defaultValue>${defaultPrintServerTag}</defaultValue> with: <defaultValue>${PRINT_SERVER_RELEASE_REVISION}</defaultValue>"
|
||||
configXMLString = configXMLString.replaceAll("<defaultValue>${defaultPrintServerTag}</defaultValue>", "<defaultValue>${PRINT_SERVER_RELEASE_REVISION}</defaultValue>")
|
||||
|
||||
for (replacement in stringreplace) {
|
||||
echo "Changing instances of: ${replacement} with: ${versionprefix}"
|
||||
configXMLString = configXMLString.replaceAll(replacement, versionprefix)
|
||||
}
|
||||
|
||||
|
||||
echo "Edit choice parameters"
|
||||
//split string on new line
|
||||
def lines = configXMLString.split('\n')
|
||||
|
||||
//iterate array for param name
|
||||
for(int i = 0; i < lines.length; i++){
|
||||
//if the line is the name of a choice parameter
|
||||
if(lines[i].contains("<name>ATLAS_SERVICES_ARTIFACT_LOCATION</name>")){
|
||||
//set index [i+4] and [i+5] based on build selection
|
||||
echo "Found ATLAS_SERVICES_ARTIFACT_LOCATION line"
|
||||
if("${ATLAS_SERVICES_ARTIFACT_LOCATION}" == "Release repository"){
|
||||
echo "Set default to release repo"
|
||||
lines[i+4] = "<string>Release repository</string>"
|
||||
lines[i+5] = "<string>Jenkins job artifact</string>"
|
||||
}
|
||||
else{
|
||||
echo "Set default to job artifact"
|
||||
lines[i+4] = "<string>Jenkins job artifact</string>"
|
||||
lines[i+5] = "<string>Release repository</string>"
|
||||
}
|
||||
}
|
||||
if(lines[i].contains("<name>PRINT_SERVER_ARTIFACT_LOCATION</name>")){
|
||||
//set index [i+4] and [i+5] based on build selection
|
||||
echo "Found PRINT_SERVER_ARTIFACT_LOCATION line"
|
||||
if("${PRINT_SERVER_ARTIFACT_LOCATION}" == "Release repository"){
|
||||
echo "Set default to release repo"
|
||||
lines[i+4] = "<string>Release repository</string>"
|
||||
lines[i+5] = "<string>Jenkins job artifact</string>"
|
||||
}
|
||||
else{
|
||||
echo "Set default to job artifact"
|
||||
lines[i+4] = "<string>Jenkins job artifact</string>"
|
||||
lines[i+5] = "<string>Release repository</string>"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//rejoin array
|
||||
configXMLString = lines.join('\n')
|
||||
|
||||
echo "XML is now: ${configXMLString}"
|
||||
def InputStream is = new ByteArrayInputStream(configXMLString.getBytes())
|
||||
|
||||
//def InputStream is = new FileInputStream(file)
|
||||
|
||||
echo "Creating new job ${newjobname}"
|
||||
def newjob = Jenkins.instance.createProjectFromXML(newjobname, is)
|
||||
newjob.save();
|
||||
echo "Created and saved new job ${newjob.getDisplayName()}"
|
||||
} else {
|
||||
echo "Job ${alreadyexistingjob.getDisplayName()} already exists"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checksum artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def checksummable = [
|
||||
]
|
||||
checksumutils = load("${autobuilder.commonscripts()}/checksum/utils.groovy")
|
||||
checksumutils.generatelist(meta, checksummable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Classifying publishable artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def publishable = [
|
||||
]
|
||||
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
|
||||
publishutils.generatelist(meta, publishable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Archiving artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def artifactlist = meta.generateartifacts([])
|
||||
archiveArtifacts "${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
255
compile/compile.groovy
Normal file
255
compile/compile.groovy
Normal file
|
|
@ -0,0 +1,255 @@
|
|||
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)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout dependencies') {
|
||||
steps {
|
||||
script {
|
||||
configurationhelper = autobuilder.configurationhelper()
|
||||
|
||||
PYTHONURL = 'git@hydra:tools/python.git'
|
||||
PYTHONBRANCH = 'origin/3.6.3_windows'
|
||||
PYTHONDIR = "${WORKSPACE}/python"
|
||||
PYTHONROOTDIR = 'python'
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR, PYTHONROOTDIR)
|
||||
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
|
||||
|
||||
VERSTAMPINGURL = 'git@hydra:releases/ver_stamping_releases.git'
|
||||
VERSTAMPINGREVISION = "refs/tags/${VERSION_STAMPING_VERSION}"
|
||||
VERSTAMPINGDIR = "${WORKSPACE}/ver_stamping"
|
||||
VERSTAMPINGROOTDIR = 'ver_stamping_releases'
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'Version stamping', VERSTAMPINGURL, VERSTAMPINGREVISION, VERSTAMPINGDIR, VERSTAMPINGROOTDIR)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout source') {
|
||||
steps {
|
||||
script {
|
||||
SOURCEURL = 'git@hydra:gis/atlas_ui.git'
|
||||
SOURCEREVISION = SOURCE_REVISION
|
||||
SOURCEDIR = "${WORKSPACE}\\atlas_ui"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'atlas_ui', SOURCEURL, SOURCEREVISION, SOURCEDIR, '', 0, false)
|
||||
env.SOURCE_PATH = SOURCEDIR
|
||||
env.JOBSCRIPTS = "${SOURCE_PATH}\\autobuild\\build_Atlas"
|
||||
env.JOBSCRIPTS_COMMON = "${SOURCE_PATH}\\autobuild\\common"
|
||||
env.SRC = SOURCE_PATH
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Clean exports') {
|
||||
steps {
|
||||
script {
|
||||
env.BUILDOUTPUT = "${WORKSPACE}/build"
|
||||
env.PSBIN = "${WORKSPACE}/ps_bin"
|
||||
env.ASBIN = "${WORKSPACE}/as_bin"
|
||||
env.PSSOURCE = "${WORKSPACE}/newsw"
|
||||
cleanfolders = [
|
||||
BUILDOUTPUT,
|
||||
"${WORKSPACE}/SharedPackages",
|
||||
PSBIN,
|
||||
ASBIN,
|
||||
"${WORKSPACE}/bin",
|
||||
"${WORKSPACE}/binKiosk",
|
||||
"${WORKSPACE}/documentation",
|
||||
"${WORKSPACE}/ildasm",
|
||||
"${WORKSPACE}/Libraries",
|
||||
"${WORKSPACE}/Atlas Release",
|
||||
"${WORKSPACE}/LocalisationSDK",
|
||||
]
|
||||
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, BASEBUILDNUMBER)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Print server to adjust version number') {
|
||||
steps {
|
||||
script {
|
||||
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
|
||||
|
||||
def psartifactfiles = "meta/**,bin/x64/Release/Engine - Render.dll,bin/x64/Release/Engine - Render.lib,bin/x64/Release/Engine - Render.pdb,bin/x64/Release/TBarCode11_x64.dll,bin/x64/Release/GIS Utility - Toolbox.dll,bin/x64/Release/GIS Utility - Toolbox.lib,bin/x64/Release/GIS Utility - Toolbox.pdb,bin/x64/Release/zlib1.dll,bin/x64/Release/zlib1.lib,bin/x64/Release/zlib1.pdb,bin/x64/Release/GIS Utility - TCP-IP Comms.dll,bin/x64/Release/GIS Utility - TCP-IP Comms.lib,bin/x64/Release/GIS Utility - TCP-IP Comms.pdb,bin/x64/Release/Dialog - Tree Node Editor.dll,bin/x64/Release/Dialog - Tree Node Editor.lib,bin/x64/Release/Dialog - Tree Node Editor.pdb"
|
||||
psmeta = importer.artifactimport(meta,
|
||||
PRINT_SERVER_ARTIFACT_LOCATION,
|
||||
PRINT_SERVER_COMPILE_JOB,
|
||||
PRINT_SERVER_BUILD_SELECTOR,
|
||||
PRINT_SERVER_RELEASE_REPO,
|
||||
PRINT_SERVER_RELEASE_REVISION,
|
||||
PSBIN,
|
||||
true,
|
||||
psartifactfiles) // This should increment the version number
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout relevant Print server source') {
|
||||
steps {
|
||||
script {
|
||||
def pssourceartifacts = "src/Engine Common"
|
||||
def pssourceurl = psmeta.gitinfo.remoteurl
|
||||
def pscommit = psmeta.gitinfo.gitrevision
|
||||
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'print_server_source', pssourceurl, pscommit, PSSOURCE, '', 0, false, pssourceartifacts)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Atlas services to adjust version number') {
|
||||
steps {
|
||||
script {
|
||||
def asartifactfiles = "meta/**,SharedPackages/**"
|
||||
asmeta = importer.artifactimport(meta,
|
||||
ATLAS_SERVICES_ARTIFACT_LOCATION,
|
||||
ATLAS_SERVICES_COMPILE_JOB,
|
||||
ATLAS_SERVICES_BUILD_SELECTOR,
|
||||
ATLAS_SERVICES_RELEASE_REPO,
|
||||
ATLAS_SERVICES_RELEASE_REVISION,
|
||||
ASBIN,
|
||||
true,
|
||||
asartifactfiles)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Version stamp files') {
|
||||
steps {
|
||||
script {
|
||||
env.BUILD_STAMP=meta.buildstampinfo.buildstamp
|
||||
env.BUILD_DATE=meta.jenkinsbuildinfo.builddate
|
||||
env.PS_VERSION="1.0.${psmeta.buildstampinfo.revision}.0"
|
||||
env.PS_PACKAGE_VERSION=psmeta.buildstampinfo.buildstampprefix
|
||||
env.AS_PACKAGE_VERSION=asmeta.buildstampinfo.buildstamp
|
||||
bat """
|
||||
call "${JOBSCRIPTS_COMMON}\\create_ps_nuget.bat"
|
||||
if errorlevel 1 exit /b 1
|
||||
call "${JOBSCRIPTS_COMMON}\\version_atlas_ui_files.bat"
|
||||
if errorlevel 1 exit /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Compile application') {
|
||||
steps {
|
||||
script {
|
||||
env.SRC_REVISION=SOURCE_REVISION
|
||||
bat """
|
||||
call "${JOBSCRIPTS}\\autobuild.bat"
|
||||
if errorlevel 1 exit /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Update localisation files') {
|
||||
steps {
|
||||
script {
|
||||
bat """
|
||||
call "${JOBSCRIPTS}\\UpdateLocalisationFiles.bat"
|
||||
if errorlevel 1 exit /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Build documentation for installer') {
|
||||
steps {
|
||||
script {
|
||||
bat """
|
||||
call "${JOBSCRIPTS}\\documentation_build_for_installers.bat"
|
||||
if errorlevel 1 exit /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Prepare exports') {
|
||||
steps {
|
||||
script {
|
||||
bat """
|
||||
move "${SRC}\\bin" .
|
||||
if errorlevel 1 exit /b 1
|
||||
|
||||
move "${SRC}\\binKiosk" .
|
||||
if errorlevel 1 exit /b 1
|
||||
|
||||
move "${SRC}\\Atlas Release" .
|
||||
if errorlevel 1 exit /b 1
|
||||
|
||||
move "${SRC}\\AtlasSDK\\LocalisationSDK" .
|
||||
if errorlevel 1 exit /b 1
|
||||
|
||||
move "${SRC}\\documentation" .
|
||||
if errorlevel 1 exit /b 1
|
||||
|
||||
move "${SRC}\\ildasm" .
|
||||
if errorlevel 1 exit /b 1
|
||||
|
||||
move "${SRC}\\Libraries" .
|
||||
if errorlevel 1 exit /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Static analysis') {
|
||||
steps {
|
||||
script {
|
||||
recordIssues(tools: [
|
||||
msBuild(enabledForFailure: true, reportEncoding: 'UTF-8'),
|
||||
])
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checksum artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def checksummable = [
|
||||
/* Binaries are signed
|
||||
'build/**',
|
||||
'SharedPackages/**',
|
||||
*/
|
||||
]
|
||||
checksumutils = load("${autobuilder.commonscripts()}/checksum/utils.groovy")
|
||||
checksumutils.generatelist(meta, checksummable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Classifying publishable artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def publishable = [
|
||||
]
|
||||
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
|
||||
publishutils.generatelist(meta, publishable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Archiving artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def artifactlist = meta.generateartifacts(["bin/**","binKiosk/**","documentation/**","ildasm/**","Libraries/**","Atlas Release/**","LocalisationSDK/**"])
|
||||
archiveArtifacts "${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
216
compile/compile_ink_ui.groovy
Normal file
216
compile/compile_ink_ui.groovy
Normal file
|
|
@ -0,0 +1,216 @@
|
|||
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)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout dependencies') {
|
||||
steps {
|
||||
script {
|
||||
configurationhelper = autobuilder.configurationhelper()
|
||||
|
||||
PYTHONURL = 'git@hydra:tools/python.git'
|
||||
PYTHONBRANCH = 'origin/3.6.3_windows'
|
||||
PYTHONDIR = "${WORKSPACE}/python"
|
||||
PYTHONROOTDIR = 'python'
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR, PYTHONROOTDIR)
|
||||
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
|
||||
|
||||
VERSTAMPINGURL = 'git@hydra:releases/ver_stamping_releases.git'
|
||||
VERSTAMPINGREVISION = "refs/tags/${VERSION_STAMPING_VERSION}"
|
||||
VERSTAMPINGDIR = "${WORKSPACE}/ver_stamping"
|
||||
VERSTAMPINGROOTDIR = 'ver_stamping_releases'
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'Version stamping', VERSTAMPINGURL, VERSTAMPINGREVISION, VERSTAMPINGDIR, VERSTAMPINGROOTDIR)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout source') {
|
||||
steps {
|
||||
script {
|
||||
SOURCEURL = 'git@hydra:gis/atlas_ui.git'
|
||||
SOURCEREVISION = SOURCE_REVISION
|
||||
SOURCEDIR = "${WORKSPACE}\\atlas_ui"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'atlas_ui', SOURCEURL, SOURCEREVISION, SOURCEDIR, '', 0, false)
|
||||
env.SOURCE_PATH = SOURCEDIR
|
||||
env.JOBSCRIPTS = "${SOURCE_PATH}\\autobuild\\build_inksystem_ui"
|
||||
env.JOBSCRIPTS_COMMON = "${SOURCE_PATH}\\autobuild\\common"
|
||||
env.SRC = SOURCE_PATH
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Clean exports') {
|
||||
steps {
|
||||
script {
|
||||
env.BUILDOUTPUT = "${WORKSPACE}/build"
|
||||
env.PSBIN = "${WORKSPACE}/ps_bin"
|
||||
env.ASBIN = "${WORKSPACE}/as_bin"
|
||||
env.AULIB = "${WORKSPACE}/atlaslibraries"
|
||||
env.TESTRESULTS = "${WORKSPACE}/testresults"
|
||||
env.PSSOURCE = "${WORKSPACE}/newsw"
|
||||
cleanfolders = [
|
||||
BUILDOUTPUT,
|
||||
"${WORKSPACE}/SharedPackages",
|
||||
PSBIN,
|
||||
ASBIN,
|
||||
AULIB,
|
||||
"${WORKSPACE}/binInk",
|
||||
TESTRESULTS,
|
||||
]
|
||||
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, BASEBUILDNUMBER)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Atlas UI libraries') {
|
||||
steps {
|
||||
script {
|
||||
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
|
||||
libmeta = importer.artifactimport(meta,
|
||||
ATLAS_UI_ARTIFACT_LOCATION,
|
||||
ATLAS_UI_COMPILE_JOB,
|
||||
ATLAS_UI_BUILD_SELECTOR,
|
||||
ATLAS_UI_RELEASE_REPO,
|
||||
ATLAS_UI_RELEASE_REVISION,
|
||||
AULIB,
|
||||
false)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Print server to adjust version number') {
|
||||
steps {
|
||||
script {
|
||||
def psartifactfiles = "meta/**"
|
||||
psmeta = importer.artifactimport(meta,
|
||||
PRINT_SERVER_ARTIFACT_LOCATION,
|
||||
PRINT_SERVER_COMPILE_JOB,
|
||||
PRINT_SERVER_BUILD_SELECTOR,
|
||||
PRINT_SERVER_RELEASE_REPO,
|
||||
PRINT_SERVER_RELEASE_REVISION,
|
||||
PSBIN,
|
||||
true,
|
||||
psartifactfiles) // This should increment the version number
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Atlas services to adjust version number') {
|
||||
steps {
|
||||
script {
|
||||
def asartifactfiles = "meta/**"
|
||||
asmeta = importer.artifactimport(meta,
|
||||
ATLAS_SERVICES_ARTIFACT_LOCATION,
|
||||
ATLAS_SERVICES_COMPILE_JOB,
|
||||
ATLAS_SERVICES_BUILD_SELECTOR,
|
||||
ATLAS_SERVICES_RELEASE_REPO,
|
||||
ATLAS_SERVICES_RELEASE_REVISION,
|
||||
ASBIN,
|
||||
true,
|
||||
asartifactfiles)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Version stamp files') {
|
||||
steps {
|
||||
script {
|
||||
env.BUILD_STAMP=meta.buildstampinfo.buildstamp
|
||||
env.BUILD_DATE=meta.jenkinsbuildinfo.builddate
|
||||
env.AS_PACKAGE_VERSION=asmeta.buildstampinfo.buildstamp
|
||||
bat """
|
||||
call "${JOBSCRIPTS_COMMON}\\version_ink_ui_files.bat"
|
||||
if errorlevel 1 exit /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Compile application') {
|
||||
steps {
|
||||
script {
|
||||
env.SRC_REVISION=SOURCE_REVISION
|
||||
bat """
|
||||
call "${JOBSCRIPTS}\\autobuild.bat"
|
||||
if errorlevel 1 exit /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Prepare exports') {
|
||||
steps {
|
||||
script {
|
||||
bat """
|
||||
move "${SRC}\\binInk" .
|
||||
if errorlevel 1 exit /b 1
|
||||
|
||||
move "${SRC}\\testresults" .
|
||||
if errorlevel 1 exit /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Static analysis') {
|
||||
steps {
|
||||
script {
|
||||
recordIssues(tools: [
|
||||
msBuild(enabledForFailure: true, reportEncoding: 'UTF-8'),
|
||||
])
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checksum artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def checksummable = [
|
||||
/* Binaries are signed
|
||||
'build/**',
|
||||
'SharedPackages/**',
|
||||
*/
|
||||
]
|
||||
checksumutils = load("${autobuilder.commonscripts()}/checksum/utils.groovy")
|
||||
checksumutils.generatelist(meta, checksummable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Classifying publishable artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def publishable = [
|
||||
]
|
||||
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
|
||||
publishutils.generatelist(meta, publishable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Archiving artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def artifactlist = meta.generateartifacts(["binInk/**","testresults/**"])
|
||||
archiveArtifacts "${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
226
documentation/build_atlas_documentation.groovy
Normal file
226
documentation/build_atlas_documentation.groovy
Normal file
|
|
@ -0,0 +1,226 @@
|
|||
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)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout dependencies') {
|
||||
steps {
|
||||
script {
|
||||
configurationhelper = autobuilder.configurationhelper()
|
||||
|
||||
PYTHONURL = 'git@hydra:tools/python.git'
|
||||
PYTHONBRANCH = 'origin/3.6.3_windows'
|
||||
PYTHONDIR = "${WORKSPACE}/python"
|
||||
PYTHONROOTDIR = 'python'
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR, PYTHONROOTDIR)
|
||||
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
|
||||
|
||||
VERSTAMPINGURL = 'git@hydra:releases/ver_stamping_releases.git'
|
||||
VERSTAMPINGREVISION = "refs/tags/${VERSION_STAMPING_VERSION}"
|
||||
VERSTAMPINGDIR = "${WORKSPACE}/ver_stamping"
|
||||
VERSTAMPINGROOTDIR = 'ver_stamping_releases'
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'Version stamping', VERSTAMPINGURL, VERSTAMPINGREVISION, VERSTAMPINGDIR, VERSTAMPINGROOTDIR)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout source') {
|
||||
steps {
|
||||
script {
|
||||
SOURCEURL = 'git@hydra:gis/atlas_ui.git'
|
||||
SOURCEREVISION = SOURCE_REVISION
|
||||
SOURCEDIR = "${WORKSPACE}\\atlas_ui"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'atlas_ui', SOURCEURL, SOURCEREVISION, SOURCEDIR, '', 0, false)
|
||||
env.SOURCE_PATH = SOURCEDIR
|
||||
env.JOBSCRIPTS = "${SOURCE_PATH}\\autobuild\\documentation"
|
||||
env.JOBSCRIPTS_COMMON = "${SOURCE_PATH}\\autobuild\\common"
|
||||
env.SRC = SOURCE_PATH
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Clean exports') {
|
||||
steps {
|
||||
script {
|
||||
env.BUILDOUTPUT = "${WORKSPACE}/build"
|
||||
env.PSBIN = "${WORKSPACE}/ps_bin"
|
||||
env.ASBIN = "${WORKSPACE}/as_bin"
|
||||
env.PSSOURCE = "${WORKSPACE}/newsw"
|
||||
cleanfolders = [
|
||||
BUILDOUTPUT,
|
||||
"${WORKSPACE}/SharedPackages",
|
||||
PSBIN,
|
||||
ASBIN,
|
||||
"${WORKSPACE}/bin",
|
||||
"${WORKSPACE}/binKiosk",
|
||||
"${WORKSPACE}/documentation",
|
||||
"${WORKSPACE}/Libraries",
|
||||
"${WORKSPACE}/Atlas Release",
|
||||
|
||||
]
|
||||
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, BASEBUILDNUMBER)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Print server dependencies') {
|
||||
steps {
|
||||
script {
|
||||
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
|
||||
|
||||
def psartifactfiles = "meta/**,bin/x64/Release/Engine - Render.dll,bin/x64/Release/Engine - Render.lib,bin/x64/Release/Engine - Render.pdb,bin/x64/Release/TBarCode11_x64.dll,bin/x64/Release/GIS Utility - Toolbox.dll,bin/x64/Release/GIS Utility - Toolbox.lib,bin/x64/Release/GIS Utility - Toolbox.pdb,bin/x64/Release/zlib1.dll,bin/x64/Release/zlib1.lib,bin/x64/Release/zlib1.pdb,bin/x64/Release/GIS Utility - TCP-IP Comms.dll,bin/x64/Release/GIS Utility - TCP-IP Comms.lib,bin/x64/Release/GIS Utility - TCP-IP Comms.pdb,bin/x64/Release/Dialog - Tree Node Editor.dll,bin/x64/Release/Dialog - Tree Node Editor.lib,bin/x64/Release/Dialog - Tree Node Editor.pdb"
|
||||
psmeta = importer.artifactimport(meta,
|
||||
PRINT_SERVER_ARTIFACT_LOCATION,
|
||||
PRINT_SERVER_COMPILE_JOB,
|
||||
PRINT_SERVER_BUILD_SELECTOR,
|
||||
PRINT_SERVER_RELEASE_REPO,
|
||||
PRINT_SERVER_RELEASE_REVISION,
|
||||
PSBIN,
|
||||
true,
|
||||
psartifactfiles)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout relevant Print server source') {
|
||||
steps {
|
||||
script {
|
||||
def pssourceartifacts = "src/Engine Common"
|
||||
def pssourceurl = psmeta.gitinfo.remoteurl
|
||||
def pscommit = psmeta.gitinfo.gitrevision
|
||||
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'print_server_source', pssourceurl, pscommit, PSSOURCE, '', 0, false, pssourceartifacts)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Atlas services dependencies') {
|
||||
steps {
|
||||
script {
|
||||
def asartifactfiles = "meta/**,SharedPackages/**"
|
||||
asmeta = importer.artifactimport(meta,
|
||||
ATLAS_SERVICES_ARTIFACT_LOCATION,
|
||||
ATLAS_SERVICES_COMPILE_JOB,
|
||||
ATLAS_SERVICES_BUILD_SELECTOR,
|
||||
ATLAS_SERVICES_RELEASE_REPO,
|
||||
ATLAS_SERVICES_RELEASE_REVISION,
|
||||
ASBIN,
|
||||
true,
|
||||
asartifactfiles)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Version files') {
|
||||
steps {
|
||||
script {
|
||||
env.BUILD_STAMP=meta.buildstampinfo.buildstamp
|
||||
env.BUILD_DATE=meta.jenkinsbuildinfo.builddate
|
||||
env.PS_VERSION="1.0.${psmeta.buildstampinfo.revision}.0"
|
||||
env.PS_PACKAGE_VERSION=psmeta.buildstampinfo.buildstampprefix
|
||||
env.AS_PACKAGE_VERSION=asmeta.buildstampinfo.buildstamp
|
||||
bat """
|
||||
call "${JOBSCRIPTS_COMMON}\\create_ps_nuget.bat"
|
||||
if errorlevel 1 exit /b 1
|
||||
call "${JOBSCRIPTS_COMMON}\\version_atlas_ui_files.bat"
|
||||
if errorlevel 1 exit /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Compile application') {
|
||||
steps {
|
||||
script {
|
||||
env.SRC_REVISION=SOURCE_REVISION
|
||||
bat """
|
||||
call "${JOBSCRIPTS}\\build_atlas.bat"
|
||||
if errorlevel 1 exit /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Build documentation') {
|
||||
steps {
|
||||
script {
|
||||
bat """
|
||||
call "${JOBSCRIPTS}\\documentation_build.bat"
|
||||
if errorlevel 1 exit /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Prepare exports') {
|
||||
steps {
|
||||
script {
|
||||
bat """
|
||||
move "${SRC}\\documentation" .
|
||||
if errorlevel 1 exit /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Static analysis') {
|
||||
steps {
|
||||
script {
|
||||
recordIssues(tools: [
|
||||
msBuild(enabledForFailure: true, reportEncoding: 'UTF-8'),
|
||||
])
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checksum artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def checksummable = [
|
||||
/* Binaries are signed
|
||||
'build/**',
|
||||
'SharedPackages/**',
|
||||
*/
|
||||
]
|
||||
checksumutils = load("${autobuilder.commonscripts()}/checksum/utils.groovy")
|
||||
checksumutils.generatelist(meta, checksummable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Classifying publishable artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def publishable = [
|
||||
]
|
||||
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
|
||||
publishutils.generatelist(meta, publishable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Archiving artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def artifactlist = meta.generateartifacts(["documentation/**"])
|
||||
archiveArtifacts "${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
222
documentation/build_ink_ui_documentation.groovy
Normal file
222
documentation/build_ink_ui_documentation.groovy
Normal file
|
|
@ -0,0 +1,222 @@
|
|||
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)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout dependencies') {
|
||||
steps {
|
||||
script {
|
||||
configurationhelper = autobuilder.configurationhelper()
|
||||
|
||||
PYTHONURL = 'git@hydra:tools/python.git'
|
||||
PYTHONBRANCH = 'origin/3.6.3_windows'
|
||||
PYTHONDIR = "${WORKSPACE}/python"
|
||||
PYTHONROOTDIR = 'python'
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR, PYTHONROOTDIR)
|
||||
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
|
||||
|
||||
VERSTAMPINGURL = 'git@hydra:releases/ver_stamping_releases.git'
|
||||
VERSTAMPINGREVISION = "refs/tags/${VERSION_STAMPING_VERSION}"
|
||||
VERSTAMPINGDIR = "${WORKSPACE}/ver_stamping"
|
||||
VERSTAMPINGROOTDIR = 'ver_stamping_releases'
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'Version stamping', VERSTAMPINGURL, VERSTAMPINGREVISION, VERSTAMPINGDIR, VERSTAMPINGROOTDIR)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout source') {
|
||||
steps {
|
||||
script {
|
||||
SOURCEURL = 'git@hydra:gis/atlas_ui.git'
|
||||
SOURCEREVISION = SOURCE_REVISION
|
||||
SOURCEDIR = "${WORKSPACE}\\atlas_ui"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'atlas_ui', SOURCEURL, SOURCEREVISION, SOURCEDIR, '', 0, false)
|
||||
env.SOURCE_PATH = SOURCEDIR
|
||||
env.JOBSCRIPTS = "${SOURCE_PATH}\\autobuild\\documentation"
|
||||
env.JOBSCRIPTS_COMMON = "${SOURCE_PATH}\\autobuild\\common"
|
||||
env.SRC = SOURCE_PATH
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Clean exports') {
|
||||
steps {
|
||||
script {
|
||||
env.BUILDOUTPUT = "${WORKSPACE}/build"
|
||||
env.PSBIN = "${WORKSPACE}/ps_bin"
|
||||
env.ASBIN = "${WORKSPACE}/as_bin"
|
||||
env.AULIB = "${WORKSPACE}/atlaslibraries"
|
||||
env.PSSOURCE = "${WORKSPACE}/newsw"
|
||||
cleanfolders = [
|
||||
BUILDOUTPUT,
|
||||
"${WORKSPACE}/SharedPackages",
|
||||
PSBIN,
|
||||
ASBIN,
|
||||
AULIB,
|
||||
"${WORKSPACE}/binInk",
|
||||
"${WORKSPACE}/documentation",
|
||||
]
|
||||
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, BASEBUILDNUMBER)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Atlas UI libraries') {
|
||||
steps {
|
||||
script {
|
||||
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
|
||||
libmeta = importer.artifactimport(meta,
|
||||
ATLAS_UI_ARTIFACT_LOCATION,
|
||||
ATLAS_UI_COMPILE_JOB,
|
||||
ATLAS_UI_BUILD_SELECTOR,
|
||||
ATLAS_UI_RELEASE_REPO,
|
||||
ATLAS_UI_RELEASE_REVISION,
|
||||
AULIB,
|
||||
false)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Print server to adjust version number') {
|
||||
steps {
|
||||
script {
|
||||
def psartifactfiles = "meta/**"
|
||||
psmeta = importer.artifactimport(meta,
|
||||
PRINT_SERVER_ARTIFACT_LOCATION,
|
||||
PRINT_SERVER_COMPILE_JOB,
|
||||
PRINT_SERVER_BUILD_SELECTOR,
|
||||
PRINT_SERVER_RELEASE_REPO,
|
||||
PRINT_SERVER_RELEASE_REVISION,
|
||||
PSBIN,
|
||||
true,
|
||||
psartifactfiles) // This should increment the version number
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Atlas services to adjust version number') {
|
||||
steps {
|
||||
script {
|
||||
def asartifactfiles = "meta/**"
|
||||
asmeta = importer.artifactimport(meta,
|
||||
ATLAS_SERVICES_ARTIFACT_LOCATION,
|
||||
ATLAS_SERVICES_COMPILE_JOB,
|
||||
ATLAS_SERVICES_BUILD_SELECTOR,
|
||||
ATLAS_SERVICES_RELEASE_REPO,
|
||||
ATLAS_SERVICES_RELEASE_REVISION,
|
||||
ASBIN,
|
||||
true,
|
||||
asartifactfiles)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Version stamp files') {
|
||||
steps {
|
||||
script {
|
||||
env.BUILD_STAMP=meta.buildstampinfo.buildstamp
|
||||
env.BUILD_DATE=meta.jenkinsbuildinfo.builddate
|
||||
env.AS_PACKAGE_VERSION=asmeta.buildstampinfo.buildstamp
|
||||
bat """
|
||||
call "${JOBSCRIPTS_COMMON}\\version_ink_ui_files.bat"
|
||||
if errorlevel 1 exit /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Compile application') {
|
||||
steps {
|
||||
script {
|
||||
env.SRC_REVISION=SOURCE_REVISION
|
||||
bat """
|
||||
call "${JOBSCRIPTS}\\build_ink_ui.bat"
|
||||
if errorlevel 1 exit /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Build documentation') {
|
||||
steps {
|
||||
script {
|
||||
bat """
|
||||
call "${JOBSCRIPTS}\\ink_ui_documentation_build.bat"
|
||||
if errorlevel 1 exit /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Prepare exports') {
|
||||
steps {
|
||||
script {
|
||||
bat """
|
||||
move "${SRC}\\documentation" .
|
||||
if errorlevel 1 exit /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Static analysis') {
|
||||
steps {
|
||||
script {
|
||||
recordIssues(tools: [
|
||||
msBuild(enabledForFailure: true, reportEncoding: 'UTF-8'),
|
||||
])
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checksum artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def checksummable = [
|
||||
/* Binaries are signed
|
||||
'build/**',
|
||||
'SharedPackages/**',
|
||||
*/
|
||||
]
|
||||
checksumutils = load("${autobuilder.commonscripts()}/checksum/utils.groovy")
|
||||
checksumutils.generatelist(meta, checksummable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Classifying publishable artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def publishable = [
|
||||
]
|
||||
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
|
||||
publishutils.generatelist(meta, publishable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Archiving artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def artifactlist = meta.generateartifacts(["documentation/**"])
|
||||
archiveArtifacts "${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
162
documentation/release_note.groovy
Normal file
162
documentation/release_note.groovy
Normal file
|
|
@ -0,0 +1,162 @@
|
|||
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)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout dependencies') {
|
||||
steps {
|
||||
script {
|
||||
configurationhelper = autobuilder.configurationhelper()
|
||||
|
||||
PYTHONURL = 'git@hydra:tools/python.git'
|
||||
if (isUnix()) {
|
||||
PYTHONBRANCH = "origin/3.6.3_linux"
|
||||
}
|
||||
else {
|
||||
PYTHONBRANCH = "origin/3.6.3_windows"
|
||||
}
|
||||
PYTHONDIR = "${WORKSPACE}/python"
|
||||
PYTHONROOTDIR = 'python'
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR, PYTHONROOTDIR)
|
||||
if (isUnix()) {
|
||||
env.PYTHON = "${PYTHONDIR}/usr/local/bin/python3"
|
||||
}
|
||||
else {
|
||||
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout source') {
|
||||
steps {
|
||||
script {
|
||||
SOURCEURL = 'git@hydra:gis/atlas_ui.git'
|
||||
SOURCEREVISION = SOURCE_REVISION
|
||||
SOURCEDIR = "${WORKSPACE}\\atlas_ui"
|
||||
SOURCEROOTDIR = 'atlas_ui'
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'atlas_ui', SOURCEURL, SOURCEREVISION, SOURCEDIR, SOURCEROOTDIR, 0, false)
|
||||
env.SOURCE_PATH = SOURCEDIR
|
||||
env.JOBSCRIPTS = "${SOURCE_PATH}\\autobuild\\build_Atlas"
|
||||
env.JOBSCRIPTS_COMMON = "${SOURCE_PATH}\\autobuild\\common"
|
||||
env.SRC = SOURCE_PATH
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Clean exports') {
|
||||
steps {
|
||||
script {
|
||||
env.RELEASE_NOTES = "release_notes"
|
||||
env.PSBIN = "${WORKSPACE}/ps_bin"
|
||||
env.ASBIN = "${WORKSPACE}/as_bin"
|
||||
cleanfolders = [
|
||||
RELEASE_NOTES,
|
||||
PSBIN,
|
||||
ASBIN,
|
||||
]
|
||||
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, BASEBUILDNUMBER)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Print server to adjust version number') {
|
||||
steps {
|
||||
script {
|
||||
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
|
||||
|
||||
def psartifactfiles = "meta/**"
|
||||
psmeta = importer.artifactimport(meta,
|
||||
PRINT_SERVER_ARTIFACT_LOCATION,
|
||||
PRINT_SERVER_COMPILE_JOB,
|
||||
PRINT_SERVER_BUILD_SELECTOR,
|
||||
PRINT_SERVER_RELEASE_REPO,
|
||||
PRINT_SERVER_RELEASE_REVISION,
|
||||
PSBIN,
|
||||
true,
|
||||
psartifactfiles)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Atlas services to adjust version number') {
|
||||
steps {
|
||||
script {
|
||||
def asartifactfiles = "meta/**"
|
||||
asmeta = importer.artifactimport(meta,
|
||||
ATLAS_SERVICES_ARTIFACT_LOCATION,
|
||||
ATLAS_SERVICES_COMPILE_JOB,
|
||||
ATLAS_SERVICES_BUILD_SELECTOR,
|
||||
ATLAS_SERVICES_RELEASE_REPO,
|
||||
ATLAS_SERVICES_RELEASE_REVISION,
|
||||
ASBIN,
|
||||
true,
|
||||
asartifactfiles)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Copy release notes') {
|
||||
steps {
|
||||
script {
|
||||
dir("${SOURCEDIR}/releasenotes") {
|
||||
fileOperations([fileCopyOperation(targetLocation: "${WORKSPACE}/${RELEASE_NOTES}", includes: '*.txt')])
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checksum artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def checksummable = [
|
||||
"${RELEASE_NOTES}/**",
|
||||
]
|
||||
checksumutils = load("${autobuilder.commonscripts()}/checksum/utils.groovy")
|
||||
checksumutils.generatelist(meta, checksummable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Classifying publishable artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def publishable = [
|
||||
"${RELEASE_NOTES}/**",
|
||||
]
|
||||
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
|
||||
publishutils.generatelist(meta, publishable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Archiving artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def artifactlist = meta.generateartifacts(["${RELEASE_NOTES}/**"])
|
||||
archiveArtifacts "${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
336
install/install_atlas_ink_ui.groovy
Normal file
336
install/install_atlas_ink_ui.groovy
Normal file
|
|
@ -0,0 +1,336 @@
|
|||
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)
|
||||
|
||||
if (INSTALLSHIELD2015_CMD == "" || INSTALLSHIELD2018_CMD == "" || INSTALLSHIELD2019_CMD == "" || DOTNET_FRAMEWORK64_PATH == "" || WINDOWS_DRIVER_KIT_8_1 == "") {
|
||||
echo "Either INSTALLSHIELD2015_CMD, INSTALLSHIELD2018_CMD, INSTALLSHIELD2019_CMD, DOTNET_FRAMEWORK64_PATH or WINDOWS_DRIVER_KIT_8_1 environment variables have not been defined"
|
||||
currentBuild.result = 'FAILED'
|
||||
exit(1)
|
||||
}
|
||||
installerlist = env.INSTALLERS_TO_BUILD
|
||||
if (installerlist != null) {
|
||||
installerlist = installerlist.trim()
|
||||
} else {
|
||||
installerlist = ''
|
||||
}
|
||||
toBuild = []
|
||||
if (installerlist) {
|
||||
toBuildUntrimmed = installerlist.split(',')
|
||||
toBuildUntrimmed.each {
|
||||
toBuild.add(it.trim())
|
||||
}
|
||||
}
|
||||
}
|
||||
echo "Installer list: ${installerlist}"
|
||||
}
|
||||
}
|
||||
stage('Nothing to build check') {
|
||||
when {
|
||||
expression {
|
||||
!toBuild
|
||||
}
|
||||
}
|
||||
steps {
|
||||
echo 'No installers to build'
|
||||
script {
|
||||
currentBuild.result = 'UNSTABLE'
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout dependencies') {
|
||||
when {
|
||||
expression {
|
||||
toBuild
|
||||
}
|
||||
}
|
||||
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 = 'origin/master'
|
||||
SUPPORTDIR = "${WORKSPACE}\\gissupport"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'gissupport', SUPPORTURL, SUPPORTBRANCH, SUPPORTDIR)
|
||||
env.INST_SUPPORT = SUPPORTDIR
|
||||
|
||||
EULAURL = 'git@hydra:gis/giseula.git'
|
||||
EULABRANCH = 'origin/master'
|
||||
EULADIR = "${WORKSPACE}\\giseula"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'giseula', EULAURL, EULABRANCH, EULADIR)
|
||||
env.INST_EULA = EULADIR
|
||||
|
||||
PREREQURL = 'git@hydra:gis/installerprerequisites.git'
|
||||
PREREQBRANCH = 'origin/master'
|
||||
PREREQDIR = "${WORKSPACE}\\prereq"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'installerprerequisites', PREREQURL, PREREQBRANCH, PREREQDIR)
|
||||
env.INST_PREQ = PREREQDIR
|
||||
|
||||
DIGSIGURL = 'git@hydra:gis/digitalsignature.git'
|
||||
DIGSIGBRANCH = 'origin/master'
|
||||
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:gis/atlas_ui.git'
|
||||
SOURCEREVISION = SOURCE_REVISION
|
||||
SOURCEDIR = "${WORKSPACE}\\atlas_ui"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'atlas_ui', SOURCEURL, SOURCEREVISION, SOURCEDIR, '', 0, false)
|
||||
env.SOURCE_PATH = SOURCEDIR
|
||||
env.INST_RELEASE_NOTES = "${SOURCE_PATH}\\releasenotes"
|
||||
env.INST_SRC = "${SOURCE_PATH}\\src"
|
||||
env.ATLAS_SOURCE_PATH = SOURCE_PATH
|
||||
}
|
||||
}
|
||||
}
|
||||
stage("Clean exports") {
|
||||
steps {
|
||||
script {
|
||||
env.IMPORTSPATH = "${WORKSPACE}\\imports"
|
||||
env.INTERMEDIATEEXPORTSPATH = "${WORKSPACE}\\info"
|
||||
env.EXPORTSPATH = "installers"
|
||||
env.PS_ARTIFACTS_ROOT = "${IMPORTSPATH}\\ps_bin"
|
||||
env.VERSIONINFO = "${WORKSPACE}\\versioninfo"
|
||||
env.PSBIN = "${WORKSPACE}/ps_bin"
|
||||
env.ASBIN = "${WORKSPACE}/as_bin"
|
||||
cleanfolders = [
|
||||
"${IMPORTSPATH}",
|
||||
"${INTERMEDIATEEXPORTSPATH}",
|
||||
"${EXPORTSPATH}",
|
||||
"${WORKSPACE}/mcs_bin",
|
||||
"${VERSIONINFO}",
|
||||
PSBIN,
|
||||
ASBIN,
|
||||
]
|
||||
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
|
||||
cleaner.clean(cleanfolders)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Generating version info') {
|
||||
when {
|
||||
expression {
|
||||
toBuild
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
version = load("${autobuilder.commonscripts()}/versionnumbering/generate.groovy")
|
||||
version.generate(meta, SOURCE_REVISION, SOURCE_PATH, BASEBUILDNUMBER)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Print server to adjust version number') {
|
||||
when {
|
||||
expression {
|
||||
toBuild
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
|
||||
|
||||
def importoptions = importer.getNewImportOptions()
|
||||
importoptions.source(PRINT_SERVER_ARTIFACT_LOCATION,
|
||||
PRINT_SERVER_COMPILE_JOB,
|
||||
PRINT_SERVER_BUILD_SELECTOR,
|
||||
PRINT_SERVER_RELEASE_REPO,
|
||||
PRINT_SERVER_RELEASE_REVISION)
|
||||
importoptions.setincrementversionnumber(true)
|
||||
importoptions.setfilter('meta/**');
|
||||
importoptions.setappendtoparentmeta(false)
|
||||
importer.artifactimport(meta, importoptions, PSBIN)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Atlas services to adjust version number') {
|
||||
when {
|
||||
expression {
|
||||
toBuild
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
def importoptions = importer.getNewImportOptions()
|
||||
importoptions.source(ATLAS_SERVICES_ARTIFACT_LOCATION,
|
||||
ATLAS_SERVICES_COMPILE_JOB,
|
||||
ATLAS_SERVICES_BUILD_SELECTOR,
|
||||
ATLAS_SERVICES_RELEASE_REPO,
|
||||
ATLAS_SERVICES_RELEASE_REVISION)
|
||||
importoptions.setincrementversionnumber(true)
|
||||
importoptions.setfilter('meta/**');
|
||||
importoptions.setappendtoparentmeta(false)
|
||||
importer.artifactimport(meta, importoptions, ASBIN)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage("Import binaries") {
|
||||
when {
|
||||
expression {
|
||||
toBuild
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
env.BUILD_STAMP=meta.buildstampinfo.buildstamp
|
||||
artifactDetails = [
|
||||
// Key, Artifacts Source project Artifacts source selector, Destination folder Increment Version Number Artifacts to copy Artifacts to not copy Binaries Folders
|
||||
AtlasSet: [ATLAS_COMPILE_JOB, ATLAS_COMPILE_JOB_SELECTOR, "${IMPORTSPATH}\\build\\atlasset", false, 'meta/**, bin/**, binKiosk/**', '**/*.lib', [ 'bin' ], ],
|
||||
InkUISet: [INK_UI_COMPILE_JOB, INK_UI_COMPILE_JOB_SELECTOR, "${IMPORTSPATH}\\build\\inkuiset", false, 'meta/**, binInk/**', '**/*.lib', [ 'binInk' ], ],
|
||||
]
|
||||
installerDetails = [
|
||||
// Key, Installer command artifactSet Target folder Execution path ISM project file Variant Intermediate output path Component base folder Final filename
|
||||
INK_CONFIG_UI: [INSTALLSHIELD2019_CMD, ['InkUISet','AtlasSet'], 'install_ink_ui', "${ATLAS_SOURCE_PATH}\\installer\\build\\ink_system_ui", 'InkSystemConfigurationUI.ism', '', "${INTERMEDIATEEXPORTSPATH}/install_ink_ui/x64/GIS Atlas Ink System Configuration UI/DiskImages/DISK1/GIS Atlas Ink System Configuration UI.exe", "${EXPORTSPATH}/GIS Atlas Ink System Configuration UI", "GIS Atlas Ink System Configuration UI ${BUILD_STAMP}.exe" ],
|
||||
INK_OPERATOR_UI: [INSTALLSHIELD2019_CMD, ['InkUISet','AtlasSet'], 'install_ink_ui', "${ATLAS_SOURCE_PATH}\\installer\\build\\ink_system_ui", 'InkSystemOperatorUI.ism', '', "${INTERMEDIATEEXPORTSPATH}/install_ink_ui/x64/GIS Atlas Ink System Operator UI/DiskImages/DISK1/GIS Atlas Ink System Operator UI.exe", "${EXPORTSPATH}/GIS Atlas Ink System Operator UI", "GIS Atlas Ink System Operator UI ${BUILD_STAMP}.exe" ],
|
||||
INK_UI_MODULES: [INSTALLSHIELD2019_CMD, ['InkUISet','AtlasSet'], 'install_ink_ui', "${ATLAS_SOURCE_PATH}\\installer\\build\\ink_system_ui", 'InkSystemToolModules.ism', '', "${INTERMEDIATEEXPORTSPATH}/install_ink_ui/x64/GIS Atlas Ink System Tool Modules/DiskImages/DISK1/GIS Atlas Ink System Tool Modules.exe", "${EXPORTSPATH}/GIS Atlas Ink System Tool Modules", "GIS Atlas Ink System Tool Modules ${BUILD_STAMP}.exe" ],
|
||||
]
|
||||
installerhelper = load("${autobuilder.commonscripts()}/install/installhelper.groovy")
|
||||
artifactFetched = installerhelper.artifactsImporter(meta, importer, 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") {
|
||||
when {
|
||||
expression {
|
||||
toBuild
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
fileOperations([folderCreateOperation(INTERMEDIATEEXPORTSPATH)])
|
||||
installerpublishlist = []
|
||||
for (installer in toBuild) {
|
||||
(installcmd, artifactKey, processingFolder, EXECUTIONPATH, ISMPROJECT, VARIANT, pathToIntermediate, FINALBASEFOLDER, FINALFILENAME) = installerDetails.get(installer)
|
||||
if (artifactKey instanceof java.util.ArrayList) {
|
||||
artifactKey = artifactKey[0]
|
||||
}
|
||||
def importmeta = artifactFetched.get(artifactKey)
|
||||
|
||||
|
||||
echo "For: ${installer} build stamp is: ${importmeta.buildstampinfo.buildstamp}"
|
||||
def INST_ISVERSION = importmeta.buildstampinfo.buildstamp
|
||||
|
||||
(sourceProject, sourceselector, destFolder, incrementversionnumber, toCopy, notToCopy, binariesFolders) = artifactDetails.get(artifactKey)
|
||||
def COMPILE_IMPORTS = destFolder
|
||||
|
||||
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
|
||||
}
|
||||
installerhelper.checkISMfile("${EXECUTIONPATH}\\${ISMPROJECT}")
|
||||
installerhelper.selectSigningCertificate(NODE_NAME, "${EXECUTIONPATH}\\${ISMPROJECT}")
|
||||
|
||||
dir(EXECUTIONPATH) {
|
||||
// INSTALLSHIELD201X_CMD and DOTNET_FRAMEWORK64_PATH must be externally defined
|
||||
bat """
|
||||
set INST_COMMON_PARAMETERS=-y "${INST_ISVERSION}" -l "WORKSPACE=${WORKSPACE}" -l "PATH_TO_CERTIFICATE_PFX=${PATH_TO_CERTIFICATE_PFX}" -l "COMPILE_IMPORTS=${COMPILE_IMPORTS}" -l "IMPORTS_ROOT=${IMPORTSPATH}" -l "PS_ARTIFACTS_ROOT=${PS_ARTIFACTS_ROOT}" -l "INST_RELEASE_NOTES=${INST_RELEASE_NOTES}" -l "INST_SRC=${INST_SRC}" -l "INST_OUT=${INST_OUT}" -l "INST_EULA=${INST_EULA}" -l "INST_SUPPORT=${INST_SUPPORT}" -prqpath "${INST_PREQ}" ${INST_VERBOSE}
|
||||
"${installcmd}" -t "${DOTNET_FRAMEWORK64_PATH}" -p "${ISMPROJECT}" %INST_COMMON_PARAMETERS% ${INST_VARIANT} -a x64"
|
||||
"""
|
||||
}
|
||||
|
||||
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') {
|
||||
when {
|
||||
expression {
|
||||
toBuild
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
def publishable = installerpublishlist
|
||||
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
|
||||
publishutils.generatelist(meta, publishable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Archiving artifacts') {
|
||||
when {
|
||||
expression {
|
||||
toBuild
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
ArrayList<String> itemsForRelease = ["info/**", "installers/**"]
|
||||
def artifactlist = meta.generateartifacts(itemsForRelease)
|
||||
archiveArtifacts "${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Check for unstable build') {
|
||||
when {
|
||||
expression {
|
||||
toBuild
|
||||
}
|
||||
}
|
||||
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'
|
||||
}
|
||||
}
|
||||
}
|
||||
333
install/install_atlas_professional.groovy
Normal file
333
install/install_atlas_professional.groovy
Normal file
|
|
@ -0,0 +1,333 @@
|
|||
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)
|
||||
|
||||
if (INSTALLSHIELD2015_CMD == "" || INSTALLSHIELD2018_CMD == "" || INSTALLSHIELD2019_CMD == "" || DOTNET_FRAMEWORK64_PATH == "" || WINDOWS_DRIVER_KIT_8_1 == "") {
|
||||
echo "Either INSTALLSHIELD2015_CMD, INSTALLSHIELD2018_CMD, INSTALLSHIELD2019_CMD, DOTNET_FRAMEWORK64_PATH or WINDOWS_DRIVER_KIT_8_1 environment variables have not been defined"
|
||||
currentBuild.result = 'FAILED'
|
||||
exit(1)
|
||||
}
|
||||
installerlist = env.INSTALLERS_TO_BUILD
|
||||
if (installerlist != null) {
|
||||
installerlist = installerlist.trim()
|
||||
} else {
|
||||
installerlist = ''
|
||||
}
|
||||
toBuild = []
|
||||
if (installerlist) {
|
||||
toBuildUntrimmed = installerlist.split(',')
|
||||
toBuildUntrimmed.each {
|
||||
toBuild.add(it.trim())
|
||||
}
|
||||
}
|
||||
}
|
||||
echo "Installer list: ${installerlist}"
|
||||
}
|
||||
}
|
||||
stage('Nothing to build check') {
|
||||
when {
|
||||
expression {
|
||||
!toBuild
|
||||
}
|
||||
}
|
||||
steps {
|
||||
echo 'No installers to build'
|
||||
script {
|
||||
currentBuild.result = 'UNSTABLE'
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout dependencies') {
|
||||
when {
|
||||
expression {
|
||||
toBuild
|
||||
}
|
||||
}
|
||||
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 = 'origin/master'
|
||||
SUPPORTDIR = "${WORKSPACE}\\gissupport"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'gissupport', SUPPORTURL, SUPPORTBRANCH, SUPPORTDIR)
|
||||
env.INST_SUPPORT = SUPPORTDIR
|
||||
|
||||
EULAURL = 'git@hydra:gis/giseula.git'
|
||||
EULABRANCH = 'origin/master'
|
||||
EULADIR = "${WORKSPACE}\\giseula"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'giseula', EULAURL, EULABRANCH, EULADIR)
|
||||
env.INST_EULA = EULADIR
|
||||
|
||||
PREREQURL = 'git@hydra:gis/installerprerequisites.git'
|
||||
PREREQBRANCH = 'origin/master'
|
||||
PREREQDIR = "${WORKSPACE}\\prereq"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'installerprerequisites', PREREQURL, PREREQBRANCH, PREREQDIR)
|
||||
env.INST_PREQ = PREREQDIR
|
||||
|
||||
DIGSIGURL = 'git@hydra:gis/digitalsignature.git'
|
||||
DIGSIGBRANCH = 'origin/master'
|
||||
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:gis/atlas_ui.git'
|
||||
SOURCEREVISION = SOURCE_REVISION
|
||||
SOURCEDIR = "${WORKSPACE}\\atlas_ui"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'atlas_ui', SOURCEURL, SOURCEREVISION, SOURCEDIR, '', 0, false)
|
||||
env.SOURCE_PATH = SOURCEDIR
|
||||
env.INST_RELEASE_NOTES = "${SOURCE_PATH}\\releasenotes"
|
||||
env.INST_SRC = "${SOURCE_PATH}\\src"
|
||||
env.ATLAS_SOURCE_PATH = SOURCE_PATH
|
||||
}
|
||||
}
|
||||
}
|
||||
stage("Clean exports") {
|
||||
steps {
|
||||
script {
|
||||
env.IMPORTSPATH = "${WORKSPACE}\\imports"
|
||||
env.INTERMEDIATEEXPORTSPATH = "${WORKSPACE}\\info"
|
||||
env.EXPORTSPATH = "installers"
|
||||
env.PS_ARTIFACTS_ROOT = "${IMPORTSPATH}\\ps_bin"
|
||||
env.PSBIN = "${WORKSPACE}/ps_bin"
|
||||
env.ASBIN = "${WORKSPACE}/as_bin"
|
||||
env.VERSIONINFO = "${WORKSPACE}\\versioninfo"
|
||||
cleanfolders = [
|
||||
"${IMPORTSPATH}",
|
||||
"${INTERMEDIATEEXPORTSPATH}",
|
||||
"${EXPORTSPATH}",
|
||||
"${WORKSPACE}/mcs_bin",
|
||||
"${VERSIONINFO}",
|
||||
PSBIN,
|
||||
ASBIN,
|
||||
]
|
||||
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
|
||||
cleaner.clean(cleanfolders)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Generating version info') {
|
||||
when {
|
||||
expression {
|
||||
toBuild
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
version = load("${autobuilder.commonscripts()}/versionnumbering/generate.groovy")
|
||||
version.generate(meta, SOURCE_REVISION, SOURCE_PATH, BASEBUILDNUMBER)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Print server to adjust version number') {
|
||||
when {
|
||||
expression {
|
||||
toBuild
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
|
||||
|
||||
def importoptions = importer.getNewImportOptions()
|
||||
importoptions.source(PRINT_SERVER_ARTIFACT_LOCATION,
|
||||
PRINT_SERVER_COMPILE_JOB,
|
||||
PRINT_SERVER_BUILD_SELECTOR,
|
||||
PRINT_SERVER_RELEASE_REPO,
|
||||
PRINT_SERVER_RELEASE_REVISION)
|
||||
importoptions.setincrementversionnumber(true)
|
||||
importoptions.setfilter('meta/**');
|
||||
importoptions.setappendtoparentmeta(false)
|
||||
importer.artifactimport(meta, importoptions, PSBIN)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Atlas services to adjust version number') {
|
||||
when {
|
||||
expression {
|
||||
toBuild
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
def importoptions = importer.getNewImportOptions()
|
||||
importoptions.source(ATLAS_SERVICES_ARTIFACT_LOCATION,
|
||||
ATLAS_SERVICES_COMPILE_JOB,
|
||||
ATLAS_SERVICES_BUILD_SELECTOR,
|
||||
ATLAS_SERVICES_RELEASE_REPO,
|
||||
ATLAS_SERVICES_RELEASE_REVISION)
|
||||
importoptions.setincrementversionnumber(true)
|
||||
importoptions.setfilter('meta/**');
|
||||
importoptions.setappendtoparentmeta(false)
|
||||
importer.artifactimport(meta, importoptions, ASBIN)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage("Import binaries") {
|
||||
when {
|
||||
expression {
|
||||
toBuild
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
env.BUILD_STAMP=meta.buildstampinfo.buildstamp
|
||||
artifactDetails = [
|
||||
// Key, Artifacts Source project Artifacts source selector, Destination folder Increment Version Number Artifacts to copy Artifacts to not copy Binaries Folders
|
||||
AtlasSet: [ATLAS_COMPILE_JOB, ATLAS_COMPILE_JOB_SELECTOR, "${IMPORTSPATH}\\build\\atlasset", false, 'meta/**, bin/**, binKiosk/**', '**/*.lib', [ 'bin' ], ],
|
||||
|
||||
]
|
||||
installerDetails = [
|
||||
// Key, Installer command artifactSet Target folder Execution path ISM project file Variant Intermediate output path Component base folder Final filename
|
||||
ATLAS_PRO_PRINT_SERVER: [INSTALLSHIELD2019_CMD, 'AtlasSet', 'install_atlas', "${ATLAS_SOURCE_PATH}\\installer\\build\\atlas", 'AtlasProfessionalPrintServer.ism', '', "${INTERMEDIATEEXPORTSPATH}/install_atlas/x64/GIS Atlas Professional for Print Server/DiskImages/DISK1/GIS Atlas Professional for Print Server.exe", "${EXPORTSPATH}/GIS Atlas Professional for Print Server", "GIS Atlas Professional for Print Server ${BUILD_STAMP}.exe" ],
|
||||
ATLAS_PRO: [INSTALLSHIELD2019_CMD, 'AtlasSet', 'install_atlas', "${ATLAS_SOURCE_PATH}\\installer\\build\\atlas", 'AtlasProfessional.ism', '', "${INTERMEDIATEEXPORTSPATH}/install_atlas/x64/GIS Atlas Professional/DiskImages/DISK1/GIS Atlas Professional.exe", "${EXPORTSPATH}/GIS Atlas Professional", "GIS Atlas Professional ${BUILD_STAMP}.exe" ],
|
||||
ATLAS_PRODUCTION: [INSTALLSHIELD2019_CMD, 'AtlasSet', 'install_atlas', "${ATLAS_SOURCE_PATH}\\installer\\build\\atlas", 'AtlasProduction.ism', '', "${INTERMEDIATEEXPORTSPATH}/install_atlas/x64/GIS Atlas Production/DiskImages/DISK1/GIS Atlas Production.exe", "${EXPORTSPATH}/GIS Atlas Production", "GIS Atlas Production ${BUILD_STAMP}.exe" ],
|
||||
]
|
||||
installerhelper = load("${autobuilder.commonscripts()}/install/installhelper.groovy")
|
||||
artifactFetched = installerhelper.artifactsImporter(meta, importer, 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") {
|
||||
when {
|
||||
expression {
|
||||
toBuild
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
fileOperations([folderCreateOperation(INTERMEDIATEEXPORTSPATH)])
|
||||
installerpublishlist = []
|
||||
for (installer in toBuild) {
|
||||
(installcmd, artifactKey, processingFolder, EXECUTIONPATH, ISMPROJECT, VARIANT, pathToIntermediate, FINALBASEFOLDER, FINALFILENAME) = installerDetails.get(installer)
|
||||
|
||||
def importmeta = artifactFetched.get(artifactKey)
|
||||
|
||||
echo "For: ${installer} build stamp is: ${importmeta.buildstampinfo.buildstamp}"
|
||||
def INST_ISVERSION = importmeta.buildstampinfo.buildstamp
|
||||
|
||||
(sourceProject, sourceselector, destFolder, incrementversionnumber, toCopy, notToCopy, binariesFolders) = artifactDetails.get(artifactKey)
|
||||
def COMPILE_IMPORTS = destFolder
|
||||
|
||||
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
|
||||
}
|
||||
installerhelper.checkISMfile("${EXECUTIONPATH}\\${ISMPROJECT}")
|
||||
installerhelper.selectSigningCertificate(NODE_NAME, "${EXECUTIONPATH}\\${ISMPROJECT}")
|
||||
|
||||
dir(EXECUTIONPATH) {
|
||||
// INSTALLSHIELD201X_CMD and DOTNET_FRAMEWORK64_PATH must be externally defined
|
||||
bat """
|
||||
set INST_COMMON_PARAMETERS=-y "${INST_ISVERSION}" -l "WORKSPACE=${WORKSPACE}" -l "PATH_TO_CERTIFICATE_PFX=${PATH_TO_CERTIFICATE_PFX}" -l "COMPILE_IMPORTS=${COMPILE_IMPORTS}" -l "IMPORTS_ROOT=${IMPORTSPATH}" -l "PS_ARTIFACTS_ROOT=${PS_ARTIFACTS_ROOT}" -l "INST_RELEASE_NOTES=${INST_RELEASE_NOTES}" -l "INST_SRC=${INST_SRC}" -l "INST_OUT=${INST_OUT}" -l "INST_EULA=${INST_EULA}" -l "INST_SUPPORT=${INST_SUPPORT}" -prqpath "${INST_PREQ}" ${INST_VERBOSE}
|
||||
"${installcmd}" -t "${DOTNET_FRAMEWORK64_PATH}" -p "${ISMPROJECT}" %INST_COMMON_PARAMETERS% ${INST_VARIANT} -a x64"
|
||||
"""
|
||||
}
|
||||
|
||||
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') {
|
||||
when {
|
||||
expression {
|
||||
toBuild
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
def publishable = installerpublishlist
|
||||
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
|
||||
publishutils.generatelist(meta, publishable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Archiving artifacts') {
|
||||
when {
|
||||
expression {
|
||||
toBuild
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
ArrayList<String> itemsForRelease = ["info/**", "installers/**"]
|
||||
def artifactlist = meta.generateartifacts(itemsForRelease)
|
||||
archiveArtifacts "${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Check for unstable build') {
|
||||
when {
|
||||
expression {
|
||||
toBuild
|
||||
}
|
||||
}
|
||||
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'
|
||||
}
|
||||
}
|
||||
}
|
||||
330
install/install_atlas_sdk.groovy
Normal file
330
install/install_atlas_sdk.groovy
Normal file
|
|
@ -0,0 +1,330 @@
|
|||
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)
|
||||
|
||||
if (INSTALLSHIELD2015_CMD == "" || INSTALLSHIELD2018_CMD == "" || INSTALLSHIELD2019_CMD == "" || DOTNET_FRAMEWORK64_PATH == "" || WINDOWS_DRIVER_KIT_8_1 == "") {
|
||||
echo "Either INSTALLSHIELD2015_CMD, INSTALLSHIELD2018_CMD, INSTALLSHIELD2019_CMD, DOTNET_FRAMEWORK64_PATH or WINDOWS_DRIVER_KIT_8_1 environment variables have not been defined"
|
||||
currentBuild.result = 'FAILED'
|
||||
exit(1)
|
||||
}
|
||||
installerlist = env.INSTALLERS_TO_BUILD
|
||||
if (installerlist != null) {
|
||||
installerlist = installerlist.trim()
|
||||
} else {
|
||||
installerlist = ''
|
||||
}
|
||||
toBuild = []
|
||||
if (installerlist) {
|
||||
toBuildUntrimmed = installerlist.split(',')
|
||||
toBuildUntrimmed.each {
|
||||
toBuild.add(it.trim())
|
||||
}
|
||||
}
|
||||
}
|
||||
echo "Installer list: ${installerlist}"
|
||||
}
|
||||
}
|
||||
stage('Nothing to build check') {
|
||||
when {
|
||||
expression {
|
||||
!toBuild
|
||||
}
|
||||
}
|
||||
steps {
|
||||
echo 'No installers to build'
|
||||
script {
|
||||
currentBuild.result = 'UNSTABLE'
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout dependencies') {
|
||||
when {
|
||||
expression {
|
||||
toBuild
|
||||
}
|
||||
}
|
||||
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 = 'origin/master'
|
||||
SUPPORTDIR = "${WORKSPACE}\\gissupport"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'gissupport', SUPPORTURL, SUPPORTBRANCH, SUPPORTDIR)
|
||||
env.INST_SUPPORT = SUPPORTDIR
|
||||
|
||||
EULAURL = 'git@hydra:gis/giseula.git'
|
||||
EULABRANCH = 'origin/master'
|
||||
EULADIR = "${WORKSPACE}\\giseula"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'giseula', EULAURL, EULABRANCH, EULADIR)
|
||||
env.INST_EULA = EULADIR
|
||||
|
||||
PREREQURL = 'git@hydra:gis/installerprerequisites.git'
|
||||
PREREQBRANCH = 'origin/master'
|
||||
PREREQDIR = "${WORKSPACE}\\prereq"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'installerprerequisites', PREREQURL, PREREQBRANCH, PREREQDIR)
|
||||
env.INST_PREQ = PREREQDIR
|
||||
|
||||
DIGSIGURL = 'git@hydra:gis/digitalsignature.git'
|
||||
DIGSIGBRANCH = 'origin/master'
|
||||
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:gis/atlas_ui.git'
|
||||
SOURCEREVISION = SOURCE_REVISION
|
||||
SOURCEDIR = "${WORKSPACE}\\atlas_ui"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'atlas_ui', SOURCEURL, SOURCEREVISION, SOURCEDIR, '', 0, false)
|
||||
env.SOURCE_PATH = SOURCEDIR
|
||||
env.INST_RELEASE_NOTES = "${SOURCE_PATH}\\releasenotes"
|
||||
env.INST_SRC = "${SOURCE_PATH}\\src"
|
||||
env.ATLAS_SOURCE_PATH = SOURCE_PATH
|
||||
}
|
||||
}
|
||||
}
|
||||
stage("Clean exports") {
|
||||
steps {
|
||||
script {
|
||||
env.IMPORTSPATH = "${WORKSPACE}\\imports"
|
||||
env.INTERMEDIATEEXPORTSPATH = "${WORKSPACE}\\info"
|
||||
env.EXPORTSPATH = "installers"
|
||||
env.PS_ARTIFACTS_ROOT = "${IMPORTSPATH}\\ps_bin"
|
||||
env.VERSIONINFO = "${WORKSPACE}\\versioninfo"
|
||||
env.PSBIN = "${WORKSPACE}/ps_bin"
|
||||
env.ASBIN = "${WORKSPACE}/as_bin"
|
||||
cleanfolders = [
|
||||
"${IMPORTSPATH}",
|
||||
"${INTERMEDIATEEXPORTSPATH}",
|
||||
"${EXPORTSPATH}",
|
||||
"${WORKSPACE}/mcs_bin",
|
||||
"${VERSIONINFO}",
|
||||
PSBIN,
|
||||
ASBIN,
|
||||
]
|
||||
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
|
||||
cleaner.clean(cleanfolders)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Generating version info') {
|
||||
when {
|
||||
expression {
|
||||
toBuild
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
version = load("${autobuilder.commonscripts()}/versionnumbering/generate.groovy")
|
||||
version.generate(meta, SOURCE_REVISION, SOURCE_PATH, BASEBUILDNUMBER)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Print server to adjust version number') {
|
||||
when {
|
||||
expression {
|
||||
toBuild
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
|
||||
|
||||
def importoptions = importer.getNewImportOptions()
|
||||
importoptions.source(PRINT_SERVER_ARTIFACT_LOCATION,
|
||||
PRINT_SERVER_COMPILE_JOB,
|
||||
PRINT_SERVER_BUILD_SELECTOR,
|
||||
PRINT_SERVER_RELEASE_REPO,
|
||||
PRINT_SERVER_RELEASE_REVISION)
|
||||
importoptions.setincrementversionnumber(true)
|
||||
importoptions.setfilter('meta/**');
|
||||
importoptions.setappendtoparentmeta(false)
|
||||
importer.artifactimport(meta, importoptions, PSBIN)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Atlas services to adjust version number') {
|
||||
when {
|
||||
expression {
|
||||
toBuild
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
def importoptions = importer.getNewImportOptions()
|
||||
importoptions.source(ATLAS_SERVICES_ARTIFACT_LOCATION,
|
||||
ATLAS_SERVICES_COMPILE_JOB,
|
||||
ATLAS_SERVICES_BUILD_SELECTOR,
|
||||
ATLAS_SERVICES_RELEASE_REPO,
|
||||
ATLAS_SERVICES_RELEASE_REVISION)
|
||||
importoptions.setincrementversionnumber(true)
|
||||
importoptions.setfilter('meta/**');
|
||||
importoptions.setappendtoparentmeta(false)
|
||||
importer.artifactimport(meta, importoptions, ASBIN)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage("Import binaries") {
|
||||
when {
|
||||
expression {
|
||||
toBuild
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
env.BUILD_STAMP=meta.buildstampinfo.buildstamp
|
||||
artifactDetails = [
|
||||
// Key, Artifacts Source project Artifacts source selector, Destination folder Increment Version Number Artifacts to copy Artifacts to not copy Binaries Folders
|
||||
AtlasSDKSet: [ATLAS_COMPILE_JOB, ATLAS_COMPILE_JOB_SELECTOR, "${IMPORTSPATH}\\build\\atlassdkset", false, 'meta/**, bin/**, binKiosk/**, Libraries/**, documentation/**, LocalisationSDK/**', '**/*.lib', [ 'bin', 'binKiosk' ], ],
|
||||
]
|
||||
installerDetails = [
|
||||
// Key, Installer command artifactSet Target folder Execution path ISM project file Variant Intermediate output path Component base folder Final filename
|
||||
ATLAS_SDK: [INSTALLSHIELD2019_CMD, 'AtlasSDKSet', 'install_atlas_sdk', "${ATLAS_SOURCE_PATH}\\installer\\build\\atlas_sdk", 'AtlasSDK.ism', '', "${INTERMEDIATEEXPORTSPATH}/install_atlas_sdk/x64/GIS Atlas SDK/DiskImages/DISK1/GIS Atlas SDK.exe", "${EXPORTSPATH}/GIS Atlas SDK", "GIS Atlas SDK ${BUILD_STAMP}.exe" ],
|
||||
]
|
||||
installerhelper = load("${autobuilder.commonscripts()}/install/installhelper.groovy")
|
||||
artifactFetched = installerhelper.artifactsImporter(meta, importer, 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") {
|
||||
when {
|
||||
expression {
|
||||
toBuild
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
fileOperations([folderCreateOperation(INTERMEDIATEEXPORTSPATH)])
|
||||
installerpublishlist = []
|
||||
for (installer in toBuild) {
|
||||
(installcmd, artifactKey, processingFolder, EXECUTIONPATH, ISMPROJECT, VARIANT, pathToIntermediate, FINALBASEFOLDER, FINALFILENAME) = installerDetails.get(installer)
|
||||
|
||||
def importmeta = artifactFetched.get(artifactKey)
|
||||
|
||||
echo "For: ${installer} build stamp is: ${importmeta.buildstampinfo.buildstamp}"
|
||||
def INST_ISVERSION = importmeta.buildstampinfo.buildstamp
|
||||
|
||||
(sourceProject, sourceselector, destFolder, incrementversionnumber, toCopy, notToCopy, binariesFolders) = artifactDetails.get(artifactKey)
|
||||
def COMPILE_IMPORTS = destFolder
|
||||
|
||||
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
|
||||
}
|
||||
installerhelper.checkISMfile("${EXECUTIONPATH}\\${ISMPROJECT}")
|
||||
installerhelper.selectSigningCertificate(NODE_NAME, "${EXECUTIONPATH}\\${ISMPROJECT}")
|
||||
|
||||
dir(EXECUTIONPATH) {
|
||||
// INSTALLSHIELD201X_CMD and DOTNET_FRAMEWORK64_PATH must be externally defined
|
||||
bat """
|
||||
set INST_COMMON_PARAMETERS=-y "${INST_ISVERSION}" -l "WORKSPACE=${WORKSPACE}" -l "PATH_TO_CERTIFICATE_PFX=${PATH_TO_CERTIFICATE_PFX}" -l "COMPILE_IMPORTS=${COMPILE_IMPORTS}" -l "IMPORTS_ROOT=${IMPORTSPATH}" -l "PS_ARTIFACTS_ROOT=${PS_ARTIFACTS_ROOT}" -l "INST_RELEASE_NOTES=${INST_RELEASE_NOTES}" -l "INST_SRC=${INST_SRC}" -l "INST_OUT=${INST_OUT}" -l "INST_EULA=${INST_EULA}" -l "INST_SUPPORT=${INST_SUPPORT}" -prqpath "${INST_PREQ}" ${INST_VERBOSE}
|
||||
"${installcmd}" -t "${DOTNET_FRAMEWORK64_PATH}" -p "${ISMPROJECT}" %INST_COMMON_PARAMETERS% ${INST_VARIANT} -a x64"
|
||||
"""
|
||||
}
|
||||
|
||||
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') {
|
||||
when {
|
||||
expression {
|
||||
toBuild
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
def publishable = installerpublishlist
|
||||
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
|
||||
publishutils.generatelist(meta, publishable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Archiving artifacts') {
|
||||
when {
|
||||
expression {
|
||||
toBuild
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
ArrayList<String> itemsForRelease = ["info/**", "installers/**"]
|
||||
def artifactlist = meta.generateartifacts(itemsForRelease)
|
||||
archiveArtifacts "${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Check for unstable build') {
|
||||
when {
|
||||
expression {
|
||||
toBuild
|
||||
}
|
||||
}
|
||||
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'
|
||||
}
|
||||
}
|
||||
}
|
||||
164
localisation_check/localisation_check.groovy
Normal file
164
localisation_check/localisation_check.groovy
Normal file
|
|
@ -0,0 +1,164 @@
|
|||
pipeline {
|
||||
agent { label "${AGENT_LABEL}" }
|
||||
stages {
|
||||
stage('Initial setup') {
|
||||
steps {
|
||||
script {
|
||||
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout dependencies') {
|
||||
steps {
|
||||
script {
|
||||
configurationhelper = autobuilder.configurationhelper()
|
||||
|
||||
PYTHONURL = 'git@hydra:tools/python.git'
|
||||
PYTHONBRANCH = 'origin/3.6.3_windows'
|
||||
PYTHONDIR = "${WORKSPACE}/python"
|
||||
PYTHONROOTDIR = 'python'
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR, PYTHONROOTDIR)
|
||||
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
|
||||
|
||||
VERSTAMPINGURL = 'git@hydra:releases/ver_stamping_releases.git'
|
||||
VERSTAMPINGREVISION = "refs/tags/${VERSION_STAMPING_VERSION}"
|
||||
VERSTAMPINGDIR = "${WORKSPACE}/ver_stamping"
|
||||
VERSTAMPINGROOTDIR = 'ver_stamping_releases'
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'Version stamping', VERSTAMPINGURL, VERSTAMPINGREVISION, VERSTAMPINGDIR, VERSTAMPINGROOTDIR)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout source') {
|
||||
steps {
|
||||
script {
|
||||
SOURCEURL = 'git@hydra:gis/atlas_ui.git'
|
||||
SOURCEREVISION = SOURCE_REVISION
|
||||
SOURCEDIR = "${WORKSPACE}\\atlas_ui"
|
||||
SOURCEROOTDIR = 'atlas_ui'
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'atlas_ui', SOURCEURL, SOURCEREVISION, SOURCEDIR, SOURCEROOTDIR, 0, false)
|
||||
env.SOURCE_PATH = SOURCEDIR
|
||||
env.JOBSCRIPTS = "${SOURCE_PATH}\\autobuild\\localisation_test"
|
||||
env.JOBSCRIPTS_COMMON = "${SOURCE_PATH}\\autobuild\\common"
|
||||
env.SRC = SOURCE_PATH
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Clean exports') {
|
||||
steps {
|
||||
script {
|
||||
env.BUILDOUTPUT = "${WORKSPACE}/build"
|
||||
env.AULIB = "${WORKSPACE}/atlaslibraries"
|
||||
cleanfolders = [
|
||||
BUILDOUTPUT,
|
||||
AULIB,
|
||||
"${WORKSPACE}/bin",
|
||||
"${WORKSPACE}/documentation",
|
||||
]
|
||||
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, BASEBUILDNUMBER)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Atlas UI libraries') {
|
||||
steps {
|
||||
script {
|
||||
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
|
||||
libmeta = importer.artifactimport(meta,
|
||||
ATLAS_UI_ARTIFACT_LOCATION,
|
||||
ATLAS_UI_COMPILE_JOB,
|
||||
ATLAS_UI_BUILD_SELECTOR,
|
||||
ATLAS_UI_RELEASE_REPO,
|
||||
ATLAS_UI_RELEASE_REVISION,
|
||||
AULIB,
|
||||
false,
|
||||
"LocalisationSDK/**")
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Check localisations are correct') {
|
||||
steps {
|
||||
script {
|
||||
env.SRC_REVISION=SOURCE_REVISION
|
||||
bat """
|
||||
call "${JOBSCRIPTS}\\test_localisations.bat"
|
||||
if errorlevel 1 exit /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Prepare exports') {
|
||||
steps {
|
||||
script {
|
||||
bat """
|
||||
move "${AULIB}\\LocalisationSDK\\bin" .
|
||||
if errorlevel 1 exit /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Scan for warnings') {
|
||||
steps {
|
||||
script {
|
||||
recordIssues(tools: [
|
||||
msBuild(enabledForFailure: true, reportEncoding: 'UTF-8'),
|
||||
])
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checksum artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def checksummable = [
|
||||
/* Binaries are signed
|
||||
'build/**',
|
||||
'SharedPackages/**',
|
||||
*/
|
||||
]
|
||||
checksumutils = load("${autobuilder.commonscripts()}/checksum/utils.groovy")
|
||||
checksumutils.generatelist(meta, checksummable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Classifying publishable artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def publishable = [
|
||||
]
|
||||
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
|
||||
publishutils.generatelist(meta, publishable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Archiving artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def artifactlist = meta.generateartifacts(["bin/**"])
|
||||
archiveArtifacts "${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
204
nuget/createpackages.groovy
Normal file
204
nuget/createpackages.groovy
Normal file
|
|
@ -0,0 +1,204 @@
|
|||
pipeline {
|
||||
agent { label "${AGENT_LABEL}" }
|
||||
stages {
|
||||
stage('Initial setup') {
|
||||
steps {
|
||||
script {
|
||||
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout dependencies') {
|
||||
steps {
|
||||
script {
|
||||
configurationhelper = autobuilder.configurationhelper()
|
||||
|
||||
PYTHONURL = 'git@hydra:tools/python.git'
|
||||
PYTHONBRANCH = 'origin/3.6.3_windows'
|
||||
PYTHONDIR = "${WORKSPACE}/python"
|
||||
PYTHONROOTDIR = 'python'
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR, PYTHONROOTDIR)
|
||||
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
|
||||
|
||||
VERSTAMPINGURL = 'git@hydra:releases/ver_stamping_releases.git'
|
||||
VERSTAMPINGREVISION = "refs/tags/${VERSION_STAMPING_VERSION}"
|
||||
VERSTAMPINGDIR = "${WORKSPACE}/ver_stamping"
|
||||
VERSTAMPINGROOTDIR = 'ver_stamping_releases'
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'Version stamping', VERSTAMPINGURL, VERSTAMPINGREVISION, VERSTAMPINGDIR, VERSTAMPINGROOTDIR)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout source') {
|
||||
steps {
|
||||
script {
|
||||
SOURCEURL = 'git@hydra:gis/atlas_ui.git'
|
||||
SOURCEREVISION = SOURCE_REVISION
|
||||
SOURCEDIR = "${WORKSPACE}\\atlas_ui"
|
||||
SOURCEROOTDIR = 'atlas_ui'
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'atlas_ui', SOURCEURL, SOURCEREVISION, SOURCEDIR, SOURCEROOTDIR, 0, false)
|
||||
env.SOURCE_PATH = SOURCEDIR
|
||||
env.JOBSCRIPTS = "${SOURCE_PATH}\\autobuild\\build_Atlas"
|
||||
env.JOBSCRIPTS_COMMON = "${SOURCE_PATH}\\autobuild\\common"
|
||||
env.SRC = SOURCE_PATH
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Clean exports') {
|
||||
steps {
|
||||
script {
|
||||
env.PSBIN = "${WORKSPACE}/ps_bin"
|
||||
env.PSSOURCE = "${WORKSPACE}/newsw"
|
||||
cleanfolders = [
|
||||
PSBIN,
|
||||
"${WORKSPACE}/packages",
|
||||
]
|
||||
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, BASEBUILDNUMBER)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Print server to adjust version number') {
|
||||
steps {
|
||||
script {
|
||||
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
|
||||
|
||||
def psartifactfiles = "meta/**,bin/x64/Release/Engine - Render.dll,bin/x64/Release/Engine - Render.lib,bin/x64/Release/Engine - Render.pdb,bin/x64/Release/TBarCode11_x64.dll,bin/x64/Release/GIS Utility - Toolbox.dll,bin/x64/Release/GIS Utility - Toolbox.lib,bin/x64/Release/GIS Utility - Toolbox.pdb,bin/x64/Release/zlib1.dll,bin/x64/Release/zlib1.lib,bin/x64/Release/zlib1.pdb,bin/x64/Release/GIS Utility - TCP-IP Comms.dll,bin/x64/Release/GIS Utility - TCP-IP Comms.lib,bin/x64/Release/GIS Utility - TCP-IP Comms.pdb,bin/x64/Release/Dialog - Tree Node Editor.dll,bin/x64/Release/Dialog - Tree Node Editor.lib,bin/x64/Release/Dialog - Tree Node Editor.pdb"
|
||||
psmeta = importer.artifactimport(meta,
|
||||
PRINT_SERVER_ARTIFACT_LOCATION,
|
||||
PRINT_SERVER_COMPILE_JOB,
|
||||
PRINT_SERVER_BUILD_SELECTOR,
|
||||
PRINT_SERVER_RELEASE_REPO,
|
||||
PRINT_SERVER_RELEASE_REVISION,
|
||||
PSBIN,
|
||||
true,
|
||||
psartifactfiles) // This should increment the version number
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout relevant Print server source') {
|
||||
steps {
|
||||
script {
|
||||
def pssourceartifacts = "src/Engine Common"
|
||||
def pssourceurl = psmeta.gitinfo.remoteurl
|
||||
def pscommit = psmeta.gitinfo.gitrevision
|
||||
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'print_server_source', pssourceurl, pscommit, PSSOURCE, '', 0, false, pssourceartifacts)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Create packages') {
|
||||
steps {
|
||||
script {
|
||||
PS_VERSION="1.0.${psmeta.buildstampinfo.revision}.0"
|
||||
PS_PACKAGE_VERSION=psmeta.buildstampinfo.buildstampprefix
|
||||
bat """
|
||||
REM Create nuget packages
|
||||
echo Create nuget packages
|
||||
|
||||
@echo on
|
||||
|
||||
set NUGET_SERVER=C:\\NugetServer\\Packages\\
|
||||
|
||||
|
||||
@echo Renaming nuget package in ${SRC} with ${PS_PACKAGE_VERSION}
|
||||
@echo Versioning nuget package in ${SRC} to ${PS_VERSION}
|
||||
|
||||
@echo on
|
||||
|
||||
REM edit autopkg file
|
||||
"${PYTHON}" "${JOBSCRIPTS_COMMON}\\ps_nuget_version_edit.py" "${JOBSCRIPTS_COMMON}\\AtlasNativeDependencies.autopkg" ${PS_VERSION} ${PS_PACKAGE_VERSION}
|
||||
if errorlevel 1 EXIT /b 1
|
||||
|
||||
REM Create nuget packages
|
||||
REM Uses COAPP modules at %COAPP_MODULES%
|
||||
set PSMODULEPATH=%COAPP_MODULES%;%PSMODULEPATH%
|
||||
PowerShell.exe Write-NuGetPackage '${JOBSCRIPTS_COMMON}\\AtlasNativeDependencies.autopkg'
|
||||
if errorlevel 1 EXIT /b 1
|
||||
REM Copy nuget packages
|
||||
copy AtlasNativeDependencies.${PS_PACKAGE_VERSION}${PS_VERSION}.nupkg %NUGET_SERVER%
|
||||
if errorlevel 1 EXIT /b 1
|
||||
|
||||
copy AtlasNativeDependencies.${PS_PACKAGE_VERSION}redist.${PS_VERSION}.nupkg %NUGET_SERVER%
|
||||
if errorlevel 1 EXIT /b 1
|
||||
|
||||
copy AtlasNativeDependencies.${PS_PACKAGE_VERSION}symbols.${PS_VERSION}.nupkg %NUGET_SERVER%
|
||||
if errorlevel 1 EXIT /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Prepare exports') {
|
||||
steps {
|
||||
script {
|
||||
bat """
|
||||
REM Place files to the exports position
|
||||
|
||||
mkdir packages
|
||||
if errorlevel 1 EXIT /b 1
|
||||
|
||||
copy AtlasNativeDependencies.${PS_PACKAGE_VERSION}${PS_VERSION}.nupkg packages
|
||||
if errorlevel 1 EXIT /b 1
|
||||
copy AtlasNativeDependencies.${PS_PACKAGE_VERSION}redist.${PS_VERSION}.nupkg packages
|
||||
if errorlevel 1 EXIT /b 1
|
||||
copy AtlasNativeDependencies.${PS_PACKAGE_VERSION}symbols.${PS_VERSION}.nupkg packages
|
||||
if errorlevel 1 EXIT /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checksum artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def checksummable = [
|
||||
/* Binaries are signed
|
||||
'build/**',
|
||||
'SharedPackages/**',
|
||||
*/
|
||||
]
|
||||
checksumutils = load("${autobuilder.commonscripts()}/checksum/utils.groovy")
|
||||
checksumutils.generatelist(meta, checksummable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Classifying publishable artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def publishable = [
|
||||
]
|
||||
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
|
||||
publishutils.generatelist(meta, publishable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Archiving artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def artifactlist = meta.generateartifacts(["bin/**,binKiosk/**,documentation/**,ildasm/**,Libraries/**, Atlas Release/**,LocalisationSDK/**"])
|
||||
archiveArtifacts "${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
17
publish/.project
Normal file
17
publish/.project
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<projectDescription>
|
||||
<name>publish</name>
|
||||
<comment></comment>
|
||||
<projects>
|
||||
</projects>
|
||||
<buildSpec>
|
||||
<buildCommand>
|
||||
<name>org.python.pydev.PyDevBuilder</name>
|
||||
<arguments>
|
||||
</arguments>
|
||||
</buildCommand>
|
||||
</buildSpec>
|
||||
<natures>
|
||||
<nature>org.python.pydev.pythonNature</nature>
|
||||
</natures>
|
||||
</projectDescription>
|
||||
8
publish/.pydevproject
Normal file
8
publish/.pydevproject
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
|
||||
<?eclipse-pydev version="1.0"?><pydev_project>
|
||||
<pydev_pathproperty name="org.python.pydev.PROJECT_SOURCE_PATH">
|
||||
<path>/${PROJECT_DIR_NAME}</path>
|
||||
</pydev_pathproperty>
|
||||
<pydev_property name="org.python.pydev.PYTHON_PROJECT_VERSION">python 3.0</pydev_property>
|
||||
<pydev_property name="org.python.pydev.PYTHON_PROJECT_INTERPRETER">Python34</pydev_property>
|
||||
</pydev_project>
|
||||
53
publish/build_post_2_0_27_atlas.py
Normal file
53
publish/build_post_2_0_27_atlas.py
Normal file
|
|
@ -0,0 +1,53 @@
|
|||
import sys
|
||||
import stat
|
||||
from publishLibrary import CommonLibrary, VersionError,ReleaseFolderIssue, Copier, AtlasLayoutCopierPost2_0_14, AtlasSDKCopier, InkSystemUICopierPost2_0_19, AtlasUIReleaseNotesCopier
|
||||
|
||||
|
||||
def main():
|
||||
# All version number specific releases have been checked out already
|
||||
(major, middle, minor) = CommonLibrary.readVersionNumber(CommonLibrary.softwareRelease)
|
||||
print("Release version number: Major:", major, "Middle:", middle, "Minor:", minor)
|
||||
|
||||
try:
|
||||
CommonLibrary.checkReleaseFolders()
|
||||
except ReleaseFolderIssue:
|
||||
print("Release folders are not correct")
|
||||
sys.exit(1)
|
||||
|
||||
try:
|
||||
tsHandle = open(CommonLibrary.transferScript, 'w')
|
||||
except:
|
||||
print("Failed to open transfer script file:", transferScript)
|
||||
sys.exit(1)
|
||||
|
||||
try:
|
||||
buildRoot = CommonLibrary.prepareBuildDirectory(tsHandle, CommonLibrary.softwareRelease)
|
||||
except Exception as e:
|
||||
print("Failed to build directory. Details:", e)
|
||||
tsHandle.close()
|
||||
sys.exit(1)
|
||||
|
||||
copiers = [
|
||||
AtlasLayoutCopierPost2_0_14(),
|
||||
AtlasSDKCopier(),
|
||||
InkSystemUICopierPost2_0_19(),
|
||||
AtlasUIReleaseNotesCopier(),
|
||||
]
|
||||
|
||||
for copier in copiers:
|
||||
print("Copying", copier.description())
|
||||
try:
|
||||
copier.transfer(buildRoot, CommonLibrary.softwareRelease)
|
||||
except Exception as e:
|
||||
print("A problem occurred while copying:", copier.description(), " Details:", e)
|
||||
tsHandle.close()
|
||||
sys.exit(1)
|
||||
|
||||
print("Showing built tree at:", buildRoot)
|
||||
CommonLibrary.listdir(buildRoot)
|
||||
|
||||
tsHandle.close()
|
||||
sys.exit(0)
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
54
publish/build_post_2_0_28_atlas.py
Normal file
54
publish/build_post_2_0_28_atlas.py
Normal file
|
|
@ -0,0 +1,54 @@
|
|||
import sys
|
||||
import stat
|
||||
from publishLibrary import CommonLibrary, VersionError,ReleaseFolderIssue, Copier, AtlasLayoutCopierPost2_0_14, AtlasSDKCopier, InkSystemUICopierPost2_0_19, McsToolsCopierPost2_0_28, AtlasUIReleaseNotesCopier
|
||||
|
||||
|
||||
def main():
|
||||
# All version number specific releases have been checked out already
|
||||
(major, middle, minor) = CommonLibrary.readVersionNumber(CommonLibrary.softwareRelease)
|
||||
print("Release version number: Major:", major, "Middle:", middle, "Minor:", minor)
|
||||
|
||||
try:
|
||||
CommonLibrary.checkReleaseFolders()
|
||||
except ReleaseFolderIssue:
|
||||
print("Release folders are not correct")
|
||||
sys.exit(1)
|
||||
|
||||
try:
|
||||
tsHandle = open(CommonLibrary.transferScript, 'w')
|
||||
except:
|
||||
print("Failed to open transfer script file:", transferScript)
|
||||
sys.exit(1)
|
||||
|
||||
try:
|
||||
buildRoot = CommonLibrary.prepareBuildDirectory(tsHandle, CommonLibrary.softwareRelease)
|
||||
except Exception as e:
|
||||
print("Failed to build directory. Details:", e)
|
||||
tsHandle.close()
|
||||
sys.exit(1)
|
||||
|
||||
copiers = [
|
||||
AtlasLayoutCopierPost2_0_14(),
|
||||
AtlasSDKCopier(),
|
||||
InkSystemUICopierPost2_0_19(),
|
||||
McsToolsCopierPost2_0_28(),
|
||||
AtlasUIReleaseNotesCopier(),
|
||||
]
|
||||
|
||||
for copier in copiers:
|
||||
print("Copying", copier.description())
|
||||
try:
|
||||
copier.transfer(buildRoot, CommonLibrary.softwareRelease)
|
||||
except Exception as e:
|
||||
print("A problem occurred while copying:", copier.description(), " Details:", e)
|
||||
tsHandle.close()
|
||||
sys.exit(1)
|
||||
|
||||
print("Showing built tree at:", buildRoot)
|
||||
CommonLibrary.listdir(buildRoot)
|
||||
|
||||
tsHandle.close()
|
||||
sys.exit(0)
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
42
publish/publish.bat
Normal file
42
publish/publish.bat
Normal file
|
|
@ -0,0 +1,42 @@
|
|||
if "%CUSTOMER%"=="None" echo No customer has been selected
|
||||
if "%CUSTOMER%"=="None" exit /b 1
|
||||
|
||||
set TRANSFER_SCRIPT=transfer.txt
|
||||
if NOT EXIST "%TRANSFER_SCRIPT%" echo No transfer file created
|
||||
if NOT EXIST "%TRANSFER_SCRIPT%" exit /b 1
|
||||
|
||||
set FTP_CLIENT=%FTP_CLIENT_LOCATION%
|
||||
|
||||
set FTP_PROTOCOL=ftp://
|
||||
set FTP_OPEN_CMD=%FTP_PROTOCOL%%FTP_USER%:%FTP_PASSWORD%@%FTP_URL%
|
||||
|
||||
set FTP_SCRIPT=ftp_script.txt
|
||||
|
||||
@echo off
|
||||
echo.open %FTP_OPEN_CMD% > %FTP_SCRIPT%
|
||||
|
||||
echo.option echo on >> %FTP_SCRIPT%
|
||||
echo.option confirm off >> %FTP_SCRIPT%
|
||||
echo.option transfer binary >> %FTP_SCRIPT%
|
||||
|
||||
echo.option batch abort >> %FTP_SCRIPT%
|
||||
echo.cd "%FTP_CUSTOMER_ROOT%" >> %FTP_SCRIPT%
|
||||
|
||||
echo.option batch continue >> %FTP_SCRIPT%
|
||||
echo.mkdir "%CUSTOMER%" >> %FTP_SCRIPT%
|
||||
echo.cd "%CUSTOMER%" >> %FTP_SCRIPT%
|
||||
echo.mkdir "Software" >> %FTP_SCRIPT%
|
||||
echo.cd "Software" >> %FTP_SCRIPT%
|
||||
echo.option batch abort >> %FTP_SCRIPT%
|
||||
|
||||
echo.pwd >> %FTP_SCRIPT%
|
||||
|
||||
type "%TRANSFER_SCRIPT%" >> %FTP_SCRIPT%
|
||||
|
||||
echo.ls >> %FTP_SCRIPT%
|
||||
|
||||
echo.exit >> %FTP_SCRIPT%
|
||||
@echo on
|
||||
|
||||
"%FTP_CLIENT%" /script=%FTP_SCRIPT%
|
||||
IF ERRORLEVEL 1 exit /b 1
|
||||
274
publish/publishLibrary.py
Normal file
274
publish/publishLibrary.py
Normal file
|
|
@ -0,0 +1,274 @@
|
|||
import os
|
||||
import shutil
|
||||
from abc import ABCMeta, abstractmethod
|
||||
import sys
|
||||
|
||||
class CommonLibrary:
|
||||
# Release Folder Release description
|
||||
releaseDetails = {
|
||||
"atlaslayout": ("atlas-layout", "Atlas Layout", ),
|
||||
"atlassdk": ("atlas-sdk", "Atlas SDK", ),
|
||||
"inksysui": ("ink-system-ui", "Ink System UI", ),
|
||||
"atlasreleasenotes": ("atlas-ui-release-notes", "Atlas UI Release notes", ),
|
||||
"atlasmcstools": ("atlas-layout", "Atlas MCS Tools Modules", ), # The MCS tools are stored in the atlas-layout releases git repo.
|
||||
}
|
||||
|
||||
workspace = os.getenv("WORKSPACE", "").strip()
|
||||
print("Workspace folder is: ", workspace)
|
||||
if not workspace:
|
||||
print("Workspace folder incorrect")
|
||||
sys.exit(1)
|
||||
|
||||
softwareRelease = os.getenv("SOFTWARE_RELEASE", "").strip()
|
||||
print("Software release to publish is:", softwareRelease)
|
||||
if not softwareRelease:
|
||||
print("No software release has not been specified")
|
||||
sys.exit(1)
|
||||
|
||||
customer = os.getenv("CUSTOMER", "").strip()
|
||||
print("Customer to publish to is:", customer)
|
||||
if not customer:
|
||||
print("No customer has not been specified")
|
||||
sys.exit(1)
|
||||
|
||||
includeAtlas = os.getenv("INCLUDE_ATLAS", "false").strip().lower()
|
||||
print("Include Atlas Layout in release:", includeAtlas)
|
||||
if not includeAtlas:
|
||||
print("No Atlas Layout include parameter has not been specified")
|
||||
sys.exit(1)
|
||||
|
||||
includeInkSystemUI = os.getenv("INCLUDE_INK_SYSTEM_UI", "false").strip().lower()
|
||||
print("Include Ink System UI in release:", includeInkSystemUI)
|
||||
if not includeInkSystemUI:
|
||||
print("No Ink System UI include parameter has not been specified")
|
||||
sys.exit(1)
|
||||
|
||||
includeAtlasSDK = os.getenv("INCLUDE_ATLAS_SDK_TOOLS", "false").strip().lower()
|
||||
print("Include Atlas SDK in release:", includeAtlasSDK)
|
||||
if not includeAtlasSDK:
|
||||
print("No Atlas SDK include parameter has not been specified")
|
||||
sys.exit(1)
|
||||
|
||||
includeMCS = os.getenv("INCLUDE_ATLAS_MCS_TOOLS", "false").strip().lower()
|
||||
print("Include Atlas MCS Tools modules in release:", includeMCS)
|
||||
if not includeMCS:
|
||||
print("No Atlas MCS Tools include parameter has not been specified")
|
||||
sys.exit(1)
|
||||
|
||||
ftpCustomerRootDir = os.getenv("FTP_CUSTOMER_ROOT", "").strip()
|
||||
print("FTP root directory:", ftpCustomerRootDir)
|
||||
if not ftpCustomerRootDir:
|
||||
print("No FTP root directory parameter has not been specified")
|
||||
sys.exit(1)
|
||||
|
||||
ftpClientExe = os.getenv("FTP_CLIENT_LOCATION", "").strip()
|
||||
print("FTP client executable:", ftpClientExe)
|
||||
if not ftpClientExe:
|
||||
print("FTP client executable parameter has not been specified")
|
||||
sys.exit(1)
|
||||
|
||||
ftpURL = os.getenv("FTP_URL", "").strip()
|
||||
print("FTP URL:", ftpURL)
|
||||
if not ftpURL:
|
||||
print("FTP URL parameter has not been specified")
|
||||
sys.exit(1)
|
||||
|
||||
ftpUser = os.getenv("FTP_USER", "").strip()
|
||||
print("FTP User:", ftpUser)
|
||||
if not ftpUser:
|
||||
print("FTP User parameter has not been specified")
|
||||
sys.exit(1)
|
||||
|
||||
ftpPassword = os.getenv("FTP_PASSWORD", "").strip()
|
||||
print("FTP Password: ********")
|
||||
if not ftpPassword:
|
||||
print("FTP Password parameter has not been specified")
|
||||
sys.exit(1)
|
||||
|
||||
def readVersionNumber(versionString):
|
||||
versionList = versionString.split(sep='.')
|
||||
items = len(versionList)
|
||||
if items < 3 or items > 4:
|
||||
raise VersionError(versionString)
|
||||
major = versionList[0]
|
||||
middle = versionList[1]
|
||||
minor = versionList[2]
|
||||
return (major, middle, minor)
|
||||
|
||||
def removeReadonly(func, path, _):
|
||||
"Clear the readonly bit and reattempt the removal"
|
||||
os.chmod(path, stat.S_IWRITE)
|
||||
func(path)
|
||||
|
||||
buildRootDir = os.path.join(workspace, "build")
|
||||
def prepareBuildDirectory(transferScriptFile, softwareRelease):
|
||||
# Make sure the build directories are cleaned away
|
||||
buildRootDir = CommonLibrary.buildRootDir
|
||||
if os.path.isdir(buildRootDir):
|
||||
shutil.rmtree(buildRootDir, onerror=CommonLibrary.removeReadonly)
|
||||
|
||||
releaseFolder = "Atlas UI " + softwareRelease
|
||||
buildRoot = os.path.join(buildRootDir, releaseFolder)
|
||||
os.makedirs(buildRoot)
|
||||
|
||||
print("option batch continue", file = transferScriptFile)
|
||||
print('mkdir "', releaseFolder, '"', file = transferScriptFile, sep='')
|
||||
print("option batch abort", file = transferScriptFile)
|
||||
print('synchronize remote "', buildRoot, '" "', releaseFolder, '"', file = transferScriptFile, sep='')
|
||||
return buildRoot
|
||||
|
||||
def checkReleaseFolders():
|
||||
for _, v in sorted(CommonLibrary.releaseDetails.items()):
|
||||
(folder, description) = v
|
||||
fullFolderPath = os.path.join(CommonLibrary.workspace, folder)
|
||||
if os.path.isdir(fullFolderPath):
|
||||
print("Release of", description, "is at folder:", fullFolderPath)
|
||||
else:
|
||||
print("Could not find folder:", fullFolderPath, " for release of:", description)
|
||||
raise ReleaseFolderIssue
|
||||
|
||||
|
||||
def listdir(rootdir):
|
||||
for root, directories, filenames in os.walk(rootdir):
|
||||
for directory in sorted(directories):
|
||||
print(os.path.join(root, directory))
|
||||
for filename in sorted(filenames):
|
||||
print(os.path.join(root, filename))
|
||||
|
||||
transferScript = os.path.join(workspace, "transfer.txt")
|
||||
|
||||
class VersionError(Exception):
|
||||
def __init__(self, versionString):
|
||||
self._versionString = versionString
|
||||
|
||||
def __repr__(self):
|
||||
return self._versionString
|
||||
|
||||
class ReleaseFolderIssue(Exception):
|
||||
def __init__(self):
|
||||
pass
|
||||
|
||||
class Copier:
|
||||
__metaclass__ = ABCMeta
|
||||
|
||||
def __init__(self, component):
|
||||
(self.releaseFolderPath, self.releaseDesc) = CommonLibrary.releaseDetails[component]
|
||||
|
||||
@abstractmethod
|
||||
def transfer(self): pass
|
||||
|
||||
def description(self):
|
||||
return self.releaseDesc
|
||||
|
||||
def makeDirectories(self, dirs):
|
||||
print("Making directories:", dirs)
|
||||
os.makedirs(dirs, exist_ok = True)
|
||||
|
||||
def copyFile(self, src, dest):
|
||||
print("Copying from:", src, "to:", dest)
|
||||
shutil.copyfile(src, dest)
|
||||
|
||||
class AtlasLayoutCopierPost2_0_14(Copier):
|
||||
def __init__(self):
|
||||
Copier.__init__(self, "atlaslayout")
|
||||
|
||||
def transfer(self, buildRoot, softwareRelease):
|
||||
# Do a copy if required
|
||||
if CommonLibrary.includeAtlas == "true":
|
||||
# Source
|
||||
srcRelPath = os.path.join(CommonLibrary.workspace, self.releaseFolderPath)
|
||||
|
||||
releaseInstaller = os.path.join(srcRelPath, "x64", "GIS Atlas 2", "DiskImages", "DISK1", "GIS Atlas Layout.exe")
|
||||
|
||||
# Destination
|
||||
atlasLayoutBuildRoot = os.path.join(buildRoot, "GIS Atlas Layout Installer")
|
||||
self.makeDirectories(atlasLayoutBuildRoot)
|
||||
destName = os.path.join(atlasLayoutBuildRoot, "GIS Inkjet OS " + softwareRelease + " Atlas Installer.exe")
|
||||
self.copyFile(releaseInstaller, destName)
|
||||
|
||||
|
||||
class AtlasSDKCopier(Copier):
|
||||
def __init__(self):
|
||||
Copier.__init__(self, "atlassdk")
|
||||
|
||||
def transfer(self, buildRoot, softwareRelease):
|
||||
# Do a copy if required
|
||||
if CommonLibrary.includeAtlasSDK == "true":
|
||||
# Source
|
||||
srcRelPath = os.path.join(CommonLibrary.workspace, self.releaseFolderPath)
|
||||
releaseInstaller = os.path.join(srcRelPath, "x64", "GIS Atlas SDK", "DiskImages", "DISK1", "GIS Atlas SDK.exe")
|
||||
|
||||
# Destination
|
||||
atlasSDKBuildRoot = os.path.join(buildRoot, "GIS Atlas Tools SDK Installer")
|
||||
self.makeDirectories(atlasSDKBuildRoot)
|
||||
destName = os.path.join(atlasSDKBuildRoot, "GIS Atlas Tools SDK " + softwareRelease + " Installer.exe")
|
||||
self.copyFile(releaseInstaller, destName)
|
||||
|
||||
class InkSystemUICopierPost2_0_19(Copier):
|
||||
def __init__(self):
|
||||
Copier.__init__(self, "inksysui")
|
||||
|
||||
def transfer(self, buildRoot, softwareRelease):
|
||||
# Do a copy if required
|
||||
if CommonLibrary.includeInkSystemUI == "true":
|
||||
# Source
|
||||
srcRelPath = os.path.join(CommonLibrary.workspace, self.releaseFolderPath)
|
||||
releaseInstaller = os.path.join(srcRelPath, "x64", "GIS Ink System Configuration UI", "DiskImages", "DISK1", "GIS Atlas Ink System Configuration UI.exe")
|
||||
|
||||
# Destination
|
||||
inkSystemConfigurationUIBuildRoot = os.path.join(buildRoot, "GIS Ink System UI Installer", "Configuration UI")
|
||||
self.makeDirectories(inkSystemConfigurationUIBuildRoot)
|
||||
destName = os.path.join(inkSystemConfigurationUIBuildRoot, "GIS Atlas Ink System Configuration UI " + softwareRelease + " Installer.exe")
|
||||
self.copyFile(releaseInstaller, destName)
|
||||
|
||||
# Source
|
||||
releaseInstaller = os.path.join(srcRelPath, "x64", "GIS Ink System Operator UI", "DiskImages", "DISK1", "GIS Atlas Ink System Operator UI.exe")
|
||||
|
||||
# Destination
|
||||
inkSystemOperatorUIBuildRoot = os.path.join(buildRoot, "GIS Ink System UI Installer", "Operator UI")
|
||||
self.makeDirectories(inkSystemOperatorUIBuildRoot)
|
||||
destName = os.path.join(inkSystemOperatorUIBuildRoot, "GIS Atlas Ink System Operator UI " + softwareRelease + " Installer.exe")
|
||||
self.copyFile(releaseInstaller, destName)
|
||||
|
||||
# Source
|
||||
releaseInstaller = os.path.join(srcRelPath, "x64", "GIS Ink System Tool Modules", "DiskImages", "DISK1", "GIS Atlas Ink System Tool Modules.exe")
|
||||
|
||||
# Destination
|
||||
inkSystemOperatorUIModuleBuildRoot = os.path.join(buildRoot, "GIS Ink System UI Installer", "Operator UI Module")
|
||||
self.makeDirectories(inkSystemOperatorUIModuleBuildRoot)
|
||||
destName = os.path.join(inkSystemOperatorUIModuleBuildRoot, "GIS Atlas Ink System Operator UI Module " + softwareRelease + " Installer.exe")
|
||||
self.copyFile(releaseInstaller, destName)
|
||||
|
||||
class McsToolsCopierPost2_0_28(Copier):
|
||||
def __init__(self):
|
||||
Copier.__init__(self, "atlasmcstools")
|
||||
|
||||
def transfer(self, buildRoot, softwareRelease):
|
||||
# Do a copy if required
|
||||
if CommonLibrary.includeMCS == "true":
|
||||
# Source
|
||||
srcRelPath = os.path.join(CommonLibrary.workspace, self.releaseFolderPath)
|
||||
releaseInstaller = os.path.join(srcRelPath, "x64", "GIS MCS Tool Modules", "DiskImages", "DISK1", "GIS Atlas MCS Tool Modules.exe")
|
||||
|
||||
# Destination
|
||||
mcsToolsBuildRoot = os.path.join(buildRoot, "GIS Atlas MCS Tool Modues Installer")
|
||||
self.makeDirectories(mcsToolsBuildRoot)
|
||||
destName = os.path.join(mcsToolsBuildRoot, "GIS MCS Tool Modules " + softwareRelease + " Installer.exe")
|
||||
self.copyFile(releaseInstaller, destName)
|
||||
|
||||
class AtlasUIReleaseNotesCopier(Copier):
|
||||
def __init__(self):
|
||||
Copier.__init__(self, "atlasreleasenotes")
|
||||
|
||||
def transfer(self, buildRoot, softwareRelease):
|
||||
# Unconditionally copy release notes
|
||||
|
||||
# Source
|
||||
srcRelPath = os.path.join(CommonLibrary.workspace, self.releaseFolderPath)
|
||||
releaseInstaller = os.path.join(srcRelPath, "Release Notes.txt")
|
||||
|
||||
# Destination
|
||||
releaseNotesBuildRoot = buildRoot
|
||||
self.makeDirectories(releaseNotesBuildRoot)
|
||||
destName = os.path.join(releaseNotesBuildRoot, "Release Notes.txt")
|
||||
self.copyFile(releaseInstaller, destName)
|
||||
8
publish/reset_imports_and_exports.bat
Normal file
8
publish/reset_imports_and_exports.bat
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
REM Reset imports and exports folders
|
||||
echo Removing previous imports and exports
|
||||
del dir_built.txt
|
||||
del tree_built.txt
|
||||
del ftp_script.txt
|
||||
del transfer.txt
|
||||
rmdir /s /q imports
|
||||
exit /b 0
|
||||
149
release_to_git/javascript_release_to_git.gsh
Normal file
149
release_to_git/javascript_release_to_git.gsh
Normal file
|
|
@ -0,0 +1,149 @@
|
|||
pipeline {
|
||||
agent { label "${AGENT_LABEL}" }
|
||||
stages {
|
||||
stage('Initial setup') {
|
||||
steps {
|
||||
script {
|
||||
configurationhelper = load("${WORKSPACE}/Common_scripts/configuration/configuration.gsh")
|
||||
githelper = load("${WORKSPACE}/Common_scripts/versioncontrol/git.gsh")
|
||||
echo "Uncomment me"
|
||||
//configurationhelper.registerPipelineScriptConfiguration()
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Clean workspace') {
|
||||
when {
|
||||
expression {
|
||||
env.CLEAN_WORKSPACE == "true"
|
||||
}
|
||||
}
|
||||
steps {
|
||||
// Save any script files that were loaded into the workspace at first and are required after cleaning the workspace
|
||||
stash allowEmpty: true, includes: 'Common_scripts/**/*', name: 'Clean workspace stash', useDefaultExcludes: false
|
||||
cleanWs()
|
||||
unstash name: 'Clean workspace stash'
|
||||
}
|
||||
}
|
||||
stage('Nothing to build check') {
|
||||
when {
|
||||
expression {
|
||||
env.RELEASE_COMMIT == "false"
|
||||
}
|
||||
}
|
||||
steps {
|
||||
echo 'No installers to build'
|
||||
script {
|
||||
currentBuild.result = 'UNSTABLE'
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout dependencies') {
|
||||
when {
|
||||
expression {
|
||||
env.RELEASE_COMMIT == "true"
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
PYTHONURL = 'git@hydra:tools/python.git'
|
||||
PYTHONBRANCH = 'origin/3.6.3_windows'
|
||||
PYTHONDIR = "${WORKSPACE}/python"
|
||||
PYTHONROOTDIR = 'python'
|
||||
configurationhelper.gitCheckoutAndRegister('python', PYTHONURL, PYTHONBRANCH, PYTHONDIR, PYTHONROOTDIR)
|
||||
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
|
||||
|
||||
SOURCEURL = 'git@hydra:gis/Hmb_Js_Client.git'
|
||||
SOURCEBRANCH = "${SOURCE_BRANCH}"
|
||||
SOURCEDIR = "${WORKSPACE}\\jsclient"
|
||||
SOURCEROOTDIR = 'jsclient'
|
||||
configurationhelper.gitCheckoutAndRegister('jsclient', SOURCEURL, SOURCEBRANCH, SOURCEDIR, SOURCEROOTDIR)
|
||||
env.SOURCE_PATH = "${SOURCEDIR}"
|
||||
}
|
||||
}
|
||||
}
|
||||
stage("Clean imports") {
|
||||
steps {
|
||||
script {
|
||||
env.IMPORTSPATH = "${WORKSPACE}/imports"
|
||||
}
|
||||
dir("${IMPORTSPATH}") {
|
||||
echo "Deleting directories in ${IMPORTSPATH}"
|
||||
deleteDir()
|
||||
}
|
||||
}
|
||||
}
|
||||
stage("Import binaries and versions") {
|
||||
when {
|
||||
expression {
|
||||
env.RELEASE_COMMIT == "true"
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
projectImports = [
|
||||
[ 'Build', "${BUILD_JOB}", "${IMPORTSPATH}", 'jsclient/**,version/**', false ],
|
||||
]
|
||||
for (projectImport in projectImports) {
|
||||
(importName, sourceProject, destFolder, toCopy, checkImports) = projectImport
|
||||
copyArtifacts excludes: '', filter: toCopy, fingerprintArtifacts: true, projectName: "${sourceProject}", selector: lastSuccessful(), target: "${destFolder}"
|
||||
if (checkImports) {
|
||||
env.importDest = destFolder
|
||||
bat '''
|
||||
"%PYTHON%" "%SOURCE_PATH%\\autobuild\\common\\fingerprint.py" -f "%importDest%\\pipeline\\hashes.txt" -v -p "%importDest%"
|
||||
'''
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage("Release to git") {
|
||||
when {
|
||||
expression {
|
||||
env.RELEASE_COMMIT == "true"
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
bat '''
|
||||
"%PYTHON34%" -u "%SOURCE_PATH%\\autobuild\\releasetogit\\conditional_add.py"
|
||||
'''
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Check for unstable build') {
|
||||
when {
|
||||
expression {
|
||||
env.RELEASE_COMMIT == "true"
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
if (env.DRY_RUN_PUSH == "true") {
|
||||
echo "Not pushing the content to git therefore marking building unstable"
|
||||
currentBuild.result = 'UNSTABLE'
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
/*
|
||||
step([$class: 'LogParserPublisher',
|
||||
parsingRulesPath: 'GitRepository/autobuild/build/log parsing rules/vs.txt',
|
||||
useProjectRule: true
|
||||
])
|
||||
*/
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
150
release_to_git/release_to_git.gsh
Normal file
150
release_to_git/release_to_git.gsh
Normal file
|
|
@ -0,0 +1,150 @@
|
|||
pipeline {
|
||||
agent { label "${AGENT_LABEL}" }
|
||||
stages {
|
||||
stage('Initial setup') {
|
||||
steps {
|
||||
script {
|
||||
configurationhelper = load("${WORKSPACE}/Common_scripts/configuration/configuration.gsh")
|
||||
githelper = load("${WORKSPACE}/Common_scripts/versioncontrol/git.gsh")
|
||||
echo "Uncomment me"
|
||||
//configurationhelper.registerPipelineScriptConfiguration()
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Clean workspace') {
|
||||
when {
|
||||
expression {
|
||||
env.CLEAN_WORKSPACE == "true"
|
||||
}
|
||||
}
|
||||
steps {
|
||||
// Save any script files that were loaded into the workspace at first and are required after cleaning the workspace
|
||||
stash allowEmpty: true, includes: 'Common_scripts/**/*', name: 'Clean workspace stash', useDefaultExcludes: false
|
||||
cleanWs()
|
||||
unstash name: 'Clean workspace stash'
|
||||
}
|
||||
}
|
||||
stage('Nothing to build check') {
|
||||
when {
|
||||
expression {
|
||||
env.RELEASE_COMMIT == "false"
|
||||
}
|
||||
}
|
||||
steps {
|
||||
echo 'No installers to build'
|
||||
script {
|
||||
currentBuild.result = 'UNSTABLE'
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout dependencies') {
|
||||
when {
|
||||
expression {
|
||||
env.RELEASE_COMMIT == "true"
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
PYTHONURL = 'git@hydra:tools/python.git'
|
||||
PYTHONBRANCH = 'origin/3.6.3_windows'
|
||||
PYTHONDIR = "${WORKSPACE}/python"
|
||||
PYTHONROOTDIR = 'python'
|
||||
configurationhelper.gitCheckoutAndRegister('python', PYTHONURL, PYTHONBRANCH, PYTHONDIR, PYTHONROOTDIR)
|
||||
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
|
||||
|
||||
SOURCEURL = 'git@hydra:gis/atlas_ui.git'
|
||||
SOURCEBRANCH = "${SOURCE_BRANCH}"
|
||||
SOURCEDIR = "${WORKSPACE}\\atlas_ui"
|
||||
SOURCEROOTDIR = 'atlas_ui'
|
||||
configurationhelper.gitCheckoutAndRegister('atlas_ui', SOURCEURL, SOURCEBRANCH, SOURCEDIR, SOURCEROOTDIR)
|
||||
env.SOURCE_PATH = "${SOURCEDIR}"
|
||||
}
|
||||
}
|
||||
}
|
||||
stage("Clean imports") {
|
||||
steps {
|
||||
script {
|
||||
env.IMPORTSPATH = "${WORKSPACE}/imports"
|
||||
}
|
||||
dir("${IMPORTSPATH}") {
|
||||
echo "Deleting directories in ${IMPORTSPATH}"
|
||||
deleteDir()
|
||||
}
|
||||
}
|
||||
}
|
||||
stage("Import binaries and versions") {
|
||||
when {
|
||||
expression {
|
||||
env.RELEASE_COMMIT == "true"
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
projectImports = [
|
||||
[ 'Installers and Binaries', "${INSTALLER_BUILD_JOB}", "${IMPORTSPATH}/install", '**', true ],
|
||||
[ 'Build', "${BUILD_JOB}", "${IMPORTSPATH}/build", 'version/**,pipeline/**', false ],
|
||||
]
|
||||
for (projectImport in projectImports) {
|
||||
(importName, sourceProject, destFolder, toCopy, checkImports) = projectImport
|
||||
copyArtifacts excludes: '', filter: toCopy, fingerprintArtifacts: true, projectName: "${sourceProject}", selector: lastSuccessful(), target: "${destFolder}"
|
||||
if (checkImports) {
|
||||
env.importDest = destFolder
|
||||
bat '''
|
||||
"%PYTHON%" "%SOURCE_PATH%\\autobuild\\common\\fingerprint.py" -f "%importDest%\\pipeline\\hashes.txt" -v -p "%importDest%"
|
||||
'''
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage("Release to git") {
|
||||
when {
|
||||
expression {
|
||||
env.RELEASE_COMMIT == "true"
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
bat '''
|
||||
"%PYTHON34%" -u "%WORKSPACE%\\atlas_ui\\autobuild\\releasetogit\\conditional_add.py"
|
||||
'''
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Check for unstable build') {
|
||||
when {
|
||||
expression {
|
||||
env.RELEASE_COMMIT == "true"
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
if (env.DRY_RUN_PUSH == "true") {
|
||||
echo "Not pushing the content to git therefore marking building unstable"
|
||||
currentBuild.result = 'UNSTABLE'
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
/*
|
||||
step([$class: 'LogParserPublisher',
|
||||
parsingRulesPath: 'GitRepository/autobuild/build/log parsing rules/vs.txt',
|
||||
useProjectRule: true
|
||||
])
|
||||
*/
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
206
resharper/atlas_ink_resharper.groovy
Normal file
206
resharper/atlas_ink_resharper.groovy
Normal file
|
|
@ -0,0 +1,206 @@
|
|||
pipeline {
|
||||
agent { label "${AGENT_LABEL}" }
|
||||
// Timeout becasue Resharper sometimes hangs indefinitely
|
||||
options {
|
||||
timeout(time: 1, unit:'HOURS')
|
||||
}
|
||||
stages {
|
||||
stage('Initial setup') {
|
||||
steps {
|
||||
script {
|
||||
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startbuild(this, PRODUCT_NAME, SUBCOMPONENT_NAME, RELEASE_REPO)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout dependencies') {
|
||||
steps {
|
||||
script {
|
||||
configurationhelper = autobuilder.configurationhelper()
|
||||
|
||||
PYTHONURL = 'git@hydra:tools/python.git'
|
||||
PYTHONBRANCH = 'origin/3.6.3_windows'
|
||||
PYTHONDIR = "${WORKSPACE}/python"
|
||||
PYTHONROOTDIR = 'python'
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR, PYTHONROOTDIR)
|
||||
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
|
||||
|
||||
VERSTAMPINGURL = 'git@hydra:releases/ver_stamping_releases.git'
|
||||
VERSTAMPINGREVISION = "refs/tags/${VERSION_STAMPING_VERSION}"
|
||||
VERSTAMPINGDIR = "${WORKSPACE}/ver_stamping"
|
||||
VERSTAMPINGROOTDIR = 'ver_stamping_releases'
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'Version stamping', VERSTAMPINGURL, VERSTAMPINGREVISION, VERSTAMPINGDIR, VERSTAMPINGROOTDIR)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout source') {
|
||||
steps {
|
||||
script {
|
||||
SOURCEURL = 'git@hydra:gis/atlas_ui.git'
|
||||
SOURCEREVISION = SOURCE_REVISION
|
||||
SOURCEDIR = "${WORKSPACE}\\atlas_ui"
|
||||
SOURCEROOTDIR = 'atlas_ui'
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'atlas_ui', SOURCEURL, SOURCEREVISION, SOURCEDIR, SOURCEROOTDIR, 0, false)
|
||||
env.SOURCE_PATH = SOURCEDIR
|
||||
env.JOBSCRIPTS = "${SOURCE_PATH}\\autobuild\\code_analysis"
|
||||
env.JOBSCRIPTS_COMMON = "${SOURCE_PATH}\\autobuild\\common"
|
||||
env.SRC = SOURCE_PATH
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Clean exports') {
|
||||
steps {
|
||||
script {
|
||||
env.BUILDOUTPUT = "${WORKSPACE}/build"
|
||||
env.PSBIN = "${WORKSPACE}/ps_bin"
|
||||
env.ASBIN = "${WORKSPACE}/as_bin"
|
||||
env.AULIB = "${WORKSPACE}/atlaslibraries"
|
||||
env.TESTRESULTS = "${WORKSPACE}/testresults"
|
||||
env.PSSOURCE = "${WORKSPACE}/newsw"
|
||||
cleanfolders = [
|
||||
BUILDOUTPUT,
|
||||
"${WORKSPACE}/SharedPackages",
|
||||
PSBIN,
|
||||
ASBIN,
|
||||
AULIB,
|
||||
"${WORKSPACE}/binInk",
|
||||
"${WORKSPACE}/documentation",
|
||||
TESTRESULTS,
|
||||
]
|
||||
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, BASEBUILDNUMBER)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Atlas UI libraries') {
|
||||
steps {
|
||||
script {
|
||||
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
|
||||
libmeta = importer.artifactimport(meta,
|
||||
ATLAS_UI_ARTIFACT_LOCATION,
|
||||
ATLAS_UI_COMPILE_JOB,
|
||||
ATLAS_UI_BUILD_SELECTOR,
|
||||
ATLAS_UI_RELEASE_REPO,
|
||||
ATLAS_UI_RELEASE_REVISION,
|
||||
AULIB,
|
||||
false)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Print server to adjust version number') {
|
||||
steps {
|
||||
script {
|
||||
def psartifactfiles = "meta/**"
|
||||
psmeta = importer.artifactimport(meta,
|
||||
PRINT_SERVER_ARTIFACT_LOCATION,
|
||||
PRINT_SERVER_COMPILE_JOB,
|
||||
PRINT_SERVER_BUILD_SELECTOR,
|
||||
PRINT_SERVER_RELEASE_REPO,
|
||||
PRINT_SERVER_RELEASE_REVISION,
|
||||
PSBIN,
|
||||
true,
|
||||
psartifactfiles) // This should increment the version number
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Atlas services to adjust version number') {
|
||||
steps {
|
||||
script {
|
||||
def asartifactfiles = "meta/**"
|
||||
asmeta = importer.artifactimport(meta,
|
||||
ATLAS_SERVICES_ARTIFACT_LOCATION,
|
||||
ATLAS_SERVICES_COMPILE_JOB,
|
||||
ATLAS_SERVICES_BUILD_SELECTOR,
|
||||
ATLAS_SERVICES_RELEASE_REPO,
|
||||
ATLAS_SERVICES_RELEASE_REVISION,
|
||||
ASBIN,
|
||||
true,
|
||||
asartifactfiles)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Version stamp files') {
|
||||
steps {
|
||||
script {
|
||||
env.BUILD_STAMP=meta.buildstampinfo.buildstamp
|
||||
env.BUILD_DATE=meta.jenkinsbuildinfo.builddate
|
||||
env.AS_PACKAGE_VERSION=asmeta.buildstampinfo.buildstamp
|
||||
bat """
|
||||
call "${JOBSCRIPTS_COMMON}\\version_ink_ui_files.bat"
|
||||
if errorlevel 1 exit /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Analyse resharper') {
|
||||
steps {
|
||||
script {
|
||||
env.SRC_REVISION=SOURCE_REVISION
|
||||
bat """
|
||||
call "${JOBSCRIPTS}\\build_and_analyse_ink_ui.bat"
|
||||
if errorlevel 1 exit /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Analysis') {
|
||||
steps {
|
||||
recordIssues enabledForFailure: true, tool: resharperInspectCode(pattern: 'results/atlas_ink_ui_resharper_results.xml'), qualityGates:[[threshold: 1000, type: 'TOTAL', unstable: true],[threshold: 1250, type: 'TOTAL', unstable: false]]
|
||||
}
|
||||
}
|
||||
stage('Checksum artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def checksummable = [
|
||||
/* Binaries are signed
|
||||
'build/**',
|
||||
'SharedPackages/**',
|
||||
*/
|
||||
]
|
||||
checksumutils = load("${autobuilder.commonscripts()}/checksum/utils.groovy")
|
||||
checksumutils.generatelist(meta, checksummable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Classifying publishable artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def publishable = [
|
||||
]
|
||||
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
|
||||
publishutils.generatelist(meta, publishable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Archiving artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def artifactlist = meta.generateartifacts(["results/**"])
|
||||
archiveArtifacts "${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
208
resharper/atlas_sdk_resharper.groovy
Normal file
208
resharper/atlas_sdk_resharper.groovy
Normal file
|
|
@ -0,0 +1,208 @@
|
|||
pipeline {
|
||||
agent { label "${AGENT_LABEL}" }
|
||||
// Timeout becasue Resharper sometimes hangs indefinitely
|
||||
options {
|
||||
timeout(time: 1, unit:'HOURS')
|
||||
}
|
||||
stages {
|
||||
stage('Initial setup') {
|
||||
steps {
|
||||
script {
|
||||
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout dependencies') {
|
||||
steps {
|
||||
script {
|
||||
configurationhelper = autobuilder.configurationhelper()
|
||||
|
||||
PYTHONURL = 'git@hydra:tools/python.git'
|
||||
PYTHONBRANCH = 'origin/3.6.3_windows'
|
||||
PYTHONDIR = "${WORKSPACE}/python"
|
||||
PYTHONROOTDIR = 'python'
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR, PYTHONROOTDIR)
|
||||
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
|
||||
|
||||
VERSTAMPINGURL = 'git@hydra:releases/ver_stamping_releases.git'
|
||||
VERSTAMPINGREVISION = "refs/tags/${VERSION_STAMPING_VERSION}"
|
||||
VERSTAMPINGDIR = "${WORKSPACE}/ver_stamping"
|
||||
VERSTAMPINGROOTDIR = 'ver_stamping_releases'
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'Version stamping', VERSTAMPINGURL, VERSTAMPINGREVISION, VERSTAMPINGDIR, VERSTAMPINGROOTDIR)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout source') {
|
||||
steps {
|
||||
script {
|
||||
SOURCEURL = 'git@hydra:gis/atlas_ui.git'
|
||||
SOURCEREVISION = SOURCE_REVISION
|
||||
SOURCEDIR = "${WORKSPACE}\\atlas_ui"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'atlas_ui', SOURCEURL, SOURCEREVISION, SOURCEDIR, '', 0, false)
|
||||
env.SOURCE_PATH = SOURCEDIR
|
||||
env.JOBSCRIPTS = "${SOURCE_PATH}\\autobuild\\code_analysis"
|
||||
env.JOBSCRIPTS_COMMON = "${SOURCE_PATH}\\autobuild\\common"
|
||||
env.SRC = SOURCE_PATH
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Clean exports') {
|
||||
steps {
|
||||
script {
|
||||
env.BUILDOUTPUT = "${WORKSPACE}/build"
|
||||
env.PSBIN = "${WORKSPACE}/ps_bin"
|
||||
env.ASBIN = "${WORKSPACE}/as_bin"
|
||||
env.PSSOURCE = "${WORKSPACE}/newsw"
|
||||
cleanfolders = [
|
||||
BUILDOUTPUT,
|
||||
"${WORKSPACE}/SharedPackages",
|
||||
PSBIN,
|
||||
ASBIN,
|
||||
"${WORKSPACE}/bin",
|
||||
"${WORKSPACE}/binKiosk",
|
||||
"${WORKSPACE}/documentation",
|
||||
"${WORKSPACE}/ildasm",
|
||||
"${WORKSPACE}/Libraries",
|
||||
"${WORKSPACE}/Atlas Release",
|
||||
"${WORKSPACE}/LocalisationSDK",
|
||||
]
|
||||
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, BASEBUILDNUMBER)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Print server dependencies') {
|
||||
steps {
|
||||
script {
|
||||
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
|
||||
|
||||
def psartifactfiles = "meta/**,bin/x64/Release/Engine - Render.dll,bin/x64/Release/Engine - Render.lib,bin/x64/Release/Engine - Render.pdb,bin/x64/Release/TBarCode11_x64.dll,bin/x64/Release/GIS Utility - Toolbox.dll,bin/x64/Release/GIS Utility - Toolbox.lib,bin/x64/Release/GIS Utility - Toolbox.pdb,bin/x64/Release/zlib1.dll,bin/x64/Release/zlib1.lib,bin/x64/Release/zlib1.pdb,bin/x64/Release/GIS Utility - TCP-IP Comms.dll,bin/x64/Release/GIS Utility - TCP-IP Comms.lib,bin/x64/Release/GIS Utility - TCP-IP Comms.pdb,bin/x64/Release/Dialog - Tree Node Editor.dll,bin/x64/Release/Dialog - Tree Node Editor.lib,bin/x64/Release/Dialog - Tree Node Editor.pdb"
|
||||
psmeta = importer.artifactimport(meta,
|
||||
PRINT_SERVER_ARTIFACT_LOCATION,
|
||||
PRINT_SERVER_COMPILE_JOB,
|
||||
PRINT_SERVER_BUILD_SELECTOR,
|
||||
PRINT_SERVER_RELEASE_REPO,
|
||||
PRINT_SERVER_RELEASE_REVISION,
|
||||
PSBIN,
|
||||
true,
|
||||
psartifactfiles)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout relevant Print server source') {
|
||||
steps {
|
||||
script {
|
||||
def pssourceartifacts = "src/Engine Common"
|
||||
def pssourceurl = psmeta.gitinfo.remoteurl
|
||||
def pscommit = psmeta.gitinfo.gitrevision
|
||||
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'print_server_source', pssourceurl, pscommit, PSSOURCE, '', 0, false, pssourceartifacts)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Atlas services dependencies') {
|
||||
steps {
|
||||
script {
|
||||
def asartifactfiles = "meta/**,SharedPackages/**"
|
||||
asmeta = importer.artifactimport(meta,
|
||||
ATLAS_SERVICES_ARTIFACT_LOCATION,
|
||||
ATLAS_SERVICES_COMPILE_JOB,
|
||||
ATLAS_SERVICES_BUILD_SELECTOR,
|
||||
ATLAS_SERVICES_RELEASE_REPO,
|
||||
ATLAS_SERVICES_RELEASE_REVISION,
|
||||
ASBIN,
|
||||
true,
|
||||
asartifactfiles)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Version files') {
|
||||
steps {
|
||||
script {
|
||||
env.BUILD_STAMP=meta.buildstampinfo.buildstamp
|
||||
env.BUILD_DATE=meta.jenkinsbuildinfo.builddate
|
||||
env.PS_VERSION="1.0.${psmeta.buildstampinfo.revision}.0"
|
||||
env.PS_PACKAGE_VERSION=psmeta.buildstampinfo.buildstampprefix
|
||||
env.AS_PACKAGE_VERSION=asmeta.buildstampinfo.buildstamp
|
||||
bat """
|
||||
call "${JOBSCRIPTS_COMMON}\\create_ps_nuget.bat"
|
||||
if errorlevel 1 exit /b 1
|
||||
call "${JOBSCRIPTS_COMMON}\\version_atlas_ui_files.bat"
|
||||
if errorlevel 1 exit /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Analyse resharper') {
|
||||
steps {
|
||||
script {
|
||||
env.SRC_REVISION=SOURCE_REVISION
|
||||
bat """
|
||||
call "${JOBSCRIPTS}\\build_and_analyse_atlas_sdk.bat"
|
||||
if errorlevel 1 exit /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
stage('Analysis') {
|
||||
steps {
|
||||
recordIssues enabledForFailure: true, tool: resharperInspectCode(pattern: 'results/**'), qualityGates:[[threshold: 230, type: 'TOTAL', unstable: true],[threshold: 250, type: 'TOTAL', unstable: false]]
|
||||
}
|
||||
}
|
||||
stage('Checksum artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def checksummable = [
|
||||
/* Binaries are signed
|
||||
'build/**',
|
||||
'SharedPackages/**',
|
||||
*/
|
||||
]
|
||||
checksumutils = load("${autobuilder.commonscripts()}/checksum/utils.groovy")
|
||||
checksumutils.generatelist(meta, checksummable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Classifying publishable artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def publishable = [
|
||||
]
|
||||
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
|
||||
publishutils.generatelist(meta, publishable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Archiving artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def artifactlist = meta.generateartifacts(["results/**"])
|
||||
archiveArtifacts "${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
208
resharper/atlas_ui_resharper.groovy
Normal file
208
resharper/atlas_ui_resharper.groovy
Normal file
|
|
@ -0,0 +1,208 @@
|
|||
pipeline {
|
||||
agent { label "${AGENT_LABEL}" }
|
||||
// Timeout becasue Resharper sometimes hangs indefinitely
|
||||
options {
|
||||
timeout(time: 1, unit:'HOURS')
|
||||
}
|
||||
stages {
|
||||
stage('Initial setup') {
|
||||
steps {
|
||||
script {
|
||||
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout dependencies') {
|
||||
steps {
|
||||
script {
|
||||
configurationhelper = autobuilder.configurationhelper()
|
||||
|
||||
PYTHONURL = 'git@hydra:tools/python.git'
|
||||
PYTHONBRANCH = 'origin/3.6.3_windows'
|
||||
PYTHONDIR = "${WORKSPACE}/python"
|
||||
PYTHONROOTDIR = 'python'
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR, PYTHONROOTDIR)
|
||||
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
|
||||
|
||||
VERSTAMPINGURL = 'git@hydra:releases/ver_stamping_releases.git'
|
||||
VERSTAMPINGREVISION = "refs/tags/${VERSION_STAMPING_VERSION}"
|
||||
VERSTAMPINGDIR = "${WORKSPACE}/ver_stamping"
|
||||
VERSTAMPINGROOTDIR = 'ver_stamping_releases'
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'Version stamping', VERSTAMPINGURL, VERSTAMPINGREVISION, VERSTAMPINGDIR, VERSTAMPINGROOTDIR)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout source') {
|
||||
steps {
|
||||
script {
|
||||
SOURCEURL = 'git@hydra:gis/atlas_ui.git'
|
||||
SOURCEREVISION = SOURCE_REVISION
|
||||
SOURCEDIR = "${WORKSPACE}\\atlas_ui"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'atlas_ui', SOURCEURL, SOURCEREVISION, SOURCEDIR, '', 0, false)
|
||||
env.SOURCE_PATH = SOURCEDIR
|
||||
env.JOBSCRIPTS = "${SOURCE_PATH}\\autobuild\\code_analysis"
|
||||
env.JOBSCRIPTS_COMMON = "${SOURCE_PATH}\\autobuild\\common"
|
||||
env.SRC = SOURCE_PATH
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Clean exports') {
|
||||
steps {
|
||||
script {
|
||||
env.BUILDOUTPUT = "${WORKSPACE}/build"
|
||||
env.PSBIN = "${WORKSPACE}/ps_bin"
|
||||
env.ASBIN = "${WORKSPACE}/as_bin"
|
||||
env.PSSOURCE = "${WORKSPACE}/newsw"
|
||||
cleanfolders = [
|
||||
BUILDOUTPUT,
|
||||
"${WORKSPACE}/SharedPackages",
|
||||
PSBIN,
|
||||
ASBIN,
|
||||
"${WORKSPACE}/bin",
|
||||
"${WORKSPACE}/binKiosk",
|
||||
"${WORKSPACE}/documentation",
|
||||
"${WORKSPACE}/ildasm",
|
||||
"${WORKSPACE}/Libraries",
|
||||
"${WORKSPACE}/Atlas Release",
|
||||
"${WORKSPACE}/LocalisationSDK",
|
||||
]
|
||||
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, BASEBUILDNUMBER)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Print server dependencies') {
|
||||
steps {
|
||||
script {
|
||||
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
|
||||
|
||||
def psartifactfiles = "meta/**,bin/x64/Release/Engine - Render.dll,bin/x64/Release/Engine - Render.lib,bin/x64/Release/Engine - Render.pdb,bin/x64/Release/TBarCode11_x64.dll,bin/x64/Release/GIS Utility - Toolbox.dll,bin/x64/Release/GIS Utility - Toolbox.lib,bin/x64/Release/GIS Utility - Toolbox.pdb,bin/x64/Release/zlib1.dll,bin/x64/Release/zlib1.lib,bin/x64/Release/zlib1.pdb,bin/x64/Release/GIS Utility - TCP-IP Comms.dll,bin/x64/Release/GIS Utility - TCP-IP Comms.lib,bin/x64/Release/GIS Utility - TCP-IP Comms.pdb,bin/x64/Release/Dialog - Tree Node Editor.dll,bin/x64/Release/Dialog - Tree Node Editor.lib,bin/x64/Release/Dialog - Tree Node Editor.pdb"
|
||||
psmeta = importer.artifactimport(meta,
|
||||
PRINT_SERVER_ARTIFACT_LOCATION,
|
||||
PRINT_SERVER_COMPILE_JOB,
|
||||
PRINT_SERVER_BUILD_SELECTOR,
|
||||
PRINT_SERVER_RELEASE_REPO,
|
||||
PRINT_SERVER_RELEASE_REVISION,
|
||||
PSBIN,
|
||||
true,
|
||||
psartifactfiles)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout relevant Print server source') {
|
||||
steps {
|
||||
script {
|
||||
def pssourceartifacts = "src/Engine Common"
|
||||
def pssourceurl = psmeta.gitinfo.remoteurl
|
||||
def pscommit = psmeta.gitinfo.gitrevision
|
||||
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'print_server_source', pssourceurl, pscommit, PSSOURCE, '', 0, false, pssourceartifacts)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Atlas services dependencies') {
|
||||
steps {
|
||||
script {
|
||||
def asartifactfiles = "meta/**,SharedPackages/**"
|
||||
asmeta = importer.artifactimport(meta,
|
||||
ATLAS_SERVICES_ARTIFACT_LOCATION,
|
||||
ATLAS_SERVICES_COMPILE_JOB,
|
||||
ATLAS_SERVICES_BUILD_SELECTOR,
|
||||
ATLAS_SERVICES_RELEASE_REPO,
|
||||
ATLAS_SERVICES_RELEASE_REVISION,
|
||||
ASBIN,
|
||||
true,
|
||||
asartifactfiles)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Version files') {
|
||||
steps {
|
||||
script {
|
||||
env.BUILD_STAMP=meta.buildstampinfo.buildstamp
|
||||
env.BUILD_DATE=meta.jenkinsbuildinfo.builddate
|
||||
env.PS_VERSION="1.0.${psmeta.buildstampinfo.revision}.0"
|
||||
env.PS_PACKAGE_VERSION=psmeta.buildstampinfo.buildstampprefix
|
||||
env.AS_PACKAGE_VERSION=asmeta.buildstampinfo.buildstamp
|
||||
bat """
|
||||
call "${JOBSCRIPTS_COMMON}\\create_ps_nuget.bat"
|
||||
if errorlevel 1 exit /b 1
|
||||
call "${JOBSCRIPTS_COMMON}\\version_atlas_ui_files.bat"
|
||||
if errorlevel 1 exit /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Analyse resharper') {
|
||||
steps {
|
||||
script {
|
||||
env.SRC_REVISION=SOURCE_REVISION
|
||||
bat """
|
||||
call "${JOBSCRIPTS}\\build_and_analyse_atlas.bat"
|
||||
if errorlevel 1 exit /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
stage('Analysis') {
|
||||
steps {
|
||||
recordIssues enabledForFailure: true, tool: resharperInspectCode(pattern: 'results/atlas_resharper_results.xml'), qualityGates:[[threshold: 1000, type: 'TOTAL', unstable: true],[threshold: 4500, type: 'TOTAL', unstable: false]]
|
||||
}
|
||||
}
|
||||
stage('Checksum artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def checksummable = [
|
||||
/* Binaries are signed
|
||||
'build/**',
|
||||
'SharedPackages/**',
|
||||
*/
|
||||
]
|
||||
checksumutils = load("${autobuilder.commonscripts()}/checksum/utils.groovy")
|
||||
checksumutils.generatelist(meta, checksummable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Classifying publishable artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def publishable = [
|
||||
]
|
||||
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
|
||||
publishutils.generatelist(meta, publishable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Archiving artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def artifactlist = meta.generateartifacts(["results/**"])
|
||||
archiveArtifacts "${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
144
resharper/ccm.groovy
Normal file
144
resharper/ccm.groovy
Normal file
|
|
@ -0,0 +1,144 @@
|
|||
pipeline {
|
||||
agent { label "${AGENT_LABEL}" }
|
||||
stages {
|
||||
stage('Initial setup') {
|
||||
steps {
|
||||
script {
|
||||
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout dependencies') {
|
||||
steps {
|
||||
script {
|
||||
configurationhelper = autobuilder.configurationhelper()
|
||||
|
||||
PYTHONURL = 'git@hydra:tools/python.git'
|
||||
PYTHONBRANCH = 'origin/3.6.3_windows'
|
||||
PYTHONDIR = "${WORKSPACE}/python"
|
||||
PYTHONROOTDIR = 'python'
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR, PYTHONROOTDIR)
|
||||
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
|
||||
|
||||
VERSTAMPINGURL = 'git@hydra:releases/ver_stamping_releases.git'
|
||||
VERSTAMPINGREVISION = "refs/tags/${VERSION_STAMPING_VERSION}"
|
||||
VERSTAMPINGDIR = "${WORKSPACE}/ver_stamping"
|
||||
VERSTAMPINGROOTDIR = 'ver_stamping_releases'
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'Version stamping', VERSTAMPINGURL, VERSTAMPINGREVISION, VERSTAMPINGDIR, VERSTAMPINGROOTDIR)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout CCM Tools') {
|
||||
steps {
|
||||
script {
|
||||
CCMSOURCEURL = 'git@hydra:tools/ccm.git'
|
||||
CCMSOURCEDIR = "${WORKSPACE}\\ccm"
|
||||
CCMSOURCEREVISION = CCM_SOURCE_REVISION
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'ccm', CCMSOURCEURL, CCMSOURCEREVISION, CCMSOURCEDIR, '', 0, false)
|
||||
env.CCM_SOURCE_PATH = CCMSOURCEDIR
|
||||
env.CCM_SRC = CCM_SOURCE_PATH
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout source') {
|
||||
steps {
|
||||
script {
|
||||
SOURCEURL = 'git@hydra:gis/atlas_ui.git'
|
||||
SOURCEREVISION = SOURCE_REVISION
|
||||
SOURCEDIR = "${WORKSPACE}\\atlas_ui"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'atlas_ui', SOURCEURL, SOURCEREVISION, SOURCEDIR, '', 0, false)
|
||||
env.SOURCE_PATH = SOURCEDIR
|
||||
env.JOBSCRIPTS = "${SOURCE_PATH}\\autobuild\\code_analysis"
|
||||
env.JOBSCRIPTS_COMMON = "${SOURCE_PATH}\\autobuild\\common"
|
||||
env.SRC = SOURCE_PATH
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Clean exports') {
|
||||
steps {
|
||||
script {
|
||||
env.BUILDOUTPUT = "${WORKSPACE}/results"
|
||||
cleanfolders = [
|
||||
BUILDOUTPUT
|
||||
]
|
||||
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, BASEBUILDNUMBER)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('CCM Analysis') {
|
||||
steps {
|
||||
script {
|
||||
env.SRC_REVISION=SOURCE_REVISION
|
||||
bat """
|
||||
rmdir /s /q "${BUILDOUTPUT}"
|
||||
mkdir "${BUILDOUTPUT}"
|
||||
|
||||
"${CCM_SRC}/bin/CCM.exe" "${JOBSCRIPTS}/ccm.config" > "${BUILDOUTPUT}/atlasui_ccm.xml"
|
||||
if errorlevel 1 exit /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
stage('Analysis') {
|
||||
steps {
|
||||
recordIssues enabledForFailure: true, tool: ccm(pattern: 'results/**'), qualityGates:[[threshold: 150, type: 'TOTAL', unstable: true],[threshold: 200, type: 'TOTAL', unstable: false]]
|
||||
}
|
||||
}
|
||||
stage('Checksum artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def checksummable = [
|
||||
/* Binaries are signed
|
||||
'build/**',
|
||||
'SharedPackages/**',
|
||||
*/
|
||||
]
|
||||
checksumutils = load("${autobuilder.commonscripts()}/checksum/utils.groovy")
|
||||
checksumutils.generatelist(meta, checksummable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Classifying publishable artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def publishable = [
|
||||
]
|
||||
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
|
||||
publishutils.generatelist(meta, publishable)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Archiving artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def artifactlist = meta.generateartifacts(["results/**"])
|
||||
archiveArtifacts "${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
123
static_analysis/static_analysis.groovy
Normal file
123
static_analysis/static_analysis.groovy
Normal file
|
|
@ -0,0 +1,123 @@
|
|||
pipeline {
|
||||
agent { label "${AGENT_LABEL}" }
|
||||
stages {
|
||||
stage('Initial setup') {
|
||||
steps {
|
||||
script {
|
||||
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout dependencies') {
|
||||
steps {
|
||||
script {
|
||||
configurationhelper = autobuilder.configurationhelper()
|
||||
|
||||
SOURCEURL = 'git@hydra:gis/atlas_ui.git'
|
||||
SOURCEREVISION = "${SOURCE_REVISION}".trim()
|
||||
SOURCEROOTDIR = 'atlas_ui'
|
||||
SOURCEDIR = "${WORKSPACE}/atlas_ui"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, SOURCEROOTDIR, SOURCEURL, SOURCEREVISION, SOURCEDIR, SOURCEROOTDIR, 0, false)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Print server to adjust version number') {
|
||||
steps {
|
||||
script {
|
||||
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
|
||||
|
||||
psartifactfiles = "meta/**"
|
||||
importer.artifactimport(meta, PRINT_SERVER_ARTIFACT_LOCATION, PRINT_SERVER_COMPILE_JOB, PRINT_SERVER_BUILD_SELECTOR, PRINT_SERVER_RELEASE_REPO, PRINT_SERVER_RELEASE_REVISION, 'ps_bin', true, psartifactfiles)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import Atlas services to adjust version number') {
|
||||
steps {
|
||||
script {
|
||||
asartifactfiles = "meta/**"
|
||||
importer.artifactimport(meta, ATLAS_SERVICES_ARTIFACT_LOCATION, ATLAS_SERVICES_COMPILE_JOB, ATLAS_SERVICES_BUILD_SELECTOR, ATLAS_SERVICES_RELEASE_REPO, ATLAS_SERVICES_RELEASE_REVISION, 'as_bin', true, asartifactfiles)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Atlas static analysis') {
|
||||
parallel {
|
||||
stage('Measure Atlas code complexity') {
|
||||
steps {
|
||||
script {
|
||||
ccm = build job: "${ATLAS_CCM_ANALYSIS_JOB}", propagate: false
|
||||
|
||||
if(ccm.result.equals("UNSTABLE") || ccm.result.equals("FAILURE"))
|
||||
{
|
||||
currentBuild.result = ccm.result
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Perform Atlas UI Resharper Analysis') {
|
||||
steps {
|
||||
script {
|
||||
atlas = build job: "${ATLAS_RESHARPER_ANALYSIS_JOB}", propagate: false
|
||||
if(!currentBuild.result.equals("FAILURE"))
|
||||
{
|
||||
if(atlas.result.equals("UNSTABLE") || atlas.result.equals("FAILURE"))
|
||||
{
|
||||
currentBuild.result = atlas.result
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Perform Atlas SDK Resharper Analysis') {
|
||||
steps {
|
||||
script {
|
||||
sdk = build job: "${ATLAS_SDK_RESHARPER_ANALYSIS_JOB}", propagate: false
|
||||
if(!currentBuild.result.equals("FAILURE"))
|
||||
{
|
||||
if(sdk.result.equals("UNSTABLE") || sdk.result.equals("FAILURE"))
|
||||
{
|
||||
currentBuild.result = sdk.result
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Perform Atlas Ink UI Resharper Analysis') {
|
||||
steps {
|
||||
script {
|
||||
ink = build job: "${ATLAS_INK_UI_RESHARPER_ANALYSIS_JOB}", propagate: false
|
||||
if(!currentBuild.result.equals("FAILURE"))
|
||||
{
|
||||
if(ink.result.equals("UNSTABLE") || ink.result.equals("FAILURE"))
|
||||
{
|
||||
currentBuild.result = ink.result
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'FAILURE build'
|
||||
/*
|
||||
step([$class: 'LogParserPublisher',
|
||||
parsingRulesPath: 'GitRepository/autobuild/build/log parsing rules/vs.txt',
|
||||
useProjectRule: true
|
||||
])
|
||||
*/
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
44
test/check_node_status.groovy
Normal file
44
test/check_node_status.groovy
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
pipeline {
|
||||
agent { label "VirtualBoxHost" }
|
||||
stages {
|
||||
stage('Checkout test utilites') {
|
||||
steps {
|
||||
checkout([$class: 'GitSCM',
|
||||
branches: [[name: 'origin/master']],
|
||||
doGenerateSubmoduleConfigurations: false,
|
||||
extensions: [[$class: 'CleanBeforeCheckout'], [$class: 'RelativeTargetDirectory', relativeTargetDir: 'Utilities']],
|
||||
submoduleCfg: [], userRemoteConfigs: [[url: 'git@hydra:gistest/Utilities.git']]])
|
||||
}
|
||||
}
|
||||
|
||||
stage('USE_CONFIG as true') {
|
||||
when {
|
||||
expression {
|
||||
"${USE_CONFIG}" == "true"
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
sh '''
|
||||
python3.6 Utilities/nodeState/node.py -n ${NODE_NAME} -c ${CONFIG}
|
||||
'''
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('USE_CONFIG as false') {
|
||||
when {
|
||||
expression {
|
||||
"${USE_CONFIG}" == "false"
|
||||
}
|
||||
}
|
||||
steps {
|
||||
script {
|
||||
sh '''
|
||||
python3.6 Utilities/nodeState/node.py -n ${NODE_NAME}
|
||||
'''
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
23
test/check_te_licences.groovy
Normal file
23
test/check_te_licences.groovy
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
pipeline {
|
||||
agent { label "VirtualBoxHost" }
|
||||
stages {
|
||||
stage('Checkout test utilites') {
|
||||
steps {
|
||||
checkout([$class: 'GitSCM',
|
||||
branches: [[name: 'origin/master']],
|
||||
doGenerateSubmoduleConfigurations: false,
|
||||
extensions: [[$class: 'CleanBeforeCheckout'], [$class: 'RelativeTargetDirectory', relativeTargetDir: 'Utilities']],
|
||||
submoduleCfg: [], userRemoteConfigs: [[url: 'git@hydra:gistest/Utilities.git']]])
|
||||
}
|
||||
}
|
||||
stage('Check available TE licences') {
|
||||
steps {
|
||||
script {
|
||||
sh '''
|
||||
python3.6 Utilities/TE_licence_checker/licence_checker.py -m ${MAX_TE_LICENCES} -t ${TIMEOUT}
|
||||
'''
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
24
test/flesh_install_dispatcher.groovy
Normal file
24
test/flesh_install_dispatcher.groovy
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
pipeline {
|
||||
agent { label "VirtualBoxHost" }
|
||||
stages {
|
||||
stage('Checkout test utilites') {
|
||||
steps {
|
||||
checkout([$class: 'GitSCM',
|
||||
branches: [[name: 'origin/master']],
|
||||
doGenerateSubmoduleConfigurations: false,
|
||||
extensions: [[$class: 'CleanBeforeCheckout'], [$class: 'RelativeTargetDirectory', relativeTargetDir: 'Utilities']],
|
||||
submoduleCfg: [], userRemoteConfigs: [[url: 'git@hydra:gistest/Utilities.git']]])
|
||||
}
|
||||
}
|
||||
stage('Node dispatch') {
|
||||
steps {
|
||||
script {
|
||||
sh '''
|
||||
python3.6 Utilities/dispatcher/node_dispatcher.py -l ${LABEL} -j ${JENKINSJOB}
|
||||
'''
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
157
test/fresh_install_master.groovy
Normal file
157
test/fresh_install_master.groovy
Normal file
|
|
@ -0,0 +1,157 @@
|
|||
pipeline {
|
||||
agent { label "${AGENT_LABEL}" }
|
||||
stages {
|
||||
stage('Checkout test utilites') {
|
||||
steps {
|
||||
checkout([$class: 'GitSCM',
|
||||
branches: [[name: 'origin/master']],
|
||||
doGenerateSubmoduleConfigurations: false,
|
||||
extensions: [[$class: 'CleanBeforeCheckout'], [$class: 'RelativeTargetDirectory', relativeTargetDir: 'Utilities']],
|
||||
submoduleCfg: [], userRemoteConfigs: [[url: 'git@hydra:gistest/Utilities.git']]])
|
||||
}
|
||||
}
|
||||
stage ('Wait for available node. Max 60min') {
|
||||
steps {
|
||||
script {
|
||||
env.NODE = sh(script: "python3.6 Utilities/dispatcher/node_dispatcher.py -l 'FreshInstallationTest'", returnStdout: true)
|
||||
}
|
||||
echo "Available Node: $env.NODE"
|
||||
}
|
||||
}
|
||||
stage ('Check VM state') {
|
||||
steps{
|
||||
script{
|
||||
sh '''#!/bin/bash
|
||||
echo "Check VM state"
|
||||
runningVMs="$(vboxmanage list runningvms | grep $NODE)"
|
||||
if [ -z "$runningVMs" ]; then exit 0; else exit 1;fi
|
||||
'''
|
||||
}
|
||||
}
|
||||
}
|
||||
stage ('Revert snapshot') {
|
||||
steps{
|
||||
sh '''#!/bin/bash
|
||||
echo "Revert snapshot"
|
||||
VBoxManage snapshot $NODE restore "clean"
|
||||
'''
|
||||
}
|
||||
}
|
||||
stage ('Start VM') {
|
||||
steps{
|
||||
sh '''#!/bin/bash
|
||||
echo "Start VM"
|
||||
vboxmanage startvm $NODE --type headless
|
||||
'''
|
||||
}
|
||||
}
|
||||
stage ('Wait till VM is up and running') {
|
||||
steps{
|
||||
sh '''#!/bin/bash
|
||||
echo "Wait up to 5 min till VM is up and running. "
|
||||
vboxmanage guestproperty wait $NODE SysprepArgs --timeout 300000
|
||||
'''
|
||||
}
|
||||
}
|
||||
stage ('Change Node to JNLP') {
|
||||
steps{
|
||||
sh '''#!/bin/bash
|
||||
echo "Change Node to JNLP"
|
||||
'''
|
||||
script {
|
||||
res = build(job: "Check_Node_Status", propagate: false,
|
||||
parameters:[
|
||||
string(name: 'NODE_NAME', value: "${NODE}"),
|
||||
string(name: 'CONFIG', value: "jnlp.xml"),
|
||||
booleanParam(name: 'USE_CONFIG', value: "true"),
|
||||
]).result
|
||||
if (res != 'SUCCESS') {
|
||||
currentBuild.result = 'FAILED'
|
||||
error "Failed to change node status. Exiting pipeline"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage ('Restart Jenkins Slave on VM'){
|
||||
steps{
|
||||
sh '''#!/bin/bash
|
||||
echo "Stop Jenkins Slave on VM"
|
||||
VBoxManage --nologo guestcontrol $NODE run --exe "c:\\Users\\jenkins_user\\Documents\\elevate.exe" --timeout 30000 --username Jenkins_user --password "ramshorn42" -- elevate /c /w net stop jenkinsslave-C__Jk
|
||||
'''
|
||||
sh '''#!/bin/bash
|
||||
echo "Start Jenkins Slave on VM"
|
||||
VBoxManage --nologo guestcontrol $NODE run --exe "c:\\Users\\jenkins_user\\Documents\\elevate.exe" --timeout 30000 --username Jenkins_user --password "ramshorn42" -- elevate /c /w net start jenkinsslave-C__Jk
|
||||
'''
|
||||
}
|
||||
}
|
||||
stage ('Check Node status') {
|
||||
steps{
|
||||
sh '''#!/bin/bash
|
||||
echo "Check Node status"
|
||||
'''
|
||||
script {
|
||||
res = build(job: "Check_Node_Status", propagate: false,
|
||||
parameters:[
|
||||
string(name: 'NODE_NAME', value: "${NODE}"),
|
||||
]).result
|
||||
if (res != 'SUCCESS') {
|
||||
currentBuild.result = 'FAILED'
|
||||
error "${NODE} is offline for Jenkins. Exiting pipeline"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage ('Install GIS software') {
|
||||
steps{
|
||||
script {
|
||||
FreshInstallJob = build(job: "${FRESHINSTALL_TEST_JOB}", propagate: false,
|
||||
parameters:[
|
||||
string(name: 'AGENT_LABEL', value: "${NODE}"),
|
||||
string(name: 'ATLAS_INSTALLER_JOB', value: "${ATLAS_INSTALLER_JOB}"),
|
||||
string(name: 'MCS_INSTALLER_JOB', value: "${MCS_INSTALLER_JOB}"),
|
||||
string(name: 'ATLAS_PROJECT', value: "${ATLAS_PROJECT}"),
|
||||
string(name: 'TESTLIST', value: "${TESTLIST}"),
|
||||
string(name: 'TEST_COMPLETE_EXECUTE', value: "TE"),
|
||||
string(name: 'ATLAS_REGRESSION_TEST_REVISION', value: "${ATLAS_REGRESSION_TEST_REVISION}"),
|
||||
string(name: 'LOG_FOLDER', value: "Test_Output"),
|
||||
])
|
||||
if (FreshInstallJob.result != 'SUCCESS') {
|
||||
currentBuild.result = 'FAILED'
|
||||
}
|
||||
currentBuild.description = "<br>" + "<a href="+FreshInstallJob.absoluteUrl +">FreshInstallTest</a>"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
sh '''#!/bin/bash
|
||||
echo "PowerOff VM"
|
||||
VBoxManage controlvm $NODE poweroff
|
||||
'''
|
||||
}
|
||||
failure {
|
||||
sh '''#!/bin/bash
|
||||
echo "Check VM state"
|
||||
runningVMs="$(vboxmanage list runningvms | grep $NODE)"
|
||||
if [ -z "$runningVMs" ]; then exit 0; else exit 0;fi
|
||||
'''
|
||||
sh '''#!/bin/bash
|
||||
echo "Disconnecting $NODE"
|
||||
curl -X POST http://surtsey/computer/$NODE/doDisconnect --basic -u test_user:ramshorn42
|
||||
'''
|
||||
}
|
||||
unstable {
|
||||
sh '''#!/bin/bash
|
||||
echo "Post unstable"
|
||||
'''
|
||||
}
|
||||
success {
|
||||
sh '''#!/bin/bash
|
||||
echo "Post success"
|
||||
echo "Disconnecting $NODE"
|
||||
curl -X POST http://surtsey/computer/$NODE/doDisconnect --basic -u test_user:ramshorn42
|
||||
'''
|
||||
}
|
||||
}
|
||||
}
|
||||
203
test/fresh_install_test.groovy
Normal file
203
test/fresh_install_test.groovy
Normal file
|
|
@ -0,0 +1,203 @@
|
|||
pipeline {
|
||||
agent { label "${AGENT_LABEL}" }
|
||||
stages {
|
||||
stage ("Initial Setup") {
|
||||
steps{
|
||||
script {
|
||||
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage ("Checkout dependencies") {
|
||||
steps {
|
||||
script{
|
||||
configurationhelper = autobuilder.configurationhelper()
|
||||
|
||||
RESULT_SOURCE_URL = "git@hydra:gistestresults/test_results.git"
|
||||
RESULT_SOURCE_REVISION = "origin/master"
|
||||
RESULT_SOURCE_DIR = "${WORKSPACE}/${HISTORY_FOLDER}"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, "TestResults", RESULT_SOURCE_URL, RESULT_SOURCE_REVISION, RESULT_SOURCE_DIR, "", 0, false)
|
||||
|
||||
CORE_SOURCE_URL = "git@hydra:gistest/giscorelite.git"
|
||||
CORE_SOURCE_REVISION = "${GISCORE}"
|
||||
CORE_SOURCE_DIR = "${WORKSPACE}/GisCore"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, "TestCore", CORE_SOURCE_URL, CORE_SOURCE_REVISION, CORE_SOURCE_DIR, "", 0, false)
|
||||
|
||||
CORE_SOURCE_URL = "git@hydra:gistest/Utilities.git"
|
||||
CORE_SOURCE_REVISION = "origin/master"
|
||||
CORE_SOURCE_DIR = "${WORKSPACE}/Utilities"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, "TestCore", CORE_SOURCE_URL, CORE_SOURCE_REVISION, CORE_SOURCE_DIR, "", 0, false)
|
||||
|
||||
PYTHONURL = 'git@hydra:tools/python.git'
|
||||
if (isUnix()) {
|
||||
PYTHONBRANCH = 'origin/3.6.3_linux'
|
||||
} else {
|
||||
PYTHONBRANCH = 'origin/3.6.3_windows'
|
||||
}
|
||||
PYTHONDIR = "${WORKSPACE}/python"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR)
|
||||
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Set Description'){
|
||||
steps{
|
||||
script{
|
||||
currentBuild.displayName = ATLAS_INSTALLER_JOB.split("_")[1]
|
||||
currentBuild.description = TESTLIST + "<br> node: ${env.NODE_NAME}"
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout test scripts') {
|
||||
steps {
|
||||
script {
|
||||
TEST_SOURCE_URL = "git@hydra:gis/atlaskiosksdk_test.git"
|
||||
TEST_SOURCE_REVISION = "${ATLAS_REGRESSION_TEST_REVISION}"
|
||||
TEST_SOURCE_DIR = "${WORKSPACE}/testscripts"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, "TestScripts", TEST_SOURCE_URL, TEST_SOURCE_REVISION, TEST_SOURCE_DIR, "", 0, false)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Generating version info') {
|
||||
steps {
|
||||
script {
|
||||
version = load("${autobuilder.commonscripts()}/versionnumbering/generate.groovy")
|
||||
version.generate(meta, TEST_SOURCE_REVISION, TEST_SOURCE_DIR )
|
||||
}
|
||||
}
|
||||
}
|
||||
stage ("Force clean artifacts"){
|
||||
steps {
|
||||
script{
|
||||
bat """
|
||||
call GisCore/jobscripts/reset_imports_and_exports.bat
|
||||
call GisCore/jobscripts/create_hwtest_shortpath_output.bat
|
||||
if errorlevel 1 exit /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage("Copy artifacts") {
|
||||
steps {
|
||||
script {
|
||||
|
||||
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
|
||||
|
||||
echo "Take the Atlas Server installer from the selected build job."
|
||||
ATLAS_SERVER_ARTIFACT_PROJECT = "${MCS_INSTALLER_JOB}"
|
||||
ATLAS_SERVER_ARTIFACT_FOLDER = "${WORKSPACE}/imports/mcs"
|
||||
ATLAS_SERVER_ARTIFACT_FILTER = "core_installer/installers/*.exe ,meta/**"
|
||||
ATLAS_SERVER_ARTIFACT_SELECTOR = "${MCS_INSTALLER_SELECTOR}"
|
||||
ATLAS_SERVER_APPLICATION = importer.artifactimport(meta, ATLAS_SERVER_ARTIFACT_PROJECT, ATLAS_SERVER_ARTIFACT_SELECTOR, ATLAS_SERVER_ARTIFACT_FOLDER, true, ATLAS_SERVER_ARTIFACT_FILTER)
|
||||
echo "Copied Atlas Server installer"
|
||||
|
||||
echo "Take the Print Server installer from the selected build job."
|
||||
PRINT_SERVER_ARTIFACT_PROJECT = "${PRINTSERVER_INSTALLER_JOB}"
|
||||
PRINT_SERVER_ARTIFACT_FOLDER = "${WORKSPACE}/imports/printserver"
|
||||
PRINT_SERVER_ARTIFACT_FILTER = "installers/installers/ALL/*.exe ,meta/**"
|
||||
PRINT_SERVER_ARTIFACT_SELECTOR = "${PRINTSERVER_INSTALLER_SELECTOR}"
|
||||
PRINT_SERVER_APPLICATION = importer.artifactimport(meta, PRINT_SERVER_ARTIFACT_PROJECT, PRINT_SERVER_ARTIFACT_SELECTOR, PRINT_SERVER_ARTIFACT_FOLDER, true, PRINT_SERVER_ARTIFACT_FILTER)
|
||||
echo "Copied Print Server installer"
|
||||
|
||||
|
||||
echo "Take the Atlas UI installer from the selected build job."
|
||||
ATLAS_UI_ARTIFACT_PROJECT = "${ATLAS_INSTALLER_JOB}"
|
||||
ATLAS_UI_ARTIFACT_FOLDER = "${WORKSPACE}/imports/atlas"
|
||||
ATLAS_UI_ARTIFACT_FILTER = "atlas_pro_installers/installers/**/*.exe, ink_ui_installers/installers/**/*.exe ,meta/**"
|
||||
ATLAS_UI_ARTIFACT_SELECTOR = "${ATLAS_INSTALLER_SELECTOR}"
|
||||
ATLAS_UI_APPLICATION = importer.artifactimport(meta, ATLAS_UI_ARTIFACT_PROJECT, ATLAS_UI_ARTIFACT_SELECTOR, ATLAS_UI_ARTIFACT_FOLDER, true, ATLAS_UI_ARTIFACT_FILTER)
|
||||
echo "Copied Atlas UI installer"
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Save environment variable(s) to file for TestExecute bug') {
|
||||
steps {
|
||||
script {
|
||||
bat '''
|
||||
set WORKSPACE > "%SystemRoot%/Temp/environment-variables-from-jenkins.txt"
|
||||
'''
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Check available TE Licences'){
|
||||
steps{
|
||||
script {
|
||||
res = build(job: "Check_TE_Licence", propagate: false).result
|
||||
if (res != 'SUCCESS') {
|
||||
currentBuild.result = 'FAILED'
|
||||
error "No more available Test Execute licences. Stopping pipeline."
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Test loop') {
|
||||
steps {
|
||||
script {
|
||||
failureCount = 0
|
||||
String[] tests
|
||||
tests = "${TESTLIST}".split(",")
|
||||
tests.each {
|
||||
testcompletetest generateMHT: true, launchType: 'lcItem', project: "${ATLAS_PROJECT}", suite: "testscripts/UITests/FreshInstallSuite/FreshInstallSuite.pjs", test: "${it}", useTCService: true, userName: 'jenkins_user', userPassword: 'ramshorn42', useActiveSession: true, executorType: "TE", useTimeout: true, timeout: '3600', actionOnErrors: 'MAKE_UNSTABLE'
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage("Create test results in JSON"){
|
||||
steps{
|
||||
script{
|
||||
rc =bat (script:"""
|
||||
%WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\testscripts\\UITests\\Utils\\HistoryStructure.py --url ${env.BUILD_URL} --ws_path ${env.WORKSPACE} --mcs_path "%WORKSPACE%\\imports\\mcs\\core_installer\\installers" --ps2_path "%WORKSPACE%\\imports\\printserver\\installers\\installers\\ALL" --aui_pro_path "%WORKSPACE%\\imports\\atlas\\atlas_pro_installers\\installers\\GIS Atlas Professional" --aui_pro4ps_path "%WORKSPACE%\\imports\\atlas\\atlas_pro_installers\\installers\\GIS Atlas Professional for Print Server" --ink_path "%WORKSPACE%\\imports\\atlas\\ink_ui_installers\\installers\\GIS Atlas Ink System Configuration UI"
|
||||
""",
|
||||
returnStatus: true
|
||||
)
|
||||
if (rc == 1){
|
||||
unstable('FAILED to process results')
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage("Archive Test History"){
|
||||
steps{
|
||||
script{
|
||||
rc =bat (script:"""
|
||||
set HistoryFail=0
|
||||
pushd %HISTORY_FOLDER%
|
||||
${env.PYTHON} GitCyclicPush.py
|
||||
if %errorlevel% neq 0 (set HistoryFail=1)
|
||||
popd
|
||||
if %HistoryFail% neq 0 (
|
||||
exit /b 1
|
||||
)
|
||||
""",
|
||||
returnStatus: true
|
||||
)
|
||||
if (rc == 1){
|
||||
unstable('FAILED to process history')
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage("Archive test artifacts"){
|
||||
steps{
|
||||
script{
|
||||
def artifactlist = meta.generateartifacts(["TestSuite/**","${ATLAS_SERVER_ARTIFACT_FOLDER}/meta/**","${LOG_FOLDER}/**","GisCore/**"])
|
||||
archiveArtifacts "${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
failure {
|
||||
bat " %WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\Utilities\\sendEmail\\emailnotification.py -t TC -j ${env.BUILD_URL} -n ${env.JOB_NAME} -s FAILED"
|
||||
}
|
||||
success {
|
||||
|
||||
bat " %WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\Utilities\\sendEmail\\emailnotification.py -t TC -j ${env.BUILD_URL} -n ${env.JOB_NAME} -s SUCCESS"
|
||||
}
|
||||
unstable {
|
||||
bat " %WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\Utilities\\sendEmail\\emailnotification.py -t TC -j ${env.BUILD_URL} -n ${env.JOB_NAME} -s FAILED"
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
204
test/test_all.groovy
Normal file
204
test/test_all.groovy
Normal file
|
|
@ -0,0 +1,204 @@
|
|||
def CheckForTestFailures (TestObject) {
|
||||
if (TestObject.result == 'UNSTABLE'){
|
||||
//currentBuild.result = 'UNSTABLE'
|
||||
unstable("Tests Failed")
|
||||
}
|
||||
else if (TestObject.result == 'SUCCESS'){
|
||||
echo("Tests Passed")
|
||||
}
|
||||
else{
|
||||
//currentBuild.result = 'FAILURE'
|
||||
unstable("Tests Job Failure! Investigate Job/Slave Setup")
|
||||
}
|
||||
}
|
||||
|
||||
pipeline {
|
||||
agent { label "${AGENT_LABEL}" }
|
||||
stages {
|
||||
stage('Initial setup') {
|
||||
steps {
|
||||
script {
|
||||
OPERATOR = 'and not'
|
||||
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
|
||||
subJobs = []
|
||||
}
|
||||
}
|
||||
}
|
||||
stage ("Checkout test results history dependencies") {
|
||||
steps {
|
||||
script{
|
||||
configurationhelper = autobuilder.configurationhelper()
|
||||
|
||||
RESULT_SOURCE_URL = "git@hydra:gistestresults/test_results.git"
|
||||
RESULT_SOURCE_REVISION = "origin/master"
|
||||
RESULT_SOURCE_DIR = "${WORKSPACE}/test_results"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, "TestResults", RESULT_SOURCE_URL, RESULT_SOURCE_REVISION, RESULT_SOURCE_DIR, "", 0, false)
|
||||
|
||||
PYTHONURL = 'git@hydra:tools/python.git'
|
||||
if (isUnix()) {
|
||||
PYTHONBRANCH = 'origin/3.6.3_linux'
|
||||
} else {
|
||||
PYTHONBRANCH = 'origin/3.6.3_windows'
|
||||
}
|
||||
PYTHONDIR = "${WORKSPACE}/python"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR)
|
||||
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Check if AtlasEngineer'){
|
||||
steps{
|
||||
script{
|
||||
if ("${ATLAS_ENGINEER}" == "true") {
|
||||
OPERATOR = 'and'
|
||||
}
|
||||
else {
|
||||
OPERATOR = 'and not'
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Atlas Operator tests') {
|
||||
parallel {
|
||||
stage('Perform Rename tests.') {
|
||||
steps {
|
||||
script {
|
||||
if ("${RUN_RENAME_TESTS}" == "true"){
|
||||
RenameTestJob = build (
|
||||
job: ATLAS_UI_META_JOB,
|
||||
parameters: [
|
||||
string(name: 'MCS_BINARIES_JOB', value: MCS_BINARIES_JOB),
|
||||
string(name: 'PRINT_SERVER_RENDER_FILES', value: PRINT_SERVER_RENDER_FILES),
|
||||
string(name: 'ATLAS_BINARIES_JOB', value: ATLAS_BINARIES_JOB),
|
||||
string(name: 'ATLAS_REGRESSION_TEST_REVISION', value: ATLAS_REGRESSION_TEST_REVISION),
|
||||
string(name: 'TAG', value: '@RenameTests ' + OPERATOR + ' @AtlasEngineer'),
|
||||
],
|
||||
propagate: false
|
||||
)
|
||||
CheckForTestFailures(RenameTestJob)
|
||||
RenameTestJob_URL = "<br>" + "<a href="+RenameTestJob.absoluteUrl +">RenameTest</a>"
|
||||
subJobs<<[ RenameTestJob, "RenameTestsResults", false, ]
|
||||
}
|
||||
else{
|
||||
RenameTestJob_URL = "<br>"}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Perform All tests.') {
|
||||
steps {
|
||||
script {
|
||||
if ("${RUN_ALL_TESTS}" == "true"){
|
||||
AllTestJob = build (
|
||||
job: ATLAS_UI_META_JOB,
|
||||
parameters: [
|
||||
string(name: 'MCS_BINARIES_JOB', value: MCS_BINARIES_JOB),
|
||||
string(name: 'PRINT_SERVER_RENDER_FILES', value: PRINT_SERVER_RENDER_FILES),
|
||||
string(name: 'ATLAS_BINARIES_JOB', value: ATLAS_BINARIES_JOB),
|
||||
string(name: 'ATLAS_REGRESSION_TEST_REVISION', value: ATLAS_REGRESSION_TEST_REVISION),
|
||||
string(name: 'TAG', value: '@AllTests ' + OPERATOR + ' @AtlasEngineer'),
|
||||
],
|
||||
propagate: false
|
||||
)
|
||||
CheckForTestFailures(AllTestJob)
|
||||
AllTestJob_URL = "<br>" + "<a href="+AllTestJob.absoluteUrl +">AllTest</a>"
|
||||
subJobs<<[ AllTestJob, "AllTestsResults", false, ]
|
||||
}
|
||||
else{
|
||||
AllTestJob_URL = "<br>"}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Perform Save and Discard tests.') {
|
||||
steps {
|
||||
script {
|
||||
if ("${RUN_SAVEANDDISCARD_TESTS}" == "true"){
|
||||
SaveAndDiscardTestJob = build (
|
||||
job: ATLAS_UI_META_JOB,
|
||||
parameters: [
|
||||
string(name: 'MCS_BINARIES_JOB', value: MCS_BINARIES_JOB),
|
||||
string(name: 'PRINT_SERVER_RENDER_FILES', value: PRINT_SERVER_RENDER_FILES),
|
||||
string(name: 'ATLAS_BINARIES_JOB', value: ATLAS_BINARIES_JOB),
|
||||
string(name: 'ATLAS_REGRESSION_TEST_REVISION', value: ATLAS_REGRESSION_TEST_REVISION),
|
||||
string(name: 'TAG', value: '@SaveAndDiscard ' + OPERATOR + ' @AtlasEngineer'),
|
||||
],
|
||||
propagate: false
|
||||
)
|
||||
CheckForTestFailures(SaveAndDiscardTestJob)
|
||||
SaveAndDiscardTestJob_URL = "<br>" + "<a href="+SaveAndDiscardTestJob.absoluteUrl +">SaveAndDiscardTest</a>"
|
||||
subJobs<<[ SaveAndDiscardTestJob, "SaveAndDiscardTestsResults", false, ]
|
||||
}
|
||||
else{
|
||||
SaveAndDiscardTestJob_URL = "<br>"}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Perform Sanity tests') {
|
||||
steps {
|
||||
script {
|
||||
if ("${RUN_SANITY_TESTS}" == "true"){
|
||||
SanityTestJob = build (
|
||||
job: ATLAS_UI_META_JOB,
|
||||
parameters: [
|
||||
string(name: 'MCS_BINARIES_JOB', value: MCS_BINARIES_JOB),
|
||||
string(name: 'PRINT_SERVER_RENDER_FILES', value: PRINT_SERVER_RENDER_FILES),
|
||||
string(name: 'ATLAS_BINARIES_JOB', value: ATLAS_BINARIES_JOB),
|
||||
string(name: 'ATLAS_REGRESSION_TEST_REVISION', value: ATLAS_REGRESSION_TEST_REVISION),
|
||||
string(name: 'TAG', value: '@SanityTests ' + OPERATOR + ' @AtlasEngineer'),
|
||||
],
|
||||
propagate: false
|
||||
)
|
||||
CheckForTestFailures(SanityTestJob)
|
||||
SanityTestJob_URL = "<br>" + "<a href="+SanityTestJob.absoluteUrl +">SanityTest</a>"
|
||||
subJobs<<[ SanityTestJob, "CoreTestsResults", false, ]
|
||||
}
|
||||
else{
|
||||
SanityTestJob_URL = "<br>"}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Set Description'){
|
||||
steps{
|
||||
script{
|
||||
currentBuild.description = SanityTestJob_URL + SaveAndDiscardTestJob_URL + RenameTestJob_URL + AllTestJob_URL
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Accumulate artifacts') {
|
||||
steps {
|
||||
script {
|
||||
artifacthelper = load("${autobuilder.commonscripts()}/artifacts/metaexport.groovy")
|
||||
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
|
||||
artifactFolders = artifacthelper.combineSubjobArtifacts(meta, importer, subJobs)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Archiving artifacts') {
|
||||
steps {
|
||||
script {
|
||||
def artifactlist = meta.generateartifacts(artifactFolders)
|
||||
archiveArtifacts "${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
post {
|
||||
always {
|
||||
echo 'Post-build'
|
||||
}
|
||||
failure {
|
||||
echo 'Failed build'
|
||||
}
|
||||
unstable {
|
||||
echo 'Unstable build'
|
||||
}
|
||||
success {
|
||||
echo 'Succeeded build'
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
172
test/ui_mcs_tools_testing_dev.groovy
Normal file
172
test/ui_mcs_tools_testing_dev.groovy
Normal file
|
|
@ -0,0 +1,172 @@
|
|||
pipeline {
|
||||
agent { label "${AGENT_LABEL}" }
|
||||
stages {
|
||||
stage ('Cleaning Test_Output') {
|
||||
steps{
|
||||
bat'''if exist %WORKSPACE%\\Test_Output rmdir /s /q %WORKSPACE%\\Test_Output'''
|
||||
}
|
||||
}
|
||||
stage ('Cleaning imports') {
|
||||
steps{
|
||||
bat'''if exist %WORKSPACE%\\imports rmdir /s /q %WORKSPACE%\\imports'''
|
||||
}
|
||||
}
|
||||
stage('Clean workspace') {
|
||||
when {
|
||||
expression {
|
||||
"${CLEAN_WORKSPACE}" == "true"
|
||||
}
|
||||
}
|
||||
steps {
|
||||
cleanWs()
|
||||
}
|
||||
}
|
||||
stage("checkout python"){
|
||||
steps{
|
||||
checkout([$class: 'GitSCM',
|
||||
branches: [[name: 'origin/3.6.3_windows']],
|
||||
doGenerateSubmoduleConfigurations: false,
|
||||
extensions: [[$class: 'CleanBeforeCheckout'], [$class: 'RelativeTargetDirectory', relativeTargetDir: 'python']],
|
||||
submoduleCfg: [], userRemoteConfigs: [[url: 'git@hydra:tools/python.git']]])
|
||||
script{
|
||||
env.PYTHON = "${WORKSPACE}/python/ver/python.exe"
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout source') {
|
||||
steps {
|
||||
checkout([$class: 'GitSCM',
|
||||
branches: [[name: 'origin/${TEST_BRANCH}']],
|
||||
doGenerateSubmoduleConfigurations: false,
|
||||
extensions: [[$class: 'CleanBeforeCheckout'], [$class: 'RelativeTargetDirectory', relativeTargetDir: 'testscripts']],
|
||||
submoduleCfg: [], userRemoteConfigs: [[url: 'git@hydra:gis/atlaskiosksdk_test.git']]])
|
||||
}
|
||||
}
|
||||
stage('Checkout GisCore') {
|
||||
steps {
|
||||
checkout([$class: 'GitSCM',
|
||||
branches: [[name: 'origin/${GISCORE_BRANCH}']],
|
||||
doGenerateSubmoduleConfigurations: false,
|
||||
extensions: [[$class: 'CleanBeforeCheckout'], [$class: 'RelativeTargetDirectory', relativeTargetDir: 'GisCore']],
|
||||
submoduleCfg: [], userRemoteConfigs: [[url: 'git@hydra:gistest/giscorelite.git']]])
|
||||
}
|
||||
}
|
||||
stage('Checkout test utilites') {
|
||||
steps {
|
||||
checkout([$class: 'GitSCM',
|
||||
branches: [[name: 'origin/master']],
|
||||
doGenerateSubmoduleConfigurations: false,
|
||||
extensions: [[$class: 'CleanBeforeCheckout'], [$class: 'RelativeTargetDirectory', relativeTargetDir: 'Utilities']],
|
||||
submoduleCfg: [], userRemoteConfigs: [[url: 'git@hydra:gistest/Utilities.git']]])
|
||||
}
|
||||
}
|
||||
stage("Clean imports") {
|
||||
steps {
|
||||
script {
|
||||
env.IMPORTSPATH = "${WORKSPACE}/imports"
|
||||
}
|
||||
dir("${IMPORTSPATH}") {
|
||||
deleteDir()
|
||||
}
|
||||
}
|
||||
}
|
||||
stage("Clean exports") {
|
||||
steps {
|
||||
dir("${WORKSPACE}/uilogs") {
|
||||
deleteDir()
|
||||
}
|
||||
dir("${WORKSPACE}/version") {
|
||||
deleteDir()
|
||||
}
|
||||
dir("${WORKSPACE}/pipeline") {
|
||||
deleteDir()
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import artifacts') {
|
||||
steps {
|
||||
script {
|
||||
MCS = "${IMPORTSPATH}/mcs"
|
||||
echo "Obtaining MCS artifacts from ${MCS_BINARIES_JOB} job and placing at folder: ${MCS}"
|
||||
copyArtifacts filter: 'build/publish/**', projectName: "${MCS_BINARIES_JOB}", selector: lastSuccessful(), target: "${MCS}"
|
||||
copyArtifacts filter: 'bin/x64/Release/Engine - Render.dll,bin/x64/Release/TBarCode11_x64.dll,bin/x64/Release/GIS Utility - Toolbox.dll,bin/x64/Release/zlib1.dll,bin/x64/Release/TECIT.TBarCode.dll', flatten: true, projectName: "${PRINT_SERVER_RENDER_FILES}", selector: lastSuccessful(), target: "${MCS}/build/publish/"
|
||||
|
||||
ATLAS = "${IMPORTSPATH}/atlas"
|
||||
echo "Obtaining Atlas artifacts from ${ATLAS_BINARIES_JOB} job and placing at folder: ${ATLAS}"
|
||||
copyArtifacts filter: 'bin/**,LocalisationSDK/**,version/**', projectName: "${ATLAS_BINARIES_JOB}", selector: lastSuccessful(), target: "${ATLAS}"
|
||||
|
||||
KIOSK = "${IMPORTSPATH}/kiosk"
|
||||
echo "Obtaining Atlas KIOSK artifacts from ${ATLAS_BINARIES_JOB} job and placing at folder: ${KIOSK}"
|
||||
copyArtifacts filter: 'binKiosk/**,LocalisationSDK/**,version/**', projectName: "${ATLAS_BINARIES_JOB}", selector: lastSuccessful(), target: "${KIOSK}"
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
stage ('Copy the kiosk tool files for Atlas Production') {
|
||||
steps {
|
||||
script {
|
||||
bat '''
|
||||
"%WORKSPACE%/testscripts/UITests/SetupScripts/copy_atlas_production.bat"
|
||||
'''
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Save environment variable(s) to file for TestExecute bug') {
|
||||
steps {
|
||||
script {
|
||||
bat '''
|
||||
set WORKSPACE > "%SystemRoot%/Temp/environment-variables-from-jenkins.txt"
|
||||
'''
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Create a VPIRender.Server.bat') {
|
||||
steps {
|
||||
script {
|
||||
bat '''
|
||||
echo "C:/Program Files/dotnet/dotnet.exe" "%WORKSPACE%/imports/mcs/build/publish/VpiRender.Server.dll" --owner localhost:5000 > "%WORKSPACE%/imports/mcs/build/publish/VpiRender.Server.bat"
|
||||
'''
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Check available TE Licences'){
|
||||
steps{
|
||||
script {
|
||||
res = build(job: "Check_TE_Licence", propagate: false).result
|
||||
if (res != 'SUCCESS') {
|
||||
currentBuild.result = 'FAILED'
|
||||
error "No more available Test Execute licences. Stopping pipeline."
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Test loop') {
|
||||
steps {
|
||||
script {
|
||||
failureCount = 0
|
||||
String[] tests
|
||||
powershell(returnStdout: true, script: '$names = @("dotnet", "Atlas Professional for Print Server", "Atlas Professional", "GIS Print Server 2", "AtlasKioskSDK", "pythonw"); foreach ($item in $names) {Get-Process -Name $item | Stop-Process}')
|
||||
testcompletetest generateMHT: true, launchType: 'lcTags', project: "AtlasMCSProject", suite: "testscripts/UITests/AtlasTestSuite/AtlasTestSuite.pjs", tags: "${TAG}", useTCService: true, userName: 'jenkins_user', userPassword: 'ramshorn42', useActiveSession: true, executorType: "TE", timeout: '14400', useTimeout: true, actionOnErrors: 'MAKE_FAILED'
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
bat " %WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\testscripts\\UITests\\Utils\\HistoryStructure.py --url ${env.BUILD_URL} --ws_path ${env.WORKSPACE}"
|
||||
}
|
||||
failure {
|
||||
bat " %WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\Utilities\\sendEmail\\emailnotification.py -t TC -j ${env.BUILD_URL} -n ${env.JOB_NAME} -s FAILED"
|
||||
}
|
||||
success {
|
||||
|
||||
bat " %WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\Utilities\\sendEmail\\emailnotification.py -t TC -j ${env.BUILD_URL} -n ${env.JOB_NAME} -s SUCCESS"
|
||||
}
|
||||
unstable {
|
||||
bat " %WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\Utilities\\sendEmail\\emailnotification.py -t TC -j ${env.BUILD_URL} -n ${env.JOB_NAME} -s FAILED"
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
240
test/ui_meta_test.groovy
Normal file
240
test/ui_meta_test.groovy
Normal file
|
|
@ -0,0 +1,240 @@
|
|||
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)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage ("Checkout dependencies") {
|
||||
steps {
|
||||
script{
|
||||
configurationhelper = autobuilder.configurationhelper()
|
||||
|
||||
RESULT_SOURCE_URL = "git@hydra:gistestresults/test_results.git"
|
||||
RESULT_SOURCE_REVISION = "origin/master"
|
||||
RESULT_SOURCE_DIR = "${WORKSPACE}/${HISTORY_FOLDER}"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, "TestResults", RESULT_SOURCE_URL, RESULT_SOURCE_REVISION, RESULT_SOURCE_DIR, "", 0, false)
|
||||
|
||||
CORE_SOURCE_URL = "git@hydra:gistest/giscorelite.git"
|
||||
CORE_SOURCE_REVISION = "${GISCORE}"
|
||||
CORE_SOURCE_DIR = "${WORKSPACE}/GisCore"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, "TestCore", CORE_SOURCE_URL, CORE_SOURCE_REVISION, CORE_SOURCE_DIR, "", 0, false)
|
||||
|
||||
CORE_SOURCE_URL = "git@hydra:gistest/Utilities.git"
|
||||
CORE_SOURCE_REVISION = "origin/master"
|
||||
CORE_SOURCE_DIR = "${WORKSPACE}/Utilities"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, "TestCore", CORE_SOURCE_URL, CORE_SOURCE_REVISION, CORE_SOURCE_DIR, "", 0, false)
|
||||
|
||||
PYTHONURL = 'git@hydra:tools/python.git'
|
||||
if (isUnix()) {
|
||||
PYTHONBRANCH = 'origin/3.6.3_linux'
|
||||
} else {
|
||||
PYTHONBRANCH = 'origin/3.6.3_windows'
|
||||
}
|
||||
PYTHONDIR = "${WORKSPACE}/python"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR)
|
||||
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Set Description'){
|
||||
steps{
|
||||
script{
|
||||
if (TAG.endsWith("and @AtlasEngineer")) {
|
||||
currentBuild.displayName = "KIOSK: " + ATLAS_BINARIES_JOB.split("_")[1] + " " + TAG.minus("and @AtlasEngineer")
|
||||
}
|
||||
else{
|
||||
currentBuild.displayName = ATLAS_BINARIES_JOB.split("_")[1] + " " + TAG.minus("and not @AtlasEngineer")
|
||||
}
|
||||
currentBuild.description = "node: ${env.NODE_NAME}"
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout test scripts') {
|
||||
steps {
|
||||
script {
|
||||
TEST_SOURCE_URL = "git@hydra:gis/atlaskiosksdk_test.git"
|
||||
TEST_SOURCE_REVISION = "${ATLAS_REGRESSION_TEST_REVISION}"
|
||||
TEST_SOURCE_DIR = "${WORKSPACE}/testscripts"
|
||||
configurationhelper.gitCheckoutAndRegister(meta, "TestScripts", TEST_SOURCE_URL, TEST_SOURCE_REVISION, TEST_SOURCE_DIR, "", 0, false)
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Generating version info') {
|
||||
steps {
|
||||
script {
|
||||
version = load("${autobuilder.commonscripts()}/versionnumbering/generate.groovy")
|
||||
version.generate(meta, TEST_SOURCE_REVISION, TEST_SOURCE_DIR )
|
||||
}
|
||||
}
|
||||
}
|
||||
stage ("Force clean artifacts"){
|
||||
steps {
|
||||
script{
|
||||
bat """
|
||||
call GisCore/jobscripts/reset_imports_and_exports.bat
|
||||
call GisCore/jobscripts/create_hwtest_shortpath_output.bat
|
||||
if errorlevel 1 exit /b 1
|
||||
"""
|
||||
}
|
||||
}
|
||||
}
|
||||
stage("Copy artifacts") {
|
||||
steps {
|
||||
script {
|
||||
|
||||
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
|
||||
|
||||
echo "Take the Atlas Server artifacts from the selected build job."
|
||||
ATLAS_SERVER_ARTIFACT_PROJECT = "${MCS_BINARIES_JOB}"
|
||||
ATLAS_SERVER_ARTIFACT_FOLDER = "${WORKSPACE}/imports/mcs"
|
||||
ATLAS_SERVER_ARTIFACT_SELECTOR = "${ATLAS_SERVER_ARTIFACT_SELECTOR}"
|
||||
ATLAS_SERVER_ARTIFACT_FILTER = "build/publish/**,meta/**"
|
||||
ATLAS_SERVER_ARTIFACT_EXCLUDES = "**/*.pdb,**/*.lib,**/*.html,**/*.aspx,**/*.php"
|
||||
ATLAS_SERVER_APPLICATION = importer.artifactimport(meta, ATLAS_SERVER_ARTIFACT_PROJECT, ATLAS_SERVER_ARTIFACT_SELECTOR, ATLAS_SERVER_ARTIFACT_FOLDER, true, ATLAS_SERVER_ARTIFACT_FILTER,ATLAS_SERVER_ARTIFACT_EXCLUDES)
|
||||
echo "Copied Atlas Server Artifacts"
|
||||
|
||||
echo "Take the Print Server artifacts from the selected build job."
|
||||
PRINT_SERVER_ARTIFACT_PROJECT = "${PRINT_SERVER_RENDER_FILES}"
|
||||
PRINT_SERVER_ARTIFACT_FOLDER = "${WORKSPACE}/imports/mcs/build/publish/"
|
||||
PRINT_SERVER_ARTIFACT_SELECTOR = "${PRINT_SERVER_ARTIFACT_SELECTOR}"
|
||||
PRINT_SERVER_ARTIFACT_FILTER = "bin/x64/Release/Engine - Render.dll,bin/x64/Release/TBarCode11_x64.dll,bin/x64/Release/GIS Utility - Toolbox.dll,bin/x64/Release/zlib1.dll,bin/x64/Release/TECIT.TBarCode.dll,meta/**"
|
||||
PRINT_SERVER_ARTIFACT_EXCLUDES = "**/*.pdb,**/*.lib,**/*.html,**/*.aspx,**/*.php"
|
||||
PRINT_SERVER_APPLICATION = importer.artifactimport(meta, PRINT_SERVER_ARTIFACT_PROJECT, PRINT_SERVER_ARTIFACT_SELECTOR, PRINT_SERVER_ARTIFACT_FOLDER, true, PRINT_SERVER_ARTIFACT_FILTER, PRINT_SERVER_ARTIFACT_EXCLUDES)
|
||||
echo "Copied Print Server Render Artifacts"
|
||||
|
||||
|
||||
echo "Take the Atlas UI artifacts from the selected build job."
|
||||
ATLAS_UI_ARTIFACT_PROJECT = "${ATLAS_BINARIES_JOB}"
|
||||
ATLAS_UI_ARTIFACT_FOLDER = "${WORKSPACE}/imports/atlas"
|
||||
ATLAS_UI_ARTIFACT_SELECTOR = "${ATLAS_UI_ARTIFACT_SELECTOR}"
|
||||
ATLAS_UI_ARTIFACT_FILTER = "bin/**,LocalisationSDK/**,,meta/**"
|
||||
ATLAS_UI_ARTIFACT_EXCLUDES = "**/*.pdb,**/*.lib,**/*.html,**/*.aspx,**/*.php"
|
||||
ATLAS_UI_APPLICATION = importer.artifactimport(meta, ATLAS_UI_ARTIFACT_PROJECT, ATLAS_UI_ARTIFACT_SELECTOR, ATLAS_UI_ARTIFACT_FOLDER, true, ATLAS_UI_ARTIFACT_FILTER,ATLAS_UI_ARTIFACT_EXCLUDES)
|
||||
echo "Copied Atlas UI Artifacts"
|
||||
|
||||
echo "Take the Atlas KIOS artifacts from the selected build job."
|
||||
ATLAS_KIOSK_ARTIFACT_PROJECT = "${ATLAS_BINARIES_JOB}"
|
||||
ATLAS_KIOSK_ARTIFACT_FOLDER = "${WORKSPACE}/imports/kiosk"
|
||||
ATLAS_KIOSK_ARTIFACT_SELECTOR = "${ATLAS_UI_ARTIFACT_SELECTOR}"
|
||||
ATLAS_KIOSK_ARTIFACT_FILTER = "binKiosk/**,LocalisationSDK/**,,meta/**"
|
||||
ATLAS_KIOSK_ARTIFACT_EXCLUDES = "**/*.pdb,**/*.lib,**/*.html,**/*.aspx,**/*.php"
|
||||
ATLAS_KIOSK_APPLICATION = importer.artifactimport(meta, ATLAS_KIOSK_ARTIFACT_PROJECT, ATLAS_KIOSK_ARTIFACT_SELECTOR, ATLAS_KIOSK_ARTIFACT_FOLDER, true, ATLAS_KIOSK_ARTIFACT_FILTER,ATLAS_KIOSK_ARTIFACT_EXCLUDES)
|
||||
echo "Copied Atlas KIOS Artifacts"
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
stage ('Copy the kiosk tool files for Atlas Production') {
|
||||
steps {
|
||||
script {
|
||||
bat '''
|
||||
"%WORKSPACE%/testscripts/UITests/SetupScripts/copy_atlas_production.bat"
|
||||
'''
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Save environment variable(s) to file for TestExecute bug') {
|
||||
steps {
|
||||
script {
|
||||
bat '''
|
||||
set WORKSPACE > "%SystemRoot%/Temp/environment-variables-from-jenkins.txt"
|
||||
'''
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Create a VPIRender.Server.bat') {
|
||||
steps {
|
||||
script {
|
||||
bat '''
|
||||
echo "C:/Program Files/dotnet/dotnet.exe" "%WORKSPACE%/imports/mcs/build/publish/VpiRender.Server.dll" --owner localhost:5000 > "%WORKSPACE%/imports/mcs/build/publish/VpiRender.Server.bat"
|
||||
'''
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Check available TE Licences'){
|
||||
steps{
|
||||
script {
|
||||
res = build(job: "Check_TE_Licence", propagate: false).result
|
||||
if (res != 'SUCCESS') {
|
||||
currentBuild.result = 'FAILED'
|
||||
error "No more available Test Execute licences. Stopping pipeline."
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Test loop') {
|
||||
steps {
|
||||
script {
|
||||
failureCount = 0
|
||||
String[] tests
|
||||
powershell(returnStdout: true, script: '$names = @("dotnet", "Atlas Professional for Print Server", "Atlas Professional", "GIS Print Server 2", "AtlasKioskSDK", "pythonw"); foreach ($item in $names) {Get-Process -Name $item | Stop-Process}')
|
||||
testcompletetest generateMHT: true, launchType: 'lcTags', project: "${ATLAS_PROJECT}", suite: "testscripts/UITests/${ATLAS_SUITE}/${ATLAS_SUITE}.pjs", tags: "${TAG}", useTCService: true, userName: 'jenkins_user', userPassword: 'ramshorn42', useActiveSession: true, executorType: "${TEST_COMPLETE_EXECUTE}", timeout: '14400', useTimeout: true, actionOnErrors: 'MAKE_FAILED'
|
||||
}
|
||||
}
|
||||
}
|
||||
stage("Create test results in JSON"){
|
||||
steps{
|
||||
script{
|
||||
rc =bat (script:"""
|
||||
%WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\testscripts\\UITests\\Utils\\HistoryStructure.py --url ${env.BUILD_URL} --ws_path ${env.WORKSPACE}
|
||||
""",
|
||||
returnStatus: true
|
||||
)
|
||||
if (rc == 1){
|
||||
unstable('FAILED to process results')
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage("Archive Test History"){
|
||||
steps{
|
||||
script{
|
||||
rc =bat (script:"""
|
||||
set HistoryFail=0
|
||||
pushd %HISTORY_FOLDER%
|
||||
${env.PYTHON} GitCyclicPush.py
|
||||
if %errorlevel% neq 0 (set HistoryFail=1)
|
||||
popd
|
||||
if %HistoryFail% neq 0 (
|
||||
exit /b 1
|
||||
)
|
||||
""",
|
||||
returnStatus: true
|
||||
)
|
||||
if (rc == 1){
|
||||
unstable('FAILED to process history')
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage("Archive test artifacts"){
|
||||
steps{
|
||||
script{
|
||||
def artifactlist = meta.generateartifacts(["TestSuite/**","${ATLAS_SERVER_ARTIFACT_FOLDER}/meta/**","${LOG_FOLDER}/**","GisCore/**"])
|
||||
archiveArtifacts "${artifactlist}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
always {
|
||||
powershell(returnStdout: true, script: '$names = @("dotnet", "Atlas Professional for Print Server", "Atlas Professional", "GIS Print Server 2", "AtlasKioskSDK", "pythonw"); foreach ($item in $names) {Get-Process -Name $item | Stop-Process}')
|
||||
}
|
||||
failure {
|
||||
bat " %WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\Utilities\\sendEmail\\emailnotification.py -t TC -j ${env.BUILD_URL} -n ${env.JOB_NAME} -s FAILED"
|
||||
}
|
||||
success {
|
||||
|
||||
bat " %WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\Utilities\\sendEmail\\emailnotification.py -t TC -j ${env.BUILD_URL} -n ${env.JOB_NAME} -s SUCCESS"
|
||||
}
|
||||
unstable {
|
||||
bat " %WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\Utilities\\sendEmail\\emailnotification.py -t TC -j ${env.BUILD_URL} -n ${env.JOB_NAME} -s FAILED"
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
149
test/ui_printserver_testing_dev.groovy
Normal file
149
test/ui_printserver_testing_dev.groovy
Normal file
|
|
@ -0,0 +1,149 @@
|
|||
pipeline {
|
||||
agent { label "${AGENT_LABEL}" }
|
||||
stages {
|
||||
stage ('Cleaning Test_Output') {
|
||||
steps{
|
||||
bat'''if exist %WORKSPACE%\\Test_Output rmdir /s /q %WORKSPACE%\\Test_Output'''
|
||||
}
|
||||
}
|
||||
stage ('Cleaning imports') {
|
||||
steps{
|
||||
bat'''if exist %WORKSPACE%\\imports rmdir /s /q %WORKSPACE%\\imports'''
|
||||
}
|
||||
}
|
||||
stage('Clean workspace') {
|
||||
when {
|
||||
expression {
|
||||
"${CLEAN_WORKSPACE}" == "true"
|
||||
}
|
||||
}
|
||||
steps {
|
||||
cleanWs()
|
||||
}
|
||||
}
|
||||
stage("checkout python"){
|
||||
steps{
|
||||
checkout([$class: 'GitSCM',
|
||||
branches: [[name: 'origin/3.6.3_windows']],
|
||||
doGenerateSubmoduleConfigurations: false,
|
||||
extensions: [[$class: 'CleanBeforeCheckout'], [$class: 'RelativeTargetDirectory', relativeTargetDir: 'python']],
|
||||
submoduleCfg: [], userRemoteConfigs: [[url: 'git@hydra:tools/python.git']]])
|
||||
script{
|
||||
env.PYTHON = "${WORKSPACE}/python/ver/python.exe"
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Checkout source') {
|
||||
steps {
|
||||
checkout([$class: 'GitSCM',
|
||||
branches: [[name: 'origin/${TEST_BRANCH}']],
|
||||
doGenerateSubmoduleConfigurations: false,
|
||||
extensions: [[$class: 'CleanBeforeCheckout'], [$class: 'RelativeTargetDirectory', relativeTargetDir: 'testscripts']],
|
||||
submoduleCfg: [], userRemoteConfigs: [[url: 'git@hydra:gis/atlaskiosksdk_test.git']]])
|
||||
}
|
||||
}
|
||||
stage('Checkout GisCore') {
|
||||
steps {
|
||||
checkout([$class: 'GitSCM',
|
||||
branches: [[name: 'origin/MCSRepo']],
|
||||
doGenerateSubmoduleConfigurations: false,
|
||||
extensions: [[$class: 'CleanBeforeCheckout'], [$class: 'RelativeTargetDirectory', relativeTargetDir: 'GisCore']],
|
||||
submoduleCfg: [], userRemoteConfigs: [[url: 'git@hydra:gistest/giscorelite.git']]])
|
||||
}
|
||||
}
|
||||
stage('Checkout test utilites') {
|
||||
steps {
|
||||
checkout([$class: 'GitSCM',
|
||||
branches: [[name: 'origin/master']],
|
||||
doGenerateSubmoduleConfigurations: false,
|
||||
extensions: [[$class: 'CleanBeforeCheckout'], [$class: 'RelativeTargetDirectory', relativeTargetDir: 'Utilities']],
|
||||
submoduleCfg: [], userRemoteConfigs: [[url: 'git@hydra:gistest/Utilities.git']]])
|
||||
}
|
||||
}
|
||||
stage("Clean imports") {
|
||||
steps {
|
||||
script {
|
||||
env.IMPORTSPATH = "${WORKSPACE}/imports"
|
||||
}
|
||||
dir("${IMPORTSPATH}") {
|
||||
deleteDir()
|
||||
}
|
||||
}
|
||||
}
|
||||
stage("Clean exports") {
|
||||
steps {
|
||||
dir("${WORKSPACE}/uilogs") {
|
||||
deleteDir()
|
||||
}
|
||||
dir("${WORKSPACE}/version") {
|
||||
deleteDir()
|
||||
}
|
||||
dir("${WORKSPACE}/pipeline") {
|
||||
deleteDir()
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Import artifacts') {
|
||||
steps {
|
||||
script {
|
||||
env.PRINTSERVER = "${IMPORTSPATH}/printserver"
|
||||
echo "Obtaining Print server artifacts from ${PRINT_SERVER_BINARIES_JOB} job and placing at folder: ${PRINTSERVER}"
|
||||
copyArtifacts filter: 'bin/x64/Release/*.exe, bin/x64/Release/*.dll', projectName: "${PRINT_SERVER_BINARIES_JOB}", selector: lastSuccessful(), target: "${PRINTSERVER}"
|
||||
|
||||
ATLAS = "${IMPORTSPATH}/atlas"
|
||||
echo "Obtaining Atlas artifacts from ${ATLAS_BINARIES_JOB} job and placing at folder: ${ATLAS}"
|
||||
copyArtifacts filter: 'bin/**,LocalisationSDK/**,version/**', projectName: "${ATLAS_BINARIES_JOB}", selector: lastSuccessful(), target: "${ATLAS}"
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
stage('Save environment variable(s) to file for TestExecute bug') {
|
||||
steps {
|
||||
script {
|
||||
bat '''
|
||||
set WORKSPACE > "%SystemRoot%/Temp/environment-variables-from-jenkins.txt"
|
||||
'''
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Check available TE Licences'){
|
||||
steps{
|
||||
script {
|
||||
res = build(job: "Check_TE_Licence", propagate: false).result
|
||||
if (res != 'SUCCESS') {
|
||||
currentBuild.result = 'FAILED'
|
||||
error "No more available Test Execute licences. Stopping pipeline."
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Test loop') {
|
||||
steps {
|
||||
script {
|
||||
failureCount = 0
|
||||
String[] tests
|
||||
tests = "${TESTLIST}".split(",")
|
||||
tests.each {
|
||||
powershell(returnStdout: true, script: '$names = @("dotnet", "Atlas Professional for Print Server", "Atlas Professional", "GIS Print Server 2", "AtlasKioskSDK", "pythonw"); foreach ($item in $names) {Get-Process -Name $item | Stop-Process}')
|
||||
testcompletetest generateMHT: true, launchType: 'lcItem', project: "AtlasPrintServerProject", suite: "testscripts/UITests/AtlasTestSuite/AtlasTestSuite.pjs", test: "${it}", useTCService: true, userName: 'jenkins_user', userPassword: 'ramshorn42', useActiveSession: true, executorType: "TE", useTimeout: true, timeout: '10800', actionOnErrors: 'MAKE_FAILED'
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
post {
|
||||
failure {
|
||||
bat " %WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\Utilities\\sendEmail\\emailnotification.py -t TC -j ${env.BUILD_URL} -n ${env.JOB_NAME} -s FAILED"
|
||||
}
|
||||
success {
|
||||
|
||||
bat " %WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\Utilities\\sendEmail\\emailnotification.py -t TC -j ${env.BUILD_URL} -n ${env.JOB_NAME} -s SUCCESS"
|
||||
}
|
||||
unstable {
|
||||
bat " %WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\Utilities\\sendEmail\\emailnotification.py -t TC -j ${env.BUILD_URL} -n ${env.JOB_NAME} -s FAILED"
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue