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/archiver.groovy b/Common_scripts/artifacts/archiver.groovy
new file mode 100644
index 0000000..bafba02
--- /dev/null
+++ b/Common_scripts/artifacts/archiver.groovy
@@ -0,0 +1,17 @@
+enum Store {
+ JENKINS,
+ ARTIFACTSERVER,
+}
+
+this.JENKINS = Store.JENKINS
+this.ARTIFACTSERVER = Store.JENKINS
+
+def archive(MetaInfo meta, String artifactlist, Store store = JENKINS) {
+ echo "Archiving artifacts to store: ${store}"
+ meta.copyrelatedmeta()
+ if (store == JENKINS) {
+ archiveArtifacts(artifacts: artifactlist)
+ }
+}
+
+return this
\ No newline at end of file
diff --git a/Common_scripts/artifacts/metaexport.groovy b/Common_scripts/artifacts/metaexport.groovy
new file mode 100644
index 0000000..8e5e56e
--- /dev/null
+++ b/Common_scripts/artifacts/metaexport.groovy
@@ -0,0 +1,26 @@
+// 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()
+ }
+
+ def importoptions = importer.getNewImportOptions()
+ importoptions.jenkinsjob(subJobName, subJobNumber)
+ importoptions.setincrementversionnumber(incrementversionnumber)
+ importer.artifactimport(meta, importoptions, destFolder)
+
+ 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..667f89a
--- /dev/null
+++ b/Common_scripts/autobuilder.groovy
@@ -0,0 +1,147 @@
+// 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
+}
+
+def alterreleaserepo(String releaserepo, String releaserepovariantsuffix) {
+ def String altered = releaserepo.trim()
+
+ if (releaserepovariantsuffix?.trim()) {
+ altered = altered.replace("-RELEASE_REPO_VARIANT_SUFFIX-", releaserepovariantsuffix)
+ }
+ return altered
+}
+
+def setBuildType(meta, boolean dofullbuild = true) {
+ def doquickbuild = false
+
+ echo "Build trigger cause: ${currentBuild.getBuildCauses()}"
+ if (currentBuild.getBuildCauses('hudson.model.Cause$UserIdCause')) {
+ echo "Build triggered by user"
+ if (!dofullbuild) {
+ echo "Marking as quick build as user wanted one"
+ doquickbuild = true
+ }
+ } else {
+ echo "Build triggered automatically"
+ if (currentBuild.getBuildCauses('jenkins.branch.BranchEventCause') || currentBuild.getBuildCauses('hudson.triggers.SCMTrigger$SCMTriggerCause')) {
+ echo "Marking as quick build as it was triggered by a commit"
+ doquickbuild = true
+ } else if (currentBuild.getBuildCauses('hudson.triggers.TimerTrigger$TimerTriggerCause')) {
+ echo "Marking as full build as it was triggered by timer"
+ }
+ }
+ echo "Build type is ${doquickbuild ? "quick" : "full"}"
+ if (doquickbuild) {
+ unstable('This not a full build - a subset of the artifacts is not being generated')
+ }
+ meta.jenkinsbuildinfo.set(!doquickbuild)
+ return doquickbuild
+}
+
+def setupmeta(script, String productname, String subcomponentname, String productvariant = '') {
+ def meta = getmetafolderscript().metareset(script)
+ echo "Product name: ${productname} Subcomponent name: ${subcomponentname} Variant: ${productvariant}"
+ meta.productinfo.set(productname, subcomponentname, productvariant)
+ def now = new Date()
+ now.format("yyMMdd.HHmm", TimeZone.getTimeZone('UTC'))
+ meta.jenkinsbuildinfo.set(JOB_NAME, BUILD_ID.toInteger(), NODE_NAME, now.toString())
+ for (p in params) {
+ meta.jenkinsbuildinfo.addParameter(p.key, p.value)
+ }
+ return meta
+}
+
+// Start up boilerplate
+def startbuild(
+ script,
+ String productname = PRODUCT_NAME,
+ String subcomponentname = SUBCOMPONENT_NAME,
+ String releaserepo = RELEASE_REPO,
+ String productvariant = '',
+ String autobuildpath = autobuildroot,
+ String commonscriptspath = commonscriptsroot
+ ) {
+ echo "Starting...."
+
+ autobuildroot = autobuildpath
+ commonscriptsroot = commonscriptspath
+ metafolderscript = load("${commonscripts()}/meta/folder.groovy")
+
+ conditionalclean()
+
+ def meta = setupmeta(script, productname, subcomponentname, productvariant)
+
+ def rr = load("${commonscripts()}/release/registerrepo.groovy")
+ def String alteredreleaserepo = alterreleaserepo(releaserepo, productvariant)
+
+ echo "Release repo: ${alteredreleaserepo}"
+ rr.registerrepo(meta, alteredreleaserepo)
+
+ def ch = load("${commonscripts()}/configuration/configuration.groovy")
+ ch.registerPipelineScriptConfiguration(meta)
+
+ return meta
+}
+
+// Start up boilerplate
+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 = setupmeta(script, "Non-build-product", "Non-build-subcomponent")
+
+ 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/build/integrity.groovy b/Common_scripts/build/integrity.groovy
new file mode 100644
index 0000000..e93c00f
--- /dev/null
+++ b/Common_scripts/build/integrity.groovy
@@ -0,0 +1,113 @@
+import static groovy.json.JsonOutput.*
+
+def check(buildmeta) {
+ def results = [
+ 'good': true,
+ 'comment': '',
+ ]
+
+ // Walk the meta looking for different versions of the same components
+ def allmeta = buildmeta.allrelatedmeta()
+ echo "All meta:\n${allmeta.comment}"
+
+ // Store build stamps associated with each product component; Store a counter against each product component version
+ def productcomponents = [:]
+ for (meta in allmeta.metacollection) {
+ def key = meta.componentidentifier()
+
+ if (!productcomponents.containsKey(key)) {
+ productcomponents[key] = [:]
+ }
+ def buildstampnumber = meta.releasetag()
+ if (!productcomponents[key].containsKey(buildstampnumber)) {
+ productcomponents[key][buildstampnumber] = 1
+ } else {
+ productcomponents[key][buildstampnumber] += 1
+ }
+ }
+
+ // Show what was collected
+ echo prettyPrint(toJson(productcomponents))
+
+ // Look for product components with more than one build stamp
+ for (pc in productcomponents.keySet()) {
+ def bsns = productcomponents[pc]
+ if (bsns.size() > 1) {
+ results.good = false
+ results.comment += "There is more than one version of Product component: ${pc} being used in this build:\n"
+ for (bsn in bsns.keySet()) {
+ results.comment += "${bsn}\n"
+ }
+ }
+ }
+
+ // Store product components associated with each release git url
+ def releasegiturls = [:]
+ for (meta in allmeta.metacollection) {
+ def String key = meta.releaseinfo.releaserepoURL
+
+ if (key) {
+ if (!releasegiturls.containsKey(key)) {
+ releasegiturls[key] = [:]
+ }
+ def componentidentifier = meta.componentidentifier()
+ if (!releasegiturls[key].containsKey(componentidentifier)) {
+ releasegiturls[key][componentidentifier] = 1
+ } else {
+ releasegiturls[key][componentidentifier] += 1
+ }
+ }
+ }
+
+ // Show what was collected
+ echo prettyPrint(toJson(releasegiturls))
+
+ // Look for release git urls being used by more than one product component
+ for (rgu in releasegiturls.keySet()) {
+ def cis = releasegiturls[rgu]
+ if (cis.size() > 1) {
+ results.good = false
+ results.comment += "There is more than one product component associated with a release git url: ${rgu} being used in this build:\n"
+ for (ci in cis.keySet()) {
+ results.comment += "${ci}\n"
+ }
+ }
+ }
+
+ // Store git commit shas associated with each source git url
+ def sourcegiturls = [:]
+ for (meta in allmeta.metacollection) {
+ def String key = meta.gitinfo.remoteurl
+
+ if (key) {
+ if (!sourcegiturls.containsKey(key)) {
+ sourcegiturls[key] = [:]
+ }
+ def commitsha = meta.gitinfo.gitrevision
+ if (!sourcegiturls[key].containsKey(commitsha)) {
+ sourcegiturls[key][commitsha] = 1
+ } else {
+ sourcegiturls[key][commitsha] += 1
+ }
+ }
+ }
+
+ // Show what was collected
+ echo prettyPrint(toJson(sourcegiturls))
+
+ // Look for source git urls associated with more than one sha code
+ for (sgu in sourcegiturls.keySet()) {
+ def cs = sourcegiturls[sgu]
+ if (cs.size() > 1) {
+ results.good = false
+ results.comment += "There is more than one source commit sha associated with a source git url: ${sgu} being used in this build:\n"
+ for (c in cs.keySet()) {
+ results.comment += "${c}\n"
+ }
+ }
+ }
+
+ return results
+}
+
+return this
\ No newline at end of file
diff --git a/Common_scripts/build/postactions.groovy b/Common_scripts/build/postactions.groovy
new file mode 100644
index 0000000..8b18908
--- /dev/null
+++ b/Common_scripts/build/postactions.groovy
@@ -0,0 +1,225 @@
+/* Example post build info
+{
+ "Build outcomes": {
+ "Success": {
+ "Actions": {
+ "Deploy documentation": {
+ "Description": "Can be empty - Name of documentation/doxygen deploy job to run if this build is successful",
+ "Job": "HMB_FD_HV_0.9.6/HMB_FD_HV_0.9.6_sg1024_doxygen_deploy"
+ },
+ "Static analysis": {
+ "Description": "Can be empty - Static analysis job to run when this build is successful",
+ "Job": ""
+ },
+ "Unit test": {
+ "Description": "Can be empty - Unit test job to run when this build is successful",
+ "Job": ""
+ },
+ "Regression test": {
+ "Description": "Can be empty - Regression test job to run when this build is successful",
+ "Job": "HMB_FD_HV_0.9.6/HMB_FD_HV_0.9.6_sg1024_run_tests"
+ },
+ "Update differences": {
+ "Description": "Can be empty - Update differences job to run when this build is successful",
+ "Job": "HMB_FD_HV_diff_releases"
+ },
+ "Release to git": {
+ "Description": "Can be empty - Name of release to git job to run if this build is successful",
+ "Job": "HMB_FD_HV_release_to_git"
+ }
+ }
+ },
+ "Failed": {
+ "Actions": {
+ "Email": {
+ "Description": "Can be empty - Name of release to git job to run if this build is successful",
+ "To": [
+ "dan.hawkins@globalinkjetsystems.com"
+ ]
+ },
+ "ExtEmail": {
+ "Description": "Send an email using Extended Email plugin",
+ "To": [
+ "dan.hawkins@globalinkjetsystems.com"
+ ],
+ "Recipient providers": [
+ "culprits",
+ "requestor",
+ "developers",
+ "upstreamDevelopers"
+ ]
+ }
+ }
+ }
+ }
+}
+*/
+
+def getActionJobName(postbuildactions, String action, String alternativeparamname) {
+ def String jobname = ''
+ if (postbuildactions) {
+ try {
+ jobname = postbuildactions[action]['Job']
+ } catch(Exception ex) {
+ echo "No post build actions found for action: ${action}"
+ jobname = ''
+ }
+ } else {
+ if (params[alternativeparamname] != null) {
+ if (params[alternativeparamname]) {
+ jobname = params[alternativeparamname]
+ }
+ }
+ }
+ if (jobname) {
+ def jobitem = Jenkins.instance.getItemByFullName(jobname)
+ if (jobitem) {
+ if (!jobitem.isBuildable()) {
+ jobname = ''
+ }
+ } else {
+ jobname = ''
+ }
+ }
+ // echo "Job name for action: ${action}: ${jobname}"
+ return jobname
+}
+
+def deployjob(String buildselector, postbuildactions, String action, String alternativeparamname, String jobnameparametername, String jobselectorparametername) {
+ def jobname = getActionJobName(postbuildactions, action, alternativeparamname)
+ if (jobname) {
+ build(
+ wait: false,
+ job: jobname,
+ parameters: [
+ string(name: jobnameparametername, value: JOB_NAME),
+ string(name: jobselectorparametername, value: buildselector),
+ ]
+ )
+ }
+}
+
+def readPostBuildInfo() {
+ def postbuildinfo = readJSON(text: POST_BUILD_INFO)
+ def postbuildjsontext = writeJSON(returnText: true, json: postbuildinfo, pretty: 1)
+ // echo "Post build info:\n${postbuildjsontext}"
+
+ return postbuildinfo
+}
+
+def performSuccessfulBuildActions() {
+ def postbuildactions
+ if (params.POST_BUILD_INFO != null) {
+ def postbuildinfo = readPostBuildInfo()
+ try {
+ postbuildactions = postbuildinfo['Build outcomes']['Success']['Actions']
+ } catch(Exception ex) {
+ echo "Post build info did not contain: Build outcomes/Success/Actions"
+ postbuildactions = null
+ }
+ }
+ def String buildselector = "${BUILD_NUMBER}"
+ deployjob(buildselector, postbuildactions, 'Deploy documentation', 'DOXYGEN_DEPLOY_JOB', 'BUILD_JOB_WITH_DOXYGEN_ARTIFACTS', 'BUILD_JOB_WITH_DOXYGEN_ARTIFACTS_SELECTOR')
+ deployjob(buildselector, postbuildactions, 'Static analysis', 'STATIC_ANALYSIS_JOB', 'BUILD_JOB_TO_ANALYSE', 'BUILD_JOB_TO_ANALYSE_SELECTOR' )
+ deployjob(buildselector, postbuildactions, 'Unit test', 'UNIT_TEST_JOB', 'BUILD_JOB_TO_TEST', 'BUILD_JOB_TO_TEST_SELECTOR')
+ deployjob(buildselector, postbuildactions, 'Regression test', 'REGRESSION_TEST_JOB', 'BUILD_JOB_TO_TEST', 'BUILD_JOB_TO_TEST_SELECTOR')
+ deployjob(buildselector, postbuildactions, 'Update differences', 'DIFF_JOB', 'LATER_BUILD_JOB', 'LATER_BUILD_SELECTOR')
+ deployjob(buildselector, postbuildactions, 'Release to git', 'RELEASE_TO_GIT_JOB', 'BUILD_JOB', 'BUILD_JOB_SELECTOR')
+}
+
+def sendemails(emailinfo) {
+ def emailtolist = emailinfo['To']
+
+ if (emailtolist) {
+ def emailbody = """
+ Failed build: ${JOB_NAME} ${BUILD_DISPLAY_NAME} : ${BUILD_URL}
+
+ Console output: ${BUILD_URL}console
+ """
+ for(emailto in emailtolist) {
+ mail(
+ subject: "[Jenkins] Failed build: ${JOB_NAME} ${BUILD_DISPLAY_NAME}",
+ body: emailbody,
+ to: emailto
+ )
+ // echo "Send email to: ${emailto}"
+ }
+ }
+}
+
+def getRecipientProviders(recipientProviderInfoList) {
+ def recipientProviderMap = [
+ culprits: [$class: 'CulpritsRecipientProvider'],
+ requestor: [$class: 'RequesterRecipientProvider'],
+ developers: [$class: 'DevelopersRecipientProvider'],
+ upstreamDevelopers: [$class: 'UpstreamComitterRecipientProvider'],
+ ]
+ def recipientProviders = []
+
+ if (recipientProviderInfoList) {
+ for(rp in recipientProviderInfoList) {
+ if (recipientProviderMap.containsKey(rp)) {
+ recipientProviders.add(recipientProviderMap[rp])
+ }
+ }
+ }
+ if (recipientProviders.size() == 0) {
+ recipientProviders = [culprits(), requestor(), developers(), upstreamDevelopers()]
+ }
+ // echo "recipientProviders: ${recipientProviders.toString()}"
+ return recipientProviders;
+}
+
+def String getToList(toListInfo) {
+ def String toList = ''
+
+ if (toListInfo) {
+ toList = toListInfo.join(',')
+ }
+ // echo "toList: ${toList}"
+ return toList
+}
+
+def sendextemail(extmailinfo) {
+ def recipientProviders = getRecipientProviders(extmailinfo['Recipient providers'])
+ def toList = getToList(extmailinfo['To'])
+
+ emailext(
+ subject: "[Jenkins] Failed build: ${JOB_NAME} ${BUILD_DISPLAY_NAME}",
+ body: '''${JELLY_SCRIPT,template="html"}''',
+ attachLog: true,
+ // attachmentsPattern: '',
+ compressLog: false,
+ // from : '',
+ mimeType: 'text/html',
+ // postsendScript: '',
+ // presendScript: '',
+ recipientProviders: recipientProviders, // Could be: buildUser, culprits, developers, brokenTestsSuspects, brokenBuildSuspects, recipients, requestor, upstreamDevelopers
+ // replyTo: '',
+ saveOutput: false,
+ to: toList,
+ )
+}
+
+def performFailedBuildActions() {
+ def postbuildactions = null
+ if (params.POST_BUILD_INFO != null) {
+ def postbuildinfo = readPostBuildInfo()
+ try {
+ postbuildactions = postbuildinfo['Build outcomes']['Failed']['Actions']
+ } catch(Exception ex) {
+ echo "Post build info did not contain: Build outcomes/Failed/Actions"
+ postbuildactions = null
+ }
+ }
+ if (postbuildactions) {
+ if (postbuildactions['Email']) {
+ sendemails(postbuildactions['Email'])
+ }
+ if (postbuildactions['ExtEmail']) {
+ sendextemail(postbuildactions['ExtEmail'])
+ }
+ }
+}
+
+return this;
diff --git a/Common_scripts/build/postactionstest.groovy b/Common_scripts/build/postactionstest.groovy
new file mode 100644
index 0000000..150f5d1
--- /dev/null
+++ b/Common_scripts/build/postactionstest.groovy
@@ -0,0 +1,43 @@
+pipeline {
+ agent { label 'master' }
+ stages {
+ stage('Initial setup') {
+ steps {
+ script {
+ CLEAN_WORKSPACE = false
+ meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
+ }
+ }
+ }
+ stage('Dummy build job') {
+ steps {
+ script {
+ echo "Execute dummy build job: ${CAUSE_ERROR}"
+ if (CAUSE_ERROR == 'true') {
+ error("Causing error")
+ }
+ }
+ }
+ }
+ }
+ post {
+ always {
+ echo 'Post-build'
+ }
+ failure {
+ echo 'Failed build'
+ script {
+ load("${autobuilder.commonscripts()}/build/postactions.groovy").performFailedBuildActions()
+ }
+ }
+ unstable {
+ echo 'Unstable build'
+ }
+ success {
+ echo 'Succeeded build'
+ script {
+ load("${autobuilder.commonscripts()}/build/postactions.groovy").performSuccessfulBuildActions()
+ }
+ }
+ }
+}
diff --git a/Common_scripts/check/build_meta.groovy b/Common_scripts/check/build_meta.groovy
new file mode 100644
index 0000000..fb8a75d
--- /dev/null
+++ b/Common_scripts/check/build_meta.groovy
@@ -0,0 +1,87 @@
+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()
+ artifactarchiver = load("${autobuilder.commonscripts()}/artifacts/archiver.groovy")
+ artifactarchiver.archive("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..4b8a89e
--- /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.metainfo.componentversionuniqueidentifier()
+ def offsetpath = entry.accumulatedpath
+ 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.accumulatedpath
+ 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..be7569d
--- /dev/null
+++ b/Common_scripts/checksum/utils.groovy
@@ -0,0 +1,15 @@
+
+// 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) {
+ echo "Checksumming: ${file.path}"
+ 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..38f80fa
--- /dev/null
+++ b/Common_scripts/commandline/commandline.groovy
@@ -0,0 +1,12 @@
+String getCommandOutput(String cmd) {
+ if (isUnix()) {
+ return sh(returnStdout: true, script: '#!/bin/sh -e\n' + cmd).trim()
+ } else {
+ return powershell(returnStdout: true, script: """
+ ${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)
+
+ return registerConfigurationInfo(meta, tool, gitURL, revision, gh.getGitInfo(targetDir))
+}
+
+return this
diff --git a/Common_scripts/configuration/tools.groovy b/Common_scripts/configuration/tools.groovy
new file mode 100644
index 0000000..dbaeedb
--- /dev/null
+++ b/Common_scripts/configuration/tools.groovy
@@ -0,0 +1,59 @@
+gh = load("${autobuilder.commonscripts()}/versioncontrol/git.groovy")
+
+class ToolOptions {
+ def m_script // Script to use if wanting to execute script commands (eg. echo -> script.echo)
+
+ String m_toolName
+
+ String m_gitURL
+ String m_revision
+ String m_repoRoot
+ int m_cloneDepth
+ boolean m_shallowClone
+
+ ToolOptions(script) {
+ m_script = script
+ m_gitURL = '-'
+ m_revision = '-'
+ m_repoRoot = ''
+ m_cloneDepth = 1
+ m_shallowClone = true
+ }
+
+ void toolName(String name) {
+ m_toolName = name.trim()
+ }
+
+ void toolRepo(String gitURL, String revision) {
+ m_gitURL = gitURL.trim()
+ m_revision = revision.trim()
+ }
+
+ void repoRoot(String root) {
+ m_repoRoot = root.trim()
+ }
+
+ void clonedepth(int depth) {
+ m_cloneDepth = depth
+ }
+
+ void shallowclone(boolean shallow) {
+ m_shallowClone = shallow
+ }
+}
+
+ToolOptions getNewToolOptions() {
+ return new ToolOptions(this)
+}
+
+def registerConfigurationInfo(meta, String configurationName, String configurationURL, String configurationVersion, String configurationSHA) {
+ meta.addConfigurationInfo(configurationName, configurationURL, configurationVersion, configurationSHA)
+}
+
+def getTool(meta, ToolOptions options, String targetDir) {
+ gh.gitCheckoutAlt(options.m_gitURL, options.m_revision, targetDir, options.m_repoRoot, options.m_cloneDepth, options.m_shallowClone)
+
+ registerConfigurationInfo(meta, options.m_toolName, options.m_gitURL, options.m_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..aab479c
--- /dev/null
+++ b/Common_scripts/copy/all.groovy
@@ -0,0 +1,79 @@
+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 {
+ IMPORTS = 'imports'
+ cleanfolders = [
+ IMPORTS,
+ ]
+ cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
+ cleaner.clean(cleanfolders)
+ }
+ }
+ }
+ stage('Import source artifacts') {
+ steps {
+ script {
+ 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('Archiving artifacts') {
+ steps {
+ script {
+ def artifactlist = meta.generateartifacts(['**/*'])
+ def artifactarchiver = load("${autobuilder.commonscripts()}/artifacts/archiver.groovy")
+
+ cleaner.clean(['meta', 'autobuild'])
+
+ dir(IMPORTS) {
+ fileOperations([
+ fileCopyOperation(excludes: '',
+ flattenFiles: false,
+ includes: '**/*',
+ targetLocation: WORKSPACE)
+ ])
+ }
+
+ cleaner.clean([IMPORTS])
+
+ artifactarchiver.archive(meta, artifactlist)
+ }
+ }
+ }
+ }
+ post {
+ always {
+ echo 'Post-build'
+ }
+ failure {
+ echo 'Failed build'
+ }
+ unstable {
+ echo 'Unstable build'
+ }
+ success {
+ echo 'Succeeded build'
+ }
+ }
+}
diff --git a/Common_scripts/copy/esw.groovy b/Common_scripts/copy/esw.groovy
new file mode 100644
index 0000000..b9eb737
--- /dev/null
+++ b/Common_scripts/copy/esw.groovy
@@ -0,0 +1,67 @@
+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 {
+ def eswimportoptions = importer.getNewImportOptions()
+ eswimportoptions.source(ESW_ARTIFACT_LOCATION, ESW_ARTIFACT_BUILD_JOB, ESW_ARTIFACT_BUILD_SELECTOR, ESW_ARTIFACT_RELEASE_REPO, ESW_ARTIFACT_RELEASE_REVISION)
+ eswimportoptions.setincrementversionnumber(true)
+ importer.artifactimport(meta, eswimportoptions, ESWDEST)
+ }
+ }
+ }
+ stage('Archiving artifacts') {
+ steps {
+ script {
+ def artifactlist = meta.generateartifacts(["${ESWEXPORT}/**"])
+ sh """
+ rm -v -rf diff
+ rm -v -rf meta
+ mv -v "${ESW}"/* .
+ """
+ artifactarchiver = load("${autobuilder.commonscripts()}/artifacts/archiver.groovy")
+ artifactarchiver.archive(meta, 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..3ad24cd
--- /dev/null
+++ b/Common_scripts/copy/filtered.groovy
@@ -0,0 +1,73 @@
+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 {
+ def importoptions = importer.getNewImportOptions()
+ importoptions.source(ARTIFACT_LOCATION, ARTIFACT_PROJECT, ARTIFACT_BUILD_SELECTOR, RELEASE_REPO, RELEASE_REVISION)
+ importer.artifactimport(meta, importoptions, 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/**"])
+ artifactarchiver = load("${autobuilder.commonscripts()}/artifacts/archiver.groovy")
+ artifactarchiver.archive(meta, 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..db9dbc3
--- /dev/null
+++ b/Common_scripts/copy/logic.groovy
@@ -0,0 +1,79 @@
+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 {
+ LOGICDEST = 'logic'
+ cleanfolders = [
+ LOGICDEST,
+ "${WORKSPACE}/embedded_logic",
+ "${WORKSPACE}/el",
+ ]
+ cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
+ cleaner.clean(cleanfolders)
+ }
+ }
+ }
+ stage('Import source artifacts') {
+ steps {
+ script {
+ def logicoptions = importer.getNewImportOptions()
+ logicoptions.source(
+ LOGIC_ARTIFACT_LOCATION,
+ LOGIC_ARTIFACT_PROJECT,
+ LOGIC_ARTIFACT_BUILD_SELECTOR,
+ LOGIC_ARTIFACT_RELEASE_REPO,
+ LOGIC_ARTIFACT_RELEASE_REVISION)
+ importer.artifactimport(meta, logicoptions, LOGICDEST)
+ }
+ }
+ }
+ stage('Archiving artifacts') {
+ steps {
+ script {
+ def artifactlist = meta.generateartifacts(['**/*'])
+ def artifactarchiver = load("${autobuilder.commonscripts()}/artifacts/archiver.groovy")
+
+ cleaner.clean(['meta', 'autobuild'])
+
+ dir(LOGICDEST) {
+ fileOperations([
+ fileCopyOperation(excludes: '',
+ flattenFiles: false,
+ includes: '**/*',
+ targetLocation: WORKSPACE)
+ ])
+ }
+
+ cleaner.clean([LOGICDEST])
+
+ artifactarchiver.archive(meta, artifactlist)
+ }
+ }
+ }
+ }
+ post {
+ always {
+ echo 'Post-build'
+ }
+ failure {
+ echo 'Failed build'
+ }
+ unstable {
+ echo 'Unstable build'
+ }
+ success {
+ echo 'Succeeded build'
+ }
+ }
+}
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..3b25798
--- /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 accumulatedpath = relatedmetainfo.accumulatedpath
+ info += "Name: ${key}\t\t\t\tPath: ${accumulatedpath}\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].metainfo
+ def latermeta = latermetaitems[key].metainfo
+
+ 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, '', earlymetafolder)
+ def latermetaitems = latermeta.releasewalkerunique(md, '', latermetafolder)
+
+ 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..ee1b8b3
--- /dev/null
+++ b/Common_scripts/differences/file.groovy
@@ -0,0 +1,24 @@
+def comparefiles(importedfile, currentfile, boolean ignorewhitespace = true) {
+ echo "Comparing file: ${importedfile} with: ${currentfile} option: ${ignorewhitespace}"
+ def wsparameter = "-w"
+ if (!ignorewhitespace) {
+ wsparameter = ""
+ }
+ if (isUnix()) {
+ sh """
+ diff -c ${wsparameter} "${importedfile}" "${currentfile}"
+ """
+ }
+ else {
+ // diffutils can be installed on windows with chocolatey
+ powershell """
+ # echo Checking utilities exist
+ # where diff
+ # if errorlevel 1 EXIT /b 1
+
+ diff.exe -c ${wsparameter} "${importedfile}" "${currentfile}"
+ """
+ }
+}
+
+return this;
diff --git a/Common_scripts/differences/json.groovy b/Common_scripts/differences/json.groovy
new file mode 100644
index 0000000..dbf47b8
--- /dev/null
+++ b/Common_scripts/differences/json.groovy
@@ -0,0 +1,51 @@
+def comparefiles(importedjsonfile, currentjsonfile) {
+ echo "Comparing json file: ${importedjsonfile} with: ${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 {
+ // Jq and diffutils can be installed on windows with chocolatey
+ powershell """
+ # echo Checking utilities exist
+ # set
+ # echo %PATH%
+ try {
+ if (Get-Command jq) {}
+ }
+ catch {
+ echo "jq is unavailable"
+ exit \$false
+ }
+ try {
+ if (Get-Command diff) {}
+ }
+ catch {
+ echo "diff is unavailable"
+ exit \$false
+ }
+
+ # echo Sorting json in files to compare
+ # jq -S sorts json output
+ jq -S . "${importedjsonfile}" > temp1.txt
+ if (\$lastexitcode -ge 1) { exit 1 }
+ jq -S . "${currentjsonfile}" > temp2.txt
+ if (\$lastexitcode -ge 1) { exit 1 }
+
+ # echo Diffing sorted json files
+ diff.exe -c temp1.txt temp2.txt
+ \$lec = \$lastexitcode
+
+ Remove-Item temp1.txt
+ Remove-Item temp2.txt
+
+ if (\$lec -ge 1) { exit 1 }
+ """
+ }
+}
+
+return this;
diff --git a/Common_scripts/differences/metahierarchy.groovy b/Common_scripts/differences/metahierarchy.groovy
new file mode 100644
index 0000000..01c1890
--- /dev/null
+++ b/Common_scripts/differences/metahierarchy.groovy
@@ -0,0 +1,102 @@
+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()
+
+ def earlyimportoptions = importer.getNewImportOptions()
+ earlyimportoptions.source(EARLY_SOURCE, EARLY_BUILD_JOB, EARLY_BUILD_SELECTOR, SOURCEURL, RELEASE_EARLY_REVISION)
+ earlyimportoptions.setincrementversionnumber(false)
+ earlyimportoptions.setfilter('meta/**')
+ importer.artifactimport(meta, earlyimportoptions, EARLYROOTDIR)
+
+ def laterimportoptions = importer.getNewImportOptions()
+ laterimportoptions.source(LATER_SOURCE, LATER_BUILD_JOB, LATER_BUILD_SELECTOR, SOURCEURL, RELEASE_LATER_REVISION)
+ laterimportoptions.setincrementversionnumber(false)
+ laterimportoptions.setfilter('meta/**')
+ importer.artifactimport(meta, laterimportoptions, LATERROOTDIR)
+ }
+ }
+ }
+ 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()
+ artifactarchiver = load("${autobuilder.commonscripts()}/artifacts/archiver.groovy")
+ artifactarchiver.archive("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..5054c02
--- /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/hardware/sominfo.groovy b/Common_scripts/hardware/sominfo.groovy
new file mode 100644
index 0000000..72a3ca9
--- /dev/null
+++ b/Common_scripts/hardware/sominfo.groovy
@@ -0,0 +1,80 @@
+def sominfostore = null
+
+/* Example expected JSON
+{
+ "SomType": {
+ "Som_BA4": {
+ "Artifact info": {
+ "Location": "Jenkins job artifact",
+ "Job": "HMB_FD_HV_0.9.6/0.9.6_SG1024_EL_syn_ba4",
+ "Job selector": "true",
+ "Release repo": "git@hydra:hmb_fd_hv-releases/sg1024/hmb_fd_hv_logic_ba4.git",
+ "Release repo revision": ""
+ }
+ },
+ "Som_FC5": {
+ "Artifact info": {
+ "Location": "Jenkins job artifact",
+ "Job": "HMB_FD_HV_0.9.6/0.9.6_SG1024_EL_syn_fc5",
+ "Job selector": "true",
+ "Release repo": "git@hydra:hmb_fd_hv-releases/sg1024/hmb_fd_hv_logic_fc5.git",
+ "Release repo revision": ""
+ }
+ }
+ }
+}
+*/
+
+def String asJsonText() {
+ return writeJSON(returnText: true, json: sominfostore, pretty: 1)
+}
+
+def boolean exists() {
+ return (sominfostore != null)
+}
+
+def set(String jsontext) {
+ sominfostore = readJSON(text: jsontext)
+ echo "Som support info:\n${asJsonText()}"
+}
+
+def get() {
+ return sominfostore
+}
+
+def somtypes() {
+ return sominfostore['SomType']
+}
+
+def artifactinfo(somtype) {
+ return somtype['Artifact info']
+}
+
+def artifactlocation(artifactinfo) {
+ return artifactinfo['Location']
+}
+
+def boolean isjoblocation(artifactinfo) {
+ return (artifactinfo['Location'] == 'Jenkins job artifact' ||
+ artifactinfo['Location'] == 'Jenkins job artefact')
+}
+
+def boolean isreleaserepolocation(artifactinfo) {
+ return artifactinfo['Location'] == 'Release repository'
+}
+
+def artifactjob(artifactinfo) {
+ return [
+ "name": artifactinfo['Job'],
+ "selector": "${artifactinfo['Job selector']}"
+ ]
+}
+
+def releaserepo(artifactinfo) {
+ return [
+ "repo": artifactinfo['Release repo'],
+ "revision": artifactinfo['Release repo revision']
+ ]
+}
+
+return this
\ No newline at end of file
diff --git a/Common_scripts/import/importer.groovy b/Common_scripts/import/importer.groovy
new file mode 100644
index 0000000..bb0d32e
--- /dev/null
+++ b/Common_scripts/import/importer.groovy
@@ -0,0 +1,377 @@
+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:
+ m_script.error("Unknown type of artifact source select: ${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, buildnumberorselector) {
+ m_jobname = jobname.trim()
+ m_buildnumberorselector = [
+ $class: 'ParameterizedBuildSelector',
+ parameterName: buildnumberorselector
+ ]
+ setsourceselect('Jenkins job artifact')
+ }
+
+ void jenkinsjob(String jobname, int buildnumberorselector) {
+ m_jobname = jobname.trim()
+ m_buildnumberorselector = [
+ $class: 'ParameterizedBuildSelector',
+ parameterName: "${buildnumberorselector}"
+ ]
+ 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 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)
+
+ echo "Build selector type: ${importoptions.m_buildnumberorselector.getClass()}"
+ echo "Importing artifacts from job: ${importoptions.m_jobname} selector: ${importoptions.m_buildnumberorselector.toString()}"
+ copyArtifacts(
+ filter: formFilter(importoptions),
+ excludes: importoptions.m_excludes,
+ fingerprintArtifacts: importoptions.m_fingerprint,
+ projectName: importoptions.m_jobname,
+ selector: 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 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))
+
+ echo "Getting associated metadata from path: ${destpath}"
+ def collectedmetalist = importedmeta.getassociated(destpath)
+ for(def collectedmeta in collectedmetalist) {
+ echo "Collection meta item: ${collectedmeta.metainfo.componentversionuniqueidentifier()} offset path: ${collectedmeta.accumulatedpath}"
+ }
+
+ echo "Cloning associated repos inside path: ${destpath}"
+ for(def collectedmeta in collectedmetalist) {
+ def relatedmeta = collectedmeta.metainfo
+ def relatedoffsetpath = collectedmeta.accumulatedpath
+ 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 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 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 = importer.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 = importer.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 = importer.getNewImportOptions()
+
+ importoptions.jenkinsjob(buildjob, buildnumberorselector)
+ importoptions.setincrementversionnumber(incrementversionnumber)
+ importoptions.setfilter(filter)
+ importoptions.setexcludes(excludes)
+ importoptions.setfingerprint(fingerprint)
+
+ return artifactimport(meta, importoptions, destpath)
+}
+
+// Import the artifacts of a named child component found below parent meta's hierarchy
+def artifactimport(meta,
+ parentmeta,
+ String parentmetapath,
+ String childproduct,
+ String childsubcomponent,
+ ImportOptions importoptions,
+ String destinationfolder) {
+ // Import from parent meta
+ def childmeta = meta.getNewMetaObject()
+ def childmeta2
+ echo "Finding meta associated with child: Product: ${childproduct} Sub-component: ${childsubcomponent}"
+ echo "From parent meta identifier: ${parentmeta.componentidentifier()} and parent meta path: ${parentmetapath}"
+ def findresults = parentmeta.findAssociatedMeta(parentmetapath, childproduct, childsubcomponent)
+ if (findresults.matchfound) {
+ childmeta = findresults.matchedmetaitem.metainfo
+ if (importoptions.m_sourceselect == 'Release repository' || childmeta.releaseinfo.released) {
+ importoptions.releaserepo(childmeta.releaseinfo.releaserepoURL, childmeta.releasetag())
+ } else {
+ importoptions.jenkinsjob(childmeta.jenkinsbuildinfo.buildjobname, childmeta.jenkinsbuildinfo.buildnumber)
+ }
+ childmeta2 = importer.artifactimport(meta, importoptions, destinationfolder)
+ } else {
+ error("Could not find meta associated with child: Product: ${childproduct} Sub-component: ${childsubcomponent}")
+ }
+ return childmeta2
+}
+
+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..6715145
--- /dev/null
+++ b/Common_scripts/meta/folder.groovy
@@ -0,0 +1,1193 @@
+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 {
+ private String format
+ private String productname
+ private String subcomponentname
+ private String variant
+ private String uniqueid
+
+ ProductInfo(script, String productname = '', String subcomponentname = '', String variant = '') {
+ super(script)
+ this.format = '0.1'
+ this.productname = productname
+ this.subcomponentname = subcomponentname
+ this.variant = variant
+ this.uniqueid = UUID.randomUUID().toString()
+ }
+
+ void set(String productname, String subcomponentname, String variant = '') {
+ // 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.powershell(script: "git check-ref-format --normalize \"refs/tags/${productname}\" 2>&1>\$null", , 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.powershell(script: "git check-ref-format --normalize \"refs/tags/${subcomponentname}\" 2>&1>\$null", , 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")
+ }
+ if (variant) {
+ def int vstatus = 0
+ if (script.isUnix()) {
+ vstatus = script.sh(script: "git check-ref-format --normalize \"refs/tags/${variant}\" >/dev/null 2>/dev/null", , returnStatus: true)
+ }
+ else {
+ vstatus = script.powershell(script: "git check-ref-format --normalize \"refs/tags/${variant}\" 2>&1>\$null", , returnStatus: true)
+ }
+ if (vstatus > 0) {
+ script.error("The subcomponent name: ${variant} needs to be renamed as it cannot be used in a git tag name")
+ }
+ }
+ this.productname = productname
+ this.subcomponentname = subcomponentname
+ this.variant = variant
+ }
+
+ void set(ProductInfo otherinfo) {
+ this.productname = otherinfo.productname
+ this.subcomponentname = otherinfo.subcomponentname
+ this.variant = otherinfo.variant
+ this.uniqueid = otherinfo.uniqueid
+ }
+
+ void deserialiseJson(rawmeta) {
+ //format = rawmeta['format']
+ productname = rawmeta['productname']
+ subcomponentname = rawmeta['subcomponentname']
+ variant = rawmeta['variant'] ?: ''
+ uniqueid = rawmeta['uniqueid'] ?: uniqueid
+ }
+
+ LinkedHashMap serialisationdata() {
+ def data = [
+ 'format' : format,
+ 'productname' : productname,
+ 'subcomponentname' : subcomponentname,
+ 'variant' : variant,
+ 'uniqueid': uniqueid,
+ ]
+ return data
+ }
+}
+
+class GitInfo extends GISJsonSerialised {
+ private String format
+ 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.format = '0.1'
+ this.sourcepath = sourcepath
+ this.sourcerevision = sourcerevision
+ this.gitrevision = gitrevision
+ this.remoteurl = remoteurl
+ this.remoteinfo = remoteinfo
+ }
+
+ GitInfo(GitInfo another) {
+ super(another.script)
+ this.sourcepath = another.sourcepath
+ this.sourcerevision = another.sourcerevision
+ this.gitrevision = another.gitrevision
+ this.remoteurl = another.remoteurl
+ this.remoteinfo = another.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 set(GitInfo otherinfo) {
+ this.sourcepath = otherinfo.sourcepath
+ this.sourcerevision = otherinfo.sourcerevision
+ this.gitrevision = otherinfo.gitrevision
+ this.remoteurl = otherinfo.remoteurl
+ this.remoteinfo = otherinfo.remoteinfo
+ }
+
+ void deserialiseJson(rawmeta) {
+ //format = rawmeta['format']
+ sourcepath = rawmeta['sourcepath']
+ sourcerevision = rawmeta['sourcerevision']
+ gitrevision = rawmeta['gitrevision']
+ remoteurl = rawmeta['remoteurl']
+ remoteinfo = rawmeta['remoteinfo']
+ }
+
+ LinkedHashMap serialisationdata() {
+ def data = [
+ 'format' : format,
+ 'sourcepath' : sourcepath,
+ 'sourcerevision' : sourcerevision,
+ 'gitrevision' : gitrevision,
+ 'remoteurl' : remoteurl,
+ 'remoteinfo' : remoteinfo,
+ ]
+ return data
+ }
+}
+
+class JenkinsBuildParameter extends GISJsonSerialised {
+ private String name
+ private String valuetype
+ private String value
+
+ JenkinsBuildParameter(script, String name = '', String valuetype = '', String value = '') {
+ super(script)
+ this.name = name
+ this.valuetype = valuetype
+ this.value = value
+ }
+
+ void set(String name, String valuetype, String value) {
+ this.name = name
+ this.valuetype = valuetype
+ this.value = value
+ }
+
+ void deserialiseJson(rawmeta) {
+ name = rawmeta['name']
+ valuetype = rawmeta['valuetype']
+ value = rawmeta['value']
+ }
+
+ LinkedHashMap serialisationdata() {
+ def data = [
+ 'name' : name,
+ 'valuetype' : valuetype,
+ 'value' : value,
+ ]
+ return data
+ }
+}
+
+class JenkinsBuildInfo extends GISJsonSerialised {
+ private String format
+ private String buildjobname
+ private int buildnumber
+ private String buildmachine
+ private String builddate
+ private ArrayList parameters
+ private boolean isfullbuild
+
+ JenkinsBuildInfo(script, String buildjobname = '', int buildnumber = 0, String buildmachine = '', String builddate = '', boolean isfullbuild = true) {
+ super(script)
+ this.format = '0.1'
+ this.buildjobname = buildjobname
+ this.buildnumber = buildnumber
+ this.buildmachine = buildmachine
+ this.builddate = builddate
+ this.isfullbuild = isfullbuild
+ parameters = new ArrayList()
+ }
+
+ void set(String buildjobname, int buildnumber, String buildmachine, String builddate, boolean isfullbuild = true) {
+ this.buildjobname = buildjobname
+ this.buildnumber = buildnumber
+ this.buildmachine = buildmachine
+ this.builddate = builddate
+ this.isfullbuild = isfullbuild
+ }
+
+ void set(boolean isfullbuild) {
+ this.isfullbuild = isfullbuild
+ }
+
+ boolean isFullBuild() {
+ return isfullbuild
+ }
+
+ void addParameter(String name, value) {
+ def p = new JenkinsBuildParameter(script, name, value.getClass().toString(), value.toString())
+ parameters.add(p)
+ return p
+ }
+
+ void deserialiseJson(rawmeta) {
+ //format = rawmeta['format']
+ buildjobname = rawmeta['buildjobname']
+ buildnumber = rawmeta['buildnumber']
+ buildmachine = rawmeta['buildmachine']
+ builddate = rawmeta['builddate']
+ isfullbuild = (rawmeta['isfullbuild'] == null) ? true : rawmeta['isfullbuild']
+ parameters = new ArrayList()
+ if (rawmeta['isfullbuild'] != null) {
+ for (rawparameter in rawmeta['parameters']) {
+ def p = new JenkinsBuildParameter(script)
+ p.deserialiseJson(rawparameter)
+ parameters.add(p)
+ }
+ }
+ }
+
+ List parametersserialised() {
+ def associated = []
+ for (p in parameters) {
+ associated.add(p.serialisationdata())
+ }
+ return associated
+ }
+
+ LinkedHashMap serialisationdata() {
+ def data = [
+ 'format' : format,
+ 'buildjobname' : buildjobname,
+ 'buildnumber' : buildnumber,
+ 'buildmachine' : buildmachine,
+ 'builddate' : builddate,
+ 'isfullbuild' : isfullbuild,
+ 'parameters' : parametersserialised(),
+ ]
+ return data
+ }
+}
+
+class BuildStampInfo extends GISJsonSerialised {
+ private String format
+ private String buildstampprefix
+ private int revision
+ private String buildstamp
+
+ BuildStampInfo(script, buildstampprefix = "0.30000.0.", revision = 0, buildstamp = "0.30000.0.0") {
+ super(script)
+ this.format = '0.1'
+ this.buildstampprefix = buildstampprefix
+ this.revision = revision
+ this.buildstamp = buildstamp
+ }
+
+ BuildStampInfo(BuildStampInfo another) {
+ super(another.script)
+ this.buildstampprefix = another.buildstampprefix
+ this.revision = another.revision
+ this.buildstamp = another.buildstamp
+ }
+
+ void set(String buildstampprefix, int revision, String buildstamp) {
+ this.buildstampprefix = buildstampprefix
+ this.revision = revision
+ this.buildstamp = buildstamp
+ }
+
+ void set(BuildStampInfo other) {
+ set(other.buildstampprefix, other.revision, other.buildstamp)
+ }
+
+ // Override the buildstamp
+ void override(String buildstamp) {
+ this.buildstamp = buildstamp
+ script.echo("Build stamp overridden to: ${this.buildstamp}")
+ def s = this.buildstamp.split('\\.')
+ if (s.size() != 4) {
+ script.error("Overriding build stamp: ${buildstamp} is not of the format: 1.2.3.4")
+ }
+ this.buildstampprefix = "${s[0]}.${s[1]}.${s[2]}"
+ script.echo("Stamp prefix overridden to: ${this.buildstampprefix}")
+ this.revision = s[3].toInteger()
+ script.echo("Revision overridden to: ${this.revision}")
+ }
+
+ 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) {
+ //format = rawmeta['format']
+ buildstampprefix = rawmeta['buildstampprefix']
+ revision = rawmeta['revision']
+ buildstamp = rawmeta['buildstamp']
+ }
+
+ LinkedHashMap serialisationdata() {
+ def data = [
+ 'format' : format,
+ 'buildstampprefix' : buildstampprefix,
+ 'revision' : revision,
+ 'buildstamp' : buildstamp,
+ ]
+ return data
+ }
+}
+
+class ReleaseInfo extends GISJsonSerialised {
+ private String format
+ private String releaserepoURL
+ private ArrayList releaseitems
+ private boolean released
+
+ ReleaseInfo(script, String releaserepoURL = '', boolean released = false) {
+ super(script)
+ this.format = '0.1'
+ 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) {
+ //format = rawmeta['format']
+ releaserepoURL = rawmeta['releaserepoURL']
+ releaseitems = new ArrayList()
+ for (rawreleaseitem in rawmeta['releaseitems']) {
+ releaseitems.add(rawreleaseitem)
+ }
+ released = rawmeta['released'] ?: false
+ }
+
+ LinkedHashMap serialisationdata() {
+ def data = [
+ 'format' : format,
+ '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 format
+ private String artifactpath
+ private ArrayList checksumpairs
+
+ ChecksumSet(script, artifactpath = '') {
+ super(script)
+ this.format = '0.1'
+ 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) {
+ //format = rawmeta['format']
+ 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 = [
+ 'format' : format,
+ '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 format
+ private String filepath
+
+ PublishableInfo(script, String filepath = '') {
+ super(script)
+ this.format = '0.1'
+ this.filepath = filepath
+ }
+
+ void deserialiseJson(rawmeta) {
+ //format = rawmeta['format']
+ filepath = rawmeta['filepath']
+ }
+
+ LinkedHashMap serialisationdata() {
+ def data = [
+ 'format' : format,
+ 'filepath' : filepath,
+ ]
+ return data
+ }
+}
+
+class MetaInfo extends GISJsonSerialised {
+ private static String METAFOLDERNAME = 'meta'
+ private static String METAFILENAME = 'info.json'
+ private static String METAARTIFACTS = "${METAFOLDERNAME}/**"
+ private static String format = '0.2'
+
+ abstract class RelatedMetaInfo extends GISJsonSerialised {
+ String format
+
+ RelatedMetaInfo(script, format) {
+ super(script)
+ this.format = format
+ }
+
+ abstract void deserialiseJson(rawmeta)
+ abstract LinkedHashMap serialisationdata()
+ abstract String getrelatedid()
+ abstract void markreleased()
+ }
+
+ class RelatedMetaInfo_v0_1 extends RelatedMetaInfo {
+ private MetaInfo meta
+ private String offsetpath
+ private String uniqueid
+
+ RelatedMetaInfo_v0_1(script, String offsetpath = '', MetaInfo meta = null, String uniqueid = UUID.randomUUID().toString()) {
+ super(script, '0.1')
+ this.offsetpath = offsetpath
+ this.uniqueid = uniqueid
+ this.meta = meta
+ }
+
+ void deserialiseJson(rawmeta) {
+ offsetpath = rawmeta['offsetpath']
+ uniqueid = rawmeta['uniqueid'] ?: uniqueid
+ meta = new MetaInfo(script)
+ meta.deserialiseJson(rawmeta['meta'])
+ }
+
+ LinkedHashMap serialisationdata() {
+ def data = [
+ 'format' : format,
+ 'offsetpath' : offsetpath,
+ 'uniqueid' : uniqueid,
+ 'meta' : meta.serialisationdata(),
+ ]
+ return data
+ }
+
+ String getrelatedid() {
+ return uniqueid
+ }
+
+ void markreleased() {
+ meta.releaseinfo.markreleased()
+ }
+ }
+
+ class RelatedMetaInfo_v0_2 extends RelatedMetaInfo {
+ private String importpath
+ private String offsetpath
+ private String uniqueid
+
+ RelatedMetaInfo_v0_2(script, String importpath = '', String offsetpath = '', String uniqueid = UUID.randomUUID().toString()) {
+ super(script, '0.2')
+ this.importpath = importpath
+ this.offsetpath = offsetpath
+ this.uniqueid = uniqueid
+ }
+
+ void deserialiseJson(rawmeta) {
+ //format = rawmeta['format']
+ offsetpath = rawmeta['offsetpath']
+ uniqueid = rawmeta['uniqueid']
+ }
+
+ LinkedHashMap serialisationdata() {
+ def data = [
+ 'format' : format,
+ 'offsetpath' : offsetpath,
+ 'uniqueid' : uniqueid
+ ]
+ return data
+ }
+
+ String getrelatedid() {
+ return uniqueid
+ }
+
+ void markreleased() {
+ // Do nothing
+ }
+ }
+
+ private ProductInfo productinfo
+ private GitInfo gitinfo
+ private JenkinsBuildInfo jenkinsbuildinfo
+ private BuildStampInfo buildstampinfo
+ private ReleaseInfo releaseinfo
+ private 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()
+ }
+
+ void markreleased() {
+ script.echo("Marking product: ${productinfo.productname} component: ${productinfo.subcomponentname} as released")
+ releaseinfo.markreleased()
+ for (associated in associatedmeta) {
+ associated.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)
+ return ci
+ }
+
+ void addCustomInfo(String customId, String customValue) {
+ custominfo.put(customId.trim(), customValue)
+ }
+
+ String getCustomInfo(String customId) {
+ return custominfo.getAt(customId.trim())
+ }
+
+ def isFullBuild() {
+ return jenkinsbuildinfo.isFullBuild()
+ }
+
+ 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'].toString() != '0.1' && rawmeta['format'].toString() != '0.2' ) {
+ script.error("Unsupported meta format found")
+ 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']) {
+ if (!rawrelatedmeta['format'] || rawrelatedmeta['format'] == '0.1') {
+ def rm = new RelatedMetaInfo_v0_1(script)
+ rm.deserialiseJson(rawrelatedmeta)
+ associatedmeta.add(rm)
+ } else if (rawrelatedmeta['format'] == '0.2') {
+ def rm = new RelatedMetaInfo_v0_2(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)) {
+ script.echo("Deserialising meta at file: ${importedmetafile} (destpath: ${destpath})")
+ mi.deserialiseJson(importedmetafile)
+
+ RelatedMetaInfo rmi = new RelatedMetaInfo_v0_2(script, importedmetafile, adjustedpath, mi.productinfo.uniqueid)
+ if (appendtoparentmeta) {
+ associatedmeta.add(rmi)
+ }
+ } else {
+ script.echo("Could not deserialise meta at file: ${importedmetafile} (destpath: ${destpath})- Does not exist")
+ addConfigurationInfo('', givenRepo, givenRevision, givenSHA)
+ }
+ return mi
+ }
+
+ def copyrelatedmeta() {
+ script.echo("Copying related input meta data to output meta")
+ for (relatedmetainfo in associatedmeta) {
+ def srcpath = "${relatedmetainfo.offsetpath}/${METAFOLDERNAME}"
+ def destpath = "${METAFOLDERNAME}/${relatedmetainfo.offsetpath}"
+ script.echo("Copying related meta folder: ${srcpath} to meta output folder: ${destpath} recursively")
+ script.fileOperations([
+ script.folderCreateOperation(folderPath: destpath),
+ script.folderCopyOperation(sourceFolderPath: srcpath, destinationFolderPath: destpath)
+ ])
+ }
+ }
+
+ 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
+ }
+
+ def 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
+ }
+
+ 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
+ }
+
+ class CollectedMeta {
+ private MetaInfo metainfo
+ private String accumulatedpath
+ private String accumulatedmetapath
+
+ CollectedMeta(MetaInfo metainfo, String accumulatedpath = '', String accumulatedmetapath = '') {
+ this.metainfo = metainfo
+ this.accumulatedpath = accumulatedpath
+ this.accumulatedmetapath = accumulatedmetapath
+ }
+ }
+
+ class IterationInfo {
+ private ArrayList metacollection
+ private Map metamap
+ private String comment
+ private int level
+ private String gatheredpath
+ private String gatheredmetapath
+ private boolean limiteddepth
+ private int maxdepth
+
+ IterationInfo(ArrayList metacollection,
+ Map metamap,
+ String comment = '',
+ int level = 0,
+ String gatheredpath = '',
+ String gatheredmetapath = '',
+ boolean limiteddepth = false,
+ int maxdepth = 0) {
+ this.metacollection = metacollection
+ this.metamap = metamap
+ this.comment = comment
+ this.level = level
+ this.gatheredpath = gatheredpath
+ this.gatheredmetapath = gatheredmetapath
+ this.limiteddepth = limiteddepth
+ this.maxdepth = maxdepth
+ }
+
+ String show() {
+ return "Iteration:\nLevel: ${level}\nGathered path: ${gatheredpath}\nGathered meta path: ${gatheredmetapath}\nLimited depth: ${limiteddepth}\nMax depth: ${maxdepth}"
+ }
+
+ void add(CollectedMeta item) {
+ metacollection.add(item)
+ metamap.put(item.metainfo.productinfo.uniqueid, item)
+ }
+ }
+
+ def openchildmeta(IterationInfo ii, RelatedMetaInfo relatedmetainfo) {
+ def MetaInfo mi = new MetaInfo(script)
+
+ def String nextgatheredpath = (ii.gatheredpath == '' ? relatedmetainfo.offsetpath : "${ii.gatheredpath}/${relatedmetainfo.offsetpath}")
+ def String nextgatheredmetapath = (ii.gatheredmetapath == '' ? "${relatedmetainfo.offsetpath}/${METAFOLDERNAME}" : "${ii.gatheredmetapath}/${relatedmetainfo.offsetpath}")
+ def importedmetafile = "${nextgatheredmetapath}/${METAFILENAME}"
+ def boolean imported
+ // If this has already been read in from a file
+ if (relatedmetainfo.getrelatedid() in ii.metamap) {
+ //script.echo("Already read in meta associated with uniqueid: ${relatedmetainfo.getrelatedid()} - Using it")
+ mi = ii.metamap[relatedmetainfo.getrelatedid()].metainfo
+ imported = true
+ } else if (script.fileExists(importedmetafile)) {
+ mi.deserialiseJson(importedmetafile)
+ imported = true
+ } else {
+ script.echo("Could not deserialise meta at file: ${importedmetafile} - Does not exist")
+ imported = false
+ }
+
+ def childmetainfo = [
+ 'imported': imported,
+ 'nextgatheredpath': nextgatheredpath,
+ 'nextgatheredmetapath': nextgatheredmetapath,
+ 'childmeta': mi
+ ]
+ return childmetainfo
+ }
+
+ def walkrelated_v0_1(IterationInfo ii) {
+ //script.echo("Walk related v0.1: ${ii.show()}")
+ if (!ii.limiteddepth || ii.maxdepth > 0) {
+ ii.add(new CollectedMeta(this, ii.gatheredpath, ii.gatheredmetapath))
+ ii.comment += "${ii.level} ".padRight(ii.level * 4) + globalreleasetag() + '\n'
+ for (relatedmetainfo in associatedmeta) {
+ if (!relatedmetainfo.format || relatedmetainfo.format == '0.1') {
+ def MetaInfo othermeta = relatedmetainfo.meta
+ def String nextgatheredpath = (ii.gatheredpath == '' ? relatedmetainfo.offsetpath : "${ii.gatheredpath}/${relatedmetainfo.offsetpath}")
+ def String nextgatheredmetapath = (ii.gatheredmetapath == '' ? relatedmetainfo.offsetpath : "${ii.gatheredmetapath}/${relatedmetainfo.offsetpath}")
+ def nextii = new IterationInfo(ii.metacollection,
+ ii.metamap,
+ ii.comment,
+ ii.level + 1,
+ nextgatheredpath,
+ nextgatheredmetapath,
+ ii.limiteddepth,
+ ii.maxdepth - 1)
+ def results = othermeta.walkrelated_v0_1(nextii)
+ ii.metacollection = results.metacollection
+ ii.metamap = results.metamap
+ ii.comment = results.comment
+ } else {
+ script.error("There is non v0.1 format related meta info under v0.1 related meta info")
+ }
+ }
+ }
+ return [ 'metacollection' : ii.metacollection, 'metamap' : ii.metamap, 'comment': ii.comment ]
+ }
+
+ def walkrelated(IterationInfo ii) {
+ //script.echo("Walk related: ${ii.show()}")
+ if (!ii.limiteddepth || ii.maxdepth > 0) {
+ ii.add(new CollectedMeta(this, ii.gatheredpath, ii.gatheredmetapath))
+ ii.comment += "${ii.level} ".padRight(ii.level * 4) + globalreleasetag() + '\n'
+ for (relatedmetainfo in associatedmeta) {
+ //script.echo("Related meta info: ${relatedmetainfo.offsetpath} format: ${relatedmetainfo.format}")
+ if (relatedmetainfo.format == '0.2') {
+ def childmetainfo = openchildmeta(ii, relatedmetainfo)
+ if (childmetainfo.imported) {
+ def nextii = new IterationInfo(ii.metacollection,
+ ii.metamap,
+ ii.comment,
+ ii.level + 1,
+ childmetainfo.nextgatheredpath,
+ childmetainfo.nextgatheredmetapath,
+ ii.limiteddepth,
+ ii.maxdepth - 1)
+ def results = childmetainfo.childmeta.walkrelated(nextii)
+ ii.metacollection = results.metacollection
+ ii.metamap = results.metamap
+ ii.comment = results.comment
+ }
+ } else if (!relatedmetainfo.format || relatedmetainfo.format == '0.1') {
+ def MetaInfo othermeta = relatedmetainfo.meta
+ def String nextgatheredpath = (ii.gatheredpath == '' ? relatedmetainfo.offsetpath : "${ii.gatheredpath}/${relatedmetainfo.offsetpath}")
+ def String nextgatheredmetapath = (ii.gatheredmetapath == '' ? relatedmetainfo.offsetpath : "${ii.gatheredmetapath}/${relatedmetainfo.offsetpath}")
+ def nextii = new IterationInfo(ii.metacollection,
+ ii.metamap,
+ ii.comment,
+ ii.level + 1,
+ nextgatheredpath,
+ nextgatheredmetapath,
+ ii.limiteddepth,
+ ii.maxdepth - 1)
+ def results = othermeta.walkrelated_v0_1(nextii)
+ ii.metacollection = results.metacollection
+ ii.metamap = results.metamap
+ ii.comment = results.comment
+ }
+ }
+ }
+ return [ 'metacollection' : ii.metacollection, 'metamap' : ii.metamap, 'comment': ii.comment ]
+ }
+
+ // Walks all layers of associated data only
+ def allrelatedmeta(String metapath = '') {
+ def ArrayList metacollection = new ArrayList()
+ def Map metamap = new LinkedHashMap()
+ return walkrelated(new IterationInfo(metacollection, metamap, '', 0, '', metapath))
+ }
+
+ ArrayList releasewalker(int maxdepth, String startpath = '', String startmetapath = '') {
+ def ArrayList metacollection = new ArrayList()
+ def Map metamap = new LinkedHashMap()
+ def IterationInfo ii = new IterationInfo(metacollection, metamap, 'meta', 0, startpath, startmetapath, true, maxdepth)
+ script.echo("Release walker iteration info at start:\n${ii.show()}")
+ def results = walkrelated(ii)
+ return results.metacollection
+ }
+
+ // Walks 1 layer of associated data only
+ def getassociated(String rootpath) {
+ return releasewalker(2, '', "${rootpath}/${METAFOLDERNAME}") // Max depth 2 (including itself)
+ }
+
+ Map putwithshortestoffsetpath(Map releasemetacollection, String uniquestring, CollectedMeta metaitem) {
+ if (releasemetacollection.containsKey(uniquestring)) {
+ def existingentry = releasemetacollection[uniquestring]
+ def existingentrypathlength = existingentry.accumulatedpath.split('/').size()
+ def newentrypathlength = metaitem.accumulatedpath.split('/').size()
+ if (existingentrypathlength > newentrypathlength) {
+ releasemetacollection.put(uniquestring, metaitem)
+ }
+ } else {
+ releasemetacollection.put(uniquestring, metaitem)
+ }
+ return releasemetacollection
+ }
+
+ Map releasewalkerversionunique(int maxdepth, String startpath = '', String startmetapath = '') {
+ def ArrayList metacollection = releasewalker(maxdepth, startpath, "${startmetapath}/${METAFOLDERNAME}")
+
+ def Map versionuniquecollection = new LinkedHashMap()
+ for (metaitem in metacollection) {
+ def String uniquestring = metaitem.metainfo.componentversionuniqueidentifier()
+ versionuniquecollection = putwithshortestoffsetpath(versionuniquecollection, uniquestring, metaitem)
+ }
+
+ return versionuniquecollection
+ }
+
+ Map releasewalkerunique(int maxdepth, String startpath = '', String startmetapath = '') {
+ def ArrayList metacollection = releasewalker(maxdepth, startpath, "${startmetapath}/${METAFOLDERNAME}")
+
+ def Map uniquecollection = new LinkedHashMap()
+ for (metaitem in metacollection) {
+ def String uniquestring = metaitem.metainfo.componentidentifier()
+ uniquecollection = putwithshortestoffsetpath(uniquecollection, uniquestring, metaitem)
+ }
+
+ return uniquecollection
+ }
+
+ MetaInfo getNewMetaObject(script) {
+ return new MetaInfo(script)
+ }
+
+ def findAssociatedMeta(String parentmetapath, String productname, String subcomponentname) {
+ def results = [
+ 'matchedmetaitem' : new CollectedMeta(this),
+ 'matchfound' : false
+ ]
+ def walkresults = allrelatedmeta("${parentmetapath}/${METAFOLDERNAME}")
+ for (dependentmetaitem in walkresults.metacollection) {
+ script.echo("Comparing: ${dependentmetaitem.metainfo.productinfo.productname} ${dependentmetaitem.metainfo.productinfo.subcomponentname}")
+ if (dependentmetaitem.metainfo.productinfo.productname == productname &&
+ dependentmetaitem.metainfo.productinfo.subcomponentname == subcomponentname) {
+ script.echo("Found matching component: ${dependentmetaitem.metainfo.globalreleasetag()}")
+ results.matchedmetaitem = dependentmetaitem
+ results.matchfound = true
+ break
+ }
+ }
+ return results
+ }
+}
+
+MetaInfo metareset(script) {
+ def mi = new MetaInfo(script)
+
+ echo "Resetting meta folder"
+ 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..9f2f4d3
--- /dev/null
+++ b/Common_scripts/packaging/debian.groovy
@@ -0,0 +1,111 @@
+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_KERNEL
+ String GIS_OPT_LOGIC
+ String GIS_OPT_PRINTHEAD
+ String GIS_OPT_BOOT
+
+ 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, String inpackagepathsuffix) {
+ 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" + inpackagepathsuffix
+ GIS_OPT_BIN = "${DEBPATH}/opt/gis/bin" + inpackagepathsuffix
+ GIS_OPT_LIB = "${DEBPATH}/opt/gis/lib" + inpackagepathsuffix
+ GIS_OPT_SCRIPTS_APP = "${DEBPATH}/opt/gis/scripts/app" + inpackagepathsuffix
+ GIS_OPT_SCRIPTS_EL = "${DEBPATH}/opt/gis/scripts/el" + inpackagepathsuffix
+ GIS_OPT_SCRIPTS_CONTROL = "${DEBPATH}/opt/gis/scripts/control" + inpackagepathsuffix
+ GIS_OPT_WWW = "${DEBPATH}/opt/gis/www" + inpackagepathsuffix
+ GIS_OPT_OTHER = "${DEBPATH}/opt/gis/other" + inpackagepathsuffix
+ GIS_OPT_KERNEL = "${DEBPATH}/opt/gis/kernel" + inpackagepathsuffix
+ GIS_OPT_LOGIC = "${DEBPATH}/opt/gis/logic" + inpackagepathsuffix
+ GIS_OPT_PRINTHEAD = "${DEBPATH}/opt/gis/printhead" + inpackagepathsuffix
+ GIS_OPT_BOOT = "${DEBPATH}/opt/gis/boot" + inpackagepathsuffix
+
+ USR_BIN = "${DEBPATH}/usr/bin" + inpackagepathsuffix
+ USR_LIB_ARCH = "${DEBPATH}/usr/lib/arm-linux-gnueabihf" + inpackagepathsuffix
+ LIB_FIRMWARE = "${DEBPATH}/lib/firmware" + inpackagepathsuffix
+ HTTP_DEV_DIV = "${DEBPATH}/var/www/gis_dev" + inpackagepathsuffix
+ LIB_SYSTEMD = "${DEBPATH}/lib/systemd" + inpackagepathsuffix
+ }
+}
+
+def DebRootDefinition debDefinition(String rootpath, String packagesourceroot, String packageprefix, String buildstamp, String inpackagepathsuffix = '') {
+ return new DebRootDefinition(rootpath, packagesourceroot, packageprefix, buildstamp, inpackagepathsuffix)
+}
+
+def buildPackage(String packageout, String uniquepackageout, DebRootDefinition packagedefs, String credentials_id) {
+ withCredentials([usernamePassword(credentialsId: credentials_id,
+ usernameVariable: 'SUDO_USERNAME',
+ passwordVariable: 'SUDO_PASSWORD')]) {
+ def sudo_S = "echo ${SUDO_PASSWORD} | sudo -S"
+ def sudo_Sk = "echo ${SUDO_PASSWORD} | sudo -S -k"
+ try {
+ sh """#!/bin/bash
+ # Exit if any command fails
+ set -xe
+
+ cp -v -r "${packagedefs.PACKAGE_SOURCE_ROOT}/${packagedefs.PACKAGE_SOURCE_FOLDER_NAME}"/* "${packagedefs.DEBPATH}"
+
+ ${sudo_Sk} 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_Sk} chown -R ${USER}: "${packagedefs.DEBPATH}"
+ """
+ }
+ catch (Exception e) {
+ echo "Exception occurred"
+ sh """#!/bin/bash -v
+ ${sudo_Sk} 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..ea090f0
--- /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.metainfo
+ 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.metainfo
+ 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 releasemetapath, 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, '', releasemetapath)
+
+ 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 releasemetapath, String customer, String softwarerelease, String maxdepth) {
+ return publishhierarchy(hostedftpsiteinfo, releasemeta, releasemetapath, '', 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..68c41f3
--- /dev/null
+++ b/Common_scripts/publish/package.groovy
@@ -0,0 +1,181 @@
+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")
+
+ def packageimportoptions = importer.getNewImportOptions()
+ packageimportoptions.jenkinsjob(PACKAGE_CREATE_JOB, PACKAGE_CREATE_JOB_SELECTOR)
+ packageimportoptions.setincrementversionnumber(true)
+ packagemeta = importer.artifactimport(meta, packageimportoptions, 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..ce6a805
--- /dev/null
+++ b/Common_scripts/publish/promptingpublish.groovy
@@ -0,0 +1,182 @@
+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("superseded") &&
+ !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,
+ SOURCEDIR,
+ 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, SOURCEDIR, selecteditems, customer, release, MAX_META_DEPTH)
+ if (markunstable) {
+ env.unstablereason = unstablereason
+ currentBuild.result = 'UNSTABLE'
+ }
+ }
+ }
+ }
+ stage('Archiving artifacts') {
+ steps {
+ script {
+ def artifactlist = meta.generateartifacts()
+ artifactarchiver = load("${autobuilder.commonscripts()}/artifacts/archiver.groovy")
+ artifactarchiver.archive("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..ad33df9
--- /dev/null
+++ b/Common_scripts/publish/publish.groovy
@@ -0,0 +1,92 @@
+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()
+ artifactarchiver = load("${autobuilder.commonscripts()}/artifacts/archiver.groovy")
+ artifactarchiver.archive("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..9f6c368
--- /dev/null
+++ b/Common_scripts/publish/publishitems.groovy
@@ -0,0 +1,129 @@
+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 releasemetapath,
+ 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, '', releasemetapath)
+ 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.metainfo
+
+ for (publishableitem in meta.publishableinfo) {
+ menuitems.add("${meta.productinfo.productname} ${meta.productinfo.subcomponentname} ${publishableitem.filepath}")
+ }
+ }
+
+ def outputSelection(menuitems, releaseinfo) {
+ def meta = releaseinfo.metainfo
+
+ 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 releasemetapath,
+ 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, releasemetapath, 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..4dcb091
--- /dev/null
+++ b/Common_scripts/release/do.groovy
@@ -0,0 +1,458 @@
+gh = load("${autobuilder.commonscripts()}/versioncontrol/git.groovy")
+
+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.metainfo.releaseinfo.releaseitems) {
+ def filterpath = artifactfilter
+ if (buildinfo.accumulatedpath) {
+ filterpath = buildinfo.accumulatedpath + '/' + artifactfilter
+ }
+ // Copy relevant artifacts to temp folder
+ echo "Copying artifacts: Filter path: ${filterpath} to ${tempfolder} from job: ${toplevelbuildmeta.jenkinsbuildinfo.buildjobname} #${toplevelbuildmeta.jenkinsbuildinfo.buildnumber}"
+ 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.accumulatedpath
+ dir(originalrootdir) {
+ sh("mv -v * ${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)) {
+ echo "Tag added: ${tag} with sha: ${postcommitshacode}"
+ 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.metainfo
+ def uriconverted = gh.uniquereporootname(buildmeta.gitinfo.remoteurl)
+ def String uniquefolder = "${buildmeta.productinfo.productname}_${buildmeta.productinfo.subcomponentname}_${uriconverted}"
+ 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(String buildfolder, String metafolder, 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, buildfolder, metafolder)
+ 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, buildfolder, metafolder)
+ def String versionuniquecomponent = ''
+ def String versionwithpathscomponent = ''
+ for (key in componentReleaseInfoVersionUnique.keySet()) {
+ versionuniquecomponent += "${key}\n"
+ versionwithpathscomponent += "${key}: path: ${componentReleaseInfoVersionUnique[key].accumulatedpath} meta path: ${componentReleaseInfoVersionUnique[key].accumulatedmetapath}\n"
+ }
+ echo 'Version unique components:'
+ echo versionuniquecomponent
+
+ echo 'Version unique components with paths:'
+ echo versionwithpathscomponent
+
+ 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? (If you ignore this issue, you will get an error much later because the system cannot tag 2 different commits of the associated source code with the same label)"
+ }
+ }
+
+ for (key in componentReleaseInfo.keySet()) {
+ def buildinfo = componentReleaseInfo[key]
+ if (!buildinfo.metainfo.jenkinsbuildinfo.isFullBuild()) {
+ error "The subcomponent: ${buildinfo.componentidentifier()} is not a full build (Some artifacts are missing)"
+ }
+ }
+
+ def toplevelid = buildmeta.componentidentifier()
+ // For each component
+ for (key in componentReleaseInfo.keySet()) {
+ def buildinfo = componentReleaseInfo[key]
+ echo "Releasing component: ${buildinfo.metainfo.componentidentifier()}"
+ if (buildinfo.metainfo.componentidentifier() != '___' && buildinfo.metainfo.componentidentifier() != '_') {
+ 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..82af511
--- /dev/null
+++ b/Common_scripts/release/release.groovy
@@ -0,0 +1,87 @@
+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 {
+ importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
+
+ BUILD_ARTIFACTS = 'build'
+
+ def importoptions = importer.getNewImportOptions()
+ importoptions.jenkinsjob(BUILD_JOB, BUILD_JOB_SELECTOR)
+ importoptions.setincrementversionnumber(false)
+ importoptions.setfilter('meta/**')
+ importoptions.setappendtoparentmeta(false)
+ buildmeta = importer.artifactimport(meta, importoptions, 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('', BUILD_ARTIFACTS, 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()
+ artifactarchiver = load("${autobuilder.commonscripts()}/artifacts/archiver.groovy")
+ artifactarchiver.archive("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..ae91cb0
--- /dev/null
+++ b/Common_scripts/staticanalysis/ccm.groovy
@@ -0,0 +1,85 @@
+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()
+
+ 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 {
+ SOURCEDIR = "${WORKSPACE}/source"
+ configurationhelper.gitCheckoutAndRegister(meta, 'source', SOURCEURL, SOURCE_REVISION, SOURCEDIR, '', 0, false)
+ }
+ }
+ }
+ stage("Clean exports") {
+ steps {
+ script {
+ RESULTS = 'results'
+ cleanfolders = [
+ RESULTS,
+ ]
+ cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
+ cleaner.clean(cleanfolders)
+ }
+ }
+ }
+ stage('Static analysis') {
+ steps {
+ script {
+ def ccmconfigurationfile = "${WORKSPACE}/ccm.xml"
+ writeFile(file: ccmconfigurationfile, text: CCM_CONFIGURATION)
+ echo "Configuration file: ${ccmconfigurationfile} contains:\n${CCM_CONFIGURATION}"
+
+ dir(RESULTS) {
+ echo "Executing: ${CCM} ${ccmconfigurationfile} > ccm.xml"
+ if (isUnix()) {
+ sh """#!/bin/bash
+ ${CCM}" "${ccmconfigurationfile}" > ccm.xml
+ """
+ } else {
+ echo "Executing: ${WINDOWS_COMMANDLINE_ENVIRONMENT} \"${CCM}\" \"${ccmconfigurationfile}\" > ccm.xml"
+ bat """
+ ${WINDOWS_COMMANDLINE_ENVIRONMENT} "${CCM}" "${ccmconfigurationfile}" > ccm.xml
+ """
+ }
+ }
+ recordIssues(tools: [
+ ccm(pattern: "**/ccm.xml", reportEncoding: 'UTF-8'),
+ ])
+ }
+ }
+ }
+ }
+ 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..c04649c
--- /dev/null
+++ b/Common_scripts/staticanalysis/cpd.groovy
@@ -0,0 +1,152 @@
+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)
+ artifactarchiver = load("${autobuilder.commonscripts()}/artifacts/archiver.groovy")
+ artifactarchiver.archive(meta, 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..d959770
--- /dev/null
+++ b/Common_scripts/staticanalysis/cppcheck.groovy
@@ -0,0 +1,114 @@
+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)
+ artifactarchiver = load("${autobuilder.commonscripts()}/artifacts/archiver.groovy")
+ artifactarchiver.archive(meta, artifactlist)
+ }
+ }
+ }
+ }
+ post {
+ always {
+ echo 'Post-build'
+ }
+ failure {
+ echo 'Failed build'
+ }
+ unstable {
+ echo 'Unstable build'
+ }
+ success {
+ echo 'Succeeded build'
+ }
+ }
+}
diff --git a/Common_scripts/test/testethernetproduct.groovy b/Common_scripts/test/testethernetproduct.groovy
new file mode 100644
index 0000000..5e2ce53
--- /dev/null
+++ b/Common_scripts/test/testethernetproduct.groovy
@@ -0,0 +1,204 @@
+import jenkins.model.Jenkins
+
+pipeline {
+ agent { label AGENT_LABEL }
+ stages {
+ stage ("Initial Setup") {
+ steps{
+ script {
+ meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
+ }
+ }
+ }
+ stage ("Checkout test environment") {
+ steps {
+ script {
+ toolsimporter = load("${autobuilder.commonscripts()}/configuration/tools.groovy")
+
+ def TEST_ENVIRONMENT_URL = 'git@hydra:gistest/jenkins-ethernet-test-environment.git'
+ def TEST_ENVIRONMENT_DIR = 'TestEnvironmentDir'
+ def TEST_ENVIRONMENT_REVISION = 'origin/master'
+
+ def environmentoptions = toolsimporter.getNewToolOptions()
+ environmentoptions.toolName('Ethernet product test environment')
+ environmentoptions.toolRepo(TEST_ENVIRONMENT_URL, TEST_SOURCE_REVISION)
+ toolsimporter.getTool(meta, environmentoptions, TEST_ENVIRONMENT_DIR)
+
+ TEST_ENVIRONMENT_FILE = "${TEST_ENVIRONMENT_DIR}/environment.json"
+ def alltestenvironment = readJSON(file: "${TEST_ENVIRONMENT_FILE}")
+ TEST_ENVIRONMENT = alltestenvironment[ETHERNET_PRODUCT_TO_RUN_TEST]
+ echo "Selected environment:\n${TEST_ENVIRONMENT}"
+ }
+ }
+ }
+ stage ('Setup') {
+ agent { label TEST_ENVIRONMENT['FTDI_AGENT'] }
+ stages {
+ stage ("Checkout dependencies") {
+ steps {
+ script {
+ def PYTHON_URL = 'git@hydra:tools/python.git'
+ if (isUnix()) {
+ PYTHON_REVISION = 'origin/3.6.3_linux'
+ }
+ else {
+ PYTHON_REVISION = 'origin/3.8.10_windows_for_test'
+ }
+ PYTHONDIR = "${WORKSPACE}/python"
+
+ def pythonimportoptions = toolsimporter.getNewToolOptions()
+ pythonimportoptions.toolName('Python')
+ pythonimportoptions.toolRepo(PYTHON_URL, PYTHON_REVISION)
+ toolsimporter.getTool(meta, pythonimportoptions, PYTHONDIR)
+ if (isUnix()) {
+ env.PYTHON = "${PYTHONDIR}/usr/local/bin/python3"
+ }
+ else {
+ env.PYTHON = "${PYTHONDIR}/ver/python.exe"
+ }
+
+ def TEST_SOURCE_URL = 'git@hydra:hmb_regression/hmb_tests.git'
+ TEST_SUITE_DIR = 'TestSuiteDir'
+ env.GIS_TEST_SUITE_HOME = "${WORKSPACE}/${TEST_SUITE_DIR}"
+
+ def regressiontestimportoptions = toolsimporter.getNewToolOptions()
+ regressiontestimportoptions.toolName('Tests')
+ regressiontestimportoptions.toolRepo(TEST_SOURCE_URL, TEST_SOURCE_REVISION)
+ toolsimporter.getTool(meta, regressiontestimportoptions, GIS_TEST_SUITE_HOME)
+
+ env.HISTORY_FOLDER = "${WORKSPACE}/testhistory"
+
+ def resultimportoptions = toolsimporter.getNewToolOptions()
+ resultimportoptions.toolName('Test history')
+ resultimportoptions.toolRepo(HISTORY_REPO, HISTORY_REVISION)
+ toolsimporter.getTool(meta, resultimportoptions, HISTORY_FOLDER)
+
+ def CORE_SOURCE_URL = 'git@hydra:gistest/giscorelite.git'
+ env.GIS_TEST_SUITE_CORE = "${WORKSPACE}/GisCore"
+
+ def coreimportoptions = toolsimporter.getNewToolOptions()
+ coreimportoptions.toolName('Test core')
+ coreimportoptions.toolRepo(CORE_SOURCE_URL, CORE_SOURCE_REVISION)
+ toolsimporter.getTool(meta, coreimportoptions, GIS_TEST_SUITE_CORE)
+
+ def FTDI_SOURCE_URL = 'git@hydra:python_scripts/ftdi_relay.git'
+ def FTDI_SOURCE_REVISION = 'origin/Core-98'
+ FTDI_SOURCE_DIR = "${WORKSPACE}/PowerController"
+
+ def ftdiimportoptions = toolsimporter.getNewToolOptions()
+ ftdiimportoptions.toolName('FTDI relay driver')
+ ftdiimportoptions.toolRepo(FTDI_SOURCE_URL, FTDI_SOURCE_REVISION)
+ toolsimporter.getTool(meta, ftdiimportoptions, FTDI_SOURCE_DIR)
+
+ def HISTORY_PROCESSING_REPO = 'git@hydra:gistestresults/ethernet-products-history-processing.git'
+ HISTORY_PROCESSING_DIR = "${WORKSPACE}/HistoryProcessing"
+
+ def resultprocessingoptions = toolsimporter.getNewToolOptions()
+ resultprocessingoptions.toolName('History processing')
+ resultprocessingoptions.toolRepo(HISTORY_PROCESSING_REPO, HISTORY_PROCESSING_REVISION)
+ toolsimporter.getTool(meta, resultprocessingoptions, HISTORY_PROCESSING_DIR)
+ }
+ }
+ }
+ stage ("Import application to test") {
+ steps {
+ script {
+ importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
+
+ APPLICATION_UNDER_TEST = 'application_under_test'
+ env.APPLICATION_ARTIFACT_FOLDER = "${WORKSPACE}/${APPLICATION_UNDER_TEST}"
+
+ def applicationimportoptions = importer.getNewImportOptions()
+ applicationimportoptions.jenkinsjob(APPLICATION_ARTIFACT_PROJECT, APPLICATION_ARTIFACT_SELECTOR)
+ applicationimportoptions.setfilter('app_package/**,control_package/**')
+ applicationmeta = importer.artifactimport(meta, applicationimportoptions, APPLICATION_ARTIFACT_FOLDER)
+
+ meta.productinfo.set(applicationmeta.productinfo)
+ meta.productinfo.subcomponentname = "${applicationmeta.productinfo.subcomponentname}_TEST"
+ meta.gitinfo.set(applicationmeta.gitinfo)
+ meta.buildstampinfo.set(applicationmeta.buildstampinfo)
+ }
+ }
+ }
+ stage("Clean") {
+ steps {
+ script {
+ LOGGING_ROOT = 'Logging'
+ env.GIS_TEST_OUTPUT_LOGGING_ROOT = "${WORKSPACE}/${LOGGING_ROOT}"
+ cleanfolders = [
+ GIS_TEST_OUTPUT_LOGGING_ROOT,
+ ]
+ cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
+ cleaner.clean(cleanfolders)
+ }
+ }
+ }
+ stage ('Test') {
+ steps {
+ script {
+ lock(TEST_ENVIRONMENT['RESOURCE_LOCK']) {
+ if (POWER_CYCLE_HARDWARE == 'true') {
+ dir(FTDI_SOURCE_DIR) {
+ bat """
+ "${PYTHON}" "${FTDI_SOURCE_DIR}/RegressionPower.py" -d ${TEST_ENVIRONMENT['FTDI_RELAY_DEVICE']} -o True
+ """
+ }
+ }
+ if (UPDATE_HARDWARE == 'true') {
+ dir(GIS_TEST_SUITE_CORE) {
+ bat """
+ "${PYTHON}" "${GIS_TEST_SUITE_CORE}/HMBCommon/hmbPackageDeployer.py" -p "${APPLICATION_ARTIFACT_FOLDER}" -t "${TEST_ENVIRONMENT['IP_ADDRESS']}"
+ """
+ rc = bat (script:"""
+ "${PYTHON}" "${GIS_TEST_SUITE_CORE}/HMBCommon/hmbinspectstate.py"
+ """,
+ returnStatus: true)
+ if (rc == 1) {
+ unstable('FAILED while inspecting state of hardware')
+ }
+ }
+ }
+ if (DO_TEST == 'true') {
+ rc = bat(script:"""
+ ${PYTHON} "${GIS_TEST_SUITE_CORE}/GISTestMaster.py" -w ${PRODUCT_LOCATION_UNDER_TEST} -fl --include ${TEST_INCLUDE_FILTER}
+ """,
+ returnStatus: true
+ )
+ if (rc == 1) {
+ unstable('FAILED while running tests')
+ }
+ }
+ }
+ }
+ }
+ }
+ stage("Archive Test History") {
+ steps{
+ script {
+ dir(HISTORY_FOLDER) {
+ rc = bat (script:"""
+ "${PYTHON}" "${HISTORY_PROCESSING_DIR}/GitCyclicPush.py"
+ """,
+ returnStatus: true
+ )
+ if (rc == 1) {
+ unstable('FAILED to process history')
+ }
+ }
+ }
+ }
+ }
+ stage("Archive test artifacts"){
+ steps{
+ script {
+ def artifactlist = meta.generateartifacts([ "${LOGGING_ROOT}/**"])
+ artifactarchiver = load("${autobuilder.commonscripts()}/artifacts/archiver.groovy")
+ artifactarchiver.archive(meta, artifactlist)
+ }
+ }
+ }
+ }
+ }
+ }
+}
+
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..a22054b
--- /dev/null
+++ b/Common_scripts/versioncontrol/git.groovy
@@ -0,0 +1,377 @@
+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 = powershell(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 {
+ powershell """
+ git status
+ if (\$lastexitcode -ge 1) { exit 1 }
+ """
+ }
+ }
+*/
+ }
+ }
+ return reporootsubfolder
+}
+
+def checkgitlfsinstall() {
+ if (isUnix()) {
+ sh """
+ git lfs install
+ if [ \$? -ne 0 ]; then exit 1; fi
+ """
+
+ } else {
+ powershell """
+ git lfs install
+ if (\$lastexitcode -ge 1) { exit 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) {
+ echo "Git: Checking out: URL: ${gitURL} Revision: ${revision} to: ${targetDir}"
+ checkout([
+ $class: 'GitSCM',
+ userRemoteConfigs: [
+ [url: gitURL]
+ ],
+ branches: [
+ [name: revision]
+ ],
+ 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)],
+ [$class: 'PruneStaleBranch'],
+ ],
+ 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 {
+ powershell """
+ 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 {
+ powershell """
+ 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 {
+ powershell """
+ git rm -rf . > \$null
+ git clean -fxd > \$null
+ git reset --hard > \$null
+ """
+ }
+ }
+ }
+
+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 = powershell( 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..208a60f
--- /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 {
+ powershell """
+ & "${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..5e974e2
--- /dev/null
+++ b/Common_scripts/versionnumbering/generate.groovy
@@ -0,0 +1,180 @@
+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 = powershell(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 = powershell(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 = powershell(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 = powershell(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) {
+ if (integerstring.length() > 6) {
+ integerstring = integerstring.substring(0, 5)
+ }
+ 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 pregenerated(meta, String sourcerevision, String sourcepath, String pregeneratedbuildstamp, int basebuildnumber = 1000) {
+ generate(meta, sourcerevision, sourcepath, basebuildnumber)
+ meta.buildstampinfo.override(pregeneratedbuildstamp)
+
+ return pregeneratedbuildstamp
+}
+
+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) {
+ // Deep copy
+ meta.gitinfo.set(othermeta.gitinfo.sourcepath, othermeta.gitinfo.sourcerevision, othermeta.gitinfo.gitrevision, othermeta.gitinfo.remoteurl, othermeta.gitinfo.remoteinfo)
+ meta.buildstampinfo.set(othermeta.buildstampinfo.buildstampprefix, othermeta.buildstampinfo.revision, othermeta.buildstampinfo.buildstamp)
+
+ 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..9243aa4
--- /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 instances 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:]))