diff --git a/Common_scripts/.project b/Common_scripts/.project
new file mode 100644
index 0000000..e329c3f
--- /dev/null
+++ b/Common_scripts/.project
@@ -0,0 +1,17 @@
+
+
+ Common Build Scripts
+
+
+
+
+
+ org.python.pydev.PyDevBuilder
+
+
+
+
+
+ org.python.pydev.pythonNature
+
+
diff --git a/Common_scripts/.pydevproject b/Common_scripts/.pydevproject
new file mode 100644
index 0000000..1ce5929
--- /dev/null
+++ b/Common_scripts/.pydevproject
@@ -0,0 +1,8 @@
+
+
+
+/${PROJECT_DIR_NAME}
+
+python 2.7
+python35
+
diff --git a/Common_scripts/.settings/org.eclipse.core.resources.prefs b/Common_scripts/.settings/org.eclipse.core.resources.prefs
new file mode 100644
index 0000000..1174a06
--- /dev/null
+++ b/Common_scripts/.settings/org.eclipse.core.resources.prefs
@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+encoding//versionnumbering/versioninfo.py=utf-8
diff --git a/Common_scripts/artifacts/metaexport.groovy b/Common_scripts/artifacts/metaexport.groovy
new file mode 100644
index 0000000..67d13c3
--- /dev/null
+++ b/Common_scripts/artifacts/metaexport.groovy
@@ -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 artifactFolders = new ArrayList()
+ 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;
diff --git a/Common_scripts/autobuilder.groovy b/Common_scripts/autobuilder.groovy
new file mode 100644
index 0000000..71d9b6a
--- /dev/null
+++ b/Common_scripts/autobuilder.groovy
@@ -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;
diff --git a/Common_scripts/check/build_meta.groovy b/Common_scripts/check/build_meta.groovy
new file mode 100644
index 0000000..34eed98
--- /dev/null
+++ b/Common_scripts/check/build_meta.groovy
@@ -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'
+ }
+ }
+}
+
diff --git a/Common_scripts/check/do_meta.groovy b/Common_scripts/check/do_meta.groovy
new file mode 100644
index 0000000..7bfe2d1
--- /dev/null
+++ b/Common_scripts/check/do_meta.groovy
@@ -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;
diff --git a/Common_scripts/checksum/utils.groovy b/Common_scripts/checksum/utils.groovy
new file mode 100644
index 0000000..c2503cd
--- /dev/null
+++ b/Common_scripts/checksum/utils.groovy
@@ -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;
\ No newline at end of file
diff --git a/Common_scripts/clean/clean.groovy b/Common_scripts/clean/clean.groovy
new file mode 100644
index 0000000..4707ba0
--- /dev/null
+++ b/Common_scripts/clean/clean.groovy
@@ -0,0 +1,10 @@
+
+def clean(folderlist) {
+ for (folder in folderlist) {
+ dir(folder) {
+ deleteDir()
+ }
+ }
+}
+
+return this;
\ No newline at end of file
diff --git a/Common_scripts/commandline/commandline.groovy b/Common_scripts/commandline/commandline.groovy
new file mode 100644
index 0000000..df99a75
--- /dev/null
+++ b/Common_scripts/commandline/commandline.groovy
@@ -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
\ No newline at end of file
diff --git a/Common_scripts/compile/eclipsebuild/disableparallelbuilds.groovy b/Common_scripts/compile/eclipsebuild/disableparallelbuilds.groovy
new file mode 100644
index 0000000..03e4c8f
--- /dev/null
+++ b/Common_scripts/compile/eclipsebuild/disableparallelbuilds.groovy
@@ -0,0 +1,12 @@
+
+// Disable parallel make builds - which may be causing autobuild issues
+def doDisableParallelMake(rootSearchFolder = "${WORKSPACE}") {
+ if (isUnix()) {
+ sh """
+ # Looks for " sparseitemlist = gh.convertSparseItemsString(filter)
+ gh.gitCheckoutAlt(gitURL, revision, targetDir, repoRoot, cloneDepth, shallowClone)
+
+ registerConfigurationInfo(meta, tool, gitURL, revision, gh.getGitInfo(targetDir))
+}
+
+return this
diff --git a/Common_scripts/copy/all.groovy b/Common_scripts/copy/all.groovy
new file mode 100644
index 0000000..b7c4607
--- /dev/null
+++ b/Common_scripts/copy/all.groovy
@@ -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'
+ }
+ }
+}
\ No newline at end of file
diff --git a/Common_scripts/copy/esw.groovy b/Common_scripts/copy/esw.groovy
new file mode 100644
index 0000000..2a63171
--- /dev/null
+++ b/Common_scripts/copy/esw.groovy
@@ -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'
+ }
+ }
+}
\ No newline at end of file
diff --git a/Common_scripts/copy/filtered.groovy b/Common_scripts/copy/filtered.groovy
new file mode 100644
index 0000000..feaa2ab
--- /dev/null
+++ b/Common_scripts/copy/filtered.groovy
@@ -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'
+ }
+ }
+}
diff --git a/Common_scripts/copy/logic.groovy b/Common_scripts/copy/logic.groovy
new file mode 100644
index 0000000..d1ece6d
--- /dev/null
+++ b/Common_scripts/copy/logic.groovy
@@ -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'
+ }
+ }
+}
\ No newline at end of file
diff --git a/Common_scripts/differences/.project b/Common_scripts/differences/.project
new file mode 100644
index 0000000..75af0fc
--- /dev/null
+++ b/Common_scripts/differences/.project
@@ -0,0 +1,17 @@
+
+
+ Release_difference
+
+
+
+
+
+ org.python.pydev.PyDevBuilder
+
+
+
+
+
+ org.python.pydev.pythonNature
+
+
diff --git a/Common_scripts/differences/.pydevproject b/Common_scripts/differences/.pydevproject
new file mode 100644
index 0000000..c3434da
--- /dev/null
+++ b/Common_scripts/differences/.pydevproject
@@ -0,0 +1,8 @@
+
+
+
+/${PROJECT_DIR_NAME}
+
+python 3.0
+Default
+
diff --git a/Common_scripts/differences/dometahierarchy.groovy b/Common_scripts/differences/dometahierarchy.groovy
new file mode 100644
index 0000000..6280960
--- /dev/null
+++ b/Common_scripts/differences/dometahierarchy.groovy
@@ -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
+ 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 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 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 commentscollection
+
+ RevertsReportRecord() {
+ jiraticket = ''
+ ticketURI = ''
+ commentscollection = new LinkedHashMap()
+ }
+}
+
+def revertsreport(String reportsubfolder, String title, LinkedHashMap 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 commentscollection
+
+ TicketedReportRecord() {
+ jiraticket = ''
+ ticketURI = ''
+ commentscollection = new LinkedHashMap()
+ }
+}
+
+def ticketedreport(String reportsubfolder, String title, LinkedHashMap 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 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;
diff --git a/Common_scripts/differences/file.groovy b/Common_scripts/differences/file.groovy
new file mode 100644
index 0000000..ab4102f
--- /dev/null
+++ b/Common_scripts/differences/file.groovy
@@ -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;
diff --git a/Common_scripts/differences/json.groovy b/Common_scripts/differences/json.groovy
new file mode 100644
index 0000000..5ac37f2
--- /dev/null
+++ b/Common_scripts/differences/json.groovy
@@ -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;
diff --git a/Common_scripts/differences/metahierarchy.groovy b/Common_scripts/differences/metahierarchy.groovy
new file mode 100644
index 0000000..4bcdcdc
--- /dev/null
+++ b/Common_scripts/differences/metahierarchy.groovy
@@ -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'
+ }
+ }
+}
+
diff --git a/Common_scripts/documentation/doxygen_deploy.groovy b/Common_scripts/documentation/doxygen_deploy.groovy
new file mode 100644
index 0000000..6642256
--- /dev/null
+++ b/Common_scripts/documentation/doxygen_deploy.groovy
@@ -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'
+ }
+ }
+}
+
diff --git a/Common_scripts/import/importer.groovy b/Common_scripts/import/importer.groovy
new file mode 100644
index 0000000..8624421
--- /dev/null
+++ b/Common_scripts/import/importer.groovy
@@ -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 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 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, " ${buildnumber}")
+ 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;
diff --git a/Common_scripts/install/installhelper.groovy b/Common_scripts/install/installhelper.groovy
new file mode 100644
index 0000000..96a8b2e
--- /dev/null
+++ b/Common_scripts/install/installhelper.groovy
@@ -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;
diff --git a/Common_scripts/meta/folder.groovy b/Common_scripts/meta/folder.groovy
new file mode 100644
index 0000000..aac8b6c
--- /dev/null
+++ b/Common_scripts/meta/folder.groovy
@@ -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 releaseitems
+ boolean released
+
+ ReleaseInfo(script, String releaserepoURL = "", boolean released = false) {
+ super(script)
+ this.releaserepoURL = releaserepoURL
+ this.releaseitems = new ArrayList()
+ 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()
+ 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 checksumpairs
+
+ ChecksumSet(script, artifactpath = "") {
+ super(script)
+ this.artifactpath = artifactpath
+ checksumpairs = new ArrayList()
+ }
+
+ 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()
+ 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 checksumsets
+
+ ChecksumInfo(script) {
+ super(script)
+ checksumsets = new ArrayList()
+ }
+
+ 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()
+ 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
+ private ArrayList publishableinfo
+ private LinkedHashMap custominfo
+ private ArrayList 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()
+ publishableinfo = new ArrayList()
+ custominfo = new LinkedHashMap()
+ associatedmeta = new ArrayList()
+ }
+
+ 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 releasedfromhere = new ArrayList(), // These items are recorded in meta as released from here
+ ArrayList releasedfromsubmeta = new ArrayList(), // 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 releasewalkerp(int maxdepth, ArrayList 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 releasewalker(int maxdepth, String startpath = "") {
+ ArrayList releasemetacollection = new ArrayList()
+ 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 putwithshortestoffsetpath(Map 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 releasewalkerunique(int maxdepth, String startpath = "") {
+ def ArrayList releasemetacollection = new ArrayList()
+ releasemetacollection = releasewalkerp(maxdepth, releasemetacollection, startpath)
+
+ def Map releasemetauniquecollection = new LinkedHashMap()
+ for (relatedmetainfo in releasemetacollection) {
+ def String uniquestring = relatedmetainfo.meta.componentidentifier()
+ releasemetauniquecollection = putwithshortestoffsetpath(releasemetauniquecollection, uniquestring, relatedmetainfo)
+ }
+
+ return releasemetauniquecollection
+ }
+
+ Map releasewalkerversionunique(int maxdepth, String startpath = "") {
+ ArrayList releasemetacollection = new ArrayList()
+ releasemetacollection = releasewalkerp(maxdepth, releasemetacollection, startpath)
+
+ def Map releasemetaversionuniquecollection = new LinkedHashMap()
+ 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;
diff --git a/Common_scripts/packaging/debian.groovy b/Common_scripts/packaging/debian.groovy
new file mode 100644
index 0000000..2ef1ba8
--- /dev/null
+++ b/Common_scripts/packaging/debian.groovy
@@ -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;
\ No newline at end of file
diff --git a/Common_scripts/platform/lineendings.groovy b/Common_scripts/platform/lineendings.groovy
new file mode 100644
index 0000000..9657b0d
--- /dev/null
+++ b/Common_scripts/platform/lineendings.groovy
@@ -0,0 +1,5 @@
+
+// Put ${nl} into strings when wanting a newline
+nl = System.properties['line.separator']
+
+return this;
diff --git a/Common_scripts/publish/.classpath b/Common_scripts/publish/.classpath
new file mode 100644
index 0000000..287c1ab
--- /dev/null
+++ b/Common_scripts/publish/.classpath
@@ -0,0 +1,9 @@
+
+
+
+
+
+
+
+
+
diff --git a/Common_scripts/publish/.gitignore b/Common_scripts/publish/.gitignore
new file mode 100644
index 0000000..abed335
--- /dev/null
+++ b/Common_scripts/publish/.gitignore
@@ -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
diff --git a/Common_scripts/publish/.project b/Common_scripts/publish/.project
new file mode 100644
index 0000000..5c60328
--- /dev/null
+++ b/Common_scripts/publish/.project
@@ -0,0 +1,18 @@
+
+
+ publish_item_select
+
+
+
+
+
+ org.eclipse.jdt.core.javabuilder
+
+
+
+
+
+ org.eclipse.jdt.groovy.core.groovyNature
+ org.eclipse.jdt.core.javanature
+
+
diff --git a/Common_scripts/publish/.settings/org.eclipse.jdt.groovy.core.prefs b/Common_scripts/publish/.settings/org.eclipse.jdt.groovy.core.prefs
new file mode 100644
index 0000000..1e68ed6
--- /dev/null
+++ b/Common_scripts/publish/.settings/org.eclipse.jdt.groovy.core.prefs
@@ -0,0 +1,3 @@
+eclipse.preferences.version=1
+groovy.compiler.level=25
+groovy.script.filters=**/*.dsld,y,**/*.gradle,n
diff --git a/Common_scripts/publish/do.groovy b/Common_scripts/publish/do.groovy
new file mode 100644
index 0000000..1b227f4
--- /dev/null
+++ b/Common_scripts/publish/do.groovy
@@ -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 publishablepaths = new ArrayList()
+ 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 ##
+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;
diff --git a/Common_scripts/publish/package.groovy b/Common_scripts/publish/package.groovy
new file mode 100644
index 0000000..3bd9565
--- /dev/null
+++ b/Common_scripts/publish/package.groovy
@@ -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'
+ }
+ }
+}
+
diff --git a/Common_scripts/publish/promptingpublish.groovy b/Common_scripts/publish/promptingpublish.groovy
new file mode 100644
index 0000000..4af0d62
--- /dev/null
+++ b/Common_scripts/publish/promptingpublish.groovy
@@ -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 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()
+ 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'
+ }
+ }
+}
+
diff --git a/Common_scripts/publish/publish.groovy b/Common_scripts/publish/publish.groovy
new file mode 100644
index 0000000..7beb134
--- /dev/null
+++ b/Common_scripts/publish/publish.groovy
@@ -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'
+ }
+ }
+}
+
diff --git a/Common_scripts/publish/publishitems.groovy b/Common_scripts/publish/publishitems.groovy
new file mode 100644
index 0000000..677970e
--- /dev/null
+++ b/Common_scripts/publish/publishitems.groovy
@@ -0,0 +1,127 @@
+import com.cwctravel.hudson.plugins.extended_choice_parameter.ExtendedChoiceParameterDefinition
+
+class PublishableItemsSelection {
+ def script
+ def ArrayList preselectedmenuitems
+ def ArrayList menuitemdescriptions
+ def ArrayList menuitemsfull
+ def ExtendedChoiceParameterDefinition multiselect
+
+ PublishableItemsSelection(script) {
+ this.script = script
+ preselectedmenuitems = new ArrayList()
+ menuitemdescriptions = new ArrayList()
+ menuitemsfull = new ArrayList()
+ }
+
+ 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;
diff --git a/Common_scripts/publishing/utils.groovy b/Common_scripts/publishing/utils.groovy
new file mode 100644
index 0000000..2daf6f6
--- /dev/null
+++ b/Common_scripts/publishing/utils.groovy
@@ -0,0 +1,27 @@
+
+
+// The filepath must end in "/**" or "/" - 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 /** or / (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;
diff --git a/Common_scripts/release/do.groovy b/Common_scripts/release/do.groovy
new file mode 100644
index 0000000..3221d25
--- /dev/null
+++ b/Common_scripts/release/do.groovy
@@ -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: "${toplevelbuildmeta.jenkinsbuildinfo.buildnumber}"
+ ],
+ 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 maketaglist(buildmeta, String buildstamp, String otherreleasetags) {
+ def ArrayList taglist = new ArrayList()
+ taglist.add(buildstamp)
+
+ def ArrayList 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 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 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 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;
diff --git a/Common_scripts/release/registerrepo.groovy b/Common_scripts/release/registerrepo.groovy
new file mode 100644
index 0000000..f565706
--- /dev/null
+++ b/Common_scripts/release/registerrepo.groovy
@@ -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;
diff --git a/Common_scripts/release/release.groovy b/Common_scripts/release/release.groovy
new file mode 100644
index 0000000..e51a174
--- /dev/null
+++ b/Common_scripts/release/release.groovy
@@ -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'
+ }
+ }
+}
diff --git a/Common_scripts/remoteaccess/ftp.groovy b/Common_scripts/remoteaccess/ftp.groovy
new file mode 100644
index 0000000..25b9143
--- /dev/null
+++ b/Common_scripts/remoteaccess/ftp.groovy
@@ -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;
diff --git a/Common_scripts/remoteaccess/hostedftp.groovy b/Common_scripts/remoteaccess/hostedftp.groovy
new file mode 100644
index 0000000..cf62d32
--- /dev/null
+++ b/Common_scripts/remoteaccess/hostedftp.groovy
@@ -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 customerfilenames = new ArrayList()
+ def List customers = new ArrayList()
+
+ 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;
\ No newline at end of file
diff --git a/Common_scripts/staticanalysis/ccm.groovy b/Common_scripts/staticanalysis/ccm.groovy
new file mode 100644
index 0000000..f0e5b80
--- /dev/null
+++ b/Common_scripts/staticanalysis/ccm.groovy
@@ -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 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'
+ }
+ }
+}
diff --git a/Common_scripts/staticanalysis/cpd.groovy b/Common_scripts/staticanalysis/cpd.groovy
new file mode 100644
index 0000000..6f3a33f
--- /dev/null
+++ b/Common_scripts/staticanalysis/cpd.groovy
@@ -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 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'
+ }
+ }
+}
diff --git a/Common_scripts/staticanalysis/cppcheck.groovy b/Common_scripts/staticanalysis/cppcheck.groovy
new file mode 100644
index 0000000..bdc6a2a
--- /dev/null
+++ b/Common_scripts/staticanalysis/cppcheck.groovy
@@ -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 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'
+ }
+ }
+}
diff --git a/Common_scripts/textutils/subst.groovy b/Common_scripts/textutils/subst.groovy
new file mode 100644
index 0000000..c0207a3
--- /dev/null
+++ b/Common_scripts/textutils/subst.groovy
@@ -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;
\ No newline at end of file
diff --git a/Common_scripts/tool configurations/vs2017install/buildmachines.vsconfig b/Common_scripts/tool configurations/vs2017install/buildmachines.vsconfig
new file mode 100644
index 0000000..ea618a3
--- /dev/null
+++ b/Common_scripts/tool configurations/vs2017install/buildmachines.vsconfig
@@ -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"
+ ]
+}
\ No newline at end of file
diff --git a/Common_scripts/versioncontrol/git.groovy b/Common_scripts/versioncontrol/git.groovy
new file mode 100644
index 0000000..f5b2ebd
--- /dev/null
+++ b/Common_scripts/versioncontrol/git.groovy
@@ -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 gettaglist(String workingSetRootPath) {
+ ArrayList taglist = new ArrayList()
+ dir(workingSetRootPath) {
+ def tagliststring = clh.getCommandOutput('git tag --sort=-version:refname')
+ taglist = tagliststring.split('\\n')
+ }
+ return taglist
+}
+
+@NonCPS
+def ArrayList sparsecheckoutconfig(ArrayList paths) {
+ ArrayList sparsecheckoutpaths = new ArrayList()
+ 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 sparseitemlist = new ArrayList()) {
+ 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 sparseitemlist = new ArrayList()) {
+ 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 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 sparseitemlist = new ArrayList()) {
+ 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
diff --git a/Common_scripts/versionnumbering/do.groovy b/Common_scripts/versionnumbering/do.groovy
new file mode 100644
index 0000000..666aee3
--- /dev/null
+++ b/Common_scripts/versionnumbering/do.groovy
@@ -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;
diff --git a/Common_scripts/versionnumbering/generate.groovy b/Common_scripts/versionnumbering/generate.groovy
new file mode 100644
index 0000000..71d7bf6
--- /dev/null
+++ b/Common_scripts/versionnumbering/generate.groovy
@@ -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;
\ No newline at end of file
diff --git a/Common_scripts/versionstamping/.project b/Common_scripts/versionstamping/.project
new file mode 100644
index 0000000..74928d6
--- /dev/null
+++ b/Common_scripts/versionstamping/.project
@@ -0,0 +1,17 @@
+
+
+ versionstamping
+
+
+
+
+
+ org.python.pydev.PyDevBuilder
+
+
+
+
+
+ org.python.pydev.pythonNature
+
+
diff --git a/Common_scripts/versionstamping/.pydevproject b/Common_scripts/versionstamping/.pydevproject
new file mode 100644
index 0000000..746d0f0
--- /dev/null
+++ b/Common_scripts/versionstamping/.pydevproject
@@ -0,0 +1,8 @@
+
+
+
+/${PROJECT_DIR_NAME}
+
+python 3.0
+python35
+
diff --git a/Common_scripts/versionstamping/versionstamper.py b/Common_scripts/versionstamping/versionstamper.py
new file mode 100644
index 0000000..441ad06
--- /dev/null
+++ b/Common_scripts/versionstamping/versionstamper.py
@@ -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:]))
diff --git a/build/build_all.groovy b/build/build_all.groovy
new file mode 100644
index 0000000..0792b1d
--- /dev/null
+++ b/build/build_all.groovy
@@ -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: " ${atlas_compile_job.getNumber()}"),
+ 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: " ${atlas_compile_job.getNumber()}"),
+ 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: " ${atlas_compile_job.getNumber()}"),
+ 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: " ${atlas_compile_job.getNumber()}"),
+ 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: " ${atlas_compile_job.getNumber()}"),
+ string(name: 'INK_UI_COMPILE_JOB', value: ink_ui_compile_job.getProjectName()),
+ string(name: 'INK_UI_COMPILE_BUILD_SELECTOR', value: " ${ink_ui_compile_job.getNumber()}"),
+ 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'
+ }
+ }
+}
diff --git a/cloning/cloning.groovy b/cloning/cloning.groovy
new file mode 100644
index 0000000..36d6fc2
--- /dev/null
+++ b/cloning/cloning.groovy
@@ -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: ${BRANCH_TO_COPY} with: ${BRANCH_TO_BUILD}"
+ configXMLString = configXMLString.replaceAll("${BRANCH_TO_COPY}", "${BRANCH_TO_BUILD}")
+
+ echo "Changing instances of: ${defaultMCSJob} with: ${ATLAS_SERVICES_BUILD_JOB}"
+ configXMLString = configXMLString.replaceAll("${defaultMCSJob}", "${ATLAS_SERVICES_BUILD_JOB}")
+
+ echo "Changing instances of: ${defaultMCSTag} with: ${ATLAS_SERVICES_RELEASE_REVISION}"
+ configXMLString = configXMLString.replaceAll("${defaultMCSTag}", "${ATLAS_SERVICES_RELEASE_REVISION}")
+
+ echo "Changing instances of: ${defaultPrintServerJob} with: ${PRINT_SERVER_COMPILE_JOB}"
+ configXMLString = configXMLString.replaceAll("${defaultPrintServerJob}", "${PRINT_SERVER_COMPILE_JOB}")
+
+ echo "Changing instances of: ${defaultPrintServerTag} with: ${PRINT_SERVER_RELEASE_REVISION}"
+ configXMLString = configXMLString.replaceAll("${defaultPrintServerTag}", "${PRINT_SERVER_RELEASE_REVISION}")
+
+ 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("ATLAS_SERVICES_ARTIFACT_LOCATION")){
+ //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] = "Release repository"
+ lines[i+5] = "Jenkins job artifact"
+ }
+ else{
+ echo "Set default to job artifact"
+ lines[i+4] = "Jenkins job artifact"
+ lines[i+5] = "Release repository"
+ }
+ }
+ if(lines[i].contains("PRINT_SERVER_ARTIFACT_LOCATION")){
+ //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] = "Release repository"
+ lines[i+5] = "Jenkins job artifact"
+ }
+ else{
+ echo "Set default to job artifact"
+ lines[i+4] = "Jenkins job artifact"
+ lines[i+5] = "Release repository"
+ }
+ }
+ }
+
+ //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'
+ }
+ }
+}
diff --git a/compile/compile.groovy b/compile/compile.groovy
new file mode 100644
index 0000000..05da1af
--- /dev/null
+++ b/compile/compile.groovy
@@ -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'
+ }
+ }
+}
diff --git a/compile/compile_ink_ui.groovy b/compile/compile_ink_ui.groovy
new file mode 100644
index 0000000..e1f9894
--- /dev/null
+++ b/compile/compile_ink_ui.groovy
@@ -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'
+ }
+ }
+}
diff --git a/documentation/build_atlas_documentation.groovy b/documentation/build_atlas_documentation.groovy
new file mode 100644
index 0000000..7d1f548
--- /dev/null
+++ b/documentation/build_atlas_documentation.groovy
@@ -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'
+ }
+ }
+}
diff --git a/documentation/build_ink_ui_documentation.groovy b/documentation/build_ink_ui_documentation.groovy
new file mode 100644
index 0000000..8046b71
--- /dev/null
+++ b/documentation/build_ink_ui_documentation.groovy
@@ -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'
+ }
+ }
+}
diff --git a/documentation/release_note.groovy b/documentation/release_note.groovy
new file mode 100644
index 0000000..4060098
--- /dev/null
+++ b/documentation/release_note.groovy
@@ -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'
+ }
+ }
+}
diff --git a/install/install_atlas_ink_ui.groovy b/install/install_atlas_ink_ui.groovy
new file mode 100644
index 0000000..0ba4502
--- /dev/null
+++ b/install/install_atlas_ink_ui.groovy
@@ -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 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'
+ }
+ }
+}
diff --git a/install/install_atlas_professional.groovy b/install/install_atlas_professional.groovy
new file mode 100644
index 0000000..fb86e6b
--- /dev/null
+++ b/install/install_atlas_professional.groovy
@@ -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 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'
+ }
+ }
+}
diff --git a/install/install_atlas_sdk.groovy b/install/install_atlas_sdk.groovy
new file mode 100644
index 0000000..68afa85
--- /dev/null
+++ b/install/install_atlas_sdk.groovy
@@ -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 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'
+ }
+ }
+}
diff --git a/localisation_check/localisation_check.groovy b/localisation_check/localisation_check.groovy
new file mode 100644
index 0000000..00d0c64
--- /dev/null
+++ b/localisation_check/localisation_check.groovy
@@ -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'
+ }
+ }
+}
diff --git a/nuget/createpackages.groovy b/nuget/createpackages.groovy
new file mode 100644
index 0000000..c7a4cd0
--- /dev/null
+++ b/nuget/createpackages.groovy
@@ -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'
+ }
+ }
+}
diff --git a/publish/.project b/publish/.project
new file mode 100644
index 0000000..2236837
--- /dev/null
+++ b/publish/.project
@@ -0,0 +1,17 @@
+
+
+ publish
+
+
+
+
+
+ org.python.pydev.PyDevBuilder
+
+
+
+
+
+ org.python.pydev.pythonNature
+
+
diff --git a/publish/.pydevproject b/publish/.pydevproject
new file mode 100644
index 0000000..8bec50a
--- /dev/null
+++ b/publish/.pydevproject
@@ -0,0 +1,8 @@
+
+
+
+/${PROJECT_DIR_NAME}
+
+python 3.0
+Python34
+
diff --git a/publish/build_post_2_0_27_atlas.py b/publish/build_post_2_0_27_atlas.py
new file mode 100644
index 0000000..0c64cfe
--- /dev/null
+++ b/publish/build_post_2_0_27_atlas.py
@@ -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())
diff --git a/publish/build_post_2_0_28_atlas.py b/publish/build_post_2_0_28_atlas.py
new file mode 100644
index 0000000..1a2aab0
--- /dev/null
+++ b/publish/build_post_2_0_28_atlas.py
@@ -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())
diff --git a/publish/publish.bat b/publish/publish.bat
new file mode 100644
index 0000000..a770b9c
--- /dev/null
+++ b/publish/publish.bat
@@ -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
diff --git a/publish/publishLibrary.py b/publish/publishLibrary.py
new file mode 100644
index 0000000..4c6feef
--- /dev/null
+++ b/publish/publishLibrary.py
@@ -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)
\ No newline at end of file
diff --git a/publish/reset_imports_and_exports.bat b/publish/reset_imports_and_exports.bat
new file mode 100644
index 0000000..773eb76
--- /dev/null
+++ b/publish/reset_imports_and_exports.bat
@@ -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
diff --git a/release_to_git/javascript_release_to_git.gsh b/release_to_git/javascript_release_to_git.gsh
new file mode 100644
index 0000000..60ffdd2
--- /dev/null
+++ b/release_to_git/javascript_release_to_git.gsh
@@ -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'
+ }
+ }
+}
diff --git a/release_to_git/release_to_git.gsh b/release_to_git/release_to_git.gsh
new file mode 100644
index 0000000..6a21a13
--- /dev/null
+++ b/release_to_git/release_to_git.gsh
@@ -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'
+ }
+ }
+}
diff --git a/resharper/atlas_ink_resharper.groovy b/resharper/atlas_ink_resharper.groovy
new file mode 100644
index 0000000..b291e9a
--- /dev/null
+++ b/resharper/atlas_ink_resharper.groovy
@@ -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'
+ }
+ }
+}
diff --git a/resharper/atlas_sdk_resharper.groovy b/resharper/atlas_sdk_resharper.groovy
new file mode 100644
index 0000000..9c60f76
--- /dev/null
+++ b/resharper/atlas_sdk_resharper.groovy
@@ -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'
+ }
+ }
+}
diff --git a/resharper/atlas_ui_resharper.groovy b/resharper/atlas_ui_resharper.groovy
new file mode 100644
index 0000000..6cb119b
--- /dev/null
+++ b/resharper/atlas_ui_resharper.groovy
@@ -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'
+ }
+ }
+}
diff --git a/resharper/ccm.groovy b/resharper/ccm.groovy
new file mode 100644
index 0000000..3670ab4
--- /dev/null
+++ b/resharper/ccm.groovy
@@ -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'
+ }
+ }
+}
diff --git a/static_analysis/static_analysis.groovy b/static_analysis/static_analysis.groovy
new file mode 100644
index 0000000..3248b7a
--- /dev/null
+++ b/static_analysis/static_analysis.groovy
@@ -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'
+ }
+ }
+}
+
diff --git a/test/check_node_status.groovy b/test/check_node_status.groovy
new file mode 100644
index 0000000..a7e59b4
--- /dev/null
+++ b/test/check_node_status.groovy
@@ -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}
+ '''
+ }
+ }
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/test/check_te_licences.groovy b/test/check_te_licences.groovy
new file mode 100644
index 0000000..0294159
--- /dev/null
+++ b/test/check_te_licences.groovy
@@ -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}
+ '''
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/test/flesh_install_dispatcher.groovy b/test/flesh_install_dispatcher.groovy
new file mode 100644
index 0000000..07d61b8
--- /dev/null
+++ b/test/flesh_install_dispatcher.groovy
@@ -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}
+ '''
+ }
+ }
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/test/fresh_install_master.groovy b/test/fresh_install_master.groovy
new file mode 100644
index 0000000..073f2a5
--- /dev/null
+++ b/test/fresh_install_master.groovy
@@ -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 = "
" + "FreshInstallTest"
+ }
+ }
+ }
+ }
+ 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
+ '''
+}
+}
+}
\ No newline at end of file
diff --git a/test/fresh_install_test.groovy b/test/fresh_install_test.groovy
new file mode 100644
index 0000000..ccc6398
--- /dev/null
+++ b/test/fresh_install_test.groovy
@@ -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 + "
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"
+
+}
+ }
+}
\ No newline at end of file
diff --git a/test/test_all.groovy b/test/test_all.groovy
new file mode 100644
index 0000000..f9186f7
--- /dev/null
+++ b/test/test_all.groovy
@@ -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 = "
" + "RenameTest"
+ subJobs<<[ RenameTestJob, "RenameTestsResults", false, ]
+ }
+ else{
+ RenameTestJob_URL = "
"}
+ }
+ }
+ }
+ 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 = "
" + "AllTest"
+ subJobs<<[ AllTestJob, "AllTestsResults", false, ]
+ }
+ else{
+ AllTestJob_URL = "
"}
+ }
+ }
+ }
+ 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 = "
" + "SaveAndDiscardTest"
+ subJobs<<[ SaveAndDiscardTestJob, "SaveAndDiscardTestsResults", false, ]
+ }
+ else{
+ SaveAndDiscardTestJob_URL = "
"}
+ }
+ }
+ }
+ 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 = "
" + "SanityTest"
+ subJobs<<[ SanityTestJob, "CoreTestsResults", false, ]
+ }
+ else{
+ SanityTestJob_URL = "
"}
+ }
+ }
+ }
+ }
+ }
+ 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'
+ }
+ }
+}
+
diff --git a/test/ui_mcs_tools_testing_dev.groovy b/test/ui_mcs_tools_testing_dev.groovy
new file mode 100644
index 0000000..e1e476c
--- /dev/null
+++ b/test/ui_mcs_tools_testing_dev.groovy
@@ -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"
+
+}
+ }
+}
\ No newline at end of file
diff --git a/test/ui_meta_test.groovy b/test/ui_meta_test.groovy
new file mode 100644
index 0000000..9c454d5
--- /dev/null
+++ b/test/ui_meta_test.groovy
@@ -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"
+
+}
+ }
+}
diff --git a/test/ui_printserver_testing_dev.groovy b/test/ui_printserver_testing_dev.groovy
new file mode 100644
index 0000000..ea17acc
--- /dev/null
+++ b/test/ui_printserver_testing_dev.groovy
@@ -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"
+
+}
+ }
+}
\ No newline at end of file