Merge commit '1f97532cc26f80aa6f7609823ad0f8702bbec0dc' as 'Common_scripts'

This commit is contained in:
Dan Hawkins 2020-12-17 13:14:07 +00:00
commit f59ce1be89
87 changed files with 5965 additions and 4552 deletions

17
.project Normal file
View file

@ -0,0 +1,17 @@
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
<name>Common Build Scripts</name>
<comment></comment>
<projects>
</projects>
<buildSpec>
<buildCommand>
<name>org.python.pydev.PyDevBuilder</name>
<arguments>
</arguments>
</buildCommand>
</buildSpec>
<natures>
<nature>org.python.pydev.pythonNature</nature>
</natures>
</projectDescription>

8
.pydevproject Normal file
View file

@ -0,0 +1,8 @@
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<?eclipse-pydev version="1.0"?><pydev_project>
<pydev_pathproperty name="org.python.pydev.PROJECT_SOURCE_PATH">
<path>/${PROJECT_DIR_NAME}</path>
</pydev_pathproperty>
<pydev_property name="org.python.pydev.PYTHON_PROJECT_VERSION">python 2.7</pydev_property>
<pydev_property name="org.python.pydev.PYTHON_PROJECT_INTERPRETER">python35</pydev_property>
</pydev_project>

View file

@ -0,0 +1,2 @@
eclipse.preferences.version=1
encoding//versionnumbering/versioninfo.py=utf-8

View file

@ -1,3 +0,0 @@
# Atlas_Custom_Modules_autobuild_scripts
Autobuild scripts for Atlas Custom Modules

View file

@ -0,0 +1,22 @@
// Take a list of Sub-job descriptors and output folder pairs, copy the artifacts, while filling in a string of artifact folders
def combineSubjobArtifacts(meta, importer, subJobs) {
def ArrayList<String> artifactFolders = new ArrayList<String>()
for (subJob in subJobs) {
def subJobObject = subJob[0]
if (subJobObject != null) {
def subJobName = subJobObject.getProjectName()
def subJobNumber = subJobObject.getNumber()
def destFolder = subJob[1]
def boolean incrementversionnumber = subJob[2]
dir(destFolder) {
deleteDir()
}
importer.artifactimport(meta, subJobName, subJobNumber, destFolder, incrementversionnumber)
artifactFolders.add("${destFolder}/**")
}
}
return artifactFolders
}
return this;

109
autobuilder.groovy Normal file
View file

@ -0,0 +1,109 @@
// 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
}
// Start up boilderplate
def startbuild(script, String productname = PRODUCT_NAME, String subcomponentname = SUBCOMPONENT_NAME, String releaserepo = RELEASE_REPO, String releaserepovariantsuffix = '', String autobuildpath = autobuildroot, String commonscriptspath = commonscriptsroot) {
echo "Starting...."
autobuildroot = autobuildpath
commonscriptsroot = commonscriptspath
metafolderscript = load("${commonscripts()}/meta/folder.groovy")
conditionalclean()
def meta = getmetafolderscript().metareset(script)
echo "Product name: ${productname} Subcomponent name: ${subcomponentname}"
meta.productinfo.set(productname, subcomponentname)
def now = new Date()
now.format("yyMMdd.HHmm", TimeZone.getTimeZone('UTC'))
meta.jenkinsbuildinfo.set(JOB_NAME, BUILD_ID.toInteger(), NODE_NAME, now.toString())
def rr = load("${commonscripts()}/release/registerrepo.groovy")
def String alteredreleaserepo = alterreleaserepo(releaserepo, releaserepovariantsuffix)
echo "Release repo: ${alteredreleaserepo}"
rr.registerrepo(meta, alteredreleaserepo)
def ch = load("${commonscripts()}/configuration/configuration.groovy")
ch.registerPipelineScriptConfiguration(meta)
return meta
}
def start(script, String productname = PRODUCT_NAME, String subcomponentname = SUBCOMPONENT_NAME, String jirakey = JIRA_KEY, String releaserepo = RELEASE_REPO, String repoRootSuffix = "", String autobuildpath = autobuildroot, String commonscriptspath = commonscriptsroot) {
echo "DEPRECATED method: start(script, String productname = PRODUCT_NAME, subcomponentname = SUBCOMPONENT_NAME, jirakey = JIRA_KEY, ...)"
return startbuild(script, productname, subcomponentname, releaserepo, autobuildpath, commonscriptspath)
}
// Start up boilderplate
def startnonbuild(script, autobuildpath = autobuildroot, commonscriptspath = commonscriptsroot) {
echo "Starting non-build job...."
autobuildroot = autobuildpath
commonscriptsroot = commonscriptspath
metafolderscript = load("${commonscripts()}/meta/folder.groovy")
conditionalclean()
def meta = getmetafolderscript().metareset(script)
meta.productinfo.set("Non-build-product", "Non-build-subcomponent")
def now = new Date()
now.format("yyMMdd.HHmm", TimeZone.getTimeZone('UTC'))
meta.jenkinsbuildinfo.set(JOB_NAME, BUILD_ID.toInteger(), NODE_NAME, now.toString())
def ch = load("${commonscripts()}/configuration/configuration.groovy")
ch.registerPipelineScriptConfiguration(meta)
return meta
}
def configurationhelper() {
return load("${commonscripts()}/configuration/configuration.groovy")
}
// Everyone wants to know this
autobuilder = this
return this;

View file

@ -1,130 +0,0 @@
pipeline {
agent { label "${AGENT_LABEL}" }
stages {
stage('Initial setup') {
steps {
script {
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startbuild(this, PRODUCT_NAME, SUBCOMPONENT_NAME, RELEASE_REPO)
}
}
}
stage('Checkout dependencies') {
steps {
script {
configurationhelper = autobuilder.configurationhelper()
SOURCEURL = 'git@hydra:atlas-ui-modules/custom-modules.git'
SOURCEREVISION = SOURCE_REVISION
SOURCEDIR = "${WORKSPACE}\\custom_modules"
configurationhelper.gitCheckoutAndRegister(meta, 'custom_modules', SOURCEURL, SOURCEREVISION, SOURCEDIR, '', 0, false)
}
}
}
stage('Generating version info') {
steps {
script {
version = load("${autobuilder.commonscripts()}/versionnumbering/generate.groovy")
version.generate(meta, SOURCEREVISION, SOURCEDIR)
}
}
}
stage('Compile') {
steps {
script {
modules_compile_job = build job: CUSTOM_MODULES_COMPILE_JOB,
parameters: [
string(name: 'SOURCE_REVISION', value: SOURCEREVISION),
string(name: 'ATLAS_UI_ARTIFACT_LOCATION', value: ATLAS_UI_ARTIFACT_LOCATION),
string(name: 'ATLAS_UI_COMPILE_JOB', value: ATLAS_UI_COMPILE_JOB),
string(name: 'ATLAS_UI_BUILD_SELECTOR', value: ATLAS_UI_BUILD_SELECTOR),
string(name: 'ATLAS_UI_RELEASE_REPO', value: ATLAS_UI_RELEASE_REPO),
string(name: 'ATLAS_UI_RELEASE_REVISION', value: ATLAS_UI_RELEASE_REVISION),
string(name: 'ATLAS_SERVICES_ARTIFACT_LOCATION', value: ATLAS_SERVICES_ARTIFACT_LOCATION),
string(name: 'ATLAS_SERVICES_COMPILE_JOB', value: ATLAS_SERVICES_COMPILE_JOB),
string(name: 'ATLAS_SERVICES_BUILD_SELECTOR', value: ATLAS_SERVICES_BUILD_SELECTOR),
string(name: 'ATLAS_SERVICES_RELEASE_REPO', value: ATLAS_SERVICES_RELEASE_REPO),
string(name: 'ATLAS_SERVICES_RELEASE_REVISION', value: ATLAS_SERVICES_RELEASE_REVISION),
booleanParam(name: 'CLEAN_WORKSPACE', value: CLEAN_WORKSPACE),
]
}
}
}
stage('Second stage') {
failFast true
parallel {
stage('Build Ink UI installers') {
steps {
script {
modules_installer_job = build job: CUSTOM_MODULES_INSTALLER_BUILD_JOB
parameters: [
string(name: 'SOURCE_REVISION', value: SOURCEREVISION),
string(name: 'ATLAS_CUSTOM_MODULES_COMPILE_JOB', value: modules_compile_job.getProjectName()),
string(name: 'ATLAS_CUSTOM_MODULES_COMPILE_JOB_SELECTOR', value: "<SpecificBuildSelector plugin='copyartifact@1.41'> <buildNumber>${modules_compile_job.getNumber()}</buildNumber></SpecificBuildSelector>"),
booleanParam(name: 'CLEAN_WORKSPACE', value: CLEAN_WORKSPACE),
]
}
}
}
stage('Release Documentation') {
steps {
script {
release_notes_job = build job: RELEASE_NOTES_JOB,
parameters: [
string(name: 'SOURCE_REVISION', value: SOURCEREVISION),
booleanParam(name: 'CLEAN_WORKSPACE', value: CLEAN_WORKSPACE),
]
}
}
}
}
}
stage('Accumulate artifacts') {
steps {
script {
artifacthelper = load("${autobuilder.commonscripts()}/artifacts/metaexport.groovy")
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
subJobs = [
// Sub-job variable, Artifact folder Increment Version Number
[ modules_compile_job, "module_binaries", false, ],
[ modules_installer_job, "module_installers", false, ],
[ release_notes_job, "release_notes", false, ],
]
artifactFolders = artifacthelper.combineSubjobArtifacts(meta, importer, subJobs)
}
}
}
stage('Classifying publishable artifacts') {
steps {
script {
def publishable = [
'meta/**',
]
def publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
publishutils.generatelist(meta, publishable)
}
}
}
stage('Archiving artifacts') {
steps {
script {
def artifactlist = meta.generateartifacts([], artifactFolders)
archiveArtifacts "${artifactlist}"
}
}
}
}
post {
always {
echo 'Post-build'
}
failure {
echo 'Failed build'
}
unstable {
echo 'Unstable build'
}
success {
echo 'Succeeded build'
}
}
}

86
check/build_meta.groovy Normal file
View file

@ -0,0 +1,86 @@
pipeline {
agent { label "${AGENT_LABEL}" }
stages {
stage('Initial setup') {
steps {
script {
autobuilderscript = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy")
meta = autobuilderscript.startnonbuild(this)
}
}
}
stage('Clean exports') {
steps {
script {
cleanfolders = [
"${WORKSPACE}/build_artifacts",
]
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
cleaner.clean(cleanfolders)
}
}
}
stage('Get build artifact meta') {
steps {
script {
BUILD_ARTIFACTS = "${WORKSPACE}/build_artifacts"
copyArtifacts(
projectName: BUILD_JOB,
selector: [
$class: 'ParameterizedBuildSelector',
parameterName: BUILD_JOB_SELECTOR
],
target: BUILD_ARTIFACTS
)
def mfs = autobuilderscript.getmetafolderscript()
buildmeta = mfs.metafromfolder(BUILD_ARTIFACTS)
}
}
}
stage('Check components') {
steps {
script {
def checker = load("${autobuilder.commonscripts()}/check/do_meta.groovy")
(summarystring, markunstable, unstablereason) = checker.checkhierarchy(buildmeta, MAX_META_DEPTH, BUILD_ARTIFACTS)
if (markunstable) {
env.unstablereason = unstablereason
currentBuild.result = 'UNSTABLE'
}
}
}
}
stage('Archiving artifacts') {
steps {
script {
def artifactlist = meta.generateartifacts()
archiveArtifacts "summary/**,${artifactlist}"
}
}
}
stage('Summarise') {
steps {
script {
echo "Summary:\n${summarystring}\n"
if (env.unstablereason) {
echo "Instability reason: ${env.unstablereason}"
}
}
}
}
}
post {
always {
echo 'Post-build'
}
failure {
echo 'Failed build'
}
unstable {
echo 'Unstable build'
}
success {
echo 'Succeeded build'
}
}
}

77
check/do_meta.groovy Normal file
View file

@ -0,0 +1,77 @@
markunstable = false
unstablereason = ""
summaryfolder = "${WORKSPACE}/summary"
summaryfile = "${summaryfolder}/summary.txt"
summarystring = ""
releaserepofolder = "${WORKSPACE}/releaserepos"
sourcerepofolder = "${WORKSPACE}/sourcerepos"
tempfolder = "${WORKSPACE}/temp"
gitrevparseoutputfile = "${tempfolder}/gitrevparse.out"
metascript = autobuilder.getmetafolderscript()
def resetfolders() {
dir(summaryfolder) {
deleteDir()
}
dir(releaserepofolder) {
deleteDir()
}
dir(tempfolder) {
deleteDir()
}
}
def preconditions() {
markunstable = false
unstablereason = ""
summarystring = ""
writeFile(file: summaryfile, text: "Release summary: \n")
}
def setunstable(String reason) {
markunstable = true
unstablereason += reason + "\n"
echo "Marked build as unstable: Reason: ${reason}"
}
def summaryappend(String summary) {
def String currentsummarycontents = readFile(file: summaryfile)
writeFile(file: summaryfile, text: currentsummarycontents + summary)
summarystring += summary
}
def checkhierarchy(buildmeta, String maxdepth, String buildpathroot) {
int md = maxdepth.toInteger()
resetfolders()
preconditions()
// Walk the meta information to a max depth
def buildinfo = buildmeta.releasewalker(md)
echo "All components:"
def String componentinfo = ""
for (entry in buildinfo) {
def name = entry.meta.componentversionuniqueidentifier()
def offsetpath = entry.offsetpath
def abspath = "${buildpathroot}/${offsetpath}"
componentinfo += "Name: ${name} \t\t\t\tPath: ${offsetpath} \t\t\t\tFile exists in import: ${fileExists(abspath)}\n"
}
echo componentinfo
// Walk the meta information to a max depth
def componentReleaseInfo = buildmeta.releasewalkerunique(md)
echo "Unique components:"
def String versioncomponent = ""
for (key in componentReleaseInfo.keySet()) {
def buildinfo2 = componentReleaseInfo[key]
def offsetpath = buildinfo2.offsetpath
def abspath = "${buildpathroot}/${offsetpath}"
versioncomponent += "Key: ${key} \t\t\tPath: ${offsetpath} \t\t\tFile exists in import: ${fileExists(abspath)}\n"
}
echo versioncomponent
return [summarystring, markunstable, unstablereason]
}
return this;

14
checksum/utils.groovy Normal file
View file

@ -0,0 +1,14 @@
// Generate a checksum file of from a list of files/directories relative to workspace
def generatelist(meta, checksummable) {
for (filepath in checksummable) {
def checksumset = meta.checksuminfo.addChecksumSet(filepath)
def files = findFiles(glob: filepath)
for (file in files) {
def sum = sha1(file: file.path).trim()
checksumset.addChecksumPair(file.path, sum)
}
}
}
return this;

10
clean/clean.groovy Normal file
View file

@ -0,0 +1,10 @@
def clean(folderlist) {
for (folder in folderlist) {
dir(folder) {
deleteDir()
}
}
}
return this;

View file

@ -1,212 +0,0 @@
pipeline {
agent { label "${AGENT_LABEL}" }
stages {
stage('Initial setup') {
steps {
script {
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
}
}
}
stage('Checkout dependencies') {
steps {
script {
configurationhelper = autobuilder.configurationhelper()
PYTHONURL = 'git@hydra:tools/python.git'
PYTHONBRANCH = 'origin/3.6.3_windows'
PYTHONDIR = "${WORKSPACE}/python"
PYTHONROOTDIR = 'python'
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR, PYTHONROOTDIR)
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
}
}
}
stage("Clean exports") {
steps {
script {
cleanfolders = [
]
def cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
cleaner.clean(cleanfolders)
}
}
}
stage('Generate new job name prefix') {
steps {
script {
def version = load("${autobuilder.commonscripts()}/versionnumbering/generate.groovy")
versionprefix = version.getVersionPrefix("origin/${BRANCH_TO_BUILD}", true)
echo "From revision: ${BRANCH_TO_BUILD} creating prefix: ${versionprefix}"
}
}
}
stage('Clone jobs') {
steps {
script {
def templates = []
def stringreplace = []
def defaultMCSJob = "MCS_master_compile"
def defaultMCSTag = "refs/tags/1.0.1.40053_35"
def defaultPrintServerJob = "Print_Server_master_compile"
def defaultPrintServerTag = "refs/tags/2.0.31.21210_34"
if (BRANCH_TO_COPY == "3.0.x") {
templates = [ // Build jobs
"Atlas_3.0.x_build",
"Atlas_3.0.x_CCM_analysis",
"Atlas_3.0.x_compile",
"Atlas_3.0.x_documentation_build",
"Atlas_3.0.x_documentation_ink_ui_build",
"Atlas_3.0.x_ink_ui_compile",
"Atlas_3.0.x_ink_ui_installer_build",
"Atlas_3.0.x_ink_ui_resharper_code_analysis",
"Atlas_3.0.x_localisation_check",
"Atlas_3.0.x_professional_installer_build",
"Atlas_3.0.x_release_notes",
"Atlas_3.0.x_resharper_code_analysis",
"Atlas_3.0.x_sdk_installer_build",
"Atlas_3.0.x_sdk_resharper_code_analysis",
"Atlas_3.0.x_static_analysis",
// Test jobs
]
stringreplace = [ "3.0.x" ]
}
for (gisjobname in templates) {
def job = hudson.model.Hudson.instance.getItem(gisjobname)
def newjobname = gisjobname.replaceAll(BRANCH_TO_COPY, versionprefix)
echo "Creating new job name: ${newjobname} from: ${gisjobname}"
def alreadyexistingjob = hudson.model.Hudson.instance.getItem(newjobname)
if (!alreadyexistingjob) {
def configXMLFile = job.getConfigFile()
//def file = configXMLFile.getFile()
def configXMLString = configXMLFile.asString()
echo "XML is: ${configXMLString}"
echo "Changing instances of: origin/${BRANCH_TO_COPY} with: origin/${BRANCH_TO_BUILD}"
configXMLString = configXMLString.replaceAll("origin/${BRANCH_TO_COPY}", "origin/${BRANCH_TO_BUILD}")
echo "Changing instances of: <defaultValue>${BRANCH_TO_COPY}</defaultValue> with: <defaultValue>${BRANCH_TO_BUILD}</defaultValue>"
configXMLString = configXMLString.replaceAll("<defaultValue>${BRANCH_TO_COPY}</defaultValue>", "<defaultValue>${BRANCH_TO_BUILD}</defaultValue>")
echo "Changing instances of: <defaultValue>${defaultMCSJob}</defaultValue> with: <defaultValue>${ATLAS_SERVICES_BUILD_JOB}</defaultValue>"
configXMLString = configXMLString.replaceAll("<defaultValue>${defaultMCSJob}</defaultValue>", "<defaultValue>${ATLAS_SERVICES_BUILD_JOB}</defaultValue>")
echo "Changing instances of: <defaultValue>${defaultMCSTag}</defaultValue> with: <defaultValue>${ATLAS_SERVICES_RELEASE_REVISION}</defaultValue>"
configXMLString = configXMLString.replaceAll("<defaultValue>${defaultMCSTag}</defaultValue>", "<defaultValue>${ATLAS_SERVICES_RELEASE_REVISION}</defaultValue>")
echo "Changing instances of: <defaultValue>${defaultPrintServerJob}</defaultValue> with: <defaultValue>${PRINT_SERVER_COMPILE_JOB}</defaultValue>"
configXMLString = configXMLString.replaceAll("<defaultValue>${defaultPrintServerJob}</defaultValue>", "<defaultValue>${PRINT_SERVER_COMPILE_JOB}</defaultValue>")
echo "Changing instances of: <defaultValue>${defaultPrintServerTag}</defaultValue> with: <defaultValue>${PRINT_SERVER_RELEASE_REVISION}</defaultValue>"
configXMLString = configXMLString.replaceAll("<defaultValue>${defaultPrintServerTag}</defaultValue>", "<defaultValue>${PRINT_SERVER_RELEASE_REVISION}</defaultValue>")
for (replacement in stringreplace) {
echo "Changing instances of: ${replacement} with: ${versionprefix}"
configXMLString = configXMLString.replaceAll(replacement, versionprefix)
}
echo "Edit choice parameters"
//split string on new line
def lines = configXMLString.split('\n')
//iterate array for param name
for(int i = 0; i < lines.length; i++){
//if the line is the name of a choice parameter
if(lines[i].contains("<name>ATLAS_SERVICES_ARTIFACT_LOCATION</name>")){
//set index [i+4] and [i+5] based on build selection
echo "Found ATLAS_SERVICES_ARTIFACT_LOCATION line"
if("${ATLAS_SERVICES_ARTIFACT_LOCATION}" == "Release repository"){
echo "Set default to release repo"
lines[i+4] = "<string>Release repository</string>"
lines[i+5] = "<string>Jenkins job artifact</string>"
}
else{
echo "Set default to job artifact"
lines[i+4] = "<string>Jenkins job artifact</string>"
lines[i+5] = "<string>Release repository</string>"
}
}
if(lines[i].contains("<name>PRINT_SERVER_ARTIFACT_LOCATION</name>")){
//set index [i+4] and [i+5] based on build selection
echo "Found PRINT_SERVER_ARTIFACT_LOCATION line"
if("${PRINT_SERVER_ARTIFACT_LOCATION}" == "Release repository"){
echo "Set default to release repo"
lines[i+4] = "<string>Release repository</string>"
lines[i+5] = "<string>Jenkins job artifact</string>"
}
else{
echo "Set default to job artifact"
lines[i+4] = "<string>Jenkins job artifact</string>"
lines[i+5] = "<string>Release repository</string>"
}
}
}
//rejoin array
configXMLString = lines.join('\n')
echo "XML is now: ${configXMLString}"
def InputStream is = new ByteArrayInputStream(configXMLString.getBytes())
//def InputStream is = new FileInputStream(file)
echo "Creating new job ${newjobname}"
def newjob = Jenkins.instance.createProjectFromXML(newjobname, is)
newjob.save();
echo "Created and saved new job ${newjob.getDisplayName()}"
} else {
echo "Job ${alreadyexistingjob.getDisplayName()} already exists"
}
}
}
}
}
stage('Checksum artifacts') {
steps {
script {
def checksummable = [
]
checksumutils = load("${autobuilder.commonscripts()}/checksum/utils.groovy")
checksumutils.generatelist(meta, checksummable)
}
}
}
stage('Classifying publishable artifacts') {
steps {
script {
def publishable = [
]
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
publishutils.generatelist(meta, publishable)
}
}
}
stage('Archiving artifacts') {
steps {
script {
def artifactlist = meta.generateartifacts([])
archiveArtifacts "${artifactlist}"
}
}
}
}
post {
always {
echo 'Post-build'
}
failure {
echo 'Failed build'
}
unstable {
echo 'Unstable build'
}
success {
echo 'Succeeded build'
}
}
}

View file

@ -0,0 +1,13 @@
String getCommandOutput(String cmd) {
if (isUnix()) {
return sh(returnStdout: true, script: '#!/bin/sh -e\n' + cmd).trim()
} else {
return bat(returnStdout: true, script: """
@echo off
${cmd}
"""
).trim()
}
}
return this

View file

@ -1,191 +0,0 @@
pipeline {
agent { label "${AGENT_LABEL}" }
stages {
stage('Initial setup') {
steps {
script {
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startbuild(this, PRODUCT_NAME, SUBCOMPONENT_NAME, RELEASE_REPO)
}
}
}
stage('Checkout dependencies') {
steps {
script {
configurationhelper = autobuilder.configurationhelper()
PYTHONURL = 'git@hydra:tools/python.git'
PYTHONBRANCH = 'origin/3.6.3_windows'
PYTHONDIR = "${WORKSPACE}/python"
PYTHONROOTDIR = 'python'
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR, PYTHONROOTDIR)
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
}
}
}
stage('Checkout source') {
steps {
script {
SOURCEURL = 'git@hydra:atlas-ui-modules/custom-modules.git'
SOURCEREVISION = SOURCE_REVISION
SOURCEDIR = "${WORKSPACE}\\custom_modules"
configurationhelper.gitCheckoutAndRegister(meta, 'custom_modules', SOURCEURL, SOURCEREVISION, SOURCEDIR, '', 0, false)
env.SOURCE_PATH = SOURCEDIR
env.JOBSCRIPTS = "${SOURCE_PATH}\\autobuild\\build"
env.JOBSCRIPTS_COMMON = "${SOURCE_PATH}\\autobuild\\common"
env.SRC = SOURCE_PATH
env.AULIB = "${SRC}/imports/atlas-ui"
}
}
}
stage('Clean exports') {
steps {
script {
env.BUILDOUTPUT = "${WORKSPACE}/build"
env.PSBIN = "${WORKSPACE}/ps_bin"
env.ASBIN = "${WORKSPACE}/as_bin"
env.TESTRESULTS = "${WORKSPACE}/testresults"
env.PSSOURCE = "${WORKSPACE}/newsw"
cleanfolders = [
BUILDOUTPUT,
"${WORKSPACE}/SharedPackages",
PSBIN,
ASBIN,
"${WORKSPACE}/bin",
TESTRESULTS,
]
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
cleaner.clean(cleanfolders)
}
}
}
stage('Generating version info') {
steps {
script {
version = load("${autobuilder.commonscripts()}/versionnumbering/generate.groovy")
version.generate(meta, SOURCE_REVISION, SOURCE_PATH)
}
}
}
stage('Import Atlas UI libraries') {
steps {
script {
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
def importoptions = importer.getNewImportOptions()
importoptions.source(ATLAS_UI_ARTIFACT_LOCATION,
ATLAS_UI_COMPILE_JOB,
ATLAS_UI_BUILD_SELECTOR,
ATLAS_UI_RELEASE_REPO,
ATLAS_UI_RELEASE_REVISION)
importoptions.setincrementversionnumber(false)
libmeta = importer.artifactimport(meta, importoptions, AULIB)
}
}
}
stage('Import Atlas services to adjust version number') {
steps {
script {
def importoptions = importer.getNewImportOptions()
importoptions.source(ATLAS_SERVICES_ARTIFACT_LOCATION,
ATLAS_SERVICES_COMPILE_JOB,
ATLAS_SERVICES_BUILD_SELECTOR,
ATLAS_SERVICES_RELEASE_REPO,
ATLAS_SERVICES_RELEASE_REVISION)
importoptions.setincrementversionnumber(true)
importoptions.setfilter('meta/**');
importoptions.setappendtoparentmeta(false)
asmeta = importer.artifactimport(meta, importoptions, ASBIN)
}
}
}
stage('Version stamp files') {
steps {
script {
env.BUILD_STAMP=meta.buildstampinfo.buildstamp
env.BUILD_DATE=meta.jenkinsbuildinfo.builddate
env.AS_PACKAGE_VERSION=asmeta.buildstampinfo.buildstamp
bat """
call "${JOBSCRIPTS_COMMON}\\version_files.bat"
if errorlevel 1 exit /b 1
"""
}
}
}
stage('Compile application') {
steps {
script {
env.SRC_REVISION=SOURCE_REVISION
bat """
call "${JOBSCRIPTS}\\autobuild.bat"
if errorlevel 1 exit /b 1
"""
}
}
}
stage('Prepare exports') {
steps {
script {
bat """
move "${SRC}\\bin" .
if errorlevel 1 exit /b 1
"""
}
}
}
stage('Static analysis') {
steps {
script {
recordIssues(tools: [
msBuild(enabledForFailure: true, reportEncoding: 'UTF-8'),
])
}
}
}
stage('Checksum artifacts') {
steps {
script {
def checksummable = [
/* Binaries are signed
'build/**',
'SharedPackages/**',
*/
]
checksumutils = load("${autobuilder.commonscripts()}/checksum/utils.groovy")
checksumutils.generatelist(meta, checksummable)
}
}
}
stage('Classifying publishable artifacts') {
steps {
script {
def publishable = [
]
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
publishutils.generatelist(meta, publishable)
}
}
}
stage('Archiving artifacts') {
steps {
script {
def artifactlist = meta.generateartifacts(["bin/**"])
archiveArtifacts "${artifactlist}"
}
}
}
}
post {
always {
echo 'Post-build'
}
failure {
echo 'Failed build'
}
unstable {
echo 'Unstable build'
}
success {
echo 'Succeeded build'
}
}
}

View file

@ -0,0 +1,12 @@
// Disable parallel make builds - which may be causing autobuild issues
def doDisableParallelMake(rootSearchFolder = "${WORKSPACE}") {
if (isUnix()) {
sh """
# Looks for "<builder*parallelBuildOn="true"* in all .cproject files and replaces the "true" with "false"
find "${rootSearchFolder}" -iname ".cproject" | xargs -iXX sed -i "s@\\(<builder.*parallelBuildOn=\\"\\)true\\(\\"\\)@\\1false\\2@g" XX
"""
}
}
return this;

View file

@ -0,0 +1,172 @@
def doDisplayLeftovers() {
}
def doKillLeftovers() {
}
def doCheck(checkpathlist, build_variant = "") {
def result = 0
for (checkpath in checkpathlist) {
echo "Checking file at: ${checkpath}"
script {
echo "Build variant is ${build_variant}"
if (build_variant) {
def srcFile = "${WORKSPACE}\${checkpath}"
def srcFileExpanded = srcFile.replace("-BUILDVARIANT-", "${build_variant}")
// Print out dependencies of the built file
echo "Showing dependencies of ${srcFileExpanded}"
if (srcFileExpanded.endsWith(".elf")) {
result = bat ( script: """
${CYGWINDIR}/bin/readelf -hS ${srcFileExpanded}
if errorlevel 1 EXIT /b 1
""",
returnStatus: true
)
}
if (result != 0) {
return result
}
}
}
}
return result
}
def doExport(exportfolder, exportpathlist, partdest = "", build_variant = "") {
def result = 0
def destFolder = ""
def srcFile = ""
def srcFileExpanded = ""
for (exportpath in exportpathlist) {
echo "Export path at: ${exportpath}"
script {
if (build_variant) {
echo "Build variant is ${build_variant}"
srcFile = "${WORKSPACE}\\${exportpath}"
srcFileExpanded = srcFile.replace("-BUILDVARIANT-", "${build_variant}")
}
else {
echo "No build variant"
srcFileExpanded = "${WORKSPACE}\\${exportpath}"
}
destFolder = "${exportfolder}"
if (partdest) {
destFolder += "\\" + partdest
}
}
def destFolderExpanded = destFolder.replace("-BUILDVARIANT-", "${build_variant}")
dir (destFolderExpanded) {
echo "Copy \"${srcFileExpanded}\" to \"${destFolderExpanded}\""
result = bat( script: """
copy "${srcFileExpanded}" "${destFolderExpanded}"
if errorlevel 1 EXIT /b 1
""",
returnStatus: true
)
if (result != 0) {
return result
}
}
}
return result
}
// Import all eclipse projects in a given folder
def doImportProjects(ds5folder, ds5shellcommand, buildcommand, sourcefolder) {
bat """
"${ds5shellcommand}" ${buildcommand} -no-indexer -importAll "${sourcefolder}"
"""
}
def doBuildAndExportProject(String ds5folder, String ds5shellcommand, String buildcommand, String project, Boolean doexport, variants, String exportfolder, exportpathlist, String destpart) {
echo "Doing build and export project: ${project} : ${doexport}"
for (build_variant in variants) {
retry(maxprojectbuildretries) { // Eclipse occasionally raises exceptions (rather than the builds failing)
try {
if (toBuild.contains(build_variant)) {
doDisplayLeftovers()
echo "Build command: ${ds5shellcommand} \'${buildcommand} -no-indexer -build ${project}/${build_variant}\'"
timeout(time: 20, unit: 'MINUTES') {
bat """
"${ds5shellcommand}" ${buildcommand} -no-indexer -build ${project}/${build_variant}
"""
}
result = doCheck(exportpathlist, build_variant)
if (result != 0) {
error "Failed to check files...."
}
echo "Doing export: ${doexport}"
if (doexport) {
result = doExport(exportfolder, exportpathlist, destpart, build_variant)
if (result != 0) {
error "Failed to copy...."
}
}
}
else {
echo "Not building ${build_variant} variant of project: ${project}"
}
} catch (Exception e) {
echo "Exception: ${e.getMessage()}\nBuild failed - Waiting for a while"
sleep(time: 4, unit: 'SECONDS')
error "Build failed..."
}
}
}
}
def doExportOnlyProject(String project, Boolean doexport, variants, String exportfolder, exportpathlist, String destpart) {
echo "Doing export only project: ${project} : ${doexport}"
if (doexport) {
if (!variants) {
result = doExport(exportfolder, exportpathlist, destpart)
if (result != 0) {
error "Failed to copy...."
}
} else {
for (build_variant in variants) {
if (toBuild.contains(build_variant)) {
result = doExport(exportfolder, exportpathlist, destpart, build_variant)
if (result != 0) {
error "Failed to copy...."
}
}
}
}
}
}
// Build and export files
def doBuild(apps, ds5folder, ds5shellcommand, buildcommand, sourcefolder, variantstobuild, exportfolder = "${WORKSPACE}") {
toBuild = []
if (variantstobuild) {
toBuildUntrimmed = variantstobuild.split(',')
toBuildUntrimmed.each {
toBuild.add(it.trim())
}
}
// The lock is being used because it was being found that the doKillLeftovers was affecting other builds
lock(resource: "eclipsebuild_${env.NODE_NAME}") {
try {
timeout(time: 5, unit: 'MINUTES') {
doImportProjects(ds5folder, ds5shellcommand, buildcommand, sourcefolder)
}
for (appInfo in apps) {
def Boolean build
def Boolean doexport
(build, doexport, project, variants, exportpathlist, destpart) = appInfo
if (build) {
doBuildAndExportProject(ds5folder, ds5shellcommand, buildcommand, project, doexport, variants, exportfolder, exportpathlist, destpart)
}
else {
doExportOnlyProject(project, doexport, variants, exportfolder, exportpathlist, destpart)
}
}
} catch (Exception e) {
// doKillLeftovers()
error "Exception: ${e.getMessage()}\nBuild failed - Killing leftovers"
}
}
}
return this;

View file

@ -0,0 +1,252 @@
def doDisplayLeftovers() {
if (isUnix()) {
sh """
# Killing any processes that may interfere with the next build
# The build system must be setup to do more than one eclipse build concurrently
# Don't return an error if the processes don't exist
USER=`whoami`
ps aux | grep "eclipse"
ps aux | grep "make"
ps aux | grep "arm-linux"
# ps aux | grep "sh"
"""
}
}
def doKillLeftovers() {
if (isUnix()) {
doDisplayLeftovers()
sh """
# Killing any processes that may interfere with the next build
# The build system must be setup to do more than one eclipse build concurrently
# Don't return an error if the processes don't exist
USER=`whoami`
pkill -U "${USER}" -9 eclipse || true
pkill -U "${USER}" -9 make || true
pkill -U "${USER}" -9 ".*arm-linux.*" || true
"""
}
}
def doCheck(checkpathlist, build_variant = "") {
def result = 0
for (checkpath in checkpathlist) {
echo "Checking file at: ${checkpath}"
script {
echo "Build variant is ${build_variant}"
if (build_variant) {
def srcFile = "${WORKSPACE}/${checkpath}"
def srcFileExpanded = srcFile.replace("-BUILDVARIANT-", "${build_variant}")
// Print out dependencies of the built file
echo "Showing dependencies of ${srcFileExpanded}"
result = sh( script: """
readelf -d "${srcFileExpanded}"
if [ \$? -ne 0 ]; then exit 1; fi
""",
returnStatus: true
)
if (result != 0) {
return result
}
}
}
}
return result
}
def doExport(exportfolder, exportpathlist, partdest = "", build_variant = "") {
def result = 0
def destFolder = ""
def srcFile = ""
def srcFileExpanded = ""
for (exportpath in exportpathlist) {
echo "Export path at: ${exportpath}"
script {
if (build_variant) {
echo "Build variant is ${build_variant}"
srcFile = "${WORKSPACE}/${exportpath}"
srcFileExpanded = srcFile.replace("-BUILDVARIANT-", "${build_variant}")
}
else {
echo "No build variant"
srcFileExpanded = "${WORKSPACE}/${exportpath}"
}
destFolder = "${exportfolder}"
if (partdest) {
destFolder += "/" + partdest
}
}
def destFolderExpanded = destFolder.replace("-BUILDVARIANT-", "${build_variant}")
dir (destFolderExpanded) {
echo "Copy \"${srcFileExpanded}\" to \"${destFolderExpanded}\""
if (isUnix()) {
result = sh( script: """
cp -v --no-dereference --preserve=links -r "${srcFileExpanded}" "${destFolderExpanded}"
if [ \$? -ne 0 ]; then exit 1; fi
""",
returnStatus: true
)
if (result != 0) {
return result
}
}
else {
result = bat( script: """
copy "${srcFileExpanded}" "${destFolderExpanded}"
if errorlevel 1 EXIT /b 1
""",
returnStatus: true
)
if (result != 0) {
return result
}
}
}
}
return result
}
// Register toolchain
def doRegisterToolchain(ds5folder, toolchainfolder) {
// Register toolchain (if it is not already)
if (isUnix()) {
sh """
"${ds5folder}/bin/add_toolchain" --non-interactive "${toolchainfolder}"
"""
}
else {
bat """
"%ds5folder%\\bin\\add_toolchain" --non-interactive "%toolchainfolder%"
"""
}
echo "Path is: ${PATH}"
}
// Add toolchain to path
def addToolchainPath(toolchainfolder) {
// Register toolchain (if it is not already)
if (isUnix()) {
env.PATH = toolchainfolder + ":" + env.PATH
}
else {
env.PATH = toolchainfolder + ";" + env.PATH
}
echo "Path is: ${PATH}"
}
// Import all eclipse projects in a given folder
def doImportProjects(ds5folder, toolchainfolder, ds5shellcommand, buildcommand, sourcefolder) {
doRegisterToolchain(ds5folder, toolchainfolder)
if (isUnix()) {
sh """
${ds5shellcommand} \'${buildcommand} -no-indexer -importAll "${sourcefolder}"\'
"""
}
else {
bat '%ds5shellcommand% %buildcommand% -no-indexer -importAll "%sourcefolder%"'
}
}
def doBuildAndExportProject(String ds5folder, String toolchainfolder, String ds5shellcommand, String buildcommand, String project, Boolean doexport, variants, String exportfolder, exportpathlist, String destpart) {
echo "Doing build and export project: ${project} : ${doexport}"
for (build_variant in variants) {
retry(maxprojectbuildretries) { // Eclipse occasionally raises exceptions (rather than the builds failing)
try {
if (toBuild.contains(build_variant)) {
doDisplayLeftovers()
doRegisterToolchain(ds5folder, toolchainfolder)
echo "Build command: ${ds5shellcommand} \'${buildcommand} -no-indexer -build \"${project}/${build_variant}\"\'"
timeout(time: 20, unit: 'MINUTES') {
if (isUnix()) {
sh """
echo Start time: `date`
${ds5shellcommand} \'${buildcommand} -no-indexer -build \"${project}/${build_variant}\"\'
echo End time: `date`
"""
}
else {
bat """
"%ds5shellcommand%" "%buildcommand%" -no-indexer -build "${project}\\${build_variant}"
"""
}
}
result = doCheck(exportpathlist, build_variant)
if (result != 0) {
error "Failed to check files...."
}
echo "Doing export: ${doexport}"
if (doexport) {
result = doExport(exportfolder, exportpathlist, destpart, build_variant)
if (result != 0) {
error "Failed to copy...."
}
}
}
else {
echo "Not building ${build_variant} variant of project: ${project}"
}
} catch (Exception e) {
echo "Exception: ${e.getMessage()}\nBuild failed - Waiting for a while"
sleep(time: 4, unit: 'SECONDS')
error "Build failed..."
}
}
}
}
def doExportOnlyProject(String project, Boolean doexport, variants, String exportfolder, exportpathlist, String destpart) {
echo "Doing export only project: ${project} : ${doexport}"
if (doexport) {
if (!variants) {
result = doExport(exportfolder, exportpathlist, destpart)
if (result != 0) {
error "Failed to copy...."
}
} else {
for (build_variant in variants) {
if (toBuild.contains(build_variant)) {
result = doExport(exportfolder, exportpathlist, destpart, build_variant)
if (result != 0) {
error "Failed to copy...."
}
}
}
}
}
}
// Build and export files
def doBuild(apps, ds5folder, toolchainfolder, ds5shellcommand, buildcommand, sourcefolder, variantstobuild, exportfolder = "${WORKSPACE}/export") {
toBuild = []
if (variantstobuild) {
toBuildUntrimmed = variantstobuild.split(',')
toBuildUntrimmed.each {
toBuild.add(it.trim())
}
}
// The lock is being used because it was being found that the doKillLeftovers was affecting other builds
lock(resource: "eclipsebuild_${env.NODE_NAME}") {
try {
timeout(time: 10, unit: 'MINUTES') {
addToolchainPath(toolchainfolder)
doImportProjects(ds5folder, toolchainfolder, ds5shellcommand, buildcommand, sourcefolder)
}
for (appInfo in apps) {
def Boolean build
def Boolean doexport
(build, doexport, project, variants, exportpathlist, destpart) = appInfo
if (build) {
doBuildAndExportProject(ds5folder, toolchainfolder, ds5shellcommand, buildcommand, project, doexport, variants, exportfolder, exportpathlist, destpart)
}
else {
doExportOnlyProject(project, doexport, variants, exportfolder, exportpathlist, destpart)
}
}
} catch (Exception e) {
// doKillLeftovers()
error "Exception: ${e.getMessage()}\nBuild failed - Killing leftovers"
}
}
}
return this;

View file

@ -0,0 +1,116 @@
// Gets the debug and optimization flags.
// Arg1 is "app" or "lib". Returns flags.
// Restore the debug and optimization levels, in case this is a dev machine.
// Arg1 is "app" or "lib". Arg2-3 is flags from getFlags. Returns nothing.
def setFlagsToRelease(NIOSEDS, project, wdir) {
if ( project == "app" ) {
if (isUnix()) {
sh """#!/bin/bash
set -x
cd "${wdir}"
"${NIOSEDS}/nios2_command_shell.sh" nios2-app-update-makefile --app-dir=. --set-optimization=-O2 --set-debug-level=
"""
}
}
else if ( project == "lib" ) {
if (isUnix()) {
sh """#!/bin/bash
set -x
cd "${wdir}"
"${NIOSEDS}/nios2_command_shell.sh" nios2-lib-update-makefile --lib-dir=. --set-optimization=-O2 --set-debug-level=
"""
}
}
}
def remake_and_check(NIOSEDS, wdir) {
if (isUnix()) {
sh """#!/bin/bash
set -x
cd "${wdir}"
# Use the makefile to clean and build
"${NIOSEDS}/nios2_command_shell.sh" make clean
if [ \$? -ne 0 ]; then exit 1; fi
# Set the debug and optimization levels to production values
"${NIOSEDS}/nios2_command_shell.sh" make -j12 all
if [ \$? -ne 0 ]; then exit 1; fi
"""
}
}
def generate_bsp(NIOSEDS, bspfolder) {
if (isUnix()) {
sh """#!/bin/bash
set -x
"${NIOSEDS}/nios2_command_shell.sh" nios2-bsp-generate-files --bsp-dir "${bspfolder}" --log "${bspfolder}/bsp.log" --settings "${bspfolder}/settings.bsp"
"""
}
}
def modifylib(NIOSEDS, bspfolder, buildconfig, wdir) {
if (isUnix()) {
sh """#!/bin/bash
set -x
cd "${wdir}"
"${NIOSEDS}/nios2_command_shell.sh" nios2-lib-update-makefile --lib-dir=. --set-bsp-dir "${bspfolder}" --set-active-build-config "${buildconfig}"
"""
}
}
def modifyapp(NIOSEDS, bspfolder, wdir) {
if (isUnix()) {
sh """#!/bin/bash
set -x
cd "${wdir}"
"${NIOSEDS}/nios2_command_shell.sh" nios2-app-update-makefile --app-dir=. --set-bsp-dir "${bspfolder}"
"""
}
}
def dump_elf_info(NIOSEDS, elffile, meta, custominfokeyprefix) {
if (isUnix()) {
def cpu_name = sh(script: """#!/bin/bash
"${NIOSEDS}/nios2_command_shell.sh" nios2-elf-query "${elffile}" --cpu_name
""",
returnStdout: true
).trim()
meta.addCustomInfo("${custominfokeyprefix}_cpu_name", cpu_name)
def sidp = sh(script: """#!/bin/bash
"${NIOSEDS}/nios2_command_shell.sh" nios2-elf-query "${elffile}" --sidp
""",
returnStdout: true
).trim()
meta.addCustomInfo("${custominfokeyprefix}_sidp", sidp)
def id = sh(script: """#!/bin/bash
"${NIOSEDS}/nios2_command_shell.sh" nios2-elf-query "${elffile}" --id
""",
returnStdout: true
).trim()
meta.addCustomInfo("${custominfokeyprefix}_id", id)
def timestamp = sh(script: """#!/bin/bash
"${NIOSEDS}/nios2_command_shell.sh" nios2-elf-query "${elffile}" --timestamp
""",
returnStdout: true
).trim()
meta.addCustomInfo("${custominfokeyprefix}_timestamp", timestamp)
/*
def sopcinfo = sh(script: """#!/bin/bash
"${NIOSEDS}/nios2_command_shell.sh" nios2-elf-query "${elffile}" --sopcinfo
""",
returnStdout: true
).trim()
meta.addCustomInfo("${custominfokeyprefix}_sopcinfo", sopcinfo)
*/
}
}
return this;

View file

@ -0,0 +1,18 @@
gh = load("${autobuilder.commonscripts()}/versioncontrol/git.groovy")
def registerConfigurationInfo(meta, String configurationName, String configurationURL, String configurationVersion, String configurationSHA) {
meta.addConfigurationInfo(configurationName, configurationURL, configurationVersion, configurationSHA)
}
def registerPipelineScriptConfiguration(meta) {
registerConfigurationInfo(meta, 'pipeline script', '-', '-', gh.getGitInfo(autobuilder.getautobuildpath()))
}
def gitCheckoutAndRegister(meta, String tool, String gitURL, String revision, String targetDir, String repoRoot = "", int cloneDepth = 1, boolean shallowClone = true, String filter = '') {
def ArrayList<String> sparseitemlist = gh.convertSparseItemsString(filter)
gh.gitCheckoutAlt(gitURL, revision, targetDir, repoRoot, cloneDepth, shallowClone)
registerConfigurationInfo(meta, tool, gitURL, revision, gh.getGitInfo(targetDir))
}
return this

86
copy/all.groovy Normal file
View file

@ -0,0 +1,86 @@
pipeline {
agent { label "${AGENT_LABEL}" }
stages {
stage('Initial setup') {
steps {
script {
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
}
}
}
stage('Clean exports') {
steps {
script {
IMPORTS = 'imports'
cleanfolders = [
IMPORTS,
]
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
cleaner.clean(cleanfolders)
}
}
}
stage('Import source artifacts') {
steps {
script {
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
def copyoptions = importer.getNewImportOptions()
copyoptions.source(
SOURCE_ARTIFACT_LOCATION,
SOURCE_ARTIFACT_BUILD_JOB,
SOURCE_ARTIFACT_BUILD_SELECTOR,
SOURCE_ARTIFACT_RELEASE_REPO,
SOURCE_ARTIFACT_RELEASE_REVISION)
echo "Nested: ${NESTED_COPY}"
copyoptions.setnested(NESTED_COPY == 'true')
importer.artifactimport(meta, copyoptions, IMPORTS)
}
}
}
stage('Copy source artifacts') {
steps {
script {
dir(IMPORTS) {
fileOperations([
fileCopyOperation(excludes: '',
flattenFiles: false,
includes: '**/*',
targetLocation: WORKSPACE)
])
}
}
}
}
stage('Archiving artifacts') {
steps {
script {
def includes = '**/*'
def excludes = "${IMPORTS}/*"
echo "Archiving artifacts: Includes: ${includes} Excludes: ${excludes}"
// This does not work: archiveArtifacts artifacts: includes, excludes: excludes
// so
cleanfolders = [
IMPORTS,
'autobuild',
]
cleaner.clean(cleanfolders)
archiveArtifacts artifacts: includes
}
}
}
}
post {
always {
echo 'Post-build'
}
failure {
echo 'Failed build'
}
unstable {
echo 'Unstable build'
}
success {
echo 'Succeeded build'
}
}
}

63
copy/esw.groovy Normal file
View file

@ -0,0 +1,63 @@
pipeline {
agent { label "${AGENT_LABEL}" }
stages {
stage('Initial setup') {
steps {
script {
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
}
}
}
stage('Clean exports') {
steps {
script {
env.ESW = 'esw'
env.ESWDEST = "${WORKSPACE}/${ESW}"
env.ESWEXPORT = 'embedded_software'
cleanfolders = [
ESWDEST,
ESWEXPORT,
]
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
cleaner.clean(cleanfolders)
}
}
}
stage('Copying embedded software artifacts') {
steps {
script {
importer.artifactimport(meta, ESW_ARTIFACT_LOCATION, ESW_ARTIFACT_BUILD_JOB, ESW_ARTIFACT_BUILD_SELECTOR, ESW_ARTIFACT_RELEASE_REPO, ESW_ARTIFACT_RELEASE_REVISION, ESWDEST)
}
}
}
stage('Archiving artifacts') {
steps {
script {
def artifactlist = meta.generateartifacts(["${ESWEXPORT}/**"])
sh """
rm -v -rf diff
rm -v -rf meta
mv -v "${ESW}"/* .
"""
archiveArtifacts "${artifactlist}"
}
}
}
}
post {
always {
echo 'Post-build'
}
failure {
echo 'Failed build'
}
unstable {
echo 'Unstable build'
}
success {
echo 'Succeeded build'
}
}
}

70
copy/filtered.groovy Normal file
View file

@ -0,0 +1,70 @@
pipeline {
agent { label AGENT_LABEL }
stages {
stage('Initial setup') {
steps {
script {
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
}
}
}
stage('Clean') {
steps {
script {
env.IMPORT = "${WORKSPACE}/import"
env.FILTEREDDEST = "${WORKSPACE}/filtered"
cleanfolders = [
FILTEREDDEST,
IMPORT,
]
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
cleaner.clean(cleanfolders)
}
}
}
stage('Import artifacts') {
steps {
script {
importer.artifactimport(meta, ARTIFACT_LOCATION, ARTIFACT_PROJECT, ARTIFACT_BUILD_SELECTOR, RELEASE_REPO, RELEASE_REVISION, IMPORT)
}
}
}
stage('Filtered copy') {
steps {
script {
dir(IMPORT) {
fileOperations([
fileCopyOperation(excludes: EXCLUDES,
flattenFiles: FLATTENOUTPUT,
includes: INCLUDES,
targetLocation: FILTEREDDEST)])
}
}
}
}
stage('Archiving artifacts') {
steps {
script {
def artifactlist = meta.generateartifacts(["filtered/**"])
archiveArtifacts "${artifactlist}"
}
}
}
}
post {
always {
echo 'Post-build'
}
failure {
echo 'Failed build'
}
unstable {
echo 'Unstable build'
}
success {
echo 'Succeeded build'
}
}
}

62
copy/logic.groovy Normal file
View file

@ -0,0 +1,62 @@
pipeline {
agent { label "${AGENT_LABEL}" }
stages {
stage('Initial setup') {
steps {
script {
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
}
}
}
stage('Clean exports') {
steps {
script {
env.LOGICDEST = "${WORKSPACE}/logic"
cleanfolders = [
LOGICDEST,
"${WORKSPACE}/embedded_logic",
]
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
cleaner.clean(cleanfolders)
}
}
}
stage('Copying logic artifacts') {
steps {
script {
importer.artifactimport(meta, LOGIC_ARTIFACT_LOCATION, LOGIC_ARTIFACT_PROJECT, LOGIC_ARTIFACT_BUILD_SELECTOR, LOGIC_RELEASE_REPO, LOGIC_RELEASE_REVISION, LOGICDEST)
}
}
}
stage('Archiving artifacts') {
steps {
script {
def artifactlist = meta.generateartifacts(["embedded_logic/**"])
sh """
rm -v -rf meta
# The following is removing a deprecated folder
rm -v -rf diff
mv -v "logic"/* .
"""
archiveArtifacts "${artifactlist}"
}
}
}
}
post {
always {
echo 'Post-build'
}
failure {
echo 'Failed build'
}
unstable {
echo 'Unstable build'
}
success {
echo 'Succeeded build'
}
}
}

17
differences/.project Normal file
View file

@ -0,0 +1,17 @@
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
<name>Release_difference</name>
<comment></comment>
<projects>
</projects>
<buildSpec>
<buildCommand>
<name>org.python.pydev.PyDevBuilder</name>
<arguments>
</arguments>
</buildCommand>
</buildSpec>
<natures>
<nature>org.python.pydev.pythonNature</nature>
</natures>
</projectDescription>

View file

@ -4,5 +4,5 @@
<path>/${PROJECT_DIR_NAME}</path>
</pydev_pathproperty>
<pydev_property name="org.python.pydev.PYTHON_PROJECT_VERSION">python 3.0</pydev_property>
<pydev_property name="org.python.pydev.PYTHON_PROJECT_INTERPRETER">Python34</pydev_property>
<pydev_property name="org.python.pydev.PYTHON_PROJECT_INTERPRETER">Default</pydev_property>
</pydev_project>

View file

@ -0,0 +1,836 @@
import groovy.json.JsonSlurper
markunstable = false
unstablereason = ""
summaryfolder = "${WORKSPACE}/summary"
summaryfile = "${summaryfolder}/summary.txt"
summarystring = ""
sourcerepofolder = "${WORKSPACE}/sourcerepos"
tempfolder = "${WORKSPACE}/temp"
reportfolder = "${WORKSPACE}/reports"
class JiraTicketInfo {
String jiranumber
String uri
JiraTicketInfo() {
jiranumber = ''
uri = ''
}
def String dump() {
return "jiranumber: ${jiranumber} uri: ${uri}"
}
}
class DifferenceRecord {
String productname
String subcomponentname
String rawdifferencetext
String sha
String type
String mergeinfo
String squashinfo
List<JiraTicketInfo> jiraticketinfo
String comment
DifferenceRecord() {
productname = ""
subcomponentname = ""
rawdifferencetext = ""
sha = ""
type = ""
mergeinfo = ""
squashinfo = ""
jiraticketinfo = []
comment = ""
}
def String dump() {
String jiraticketstring = ''
for (j in jiraticketinfo) {
jiraticketstring += j.dump() + " "
}
return "Difference Record:\nproductname: ${productname}\nsubcomponentname: ${subcomponentname}\nrawdifferencetext: ${rawdifferencetext}\nsha: ${sha}\ntype: ${type}\nmergeinfo: ${mergeinfo}\njiraticketinfo: ${jiraticketstring}\ncomment: ${comment}"
}
}
def resetfolders() {
dir(summaryfolder) {
deleteDir()
}
dir(tempfolder) {
deleteDir()
}
dir(reportfolder) {
deleteDir()
}
}
def preconditions() {
markunstable = false
unstablereason = ""
summarystring = ""
writeFile(file: summaryfile, text: "Release summary: \n")
}
def setunstable(String reason) {
markunstable = true
unstablereason += reason + "\n"
echo "Marked build as unstable: Reason: ${reason}"
}
def summaryappend(String summary) {
def String currentsummarycontents = readFile(file: summaryfile)
writeFile(file: summaryfile, text: currentsummarycontents + summary)
summarystring += summary
}
def showmetaitems(metaitems) {
String info = ''
for (key in metaitems.keySet()) {
def relatedmetainfo = metaitems[key]
def offsetpath = relatedmetainfo.offsetpath
info += "Name: ${key}\t\t\t\tPath: ${offsetpath}\n"
}
echo info
}
def boolean checkoutsourcerepo(buildmeta, String checkoutfolder) {
boolean checkedout = false
def String sourcerepo = buildmeta.gitinfo.remoteurl
if (sourcerepo?.trim()) {
echo "Updating source repo: ${sourcerepo} in folder: ${checkoutfolder}"
if (sourcerepo) {
// Get the latest revision of the source repo without checking out working copy; Check out to a folder unique to component
if (fileExists(checkoutfolder)) {
dir(checkoutfolder) {
sh("""
git reset --hard
git clean -fdx
git pull
"""
)
}
}
else {
dir(sourcerepofolder) {
sh("git clone ${sourcerepo} ${checkoutfolder}")
}
}
}
checkedout = true
}
return checkedout
}
def String getcomponent(meta) {
def String uniquefolder = "${meta.productinfo.productname}_${meta.productinfo.subcomponentname}"
def String uniquefoldertemp = "${tempfolder}/${uniquefolder}"
def String uniquefolderforsourcerepo = "${sourcerepofolder}/${uniquefolder}"
boolean checkedout = checkoutsourcerepo(meta, uniquefolderforsourcerepo)
return [checkedout, uniquefolderforsourcerepo]
}
def getgitlogdifferences(String gitrootfolder, String earlyrevision, String laterrevision, boolean tripledot = false) {
def String releaseexpression
if (tripledot) {
releaseexpression = earlyrevision + "..." + laterrevision
} else {
releaseexpression = earlyrevision + ".." + laterrevision
}
def String differencetext
dir(gitrootfolder) {
differencetext = sh(returnStdout: true, script: "git --no-pager log --oneline ${releaseexpression}").trim()
}
return differencetext
}
def extractsha(String line) {
def pattern = ~"^(\\p{XDigit}*) (.*)"
def match = (line =~ pattern)
match.find()
def sha = match.group(1)
def restofline = match.group(2)
//echo "Sha filtering: line: ${line} sha: ${sha} therest: ${restofline}"
return [sha.trim(), restofline.trim()]
}
def extractsquashes(String line) {
def pattern1 = "^(.*)(Squashed .*)"
def match1 = (line =~ pattern1)
if (match1.find()) {
return [true, match1.group(2)]
}
return [false, line]
}
def extractmerges(String line) {
def pattern1 = "^(.*)(Merge branch .*)"
def match1 = (line =~ pattern1)
if (match1.find()) {
return [true, match1.group(2)]
}
def pattern2 = "^(.*)(Merge remote-tracking branch .*)"
def match2 = (line =~ pattern2)
if (match2.find()) {
return [true, match2.group(2)]
}
def pattern3 = "^(.*)(Merge commit .*)"
def match3 = (line =~ pattern3)
if (match3.find()) {
return [true, match3.group(2)]
}
def pattern4 = "^(.*)(Add .* from commit .*)"
def match4 = (line =~ pattern4)
if (match4.find()) {
return [true, match4.group(2)]
}
return [false, line]
}
def jiraticketexists(String jiraticket) {
def String URI = "${JIRA_URI}/browse/${jiraticket}"
def String RestfulURI = "${JIRA_URI}/rest/api/latest/issue/${jiraticket}?fields=summary"
def get = new URL(RestfulURI).openConnection();
get.setRequestProperty( 'X-AUSERNAME', "${JIRA_USERNAME}" )
get.setRequestProperty( 'Authorization', "Basic ${JIRA_ENCODED_PASSWORD}" )
get.setRequestProperty( 'User-Agent', 'groovy-2.4.4' )
get.setRequestProperty( 'Accept', 'application/json' )
def getRC = get.getResponseCode();
def String redirectedjiraticket = jiraticket
if(!getRC.equals(200)) {
return [false, '', jiraticket]
} else {
def jsonresponse = new JsonSlurper().parseText(get.inputStream.getText('UTF-8'))
redirectedjiraticket = jsonresponse['key']
}
return [true, URI, redirectedjiraticket]
}
def extractjiraticketinfo(String line) {
def List jiratickets = []
boolean exists = false
String URI = ''
while (true) {
line = line.trim()
def commapattern = '^\\s*,(.*)' // Consume separating commas at the beginning of the line
def commamatch = (line =~ commapattern)
if (commamatch.find()) {
line = commamatch.group(1).trim()
}
def pattern1 = '^(\\w+-\\d+)(.*)' //GIS-1234 hmbxr5601-1234
def match1 = (line =~ pattern1)
if (match1.find()) {
jiraticket = match1.group(1)
(exists, URI, jiraticket) = jiraticketexists(jiraticket)
if (exists) {
def JiraTicketInfo j = new JiraTicketInfo()
j.jiranumber = jiraticket
j.uri = URI
jiratickets.add(j)
line = match1.group(2)
} else {
break
}
} else {
def pattern2 = '^(\\w+)(\\d+)(.*)' //GIS1234 smb1234
def match2 = (line =~ pattern2)
if (match2.find()) {
jiraticket = match2.group(1) + "-" + match2.group(2)
(exists, URI, jiraticket) = jiraticketexists(jiraticket)
if (exists) {
def JiraTicketInfo j = new JiraTicketInfo()
j.jiranumber = jiraticket
j.uri = URI
jiratickets.add(j)
line = match2.group(3)
} else {
break
}
} else {
def pattern3 = '^(\\w+)\\s(\\d+)(.*)' //GIS 1234 smb 1234
def match3 = (line =~ pattern3)
if (match3.find()) {
jiraticket = match3.group(1) + "-" + match3.group(2)
(exists, URI, jiraticket) = jiraticketexists(jiraticket)
if (exists) {
def JiraTicketInfo j = new JiraTicketInfo()
j.jiranumber = jiraticket
j.uri = URI
jiratickets.add(j)
line = match3.group(3)
} else {
break
}
} else {
break
}
}
}
}
boolean result = jiratickets.size() > 0
return [result, jiratickets, line]
}
def extractreverts(String line) {
boolean result = true
def pattern1 = '^(.*)Revert \"(.*)\"'
def match1 = (line =~ pattern1)
if (match1.find()) {
def line2 = match1.group(2)
(result, originaljiraticketinfo, originalcomment) = extractjiraticketinfo(line2)
return [true, originaljiraticketinfo, originalcomment]
}
def pattern2 = '^(.*)Partial Revert \"(.*)\"'
def match2 = (line =~ pattern2)
if (match2.find()) {
def line2 = match2.group(2)
(result, originaljiraticketinfo, originalcomment) = extractjiraticketinfo(line2)
return [true, originaljiraticketinfo, originalcomment]
}
return [false, [], line]
}
def getgitlogdifferencesfromsquash(String gitrootfolder, String squashedrevision) {
def String differencetext
dir(gitrootfolder) {
differencetext = sh(returnStdout: true, script: "git --no-pager log --oneline ${squashedrevision}").trim()
}
return differencetext
}
def List fillsquashrecords(String sourcepath, String sha) {
def List differencerecords = []
String squashloglines = getgitlogdifferencesfromsquash(sourcepath, sha)
int count = 0
squashloglines.split('\n').each {
if (count > 0) { // Ignore first line
def line = it
if (line?.trim()) {
def List drs = fillrecord(meta, line.trim(), sourcepath)
differencerecords.addAll(drs)
//echo "${dr.dump()}"
}
}
count += 1
}
return differencerecords
}
def List fillrecord(meta, line, String sourcepath) {
def List differencerecords = []
def DifferenceRecord dr = new DifferenceRecord()
dr.productname = meta.productinfo.productname
dr.subcomponentname = meta.productinfo.subcomponentname
dr.rawdifferencetext = line
// Example of raw text to process:
// 76056562e4 GIS-1621 - Removing redundant lines and effects of this - Restore nuget_version_edit.py
(sha, line2) = extractsha(line)
dr.sha = sha
(result, squashinfo) = extractsquashes(line2)
if (result) {
dr.type = "Squash"
dr.squashinfo = squashinfo
squashrecords = fillsquashrecords(sourcepath, sha)
differencerecords.addAll(squashrecords)
} else {
(result, mergeinfo) = extractmerges(line2)
if (result) {
dr.type = "Merge"
dr.mergeinfo = mergeinfo
} else {
(result, jiraticketinfo, comment) = extractreverts(line2)
if (result) {
dr.type = "Revert"
dr.jiraticketinfo = jiraticketinfo
dr.comment = comment
} else {
(result, jiraticketinfo, comment) = extractjiraticketinfo(line2)
if (result) {
dr.type = "Ticketed"
dr.jiraticketinfo = jiraticketinfo
dr.comment = comment
} else {
dr.type = "Unticketed"
dr.comment = line2
}
}
}
}
differencerecords.add(dr)
return differencerecords
}
def List processtext(meta, String text, String sourcepath) {
def List differencerecords = []
text.split('\n').each {
def line = it
if (line?.trim()) {
def List drs = fillrecord(meta, line.trim(), sourcepath)
differencerecords.addAll(drs)
//echo "${dr.dump()}"
}
}
return differencerecords
}
def getdifferencerecords(earlymeta, latermeta, String sourcepath) {
boolean result = true;
def List differencerecords = []
def earlygitinfo = earlymeta.gitinfo
def latergitinfo = latermeta.gitinfo
if (earlygitinfo.remoteurl == latergitinfo.remoteurl) {
def earlyrevision = earlygitinfo.gitrevision
def laterrevision = latergitinfo.gitrevision
echo "Comparing early revision: ${earlyrevision} with: ${laterrevision} Working copy path: ${sourcepath}"
summaryappend("Early revision: ${earlyrevision} Later revision: ${laterrevision}")
def String differencetext = getgitlogdifferences(sourcepath, earlyrevision, laterrevision)
differencerecords = processtext(earlymeta, differencetext, sourcepath)
if (earlyrevision == laterrevision) {
summaryappend(" No change")
}
} else {
summaryappend("The early and later git urls don't match")
echo "The early and later git urls don't match"
result = false;
setunstable("The early and later git urls don't match in: ${earlymeta.componentidentifier()}")
}
return [result, differencerecords]
}
def deletedcomponent(earlymetaitems, key) {
echo "Component ${key} has been deleted in later version"
summaryappend("Deleted ")
}
def addedcomponent(latermetaitems, key) {
echo "Component ${key} has been added in later version"
summaryappend("Added ")
}
class SquashReportRecord {
String comment
int duplicates
SquashReportRecord() {
comment = ''
duplicates = 0
}
}
def squashreport(String reportsubfolder, String title, LinkedHashMap<String, SquashReportRecord> squashes, boolean iscomponent = true) {
dir(reportsubfolder) {
def String squashlist = "${title}\nSquash list:\n"
def squashessorted = squashes.sort()
for (asquash in squashessorted) {
def SquashReportRecord s = asquash.value
squashlist += "${s.comment} (${s.duplicates})\n"
}
writeFile(file: "squashlist.txt", text: squashlist)
}
}
class MergeReportRecord {
String comment
int duplicates
MergeReportRecord() {
comment = ''
duplicates = 0
}
}
def mergereport(String reportsubfolder, String title, LinkedHashMap<String, MergeReportRecord> merges, boolean iscomponent = true) {
dir(reportsubfolder) {
def String mergelist = "${title}\nMerge list:\n"
def mergessorted = merges.sort()
for (amerge in mergessorted) {
def MergeReportRecord m = amerge.value
mergelist += "${m.comment} (${m.duplicates})\n"
}
writeFile(file: "mergelist.txt", text: mergelist)
}
}
class CommentsRecord {
String comment
int duplicates
CommentsRecord() {
comment = ''
duplicates = 0
}
}
class RevertsReportRecord {
String jiraticket
String ticketURI
LinkedHashMap<String, CommentsRecord> commentscollection
RevertsReportRecord() {
jiraticket = ''
ticketURI = ''
commentscollection = new LinkedHashMap<String, CommentsRecord>()
}
}
def revertsreport(String reportsubfolder, String title, LinkedHashMap<String, RevertsReportRecord> reverts, boolean iscomponent = true) {
dir(reportsubfolder) {
def String revertlist = "${title}\nRevert list:\n"
def revertssorted = reverts.sort()
for (arevert in revertssorted) {
def RevertsReportRecord r = arevert.value
revertlist += "${r.jiraticket} (${r.ticketURI}):\n"
def commentscollection = r.commentscollection
def sortedcommentscollection = commentscollection.sort()
for (commentrecord in sortedcommentscollection) {
def CommentsRecord c = commentrecord.value
revertlist += "${c.comment} (${c.duplicates})\n"
}
revertlist += "\n"
}
writeFile(file: "revertlist.txt", text: revertlist)
}
}
class TicketedReportRecord {
String jiraticket
String ticketURI
LinkedHashMap<String, CommentsRecord> commentscollection
TicketedReportRecord() {
jiraticket = ''
ticketURI = ''
commentscollection = new LinkedHashMap<String, CommentsRecord>()
}
}
def ticketedreport(String reportsubfolder, String title, LinkedHashMap<String, TicketedReportRecord> ticketed, boolean iscomponent = true) {
dir(reportsubfolder) {
def String ticketedlist = "${title}\nTicketed list:\n"
def ticketedsorted = ticketed.sort()
for (aticketed in ticketedsorted) {
def TicketedReportRecord r = aticketed.value
ticketedlist += "${r.jiraticket} (${r.ticketURI}):\n"
def commentscollection = r.commentscollection
def sortedcommentscollection = commentscollection.sort()
for (commentrecord in sortedcommentscollection) {
def CommentsRecord c = commentrecord.value
ticketedlist += "${c.comment} (${c.duplicates})\n"
}
ticketedlist += "\n"
}
writeFile(file: "ticketedlist.txt", text: ticketedlist)
}
}
class UnticketedReportRecord {
String comment
int duplicates
UnticketedReportRecord() {
comment = ''
duplicates = 0
}
}
def unticketedreport(String reportsubfolder, String title, LinkedHashMap<String, UnticketedReportRecord> unticketed, boolean iscomponent = true) {
dir(reportsubfolder) {
def String unticketedlist = "${title}\nUnticketed list:\n"
def unticketedsorted = unticketed.sort()
for (anunticketed in unticketedsorted) {
UnticketedReportRecord u = anunticketed.value
unticketedlist += "${u.comment} (${u.duplicates})\n"
}
writeFile(file: "unticketedlist.txt", text: unticketedlist)
}
}
class TicketsReportRecord {
String jiraticket
String ticketURI
int duplicates
TicketsReportRecord() {
jiraticket = ''
ticketURI = ''
duplicates = 0
}
}
def ticketsreport(String reportsubfolder, String title, tickets, boolean iscomponent = true) {
dir(reportsubfolder) {
String ticketlist = "${title}\nTicket list:\n"
ticketssorted = tickets.sort()
for (ticketnumber in ticketssorted) {
TicketsReportRecord t = ticketnumber.value
ticketlist += "${t.jiraticket} (${t.ticketURI}) (${t.duplicates})\n"
}
writeFile(file: "ticketlist.txt", text: ticketlist)
}
}
def differencerecordsreport(String reportsubfolder, String title, differencerecords, boolean iscomponent = true) {
dir(reportsubfolder) {
String recordlist = "${title}\n"
for (dr in differencerecords) {
recordlist += dr.dump() + "\n\n"
}
writeFile(file: "recordlist.txt", text: recordlist)
}
}
def boolean report(meta, title, differencerecords, boolean iscomponent = true) {
def Map ticketed = [:]
def Map squashes = [:]
def Map merges = [:]
def Map reverts = [:]
def Map unticketed = [:]
def Map tickets = [:]
for (dr in differencerecords) {
if (dr.type == "Squash") {
def SquashReportRecord s
if (!squashes.containsKey(dr.mergeinfo)) {
s = new SquashReportRecord()
s.comment = dr.squashinfo
s.duplicates = 1
} else {
s = squashes[dr.squashinfo]
s.duplicates += 1
}
squashes[dr.squashinfo] = s
}
if (dr.type == "Merge") {
def MergeReportRecord m
if (!merges.containsKey(dr.mergeinfo)) {
m = new MergeReportRecord()
m.comment = dr.mergeinfo
m.duplicates = 1
} else {
m = merges[dr.mergeinfo]
m.duplicates += 1
}
merges[dr.mergeinfo] = m
}
if (dr.type == "Revert") {
def RevertsReportRecord r
for (ticket in dr.jiraticketinfo) {
JiraTicketInfo j = ticket
if (!reverts.containsKey(j.jiranumber)) {
r = new RevertsReportRecord()
r.jiraticket = j.jiranumber
r.ticketURI = j.uri
CommentsRecord c = new CommentsRecord()
c.comment = dr.comment
c.duplicates = 1
r.commentscollection[dr.comment] = c
} else {
r = reverts[j.jiranumber]
def CommentsRecord c
if (!r.commentscollection.containsKey(dr.comment)) {
c = new CommentsRecord()
c.comment = dr.comment
c.duplicates = 1
r.commentscollection[dr.comment] = c
} else {
c = r.commentscollection[dr.comment]
c.duplicates += 1
}
r.commentscollection[dr.comment] = c
}
reverts[j.jiranumber] = r
def TicketsReportRecord t
if (!tickets.containsKey(j.jiranumber)) {
t = new TicketsReportRecord()
t.jiraticket = j.jiranumber
t.ticketURI = j.uri
t.duplicates = 1
} else {
t = tickets[j.jiranumber]
t.duplicates += 1
}
tickets[j.jiranumber] = t
}
}
if (dr.type == "Ticketed") {
def TicketedReportRecord t
for (ticket in dr.jiraticketinfo) {
JiraTicketInfo j = ticket
if (!ticketed.containsKey(j.jiranumber)) {
t = new TicketedReportRecord()
t.jiraticket = j.jiranumber
t.ticketURI = j.uri
CommentsRecord c = new CommentsRecord()
c.comment = dr.comment
c.duplicates = 1
t.commentscollection[dr.comment] = c
} else {
t = ticketed[j.jiranumber]
def CommentsRecord c
if (!t.commentscollection.containsKey(dr.comment)) {
c = new CommentsRecord()
c.comment = dr.comment
c.duplicates = 1
t.commentscollection[dr.comment] = c
} else {
c = t.commentscollection[dr.comment]
c.duplicates += 1
}
t.commentscollection[dr.comment] = c
}
ticketed[j.jiranumber] = t
def TicketsReportRecord ti
if (!tickets.containsKey(j.jiranumber)) {
ti = new TicketsReportRecord()
ti.jiraticket = j.jiranumber
ti.ticketURI = j.uri
ti.duplicates = 1
} else {
ti = tickets[j.jiranumber]
ti.duplicates += 1
}
tickets[j.jiranumber] = ti
}
}
if (dr.type == "Unticketed") {
UnticketedReportRecord u
if (!unticketed.containsKey(dr.comment)) {
u = new UnticketedReportRecord()
u.comment = dr.comment
u.duplicates = 1
} else {
u = unticketed[dr.comment]
u.duplicates += 1
}
unticketed[dr.comment] = u
}
}
String reportsubfolder = ""
if (iscomponent) {
reportsubfolder = "${reportfolder}/${meta.componentidentifier()}"
} else {
reportsubfolder = "${reportfolder}/Combined"
}
mergereport(reportsubfolder, title, merges, iscomponent)
squashreport(reportsubfolder, title, squashes, iscomponent)
revertsreport(reportsubfolder, title, reverts, iscomponent)
ticketedreport(reportsubfolder, title, ticketed, iscomponent)
unticketedreport(reportsubfolder, title, unticketed, iscomponent)
ticketsreport(reportsubfolder, title, tickets, iscomponent)
differencerecordsreport(reportsubfolder, title, differencerecords, iscomponent)
}
def title(earlymeta, latermeta) {
return """
Differences in:
Product: ${earlymeta.productinfo.productname} Subcomponent: ${earlymeta.productinfo.subcomponentname}
between:
then:
Build date: ${earlymeta.jenkinsbuildinfo.builddate} Build stamp: ${earlymeta.buildstampinfo.buildstamp} Git revision: ${earlymeta.gitinfo.gitrevision}
now:
Build date: ${latermeta.jenkinsbuildinfo.builddate} Build stamp: ${latermeta.buildstampinfo.buildstamp} Git revision: ${latermeta.gitinfo.gitrevision}
"""
}
def compare(earlymetaitems, latermetaitems, key) {
boolean result = true;
echo "Collecting changes between early and later versions of component: ${key}"
def earlymeta = earlymetaitems[key].meta
def latermeta = latermetaitems[key].meta
summaryappend("${earlymeta.productinfo.productname} ${earlymeta.productinfo.subcomponentname}: Changed: ")
def boolean repoavailable
def String uniquefolderforsourcerepo
(repoavailable, uniquefolderforsourcerepo) = getcomponent(earlymeta)
List differencerecords = []
if (repoavailable) {
(result, differencerecords) = getdifferencerecords(earlymeta, latermeta, uniquefolderforsourcerepo)
summaryappend(" Items: ${differencerecords.size()} ")
report(earlymeta, title(earlymeta, latermeta), differencerecords)
} else {
summaryappend(" No source repo ")
}
summaryappend("\n")
return [result, differencerecords];
}
def comparehierarchy(meta, String earlymetafolder, String latermetafolder, String maxdepth, String summaryfolder) {
def List differencerecords = []
def int md = maxdepth.toInteger()
resetfolders()
preconditions()
echo "Comparing product meta hierarchy from folders: ${earlymetafolder} and ${latermetafolder} to a depth of ${md}. Exporting summary to ${summaryfolder}"
def earlymeta = meta.importrelated(true, earlymetafolder)
def latermeta = meta.importrelated(true, latermetafolder)
def earlymetaitems = earlymeta.releasewalkerunique(md)
def latermetaitems = latermeta.releasewalkerunique(md)
echo "Early items:"
showmetaitems(earlymetaitems)
echo "Later items:"
showmetaitems(latermetaitems)
for (key in earlymetaitems.keySet()) {
if (latermetaitems.containsKey(key)) {
(result, componentdifferencerecords) = compare(earlymetaitems, latermetaitems, key)
differencerecords = differencerecords + componentdifferencerecords
} else {
summaryappend("${earlymeta.productinfo.productname} ${earlymeta.productinfo.subcomponentname}: ")
deletedcomponent(earlymetaitems, key)
summaryappend("\n")
}
}
for (key in latermetaitems.keySet()) {
if (!earlymetaitems.containsKey(key)) {
summaryappend("${latermeta.productinfo.productname} ${latermeta.productinfo.subcomponentname}: ")
addedcomponent(latermetaitems, key)
summaryappend("\n")
}
}
report(meta, title(earlymeta, latermeta), differencerecords, false)
return [summarystring, markunstable, unstablereason]
}
return this;

16
differences/file.groovy Normal file
View file

@ -0,0 +1,16 @@
def comparefiles(importedfile, currentfile, boolean ignorewhitespace = true) {
if (isUnix()) {
def wsparameter = "-w"
if (!ignorewhitespace) {
wsparameter = ""
}
sh """
diff -c ${wsparameter} "${importedfile}" "${currentfile}"
"""
}
else {
error "Windows not currently supporting file comparison"
}
}
return this;

15
differences/json.groovy Normal file
View file

@ -0,0 +1,15 @@
def comparefiles(importedjsonfile, currentjsonfile) {
if (isUnix()) {
sh """
which jq
if [ \$? -ne 0 ]; then exit 1; fi
# jq -S sorts json output
diff -c <(jq -S . "${importedjsonfile}") <(jq -S . "${currentjsonfile}")
"""
}
else {
error "Windows not currently supporting json file comparison"
}
}
return this;

View file

@ -0,0 +1,91 @@
pipeline {
agent { label "${AGENT_LABEL}" }
stages {
stage('Initial setup') {
steps {
script {
autobuilderscript = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy")
meta = autobuilderscript.startnonbuild(this)
}
}
}
stage('Clean exports') {
steps {
script {
SUMMARYDIR = "${WORKSPACE}/summary"
REPORTDIR = "${WORKSPACE}/reports"
EARLYROOTDIR = 'early'
EARLYDIR = "${WORKSPACE}/${EARLYROOTDIR}"
LATERROOTDIR = 'later'
LATERDIR = "${WORKSPACE}/${LATERROOTDIR}"
cleanfolders = [
"${WORKSPACE}/build_artifacts",
"${EARLYDIR}",
"${LATERDIR}",
"${SUMMARYDIR}",
"${REPORTDIR}",
]
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
cleaner.clean(cleanfolders)
}
}
}
stage('Obtain top level meta') {
steps {
script {
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
SOURCEURL = TOP_LEVEL_META_REPOSITORY.trim()
importer.artifactimport(meta, EARLY_SOURCE, EARLY_BUILD_JOB, EARLY_BUILD_SELECTOR, SOURCEURL, RELEASE_EARLY_REVISION, EARLYROOTDIR, false, 'meta/**')
importer.artifactimport(meta, LATER_SOURCE, LATER_BUILD_JOB, LATER_BUILD_SELECTOR, SOURCEURL, RELEASE_LATER_REVISION, LATERROOTDIR, false, 'meta/**')
}
}
}
stage('Diff components') {
steps {
script {
def comparator = load("${autobuilder.commonscripts()}/differences/dometahierarchy.groovy")
(summarystring, markunstable, unstablereason) = comparator.comparehierarchy(meta, EARLYDIR, LATERDIR, MAX_META_DEPTH, SUMMARYDIR)
if (markunstable) {
env.unstablereason = unstablereason
currentBuild.result = 'UNSTABLE'
}
}
}
}
stage('Archiving artifacts') {
steps {
script {
def artifactlist = meta.generateartifacts()
archiveArtifacts "summary/**,reports/**,${artifactlist}"
}
}
}
stage('Summarise') {
steps {
script {
echo "Summary:\n${summarystring}\n"
if (env.unstablereason) {
echo "Instability reason: ${env.unstablereason}"
}
}
}
}
}
post {
always {
echo 'Post-build'
}
failure {
echo 'Failed build'
}
unstable {
echo 'Unstable build'
}
success {
echo 'Succeeded build'
}
}
}

View file

@ -1,226 +0,0 @@
pipeline {
agent { label "${AGENT_LABEL}" }
stages {
stage('Initial setup') {
steps {
script {
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startbuild(this, PRODUCT_NAME, SUBCOMPONENT_NAME, RELEASE_REPO)
}
}
}
stage('Checkout dependencies') {
steps {
script {
configurationhelper = autobuilder.configurationhelper()
PYTHONURL = 'git@hydra:tools/python.git'
PYTHONBRANCH = 'origin/3.6.3_windows'
PYTHONDIR = "${WORKSPACE}/python"
PYTHONROOTDIR = 'python'
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR, PYTHONROOTDIR)
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
VERSTAMPINGURL = 'git@hydra:releases/ver_stamping_releases.git'
VERSTAMPINGREVISION = "refs/tags/${VERSION_STAMPING_VERSION}"
VERSTAMPINGDIR = "${WORKSPACE}/ver_stamping"
VERSTAMPINGROOTDIR = 'ver_stamping_releases'
configurationhelper.gitCheckoutAndRegister(meta, 'Version stamping', VERSTAMPINGURL, VERSTAMPINGREVISION, VERSTAMPINGDIR, VERSTAMPINGROOTDIR)
}
}
}
stage('Checkout source') {
steps {
script {
SOURCEURL = 'git@hydra:gis/atlas_ui.git'
SOURCEREVISION = SOURCE_REVISION
SOURCEDIR = "${WORKSPACE}\\atlas_ui"
configurationhelper.gitCheckoutAndRegister(meta, 'atlas_ui', SOURCEURL, SOURCEREVISION, SOURCEDIR, '', 0, false)
env.SOURCE_PATH = SOURCEDIR
env.JOBSCRIPTS = "${SOURCE_PATH}\\autobuild\\documentation"
env.JOBSCRIPTS_COMMON = "${SOURCE_PATH}\\autobuild\\common"
env.SRC = SOURCE_PATH
}
}
}
stage('Clean exports') {
steps {
script {
env.BUILDOUTPUT = "${WORKSPACE}/build"
env.PSBIN = "${WORKSPACE}/ps_bin"
env.ASBIN = "${WORKSPACE}/as_bin"
env.PSSOURCE = "${WORKSPACE}/newsw"
cleanfolders = [
BUILDOUTPUT,
"${WORKSPACE}/SharedPackages",
PSBIN,
ASBIN,
"${WORKSPACE}/bin",
"${WORKSPACE}/binKiosk",
"${WORKSPACE}/documentation",
"${WORKSPACE}/Libraries",
"${WORKSPACE}/Atlas Release",
]
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
cleaner.clean(cleanfolders)
}
}
}
stage('Generating version info') {
steps {
script {
version = load("${autobuilder.commonscripts()}/versionnumbering/generate.groovy")
version.generate(meta, SOURCE_REVISION, SOURCE_PATH, BASEBUILDNUMBER)
}
}
}
stage('Import Print server dependencies') {
steps {
script {
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
def psartifactfiles = "meta/**,bin/x64/Release/Engine - Render.dll,bin/x64/Release/Engine - Render.lib,bin/x64/Release/Engine - Render.pdb,bin/x64/Release/TBarCode11_x64.dll,bin/x64/Release/GIS Utility - Toolbox.dll,bin/x64/Release/GIS Utility - Toolbox.lib,bin/x64/Release/GIS Utility - Toolbox.pdb,bin/x64/Release/zlib1.dll,bin/x64/Release/zlib1.lib,bin/x64/Release/zlib1.pdb,bin/x64/Release/GIS Utility - TCP-IP Comms.dll,bin/x64/Release/GIS Utility - TCP-IP Comms.lib,bin/x64/Release/GIS Utility - TCP-IP Comms.pdb,bin/x64/Release/Dialog - Tree Node Editor.dll,bin/x64/Release/Dialog - Tree Node Editor.lib,bin/x64/Release/Dialog - Tree Node Editor.pdb"
psmeta = importer.artifactimport(meta,
PRINT_SERVER_ARTIFACT_LOCATION,
PRINT_SERVER_COMPILE_JOB,
PRINT_SERVER_BUILD_SELECTOR,
PRINT_SERVER_RELEASE_REPO,
PRINT_SERVER_RELEASE_REVISION,
PSBIN,
true,
psartifactfiles)
}
}
}
stage('Checkout relevant Print server source') {
steps {
script {
def pssourceartifacts = "src/Engine Common"
def pssourceurl = psmeta.gitinfo.remoteurl
def pscommit = psmeta.gitinfo.gitrevision
configurationhelper.gitCheckoutAndRegister(meta, 'print_server_source', pssourceurl, pscommit, PSSOURCE, '', 0, false, pssourceartifacts)
}
}
}
stage('Import Atlas services dependencies') {
steps {
script {
def asartifactfiles = "meta/**,SharedPackages/**"
asmeta = importer.artifactimport(meta,
ATLAS_SERVICES_ARTIFACT_LOCATION,
ATLAS_SERVICES_COMPILE_JOB,
ATLAS_SERVICES_BUILD_SELECTOR,
ATLAS_SERVICES_RELEASE_REPO,
ATLAS_SERVICES_RELEASE_REVISION,
ASBIN,
true,
asartifactfiles)
}
}
}
stage('Version files') {
steps {
script {
env.BUILD_STAMP=meta.buildstampinfo.buildstamp
env.BUILD_DATE=meta.jenkinsbuildinfo.builddate
env.PS_VERSION="1.0.${psmeta.buildstampinfo.revision}.0"
env.PS_PACKAGE_VERSION=psmeta.buildstampinfo.buildstampprefix
env.AS_PACKAGE_VERSION=asmeta.buildstampinfo.buildstamp
bat """
call "${JOBSCRIPTS_COMMON}\\create_ps_nuget.bat"
if errorlevel 1 exit /b 1
call "${JOBSCRIPTS_COMMON}\\version_atlas_ui_files.bat"
if errorlevel 1 exit /b 1
"""
}
}
}
stage('Compile application') {
steps {
script {
env.SRC_REVISION=SOURCE_REVISION
bat """
call "${JOBSCRIPTS}\\build_atlas.bat"
if errorlevel 1 exit /b 1
"""
}
}
}
stage('Build documentation') {
steps {
script {
bat """
call "${JOBSCRIPTS}\\documentation_build.bat"
if errorlevel 1 exit /b 1
"""
}
}
}
stage('Prepare exports') {
steps {
script {
bat """
move "${SRC}\\documentation" .
if errorlevel 1 exit /b 1
"""
}
}
}
stage('Static analysis') {
steps {
script {
recordIssues(tools: [
msBuild(enabledForFailure: true, reportEncoding: 'UTF-8'),
])
}
}
}
stage('Checksum artifacts') {
steps {
script {
def checksummable = [
/* Binaries are signed
'build/**',
'SharedPackages/**',
*/
]
checksumutils = load("${autobuilder.commonscripts()}/checksum/utils.groovy")
checksumutils.generatelist(meta, checksummable)
}
}
}
stage('Classifying publishable artifacts') {
steps {
script {
def publishable = [
]
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
publishutils.generatelist(meta, publishable)
}
}
}
stage('Archiving artifacts') {
steps {
script {
def artifactlist = meta.generateartifacts(["documentation/**"])
archiveArtifacts "${artifactlist}"
}
}
}
}
post {
always {
echo 'Post-build'
}
failure {
echo 'Failed build'
}
unstable {
echo 'Unstable build'
}
success {
echo 'Succeeded build'
}
}
}

View file

@ -1,222 +0,0 @@
pipeline {
agent { label "${AGENT_LABEL}" }
stages {
stage('Initial setup') {
steps {
script {
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startbuild(this, PRODUCT_NAME, SUBCOMPONENT_NAME, RELEASE_REPO)
}
}
}
stage('Checkout dependencies') {
steps {
script {
configurationhelper = autobuilder.configurationhelper()
PYTHONURL = 'git@hydra:tools/python.git'
PYTHONBRANCH = 'origin/3.6.3_windows'
PYTHONDIR = "${WORKSPACE}/python"
PYTHONROOTDIR = 'python'
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR, PYTHONROOTDIR)
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
VERSTAMPINGURL = 'git@hydra:releases/ver_stamping_releases.git'
VERSTAMPINGREVISION = "refs/tags/${VERSION_STAMPING_VERSION}"
VERSTAMPINGDIR = "${WORKSPACE}/ver_stamping"
VERSTAMPINGROOTDIR = 'ver_stamping_releases'
configurationhelper.gitCheckoutAndRegister(meta, 'Version stamping', VERSTAMPINGURL, VERSTAMPINGREVISION, VERSTAMPINGDIR, VERSTAMPINGROOTDIR)
}
}
}
stage('Checkout source') {
steps {
script {
SOURCEURL = 'git@hydra:gis/atlas_ui.git'
SOURCEREVISION = SOURCE_REVISION
SOURCEDIR = "${WORKSPACE}\\atlas_ui"
configurationhelper.gitCheckoutAndRegister(meta, 'atlas_ui', SOURCEURL, SOURCEREVISION, SOURCEDIR, '', 0, false)
env.SOURCE_PATH = SOURCEDIR
env.JOBSCRIPTS = "${SOURCE_PATH}\\autobuild\\documentation"
env.JOBSCRIPTS_COMMON = "${SOURCE_PATH}\\autobuild\\common"
env.SRC = SOURCE_PATH
}
}
}
stage('Clean exports') {
steps {
script {
env.BUILDOUTPUT = "${WORKSPACE}/build"
env.PSBIN = "${WORKSPACE}/ps_bin"
env.ASBIN = "${WORKSPACE}/as_bin"
env.AULIB = "${WORKSPACE}/atlaslibraries"
env.PSSOURCE = "${WORKSPACE}/newsw"
cleanfolders = [
BUILDOUTPUT,
"${WORKSPACE}/SharedPackages",
PSBIN,
ASBIN,
AULIB,
"${WORKSPACE}/binInk",
"${WORKSPACE}/documentation",
]
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
cleaner.clean(cleanfolders)
}
}
}
stage('Generating version info') {
steps {
script {
version = load("${autobuilder.commonscripts()}/versionnumbering/generate.groovy")
version.generate(meta, SOURCE_REVISION, SOURCE_PATH, BASEBUILDNUMBER)
}
}
}
stage('Import Atlas UI libraries') {
steps {
script {
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
libmeta = importer.artifactimport(meta,
ATLAS_UI_ARTIFACT_LOCATION,
ATLAS_UI_COMPILE_JOB,
ATLAS_UI_BUILD_SELECTOR,
ATLAS_UI_RELEASE_REPO,
ATLAS_UI_RELEASE_REVISION,
AULIB,
false)
}
}
}
stage('Import Print server to adjust version number') {
steps {
script {
def psartifactfiles = "meta/**"
psmeta = importer.artifactimport(meta,
PRINT_SERVER_ARTIFACT_LOCATION,
PRINT_SERVER_COMPILE_JOB,
PRINT_SERVER_BUILD_SELECTOR,
PRINT_SERVER_RELEASE_REPO,
PRINT_SERVER_RELEASE_REVISION,
PSBIN,
true,
psartifactfiles) // This should increment the version number
}
}
}
stage('Import Atlas services to adjust version number') {
steps {
script {
def asartifactfiles = "meta/**"
asmeta = importer.artifactimport(meta,
ATLAS_SERVICES_ARTIFACT_LOCATION,
ATLAS_SERVICES_COMPILE_JOB,
ATLAS_SERVICES_BUILD_SELECTOR,
ATLAS_SERVICES_RELEASE_REPO,
ATLAS_SERVICES_RELEASE_REVISION,
ASBIN,
true,
asartifactfiles)
}
}
}
stage('Version stamp files') {
steps {
script {
env.BUILD_STAMP=meta.buildstampinfo.buildstamp
env.BUILD_DATE=meta.jenkinsbuildinfo.builddate
env.AS_PACKAGE_VERSION=asmeta.buildstampinfo.buildstamp
bat """
call "${JOBSCRIPTS_COMMON}\\version_ink_ui_files.bat"
if errorlevel 1 exit /b 1
"""
}
}
}
stage('Compile application') {
steps {
script {
env.SRC_REVISION=SOURCE_REVISION
bat """
call "${JOBSCRIPTS}\\build_ink_ui.bat"
if errorlevel 1 exit /b 1
"""
}
}
}
stage('Build documentation') {
steps {
script {
bat """
call "${JOBSCRIPTS}\\ink_ui_documentation_build.bat"
if errorlevel 1 exit /b 1
"""
}
}
}
stage('Prepare exports') {
steps {
script {
bat """
move "${SRC}\\documentation" .
if errorlevel 1 exit /b 1
"""
}
}
}
stage('Static analysis') {
steps {
script {
recordIssues(tools: [
msBuild(enabledForFailure: true, reportEncoding: 'UTF-8'),
])
}
}
}
stage('Checksum artifacts') {
steps {
script {
def checksummable = [
/* Binaries are signed
'build/**',
'SharedPackages/**',
*/
]
checksumutils = load("${autobuilder.commonscripts()}/checksum/utils.groovy")
checksumutils.generatelist(meta, checksummable)
}
}
}
stage('Classifying publishable artifacts') {
steps {
script {
def publishable = [
]
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
publishutils.generatelist(meta, publishable)
}
}
}
stage('Archiving artifacts') {
steps {
script {
def artifactlist = meta.generateartifacts(["documentation/**"])
archiveArtifacts "${artifactlist}"
}
}
}
}
post {
always {
echo 'Post-build'
}
failure {
echo 'Failed build'
}
unstable {
echo 'Unstable build'
}
success {
echo 'Succeeded build'
}
}
}

View file

@ -0,0 +1,80 @@
pipeline {
agent { label "${AGENT_LABEL}" }
stages {
stage('Initial setup') {
steps {
script {
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
}
}
}
stage('Clean imports') {
steps {
script {
env.DOXYGEN = "doxygen"
cleanfolders = [
DOXYGEN,
]
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
cleaner.clean(cleanfolders)
}
}
}
stage('Import doxygen artifacts') {
steps {
script {
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
def importoptions = importer.getNewImportOptions()
importoptions.jenkinsjob(BUILD_JOB_WITH_DOXYGEN_ARTIFACTS, BUILD_JOB_WITH_DOXYGEN_ARTIFACTS_SELECTOR)
importoptions.setfilter(ARTIFACT_PATH_TO_DOXYGEN_ROOT + '/**')
doxygenmeta = importer.artifactimportfrombuildjob(meta, importoptions, DOXYGEN)
productname = doxygenmeta.productinfo.productname
buildstampprefix = doxygenmeta.buildstampinfo.buildstampprefix
echo "Doyxgen imported for product: ${productname} and build stamp prefix: ${buildstampprefix}"
}
}
}
stage('Copy doxygen to server') {
steps {
script {
doxygensource = "${DOXYGEN}/${ARTIFACT_PATH_TO_DOXYGEN_ROOT}"
pathonserver = "${ROOT_PATH_ON_SERVER.trim()}/${productname}/${buildstampprefix}"
echo "Copying from ${doxygensource} to ${pathonserver}"
if (isUnix()) {
sh """#!/bin/bash
rm -rfv "${pathonserver}"
if [ \$? -ne 0 ]; then exit 1; fi
mkdir -pv "${pathonserver}"
if [ \$? -ne 0 ]; then exit 1; fi
echo mv -v "${doxygensource}"/ "${pathonserver}"
mv -v "${doxygensource}"/ "${pathonserver}"
if [ \$? -ne 0 ]; then exit 1; fi
"""
} else {
error("This job does not run on Windows at the moment")
}
}
}
}
}
post {
always {
echo 'Post-build'
}
failure {
echo 'Failed build'
}
unstable {
echo 'Unstable build'
}
success {
echo 'Succeeded build'
}
}
}

333
import/importer.groovy Normal file
View file

@ -0,0 +1,333 @@
gh = load("${autobuilder.commonscripts()}/versioncontrol/git.groovy")
versiongenerator = load("${autobuilder.commonscripts()}/versionnumbering/generate.groovy")
class ImportOptions {
def m_script // Script to use if wanting to execute script commands (eg. echo -> script.echo)
boolean m_incrementversionnumber // If true, increment the parent's (4th) version number with the (4th) version number of this object being imported
String m_filter // Only import files/paths/folders that match the filter
String m_excludes // Exclude files/paths/folders that match the exclude filter
boolean m_fingerprint // Do Jenkins fingerprinting on imported artifacts
boolean m_nested // Import all child artifacts too (identified in the related meta info
boolean m_flatten // Flatten files and folders imported
boolean m_includemetainfilter // Make sure meta is also included in filter
boolean m_clean // Clean import folder before obtaining artifacts
boolean m_appendtoparentmeta // Append to parent meta
String m_sourceselect // Where are the artifacts coming from
String m_jobname
def m_buildnumberorselector
String m_repo
String m_revision
ImportOptions(script,
String sourceselect = 'Jenkins job artifact',
boolean incrementversionnumber = true,
String filter = '',
String excludes = '',
boolean fingerprint = false,
boolean nested = false,
boolean flatten = false,
boolean includemetainfilter = true,
boolean clean = true,
appendtoparentmeta = true) {
m_script = script
m_sourceselect = sourceselect.trim()
m_incrementversionnumber = incrementversionnumber
m_filter = filter.trim()
m_excludes = excludes.trim()
m_fingerprint = fingerprint
m_nested = nested
m_flatten = flatten
m_includemetainfilter = includemetainfilter
m_clean = clean
m_appendtoparentmeta = appendtoparentmeta
}
void setsourceselect(String sourceselect) {
sourceselect = sourceselect.trim()
switch (sourceselect) {
case 'Jenkins job artefact':
m_sourceselect = 'Jenkins job artifact'
break
case 'Jenkins job artifact':
case 'Release repository':
m_sourceselect = sourceselect
break
default:
error("Unknown type of artifact source select: ${m_sourceselect}")
}
}
void setincrementversionnumber(boolean incrementversionnumber = true) {
m_incrementversionnumber = incrementversionnumber
}
void setfilter(String filter) {
m_filter = filter.trim()
}
void setexcludes(String excludes) {
m_excludes = excludes.trim()
}
void setfingerprint(boolean fingerprint = true) {
m_fingerprint = fingerprint
}
void setnested(boolean nested = true) {
m_nested = nested
}
void flattenimports(boolean flatten = true) {
m_flatten = flatten
}
void includemetainfilter(boolean includemetainfilter = true) {
m_includemetainfilter = includemetainfilter
}
void clean(boolean clean = true) {
m_clean = clean
}
void setappendtoparentmeta(boolean appendtoparentmeta) {
m_appendtoparentmeta = appendtoparentmeta
}
void jenkinsjob(String jobname, String buildnumberorselector) {
m_jobname = jobname.trim()
m_buildnumberorselector = buildnumberorselector.trim()
setsourceselect('Jenkins job artifact')
}
void releaserepo(String repo, String revision) {
m_repo = repo.trim()
m_revision = revision.trim()
setsourceselect('Release repository')
}
void source(String sourceselect, String jobname, String buildnumberorselector, String repo, String revision) {
jenkinsjob(jobname, buildnumberorselector)
releaserepo(repo, revision)
setsourceselect(sourceselect)
}
}
ImportOptions getNewImportOptions() {
return new ImportOptions(this)
}
def formFilter(ImportOptions importoptions) {
def String filter = importoptions.m_filter
if (filter != '') {
if (importoptions.m_includemetainfilter) {
filter = 'meta/**,' + filter
}
}
echo "Import options filter is: ${filter}"
return filter
}
def conditionalClean(ImportOptions importoptions, String destpath) {
if (importoptions.m_clean) {
echo "Cleaning ${destpath}"
dir(destpath) {
deleteDir()
}
}
}
def artifactimportfrombuildjob(meta, importoptions, String destpath) {
if (importoptions.m_sourceselect != 'Jenkins job artifact') {
error("Import options settings have not been set for: Jenkins job artifact")
return
}
conditionalClean(importoptions, destpath)
copyArtifacts(
filter: formFilter(importoptions),
excludes: importoptions.m_excludes,
fingerprintArtifacts: importoptions.m_fingerprint,
projectName: importoptions.m_jobname,
selector: [
$class: 'ParameterizedBuildSelector',
parameterName: importoptions.m_buildnumberorselector
],
flatten: importoptions.m_flatten,
target: destpath
)
def importedmeta = meta.importrelated(importoptions.m_appendtoparentmeta, destpath)
if (importoptions.m_incrementversionnumber) {
meta.buildstampinfo.changerevision(versiongenerator.incrementrevision(meta.buildstampinfo.revision, importedmeta.buildstampinfo.revision))
}
return importedmeta
}
def rewritemetafileasreleased(meta, String filepath) {
// Modify the meta info to say that is has already been released
meta.markreleased()
meta.saveJsonSerialised(filepath)
}
def hierarchyartifactimportfromrepo(meta, importoptions, String destpath) {
if (importoptions.m_sourceselect != 'Release repository') {
error("Import options settings have not been set for: Release repository")
return
}
def rooturl = importoptions.m_repo
def rootrevision = importoptions.m_revision
echo "Cloning root release repo: ${rooturl}, revision: ${rootrevision} at folder: ${destpath}"
conditionalClean(importoptions, destpath)
def ArrayList<String> sparseitemlist = gh.convertSparseItemsString(formFilter(importoptions))
gh.gitCheckoutAlt(rooturl, rootrevision, destpath, "", 1, true, sparseitemlist)
def importedmeta = meta.importrelated(importoptions.m_appendtoparentmeta, destpath, rooturl, rootrevision, gh.getGitInfo(destpath))
relatedimportinfo = importedmeta.getassociated()
echo "Cloning associated repos"
for(relatedmetainfo in relatedimportinfo) {
def relatedmeta = relatedmetainfo.meta
def relatedoffsetpath = relatedmetainfo.offsetpath
def cloneurl = relatedmeta.releaseinfo.releaserepoURL
def clonerevision = "refs/tags/${relatedmeta.releasetag()}"
def clonepath = "${destpath}/${relatedoffsetpath}"
echo "Cloning release repo: ${cloneurl}, revision: ${clonerevision} at folder: ${clonepath}"
gh.gitCheckoutAlt(cloneurl, clonerevision, clonepath, "", 1, true, [])
gh.stripgithistory(clonepath)
def metafilepath = "${clonepath}/${relatedmeta.metafilepath()}"
echo "Marking related meta as released and rewriting meta file: ${metafilepath}"
rewritemetafileasreleased(relatedmeta, metafilepath)
}
gh.stripgithistory(destpath)
def metafilepath = "${destpath}/${meta.metafilepath()}"
echo "Marking root meta as released and rewriting meta file: ${metafilepath}"
rewritemetafileasreleased(importedmeta, metafilepath)
if (importoptions.m_incrementversionnumber) {
meta.buildstampinfo.changerevision(versiongenerator.incrementrevision(meta.buildstampinfo.revision, importedmeta.buildstampinfo.revision))
}
return importedmeta
}
def artifactimportfromrepo(meta, importoptions, String destpath) {
if (importoptions.m_sourceselect != 'Release repository') {
error("Import options settings have not been set for: Release repository")
return
}
conditionalClean(importoptions, destpath)
def rooturl = importoptions.m_repo
def rootrevision = importoptions.m_revision
echo "Cloning release repo: ${rooturl}, revision: ${rootrevision} at folder: ${destpath}"
def ArrayList<String> sparseitemlist = gh.convertSparseItemsString(formFilter(importoptions))
gh.gitCheckoutAlt(rooturl, rootrevision, destpath, "", 1, true, sparseitemlist)
def importedmeta = meta.importrelated(importoptions.m_appendtoparentmeta, destpath, rooturl, rootrevision, gh.getGitInfo(destpath))
gh.stripgithistory(destpath)
def metafilepath = "${destpath}/${meta.metafilepath()}"
echo "Marking meta as released and rewriting meta file: ${metafilepath}"
rewritemetafileasreleased(importedmeta, metafilepath)
if (importoptions.m_incrementversionnumber) {
meta.buildstampinfo.changerevision(versiongenerator.incrementrevision(meta.buildstampinfo.revision, importedmeta.buildstampinfo.revision))
}
return importedmeta
}
def artifactimport(meta, importoptions, String destpath) {
switch (importoptions.m_sourceselect) {
case 'Jenkins job artifact':
case 'Jenkins job artefact':
return artifactimportfrombuildjob(meta, importoptions, destpath)
case 'Release repository':
if (importoptions.m_nested) {
return hierarchyartifactimportfromrepo(meta, importoptions, destpath)
}
return artifactimportfromrepo(meta, importoptions, destpath)
default:
error("Unknown type of artifact source: ${source}")
}
return meta
}
// Deprecated (use above)
def artifactimport(meta,
String sourceselect,
String jenkinsjob,
buildnumberorselector,
String repo,
String revision,
String destpath,
boolean incrementversionnumber = true,
String filter = '',
String excludes = '',
boolean fingerprint = false,
boolean nested = false) {
echo "DEPRECATED method: artifactimport(meta, String source, String jenkinsjob, buildnumberorselector, String repo, String revision, String destpath ...)"
def importoptions = getNewImportOptions()
importoptions.source(sourceselect, jenkinsjob, buildnumberorselector, repo, revision)
importoptions.setincrementversionnumber(incrementversionnumber)
importoptions.setfilter(filter)
importoptions.setexcludes(excludes)
importoptions.setfingerprint(fingerprint)
importoptions.setnested(nested)
return artifactimport(meta, importoptions, destpath)
}
// Deprecated (use above)
def artifactimport(meta,
String buildjob,
int buildnumber,
String destpath,
boolean incrementversionnumber = true,
String filter = '**',
String excludes = '',
boolean fingerprint = false) {
echo "DEPRECATED method: artifactimport(meta, String buildjob, int buildnumber, String destpath, ...)"
def importoptions = getNewImportOptions()
importoptions.jenkinsjob(buildjob, "<SpecificBuildSelector plugin='copyartifact@1.41'> <buildNumber>${buildnumber}</buildNumber></SpecificBuildSelector>")
importoptions.setincrementversionnumber(incrementversionnumber)
importoptions.setfilter(filter)
importoptions.setexcludes(excludes)
importoptions.setfingerprint(fingerprint)
return artifactimport(meta, importoptions, destpath)
}
// Deprecated (use above)
def artifactimport(meta,
String buildjob,
buildnumberorselector,
String destpath,
boolean incrementversionnumber = true,
String filter = '',
String excludes = '',
boolean fingerprint = false) {
echo "DEPRECATED method: artifactimport(meta, String buildjob, buildnumberorselector, String destpath, ...)"
def importoptions = getNewImportOptions()
importoptions.jenkinsjob(buildjob, buildnumberorselector)
importoptions.setincrementversionnumber(incrementversionnumber)
importoptions.setfilter(filter)
importoptions.setexcludes(excludes)
importoptions.setfingerprint(fingerprint)
return artifactimport(meta, importoptions, destpath)
}
return this;

View file

@ -1,319 +0,0 @@
pipeline {
agent { label "${AGENT_LABEL}" }
stages {
stage('Initial setup') {
steps {
script {
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startbuild(this, PRODUCT_NAME, SUBCOMPONENT_NAME, RELEASE_REPO)
if (INSTALLSHIELD2015_CMD == "" || INSTALLSHIELD2018_CMD == "" || INSTALLSHIELD2019_CMD == "" || DOTNET_FRAMEWORK64_PATH == "" || WINDOWS_DRIVER_KIT_8_1 == "") {
echo "Either INSTALLSHIELD2015_CMD, INSTALLSHIELD2018_CMD, INSTALLSHIELD2019_CMD, DOTNET_FRAMEWORK64_PATH or WINDOWS_DRIVER_KIT_8_1 environment variables have not been defined"
currentBuild.result = 'FAILED'
exit(1)
}
installerlist = env.INSTALLERS_TO_BUILD
if (installerlist != null) {
installerlist = installerlist.trim()
} else {
installerlist = ''
}
toBuild = []
if (installerlist) {
toBuildUntrimmed = installerlist.split(',')
toBuildUntrimmed.each {
toBuild.add(it.trim())
}
}
}
echo "Installer list: ${installerlist}"
}
}
stage('Nothing to build check') {
when {
expression {
!toBuild
}
}
steps {
echo 'No installers to build'
script {
currentBuild.result = 'UNSTABLE'
}
}
}
stage('Checkout dependencies') {
when {
expression {
toBuild
}
}
steps {
script {
configurationhelper = autobuilder.configurationhelper()
PYTHONURL = 'git@hydra:tools/python.git'
PYTHONBRANCH = 'origin/3.6.3_windows'
PYTHONDIR = "${WORKSPACE}/python"
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR)
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
SUPPORTURL = 'git@hydra:gis/gissupport.git'
SUPPORTBRANCH = 'origin/master'
SUPPORTDIR = "${WORKSPACE}\\gissupport"
configurationhelper.gitCheckoutAndRegister(meta, 'gissupport', SUPPORTURL, SUPPORTBRANCH, SUPPORTDIR)
env.INST_SUPPORT = SUPPORTDIR
EULAURL = 'git@hydra:gis/giseula.git'
EULABRANCH = 'origin/master'
EULADIR = "${WORKSPACE}\\giseula"
configurationhelper.gitCheckoutAndRegister(meta, 'giseula', EULAURL, EULABRANCH, EULADIR)
env.INST_EULA = EULADIR
PREREQURL = 'git@hydra:gis/installerprerequisites.git'
PREREQBRANCH = 'origin/master'
PREREQDIR = "${WORKSPACE}\\prereq"
configurationhelper.gitCheckoutAndRegister(meta, 'installerprerequisites', PREREQURL, PREREQBRANCH, PREREQDIR)
env.INST_PREQ = PREREQDIR
DIGSIGURL = 'git@hydra:gis/digitalsignature.git'
DIGSIGBRANCH = 'origin/master'
DIGSIGDIR = "${WORKSPACE}\\certificates"
configurationhelper.gitCheckoutAndRegister(meta, 'digitalsignature', DIGSIGURL, DIGSIGBRANCH, DIGSIGDIR)
env.PATH_TO_CERTIFICATE_PFX = "${DIGSIGDIR}\\GIS"
}
}
}
stage('Checkout source') {
steps {
script {
SOURCEURL = 'git@hydra:atlas-ui-modules/custom-modules.git'
SOURCEREVISION = SOURCE_REVISION
SOURCEDIR = "${WORKSPACE}\\custom_modules"
configurationhelper.gitCheckoutAndRegister(meta, 'custom_modules', SOURCEURL, SOURCEREVISION, SOURCEDIR, '', 0, false)
env.SOURCE_PATH = SOURCEDIR
env.INST_RELEASE_NOTES = "${SOURCE_PATH}\\releasenotes"
env.INST_SRC = "${SOURCE_PATH}\\src"
env.ATLAS_SOURCE_PATH = SOURCE_PATH
}
}
}
stage("Clean exports") {
steps {
script {
env.IMPORTSPATH = "${WORKSPACE}\\imports"
env.INTERMEDIATEEXPORTSPATH = "${WORKSPACE}\\info"
env.EXPORTSPATH = "installers"
env.PS_ARTIFACTS_ROOT = "${IMPORTSPATH}\\ps_bin"
env.VERSIONINFO = "${WORKSPACE}\\versioninfo"
env.PSBIN = "${WORKSPACE}/ps_bin"
env.ASBIN = "${WORKSPACE}/as_bin"
cleanfolders = [
"${IMPORTSPATH}",
"${INTERMEDIATEEXPORTSPATH}",
"${EXPORTSPATH}",
"${WORKSPACE}/mcs_bin",
"${VERSIONINFO}",
PSBIN,
ASBIN,
]
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
cleaner.clean(cleanfolders)
}
}
}
stage('Generating version info') {
when {
expression {
toBuild
}
}
steps {
script {
version = load("${autobuilder.commonscripts()}/versionnumbering/generate.groovy")
version.generate(meta, SOURCE_REVISION, SOURCE_PATH)
}
}
}
stage('Get Atlas UI buildstamp') {
when {
expression {
toBuild
}
}
steps {
script {
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
def importoptions = importer.getNewImportOptions()
importoptions.jenkinsjob(ATLAS_CUSTOM_MODULES_COMPILE_JOB, ATLAS_CUSTOM_MODULES_COMPILE_JOB_SELECTOR)
importoptions.setincrementversionnumber(false)
def compilemeta = importer.artifactimport(meta, importoptions, "${IMPORTSPATH}\\build\\moduleset")
def maxdepth = 2
def relatedcomponents = compilemeta.releasewalkerunique(maxdepth.toInteger())
atlasuibinariesmeta = relatedcomponents['ATLAS_UI_CORE_BINARIES']
env.ATLAS_UI_BUILD_STAMP = atlasuibinariesmeta.buildstampinfo.buildstamp
echo "Build stamp of associated Atlas UI: ${ATLAS_UI_BUILD_STAMP}"
}
}
}
stage("Import binaries 2") {
when {
expression {
toBuild
}
}
steps {
script {
artifactDetails = [
// Key, Artifacts Source project Artifacts source selector, Destination folder Increment Version Number Artifacts to copy Artifacts to not copy Binaries Folders
ModuleSet: [ATLAS_CUSTOM_MODULES_COMPILE_JOB, ATLAS_CUSTOM_MODULES_COMPILE_JOB_SELECTOR, "${IMPORTSPATH}\\build\\moduleset", false, 'meta/**, bin/**', '**/*.lib', [ 'bin' ], ],
]
installerDetails = [
// Key, Installer command artifactSet Target folder Execution path ISM project file Variant Intermediate output path Component base folder Final filename
OUTPUT_SIMULATOR: [INSTALLSHIELD2019_CMD, ['ModuleSet'], 'module', "${SOURCE_PATH}\\installer\\build\\moduleset", 'CM_output_simulate.ism', '', "${INTERMEDIATEEXPORTSPATH}/module/x64/GIS Atlas UI Custom Module - Output Simulator/DiskImages/DISK1/GIS Atlas UI Custom Module - Output Simulator.exe", "${EXPORTSPATH}/GIS Atlas UI Custom Module - Output Simulator", "GIS Atlas UI Custom Module - Output Simulator ${ATLAS_UI_BUILD_STAMP}.exe" ],
SCANNING_XY_CAMERA_ALIGN: [INSTALLSHIELD2019_CMD, ['ModuleSet'], 'module', "${SOURCE_PATH}\\installer\\build\\moduleset", 'CM_scanning_xy_camera_align.ism', '', "${INTERMEDIATEEXPORTSPATH}/module/x64/GIS Atlas UI Custom Module - Scanning XY Camera Align/DiskImages/DISK1/GIS Atlas UI Custom Module - Scanning XY Camera Align.exe","${EXPORTSPATH}/GIS Atlas UI Custom Module - Scanning XY Camera Align", "GIS Atlas UI Custom Module - Scanning XY Camera Align ${ATLAS_UI_BUILD_STAMP}.exe" ],
IMAGE_CONVERTER: [INSTALLSHIELD2019_CMD, ['ModuleSet'], 'module', "${SOURCE_PATH}\\installer\\build\\moduleset", 'CM_image_convert.ism', '', "${INTERMEDIATEEXPORTSPATH}/module/x64/GIS Atlas UI Custom Module - Image Conversion/DiskImages/DISK1/GIS Atlas UI Custom Module - Image Conversion.exe", "${EXPORTSPATH}/GIS Atlas UI Custom Module - Image Conversion", "GIS Atlas UI Custom Module - Image Conversion ${ATLAS_UI_BUILD_STAMP}.exe" ],
LINEARISATION_IMPORTER: [INSTALLSHIELD2019_CMD, ['ModuleSet'], 'module', "${SOURCE_PATH}\\installer\\build\\moduleset", 'CM_linear_import.ism', '', "${INTERMEDIATEEXPORTSPATH}/module/x64/GIS Atlas UI Custom Module - Linearisation Importer/DiskImages/DISK1/GIS Atlas UI Custom Module - Linearisation Importer.exe", "${EXPORTSPATH}/GIS Atlas UI Custom Module - Linearisation Importer", "GIS Atlas UI Custom Module - Linearisation Importer ${ATLAS_UI_BUILD_STAMP}.exe" ],
DIRECT_TO_SHAPE: [INSTALLSHIELD2019_CMD, ['ModuleSet'], 'module', "${SOURCE_PATH}\\installer\\build\\moduleset", 'CM_direct_to_shape.ism', '', "${INTERMEDIATEEXPORTSPATH}/module/x64/GIS Atlas UI Custom Module - Direct To Shape/DiskImages/DISK1/GIS Atlas UI Custom Module - Direct To Shape.exe", "${EXPORTSPATH}/GIS Atlas UI Custom Module - Direct To Shape", "GIS Atlas UI Custom Module - Direct To Shape ${ATLAS_UI_BUILD_STAMP}.exe" ],
PRINTHEAD_PROFILER: [INSTALLSHIELD2019_CMD, ['ModuleSet'], 'module', "${SOURCE_PATH}\\installer\\build\\moduleset", 'CM_printhead_profiler.ism', '', "${INTERMEDIATEEXPORTSPATH}/module/x64/GIS Atlas UI Custom Module - Printhead Profiler/DiskImages/DISK1/GIS Atlas UI Custom Module - Printhead Profiler.exe", "${EXPORTSPATH}/GIS Atlas UI Custom Module - Printhead Profiler", "GIS Atlas UI Custom Module - Printhead Profiler ${ATLAS_UI_BUILD_STAMP}.exe" ],
COMMON_LIBRARIES: [INSTALLSHIELD2019_CMD, ['ModuleSet'], 'module', "${SOURCE_PATH}\\installer\\build\\moduleset", 'CM_common.ism', '', "${INTERMEDIATEEXPORTSPATH}/module/x64/GIS Atlas UI Custom Module - Common Lib/DiskImages/DISK1/GIS Atlas UI Custom Module - Common Lib.exe", "${EXPORTSPATH}/GIS Atlas UI Custom Module - Common Lib", "GIS Atlas UI Custom Module - Common Lib ${ATLAS_UI_BUILD_STAMP}.exe" ],
ENC_AND_PD: [INSTALLSHIELD2019_CMD, ['ModuleSet'], 'module', "${SOURCE_PATH}\\installer\\build\\moduleset", 'CM_enc_and_pd.ism', '', "${INTERMEDIATEEXPORTSPATH}/module/x64/GIS Atlas UI Custom Module - Enc and PD/DiskImages/DISK1/GIS Atlas UI Custom Module - Enc and PD.exe", "${EXPORTSPATH}/GIS Atlas UI Custom Module - Enc and PD", "GIS Atlas UI Custom Module - Enc and PD ${ATLAS_UI_BUILD_STAMP}.exe" ],
LOG_VIEWER: [INSTALLSHIELD2019_CMD, ['ModuleSet'], 'module', "${SOURCE_PATH}\\installer\\build\\moduleset", 'CM_log_viewer.ism', '', "${INTERMEDIATEEXPORTSPATH}/module/x64/GIS Atlas UI Custom Module - Log Viewer/DiskImages/DISK1/GIS Atlas UI Custom Module - Log Viewer.exe", "${EXPORTSPATH}/GIS Atlas UI Custom Module - Log Viewer", "GIS Atlas UI Custom Module - Log Viewer ${ATLAS_UI_BUILD_STAMP}.exe" ],
COMPONENT_MONITOR: [INSTALLSHIELD2019_CMD, ['ModuleSet'], 'module', "${SOURCE_PATH}\\installer\\build\\moduleset", 'CM_component_monitor.ism', '', "${INTERMEDIATEEXPORTSPATH}/module/x64/GIS Atlas UI Custom Module - Component Monitor/DiskImages/DISK1/GIS Atlas UI Custom Module - Component Monitor.exe", "${EXPORTSPATH}/GIS Atlas UI Custom Module - Component Monitor", "GIS Atlas UI Custom Module - Component Monitor ${ATLAS_UI_BUILD_STAMP}.exe" ],
]
installerhelper = load("${autobuilder.commonscripts()}/install/installhelper.groovy")
artifactFetched = installerhelper.artifactsImporter(meta, importer, artifactDetails, installerDetails)
}
}
}
stage("Generate version info folder for installer") {
steps {
script {
def metamap = [
[VERSIONINFO, meta], // Incomplete until this job ends
]
for (metaitem in metamap) {
(destfolder, componentmeta) = metaitem
dir(destfolder) {
componentmeta.saveJsonSerialised("meta.json")
}
}
}
}
}
stage("Build installers") {
when {
expression {
toBuild
}
}
steps {
script {
fileOperations([folderCreateOperation(INTERMEDIATEEXPORTSPATH)])
installerpublishlist = []
for (installer in toBuild) {
(installcmd, artifactKey, processingFolder, EXECUTIONPATH, ISMPROJECT, VARIANT, pathToIntermediate, FINALBASEFOLDER, FINALFILENAME) = installerDetails.get(installer)
if (artifactKey instanceof java.util.ArrayList) {
artifactKey = artifactKey[0]
}
def importmeta = artifactFetched.get(artifactKey)
echo "For: ${installer} build stamp is: ${ATLAS_UI_BUILD_STAMP}"
def INST_ISVERSION = ATLAS_UI_BUILD_STAMP
(sourceProject, sourceselector, destFolder, incrementversionnumber, toCopy, notToCopy, binariesFolders) = artifactDetails.get(artifactKey)
def COMPILE_IMPORTS = destFolder
def INST_VERBOSE = ''
if (VERBOSE == "true") {
INST_VERBOSE = '-v'
}
def INST_OUT = "${INTERMEDIATEEXPORTSPATH}\\${processingFolder}"
fileOperations([folderCreateOperation(INST_OUT)])
def INST_VARIANT = ''
if (VARIANT != "" ) {
INST_VARIANT = '-r ' + VARIANT
}
installerhelper.checkISMfile("${EXECUTIONPATH}\\${ISMPROJECT}")
installerhelper.selectSigningCertificate(NODE_NAME, "${EXECUTIONPATH}\\${ISMPROJECT}")
dir(EXECUTIONPATH) {
// INSTALLSHIELD201X_CMD and DOTNET_FRAMEWORK64_PATH must be externally defined
bat """
set INST_COMMON_PARAMETERS=-y "${INST_ISVERSION}" -l "WORKSPACE=${WORKSPACE}" -l "PATH_TO_CERTIFICATE_PFX=${PATH_TO_CERTIFICATE_PFX}" -l "COMPILE_IMPORTS=${COMPILE_IMPORTS}" -l "IMPORTS_ROOT=${IMPORTSPATH}" -l "PS_ARTIFACTS_ROOT=${PS_ARTIFACTS_ROOT}" -l "INST_RELEASE_NOTES=${INST_RELEASE_NOTES}" -l "INST_SRC=${INST_SRC}" -l "INST_OUT=${INST_OUT}" -l "INST_EULA=${INST_EULA}" -l "INST_SUPPORT=${INST_SUPPORT}" -prqpath "${INST_PREQ}" ${INST_VERBOSE}
"${installcmd}" -t "${DOTNET_FRAMEWORK64_PATH}" -p "${ISMPROJECT}" %INST_COMMON_PARAMETERS% ${INST_VARIANT} -a x64"
"""
}
installerhelper.copyToFinalPosition(pathToIntermediate, FINALBASEFOLDER, FINALFILENAME)
def EXPORT_OUT_GLOB = "${FINALBASEFOLDER}/**"
echo "Adding ${EXPORT_OUT_GLOB} to installer publish list"
installerpublishlist.add(EXPORT_OUT_GLOB)
}
}
}
}
stage('Classifying publishable artifacts') {
when {
expression {
toBuild
}
}
steps {
script {
def publishable = installerpublishlist
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
publishutils.generatelist(meta, publishable)
}
}
}
stage('Archiving artifacts') {
when {
expression {
toBuild
}
}
steps {
script {
ArrayList<String> itemsForRelease = ["info/**", "installers/**"]
def artifactlist = meta.generateartifacts(itemsForRelease)
archiveArtifacts "${artifactlist}"
}
}
}
stage('Check for unstable build') {
when {
expression {
toBuild
}
}
steps {
script {
def installersToBuild = installerDetails.size()
if (installersToBuild != toBuild.size()) {
echo "Not building the complete set of installers (${installersToBuild}) therefore marking building unstable"
currentBuild.result = 'UNSTABLE'
}
}
}
}
}
post {
always {
echo 'Post-build'
}
failure {
echo 'Failed build'
}
unstable {
echo 'Unstable build'
}
success {
echo 'Succeeded build'
}
}
}

View file

@ -0,0 +1,117 @@
import hudson.FilePath
// Transfer file from intermediate position to final position;
// creating necessary folders on the way;
// deleting intermediate file
def copyToFinalPosition(String pathToIntermediate, String finalBaseFolder, String finalFilename) {
def channel = Jenkins.getInstance().getComputer(env['NODE_NAME']).getChannel()
def String abs_exports_root_path = "${WORKSPACE}/${finalBaseFolder}"
def String abs_export_out = "${abs_exports_root_path}/${finalFilename}"
def export_filepath = new hudson.FilePath(channel, abs_export_out)
def export_out_folder = export_filepath.getParent()
def export_out_folder_string = export_out_folder.toString()
def export_out_file = export_filepath.getName()
echo "Creating folder ${export_out_folder_string}"
export_out_folder.mkdirs()
echo "Copying from ${pathToIntermediate} to ${abs_export_out}"
def intermediate_filepath = new hudson.FilePath(channel, pathToIntermediate)
intermediate_filepath.copyTo(export_filepath)
intermediate_filepath.delete()
}
// Given details about artifacts to import and details of installers to build, import artifacts that are required
def Map artifactsImporter(meta, importer, artifactDetails, installerDetails) {
artifactFetched = [:]
def importoptions = importer.getNewImportOptions()
for (installer in toBuild) {
def artifactKeys = installerDetails.get(installer)[1]
if (artifactKeys instanceof java.lang.String) {
artifactKeys = [ artifactKeys ]
}
for (artifactKey in artifactKeys) {
(sourceProject, sourceselector, destFolder, incrementversionnumber, toCopy, notToCopy, binariesFolders) = artifactDetails.get(artifactKey)
if (artifactFetched.get(artifactKey) == null) {
importoptions.jenkinsjob(sourceProject, sourceselector)
importoptions.setincrementversionnumber(incrementversionnumber)
importoptions.setfilter(toCopy)
importoptions.setexcludes(notToCopy)
def importmeta = importer.artifactimport(meta, importoptions, destFolder)
artifactFetched.put(artifactKey, importmeta)
}
}
}
return artifactFetched
}
@NonCPS
def checkISMfilebackend(String xml) {
def String message = ""
def parsedxml = new XmlParser(true, true, true).parseText(xml)
def pathvariableinfo = [:]
def exitcode = 0
// Load up a map of path variable and path pairs
// Ignore blank path definitions
// Ignore the workspace definition which should have the only absolute path
parsedxml.each{ table ->
if (table.@name == "ISPathVariable") {
table['row'].each{ row ->
def pathname = row['td'][0].value()[0]
def path = row['td'][1].value()[0]
if (path && pathname != 'WORKSPACE') {
pathvariableinfo[pathname] = path
}
}
}
}
// Check that each path variable is defined beginning with a path variable or the WORKSPACE one
pathvariableinfo.each{ pair ->
message += "pair key: ${pair.key} value: ${pair.value}\n"
def path = pair.value
def pathvarmatcher = path =~ /<(.*)>.*/
if (pathvarmatcher.matches()) {
def pathvarfound = pathvarmatcher.group(1)
if (pathvarfound != 'WORKSPACE') {
if (!pathvariableinfo.containsKey(pathvarfound)) {
message += "Undefined path variable ${pathvarfound} found\n"
exitcode = 1
}
}
} else {
message += "Path: ${path} does not begin with a path variable\n"
exitcode = 1
}
}
return [exitcode, message]
}
def checkISMfile(String ISMfile) {
echo "Checking ISM file: ${ISMfile}"
def xml = readFile(ISMfile)
(exitcode, message) = checkISMfilebackend(xml)
echo message
if (exitcode > 0) {
error "ISM file errors found"
} else {
echo "Checked ISM file - ok"
}
}
certificatethumbprints = [:]
certificatethumbprints['floreana'] = '0FDEB0A227982C877146CA595091173AC9655479' // Authoring takes place on this machine - so this is what should be in the ISM file already
certificatethumbprints['hawaii'] = '49FD1B361CFF35014B81940C5B046543045DD34B'
def selectSigningCertificate(String nodeName, String ISMfile) {
def masterpattern = '0FDEB0A227982C877146CA595091173AC9655479'
echo "Substituting occurrences of ${masterpattern} with ${certificatethumbprints[nodeName]} in ISM file: ${ISMfile}"
textutils_subst = load("${autobuilder.commonscripts()}/textutils/subst.groovy")
textutils_subst.substitute(ISMfile, masterpattern, certificatethumbprints[nodeName])
}
return this;

View file

@ -1,164 +0,0 @@
pipeline {
agent { label "${AGENT_LABEL}" }
stages {
stage('Initial setup') {
steps {
script {
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
}
}
}
stage('Checkout dependencies') {
steps {
script {
configurationhelper = autobuilder.configurationhelper()
PYTHONURL = 'git@hydra:tools/python.git'
PYTHONBRANCH = 'origin/3.6.3_windows'
PYTHONDIR = "${WORKSPACE}/python"
PYTHONROOTDIR = 'python'
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR, PYTHONROOTDIR)
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
VERSTAMPINGURL = 'git@hydra:releases/ver_stamping_releases.git'
VERSTAMPINGREVISION = "refs/tags/${VERSION_STAMPING_VERSION}"
VERSTAMPINGDIR = "${WORKSPACE}/ver_stamping"
VERSTAMPINGROOTDIR = 'ver_stamping_releases'
configurationhelper.gitCheckoutAndRegister(meta, 'Version stamping', VERSTAMPINGURL, VERSTAMPINGREVISION, VERSTAMPINGDIR, VERSTAMPINGROOTDIR)
}
}
}
stage('Checkout source') {
steps {
script {
SOURCEURL = 'git@hydra:gis/atlas_ui.git'
SOURCEREVISION = SOURCE_REVISION
SOURCEDIR = "${WORKSPACE}\\atlas_ui"
SOURCEROOTDIR = 'atlas_ui'
configurationhelper.gitCheckoutAndRegister(meta, 'atlas_ui', SOURCEURL, SOURCEREVISION, SOURCEDIR, SOURCEROOTDIR, 0, false)
env.SOURCE_PATH = SOURCEDIR
env.JOBSCRIPTS = "${SOURCE_PATH}\\autobuild\\localisation_test"
env.JOBSCRIPTS_COMMON = "${SOURCE_PATH}\\autobuild\\common"
env.SRC = SOURCE_PATH
}
}
}
stage('Clean exports') {
steps {
script {
env.BUILDOUTPUT = "${WORKSPACE}/build"
env.AULIB = "${WORKSPACE}/atlaslibraries"
cleanfolders = [
BUILDOUTPUT,
AULIB,
"${WORKSPACE}/bin",
"${WORKSPACE}/documentation",
]
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
cleaner.clean(cleanfolders)
}
}
}
stage('Generating version info') {
steps {
script {
version = load("${autobuilder.commonscripts()}/versionnumbering/generate.groovy")
version.generate(meta, SOURCE_REVISION, SOURCE_PATH, BASEBUILDNUMBER)
}
}
}
stage('Import Atlas UI libraries') {
steps {
script {
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
libmeta = importer.artifactimport(meta,
ATLAS_UI_ARTIFACT_LOCATION,
ATLAS_UI_COMPILE_JOB,
ATLAS_UI_BUILD_SELECTOR,
ATLAS_UI_RELEASE_REPO,
ATLAS_UI_RELEASE_REVISION,
AULIB,
false,
"LocalisationSDK/**")
}
}
}
stage('Check localisations are correct') {
steps {
script {
env.SRC_REVISION=SOURCE_REVISION
bat """
call "${JOBSCRIPTS}\\test_localisations.bat"
if errorlevel 1 exit /b 1
"""
}
}
}
stage('Prepare exports') {
steps {
script {
bat """
move "${AULIB}\\LocalisationSDK\\bin" .
if errorlevel 1 exit /b 1
"""
}
}
}
stage('Scan for warnings') {
steps {
script {
recordIssues(tools: [
msBuild(enabledForFailure: true, reportEncoding: 'UTF-8'),
])
}
}
}
stage('Checksum artifacts') {
steps {
script {
def checksummable = [
/* Binaries are signed
'build/**',
'SharedPackages/**',
*/
]
checksumutils = load("${autobuilder.commonscripts()}/checksum/utils.groovy")
checksumutils.generatelist(meta, checksummable)
}
}
}
stage('Classifying publishable artifacts') {
steps {
script {
def publishable = [
]
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
publishutils.generatelist(meta, publishable)
}
}
}
stage('Archiving artifacts') {
steps {
script {
def artifactlist = meta.generateartifacts(["bin/**"])
archiveArtifacts "${artifactlist}"
}
}
}
}
post {
always {
echo 'Post-build'
}
failure {
echo 'Failed build'
}
unstable {
echo 'Unstable build'
}
success {
echo 'Succeeded build'
}
}
}

772
meta/folder.groovy Normal file
View file

@ -0,0 +1,772 @@
import java.nio.file.Paths
import java.nio.file.Path
import groovy.json.JsonSlurperClassic
abstract class GISJsonSerialised implements Serializable {
def script
GISJsonSerialised(script) {
this.script = script
}
abstract LinkedHashMap serialisationdata()
abstract void deserialiseJson(rawmeta)
def saveJsonSerialised(String outputfile, int prettylevel = 4) {
def outJson = script.readJSON text: groovy.json.JsonOutput.toJson(serialisationdata())
script.writeJSON(file: outputfile, json: outJson, pretty: prettylevel)
}
}
class ProductInfo extends GISJsonSerialised {
String productname
String subcomponentname
ProductInfo(script, productname = "", subcomponentname = "") {
super(script)
this.productname = productname
this.subcomponentname = subcomponentname
}
void set(String productname, String subcomponentname) {
// Make sure the fields can be used in git tags
def int pstatus = 0
if (script.isUnix()) {
pstatus = script.sh(script: "git check-ref-format --normalize \"refs/tags/${productname}\" >/dev/null 2>/dev/null", , returnStatus: true)
}
else {
pstatus = script.bat(script: "@git check-ref-format --normalize \"refs/tags/${productname}\" > NUL 2> NUL", , returnStatus: true)
}
if (pstatus > 0) {
script.error("The product name: ${productname} needs to be renamed as it cannot be used in a git tag name")
}
def int sstatus = 0
if (script.isUnix()) {
sstatus = script.sh(script: "git check-ref-format --normalize \"refs/tags/${subcomponentname}\" >/dev/null 2>/dev/null", , returnStatus: true)
}
else {
sstatus = script.bat(script: "@git check-ref-format --normalize \"refs/tags/${subcomponentname}\" > NUL 2> NUL", , returnStatus: true)
}
if (sstatus > 0) {
script.error("The subcomponent name: ${subcomponentname} needs to be renamed as it cannot be used in a git tag name")
}
this.productname = productname
this.subcomponentname = subcomponentname
}
void deserialiseJson(rawmeta) {
productname = rawmeta['productname']
subcomponentname = rawmeta['subcomponentname']
}
LinkedHashMap serialisationdata() {
def data = [
'productname' : productname,
'subcomponentname' : subcomponentname,
]
return data
}
}
class GitInfo extends GISJsonSerialised {
private String sourcepath
private String sourcerevision
private String gitrevision
private String remoteurl
private String remoteinfo
GitInfo(script, sourcepath = "", sourcerevision = "", gitrevision = "", remoteurl = "", remoteinfo = "") {
super(script)
this.sourcepath = sourcepath
this.sourcerevision = sourcerevision
this.gitrevision = gitrevision
this.remoteurl = remoteurl
this.remoteinfo = remoteinfo
}
void set(String sourcepath, String sourcerevision, String gitrevision, String remoteurl, String remoteinfo) {
this.sourcepath = sourcepath
this.sourcerevision = sourcerevision
this.gitrevision = gitrevision
this.remoteurl = remoteurl
this.remoteinfo = remoteinfo
}
void deserialiseJson(rawmeta) {
sourcepath = rawmeta['sourcepath']
sourcerevision = rawmeta['sourcerevision']
gitrevision = rawmeta['gitrevision']
remoteurl = rawmeta['remoteurl']
remoteinfo = rawmeta['remoteinfo']
}
LinkedHashMap serialisationdata() {
def data = [
'sourcepath' : sourcepath,
'sourcerevision' : sourcerevision,
'gitrevision' : gitrevision,
'remoteurl' : remoteurl,
'remoteinfo' : remoteinfo,
]
return data
}
}
class JenkinsBuildInfo extends GISJsonSerialised {
String buildjobname
int buildnumber
private String buildmachine
private String builddate
JenkinsBuildInfo(script, String buildjobname = "", int buildnumber = 0, String buildmachine = "", String builddate = "") {
super(script)
this.buildjobname = buildjobname
this.buildnumber = buildnumber
this.buildmachine = buildmachine
this.builddate = builddate
}
void set(String buildjobname, int buildnumber, String buildmachine, String builddate) {
this.buildjobname = buildjobname
this.buildnumber = buildnumber
this.buildmachine = buildmachine
this.builddate = builddate
}
void deserialiseJson(rawmeta) {
buildjobname = rawmeta['buildjobname']
buildnumber = rawmeta['buildnumber']
buildmachine = rawmeta['buildmachine']
builddate = rawmeta['builddate']
}
LinkedHashMap serialisationdata() {
def data = [
'buildjobname' : buildjobname,
'buildnumber' : buildnumber,
'buildmachine' : buildmachine,
'builddate' : builddate,
]
return data
}
}
class BuildStampInfo extends GISJsonSerialised {
String buildstampprefix
int revision
String buildstamp
BuildStampInfo(script, buildstampprefix = "0.30000.0.", revision = 0, buildstamp = "0.30000.0.0") {
super(script)
this.buildstampprefix = buildstampprefix
this.revision = revision
this.buildstamp = buildstamp
}
void set(String buildstampprefix, int revision, String buildstamp) {
this.buildstampprefix = buildstampprefix
this.revision = revision
this.buildstamp = buildstamp
}
String buildstampcommasep() {
def String buildstampcommasep = buildstamp.replace(".", ",")
return buildstampcommasep
}
void changerevision(int newrevision) {
script.echo("Build stamp currently ${buildstamp}")
revision = newrevision
def List buildstampsplit = buildstamp.split('\\.')
buildstampsplit[-1] = newrevision.toString()
buildstamp = buildstampsplit.join('.')
script.echo("Build stamp now ${buildstamp}")
}
void set(String buildstampprefix, int revision) {
buildstampprefix += buildstampprefix.endsWith('.') ? '' : '.'
this.buildstampprefix = buildstampprefix
this.buildstamp = buildstampprefix + "0"
changerevision(revision)
}
void set(String buildstampprefix, String revision = '0') {
set(buildstampprefix, revision.toInteger())
}
void deserialiseJson(rawmeta) {
buildstampprefix = rawmeta['buildstampprefix']
revision = rawmeta['revision']
buildstamp = rawmeta['buildstamp']
}
LinkedHashMap serialisationdata() {
def data = [
'buildstampprefix' : buildstampprefix,
'revision' : revision,
'buildstamp' : buildstamp,
]
return data
}
}
class ReleaseInfo extends GISJsonSerialised {
String releaserepoURL
ArrayList<String> releaseitems
boolean released
ReleaseInfo(script, String releaserepoURL = "", boolean released = false) {
super(script)
this.releaserepoURL = releaserepoURL
this.releaseitems = new ArrayList<String>()
this.released = released
}
void set(String releaserepoURL = "") {
this.releaserepoURL = releaserepoURL
}
void addReleaseItem(String releaseitem) {
script.echo("Adding release item: ${releaseitem} to release items")
releaseitems.add(releaseitem)
}
void markreleased() {
this.released = true
}
List releaseitemssserialised() {
def items = []
for (ri in releaseitems) {
items.add(ri)
}
return items
}
void deserialiseJson(rawmeta) {
releaserepoURL = rawmeta['releaserepoURL']
releaseitems = new ArrayList<String>()
for (rawreleaseitem in rawmeta['releaseitems']) {
releaseitems.add(rawreleaseitem)
}
released = rawmeta['released'] ?: false
}
LinkedHashMap serialisationdata() {
def data = [
'releaserepoURL' : releaserepoURL,
'releaseitems' : releaseitemssserialised(),
'released' : released
]
return data
}
}
class ConfigurationInfo extends GISJsonSerialised {
private String configurationname
private String configurationURL
private String configurationversion
private String configurationSHA
ConfigurationInfo(script, configurationname = "", configurationURL = "", configurationversion = "", configurationSHA = "") {
super(script)
this.configurationname = configurationname
this.configurationURL = configurationURL
this.configurationversion = configurationversion
this.configurationSHA = configurationSHA
}
void deserialiseJson(rawmeta) {
configurationname = rawmeta['configurationname']
configurationURL = rawmeta['configurationURL']
configurationversion = rawmeta['configurationversion']
configurationSHA = rawmeta['configurationSHA']
}
LinkedHashMap serialisationdata() {
def data = [
'configurationname' : configurationname,
'configurationURL' : configurationURL,
'configurationversion' : configurationversion,
'configurationSHA' : configurationSHA,
]
return data
}
}
class ChecksumPair extends GISJsonSerialised {
private String filepath
private String sum
ChecksumPair(script, String filepath = "", String sum = "") {
super(script)
this.filepath = filepath
this.sum = sum
}
void deserialiseJson(rawmeta) {
filepath = rawmeta['filepath']
sum = rawmeta['sum']
}
LinkedHashMap serialisationdata() {
def data = [
'filepath' : filepath,
'sum' : sum,
]
return data
}
}
class ChecksumSet extends GISJsonSerialised {
private String artifactpath
private ArrayList<ChecksumPair> checksumpairs
ChecksumSet(script, artifactpath = "") {
super(script)
this.artifactpath = artifactpath
checksumpairs = new ArrayList<ChecksumPair>()
}
ChecksumPair addChecksumPair(String filepath, String sum) {
def cp = new ChecksumPair(script, filepath, sum)
checksumpairs.add(cp)
return cp
}
List checksumpairsserialised() {
def associated = []
for (cp in checksumpairs) {
associated.add(cp.serialisationdata())
}
return associated
}
void deserialiseJson(rawmeta) {
artifactpath = rawmeta['artifactpath']
checksumpairs = new ArrayList<ChecksumPair>()
for (rawchecksumpair in rawmeta['checksumpairs']) {
def csp = new ChecksumPair(script)
csp.deserialiseJson(rawchecksumpair)
checksumpairs.add(csp)
}
}
LinkedHashMap serialisationdata() {
def data = [
'artifactpath' : artifactpath,
'checksumpairs' : checksumpairsserialised(),
]
return data
}
}
class ChecksumInfo extends GISJsonSerialised {
private ArrayList<ChecksumSet> checksumsets
ChecksumInfo(script) {
super(script)
checksumsets = new ArrayList<ChecksumSet>()
}
ChecksumSet addChecksumSet(String artifactpath) {
def cs = new ChecksumSet(script, artifactpath)
checksumsets.add(cs)
return cs
}
List checksumsetsserialised() {
def associated = []
for (cs in checksumsets) {
associated.add(cs.serialisationdata())
}
return associated
}
void deserialiseJson(rawmeta) {
checksumsets = new ArrayList<ChecksumSet>()
for (rawchecksumset in rawmeta['checksumsets']) {
def cs = new ChecksumSet(script)
cs.deserialiseJson(rawchecksumset)
checksumsets.add(cs)
}
}
LinkedHashMap serialisationdata() {
def data = [
'checksumsets' : checksumsetsserialised(),
]
return data
}
}
class PublishableInfo extends GISJsonSerialised {
private String filepath
PublishableInfo(script, String filepath = "") {
super(script)
this.filepath = filepath
}
void deserialiseJson(rawmeta) {
filepath = rawmeta['filepath']
}
LinkedHashMap serialisationdata() {
def data = [
'filepath' : filepath,
]
return data
}
}
class MetaInfo extends GISJsonSerialised {
private static String FORMAT = "0.1"
private static String METAFOLDERNAME = "meta"
private static String METAFILENAME = "info.json"
private static String METAARTIFACTS = "${METAFOLDERNAME}/**"
class RelatedMetaInfo extends GISJsonSerialised {
String offsetpath
MetaInfo meta
RelatedMetaInfo(script, offsetpath = "", MetaInfo meta = null) {
super(script)
this.offsetpath = offsetpath
this.meta = meta
}
void deserialiseJson(rawmeta) {
offsetpath = rawmeta['offsetpath']
meta = new MetaInfo(script)
meta.deserialiseJson(rawmeta['meta'])
}
LinkedHashMap serialisationdata() {
def data = [
'offsetpath' : offsetpath,
'meta' : meta.serialisationdata(),
]
return data
}
}
private String format = FORMAT
ProductInfo productinfo
GitInfo gitinfo
JenkinsBuildInfo jenkinsbuildinfo
BuildStampInfo buildstampinfo
ReleaseInfo releaseinfo
ChecksumInfo checksuminfo
private ArrayList<ConfigurationInfo> configurationinfo
private ArrayList<PublishableInfo> publishableinfo
private LinkedHashMap<String, String> custominfo
private ArrayList<RelatedMetaInfo> associatedmeta
MetaInfo(script) {
super(script)
productinfo = new ProductInfo(script)
gitinfo = new GitInfo(script)
jenkinsbuildinfo = new JenkinsBuildInfo(script)
buildstampinfo = new BuildStampInfo(script)
releaseinfo = new ReleaseInfo(script)
checksuminfo = new ChecksumInfo(script)
configurationinfo = new ArrayList<ConfigurationInfo>()
publishableinfo = new ArrayList<PublishableInfo>()
custominfo = new LinkedHashMap<String, String>()
associatedmeta = new ArrayList<RelatedMetaInfo>()
}
List getassociated() {
return associatedmeta
}
void markreleased() {
script.echo("Marking product: ${productinfo.productname} component: ${productinfo.subcomponentname} as released")
releaseinfo.markreleased()
for (associated in associatedmeta) {
associated.meta.releaseinfo.markreleased()
}
}
List configurationinfoserialised() {
def configuration = []
for (configurationitem in configurationinfo) {
configuration.add(configurationitem.serialisationdata())
}
return configuration
}
void addPublishable(String filepath) {
def PublishableInfo pi = new PublishableInfo(script, filepath)
script.echo("Adding ${filepath} to publishable list")
publishableinfo.add(pi)
}
void addConfigurationInfo(String configurationname, String configurationURL, String configurationversion, String configurationSHA) {
def ConfigurationInfo ci = new ConfigurationInfo(script, configurationname, configurationURL, configurationversion, configurationSHA)
script.echo("Adding configuration info: name: ${configurationname} url: ${configurationURL} version: ${configurationversion} sha: ${configurationSHA}")
configurationinfo.add(ci)
}
void addCustomInfo(String customId, String customValue) {
custominfo.put(customId.trim(), customValue)
}
String getCustomInfo(String customId) {
return custominfo.getAt(customId.trim())
}
List publishableinfoserialised() {
def publishable = []
for (publishableitem in publishableinfo) {
publishable.add(publishableitem.serialisationdata())
}
return publishable
}
List associatedmetaserialised() {
def associated = []
for (metaitem in associatedmeta) {
associated.add(metaitem.serialisationdata())
}
return associated
}
void deserialiseJson(rawmeta) {
if (rawmeta['format'] != FORMAT) {
script.error("Unsupported meta format found at ${filepath}")
return
}
productinfo.deserialiseJson(rawmeta['productinfo'])
gitinfo.deserialiseJson(rawmeta['gitinfo'])
jenkinsbuildinfo.deserialiseJson(rawmeta['jenkinsbuildinfo'])
buildstampinfo.deserialiseJson(rawmeta['buildstampinfo'])
releaseinfo.deserialiseJson(rawmeta['releaseinfo'])
checksuminfo.deserialiseJson(rawmeta['checksuminfo'])
for (rawconfig in rawmeta['configuration']) {
def cf = new ConfigurationInfo(script)
cf.deserialiseJson(rawconfig)
configurationinfo.add(cf)
}
for (rawpublishable in rawmeta['publishableinfo']) {
def pb = new PublishableInfo(script)
pb.deserialiseJson(rawpublishable)
publishableinfo.add(pb)
}
custominfo = rawmeta['custominfo']
for (rawrelatedmeta in rawmeta['associatedmeta']) {
def rm = new RelatedMetaInfo(script)
rm.deserialiseJson(rawrelatedmeta)
associatedmeta.add(rm)
}
}
def deserialiseJson(String filepath) {
script.echo("Deserialising JSON at file: ${filepath}")
def rawmeta = script.readJSON(file: filepath)
deserialiseJson(rawmeta)
}
def deserialiseJsonSlurper(String filepath) {
File jsonfile = new File(filepath)
def jsonfiletext = jsonfile.getText()
def rawmeta = new JsonSlurperClassic().parseText(jsonfiletext)
deserialiseJson(rawmeta)
}
String relativize(String mypath) {
String pathRelative
script.echo("Seeing if ${mypath} begins with ${script.WORKSPACE}")
if (mypath.startsWith(script.WORKSPACE)) {
pathRelative = mypath.minus(script.WORKSPACE)
script.echo("Extracted ${pathRelative} from ${script.WORKSPACE} and ${mypath}")
} else {
pathRelative = mypath
script.echo("Path relative is unchanged: ${pathRelative}")
}
// Convert \ with /
pathRelative = pathRelative.tokenize('\\').join('/')
// Strip leading / if any
pathRelative = pathRelative.replaceAll('^/+', '')
script.echo("Path relative is ${pathRelative}")
return pathRelative
}
static String metafilepath() {
return METAFOLDERNAME + "/" + METAFILENAME
}
MetaInfo importrelated(boolean appendtoparentmeta, String destpath, String givenRepo = 'Unknown', String givenRevision = 'Unknown', String givenSHA = 'Unknown') {
MetaInfo mi = new MetaInfo(script)
def String adjustedpath = relativize(destpath)
def importedmetafile = adjustedpath + "/" + metafilepath()
if (script.fileExists(importedmetafile)) {
mi.deserialiseJson(importedmetafile)
} else {
script.echo("Could not deserialise meta at file: ${importedmetafile} (destpath: ${destpath})- Does not exist")
mi.addConfigurationInfo('', givenRepo, givenRevision, givenSHA)
}
RelatedMetaInfo rmi = new RelatedMetaInfo(script, adjustedpath, mi)
if (appendtoparentmeta) {
associatedmeta.add(rmi)
}
return mi
}
LinkedHashMap serialisationdata() {
def data = [
'format' : format,
'productinfo' : productinfo.serialisationdata(),
'gitinfo' : gitinfo.serialisationdata(),
'jenkinsbuildinfo' : jenkinsbuildinfo.serialisationdata(),
'buildstampinfo' : buildstampinfo.serialisationdata(),
'releaseinfo' : releaseinfo.serialisationdata(),
'configuration' : configurationinfoserialised(),
'checksuminfo' : checksuminfo.serialisationdata(),
'publishableinfo' : publishableinfoserialised(),
'custominfo' : custominfo,
'associatedmeta' : associatedmetaserialised(),
]
return data
}
static String folder() {
return METAFOLDERNAME
}
String generateartifacts(ArrayList<String> releasedfromhere = new ArrayList<String>(), // These items are recorded in meta as released from here
ArrayList<String> releasedfromsubmeta = new ArrayList<String>(), // These items are not recorded in meta as released from here
String metafilepath ="${METAFOLDERNAME}/${METAFILENAME}"
) {
def String artifactlist = METAARTIFACTS
releaseinfo.addReleaseItem(METAARTIFACTS)
for (releaseitem in releasedfromhere) {
artifactlist += "," + releaseitem
releaseinfo.addReleaseItem(releaseitem)
}
for (releaseitem in releasedfromsubmeta) {
artifactlist += "," + releaseitem
}
saveJsonSerialised(metafilepath)
return artifactlist
}
// Recurse tree of meta looking for release info and accumulate path - Pass by reference unavailable in Groovy/Java
private ArrayList<RelatedMetaInfo> releasewalkerp(int maxdepth, ArrayList<RelatedMetaInfo> releasemetacollection, String pathsofar) {
if (maxdepth > 0) {
if (releaseinfo.releaserepoURL) {
RelatedMetaInfo rmi = new RelatedMetaInfo(script, pathsofar, this)
releasemetacollection.add(rmi)
}
if (pathsofar) {
pathsofar += "/"
}
for (relatedmetainfo in associatedmeta) {
MetaInfo othermeta = relatedmetainfo.meta
String newpathsofar = pathsofar + relatedmetainfo.offsetpath
releasemetacollection = othermeta.releasewalkerp(maxdepth - 1, releasemetacollection, newpathsofar)
}
}
return releasemetacollection
}
ArrayList<RelatedMetaInfo> releasewalker(int maxdepth, String startpath = "") {
ArrayList<RelatedMetaInfo> releasemetacollection = new ArrayList<RelatedMetaInfo>()
releasemetacollection = releasewalkerp(maxdepth, releasemetacollection, startpath)
return releasemetacollection
}
String componentidentifier() {
return productinfo.productname + "_" + productinfo.subcomponentname
}
String componentversionuniqueidentifier() {
return componentidentifier() + "_" + buildstampinfo.buildstamp
}
String globalreleasetag() {
return componentversionuniqueidentifier() + "_" + jenkinsbuildinfo.buildnumber
}
String releasetag() {
return buildstampinfo.buildstamp + "_" + jenkinsbuildinfo.buildnumber
}
String releasetagfordebpackage() {
return buildstampinfo.buildstamp + "-" + jenkinsbuildinfo.buildnumber
}
Map<String, RelatedMetaInfo> putwithshortestoffsetpath(Map<String, RelatedMetaInfo> releasemetacollection, String uniquestring, RelatedMetaInfo relatedmetainfo) {
if (releasemetacollection.containsKey(uniquestring)) {
def existingentry = releasemetacollection[uniquestring]
if (existingentry.offsetpath.size() > relatedmetainfo.offsetpath.size()) {
releasemetacollection.put(uniquestring, relatedmetainfo)
}
} else {
releasemetacollection.put(uniquestring, relatedmetainfo)
}
return releasemetacollection
}
Map<String, RelatedMetaInfo> releasewalkerunique(int maxdepth, String startpath = "") {
def ArrayList<RelatedMetaInfo> releasemetacollection = new ArrayList<RelatedMetaInfo>()
releasemetacollection = releasewalkerp(maxdepth, releasemetacollection, startpath)
def Map<String, RelatedMetaInfo> releasemetauniquecollection = new LinkedHashMap<String, RelatedMetaInfo>()
for (relatedmetainfo in releasemetacollection) {
def String uniquestring = relatedmetainfo.meta.componentidentifier()
releasemetauniquecollection = putwithshortestoffsetpath(releasemetauniquecollection, uniquestring, relatedmetainfo)
}
return releasemetauniquecollection
}
Map<String, RelatedMetaInfo> releasewalkerversionunique(int maxdepth, String startpath = "") {
ArrayList<RelatedMetaInfo> releasemetacollection = new ArrayList<RelatedMetaInfo>()
releasemetacollection = releasewalkerp(maxdepth, releasemetacollection, startpath)
def Map<String, RelatedMetaInfo> releasemetaversionuniquecollection = new LinkedHashMap<String, RelatedMetaInfo>()
for (relatedmetainfo in releasemetacollection) {
def String uniquestring = relatedmetainfo.meta.componentversionuniqueidentifier()
releasemetaversionuniquecollection = putwithshortestoffsetpath(releasemetaversionuniquecollection, uniquestring, relatedmetainfo)
}
return releasemetaversionuniquecollection
}
MetaInfo getNewMetaObject(script) {
return new MetaInfo(script)
}
}
MetaInfo metareset(script) {
echo "Resetting meta folder"
def mi = new MetaInfo(script)
dir(mi.folder()) {
deleteDir()
}
return mi
}
MetaInfo metafromfolder(String folder = "") {
MetaInfo buildmeta = new MetaInfo(this)
buildmeta.deserialiseJson("${folder}/${MetaInfo.metafilepath()}")
return buildmeta
}
MetaInfo metafromfolderSlurper(String folder = "") {
MetaInfo buildmeta = new MetaInfo(this)
buildmeta.deserialiseJsonSlurper("${folder}/${MetaInfo.metafilepath()}")
return buildmeta
}
return this;

View file

@ -1,204 +0,0 @@
pipeline {
agent { label "${AGENT_LABEL}" }
stages {
stage('Initial setup') {
steps {
script {
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
}
}
}
stage('Checkout dependencies') {
steps {
script {
configurationhelper = autobuilder.configurationhelper()
PYTHONURL = 'git@hydra:tools/python.git'
PYTHONBRANCH = 'origin/3.6.3_windows'
PYTHONDIR = "${WORKSPACE}/python"
PYTHONROOTDIR = 'python'
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR, PYTHONROOTDIR)
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
VERSTAMPINGURL = 'git@hydra:releases/ver_stamping_releases.git'
VERSTAMPINGREVISION = "refs/tags/${VERSION_STAMPING_VERSION}"
VERSTAMPINGDIR = "${WORKSPACE}/ver_stamping"
VERSTAMPINGROOTDIR = 'ver_stamping_releases'
configurationhelper.gitCheckoutAndRegister(meta, 'Version stamping', VERSTAMPINGURL, VERSTAMPINGREVISION, VERSTAMPINGDIR, VERSTAMPINGROOTDIR)
}
}
}
stage('Checkout source') {
steps {
script {
SOURCEURL = 'git@hydra:gis/atlas_ui.git'
SOURCEREVISION = SOURCE_REVISION
SOURCEDIR = "${WORKSPACE}\\atlas_ui"
SOURCEROOTDIR = 'atlas_ui'
configurationhelper.gitCheckoutAndRegister(meta, 'atlas_ui', SOURCEURL, SOURCEREVISION, SOURCEDIR, SOURCEROOTDIR, 0, false)
env.SOURCE_PATH = SOURCEDIR
env.JOBSCRIPTS = "${SOURCE_PATH}\\autobuild\\build_Atlas"
env.JOBSCRIPTS_COMMON = "${SOURCE_PATH}\\autobuild\\common"
env.SRC = SOURCE_PATH
}
}
}
stage('Clean exports') {
steps {
script {
env.PSBIN = "${WORKSPACE}/ps_bin"
env.PSSOURCE = "${WORKSPACE}/newsw"
cleanfolders = [
PSBIN,
"${WORKSPACE}/packages",
]
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
cleaner.clean(cleanfolders)
}
}
}
stage('Generating version info') {
steps {
script {
version = load("${autobuilder.commonscripts()}/versionnumbering/generate.groovy")
version.generate(meta, SOURCE_REVISION, SOURCE_PATH, BASEBUILDNUMBER)
}
}
}
stage('Import Print server to adjust version number') {
steps {
script {
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
def psartifactfiles = "meta/**,bin/x64/Release/Engine - Render.dll,bin/x64/Release/Engine - Render.lib,bin/x64/Release/Engine - Render.pdb,bin/x64/Release/TBarCode11_x64.dll,bin/x64/Release/GIS Utility - Toolbox.dll,bin/x64/Release/GIS Utility - Toolbox.lib,bin/x64/Release/GIS Utility - Toolbox.pdb,bin/x64/Release/zlib1.dll,bin/x64/Release/zlib1.lib,bin/x64/Release/zlib1.pdb,bin/x64/Release/GIS Utility - TCP-IP Comms.dll,bin/x64/Release/GIS Utility - TCP-IP Comms.lib,bin/x64/Release/GIS Utility - TCP-IP Comms.pdb,bin/x64/Release/Dialog - Tree Node Editor.dll,bin/x64/Release/Dialog - Tree Node Editor.lib,bin/x64/Release/Dialog - Tree Node Editor.pdb"
psmeta = importer.artifactimport(meta,
PRINT_SERVER_ARTIFACT_LOCATION,
PRINT_SERVER_COMPILE_JOB,
PRINT_SERVER_BUILD_SELECTOR,
PRINT_SERVER_RELEASE_REPO,
PRINT_SERVER_RELEASE_REVISION,
PSBIN,
true,
psartifactfiles) // This should increment the version number
}
}
}
stage('Checkout relevant Print server source') {
steps {
script {
def pssourceartifacts = "src/Engine Common"
def pssourceurl = psmeta.gitinfo.remoteurl
def pscommit = psmeta.gitinfo.gitrevision
configurationhelper.gitCheckoutAndRegister(meta, 'print_server_source', pssourceurl, pscommit, PSSOURCE, '', 0, false, pssourceartifacts)
}
}
}
stage('Create packages') {
steps {
script {
PS_VERSION="1.0.${psmeta.buildstampinfo.revision}.0"
PS_PACKAGE_VERSION=psmeta.buildstampinfo.buildstampprefix
bat """
REM Create nuget packages
echo Create nuget packages
@echo on
set NUGET_SERVER=C:\\NugetServer\\Packages\\
@echo Renaming nuget package in ${SRC} with ${PS_PACKAGE_VERSION}
@echo Versioning nuget package in ${SRC} to ${PS_VERSION}
@echo on
REM edit autopkg file
"${PYTHON}" "${JOBSCRIPTS_COMMON}\\ps_nuget_version_edit.py" "${JOBSCRIPTS_COMMON}\\AtlasNativeDependencies.autopkg" ${PS_VERSION} ${PS_PACKAGE_VERSION}
if errorlevel 1 EXIT /b 1
REM Create nuget packages
REM Uses COAPP modules at %COAPP_MODULES%
set PSMODULEPATH=%COAPP_MODULES%;%PSMODULEPATH%
PowerShell.exe Write-NuGetPackage '${JOBSCRIPTS_COMMON}\\AtlasNativeDependencies.autopkg'
if errorlevel 1 EXIT /b 1
REM Copy nuget packages
copy AtlasNativeDependencies.${PS_PACKAGE_VERSION}${PS_VERSION}.nupkg %NUGET_SERVER%
if errorlevel 1 EXIT /b 1
copy AtlasNativeDependencies.${PS_PACKAGE_VERSION}redist.${PS_VERSION}.nupkg %NUGET_SERVER%
if errorlevel 1 EXIT /b 1
copy AtlasNativeDependencies.${PS_PACKAGE_VERSION}symbols.${PS_VERSION}.nupkg %NUGET_SERVER%
if errorlevel 1 EXIT /b 1
"""
}
}
}
stage('Prepare exports') {
steps {
script {
bat """
REM Place files to the exports position
mkdir packages
if errorlevel 1 EXIT /b 1
copy AtlasNativeDependencies.${PS_PACKAGE_VERSION}${PS_VERSION}.nupkg packages
if errorlevel 1 EXIT /b 1
copy AtlasNativeDependencies.${PS_PACKAGE_VERSION}redist.${PS_VERSION}.nupkg packages
if errorlevel 1 EXIT /b 1
copy AtlasNativeDependencies.${PS_PACKAGE_VERSION}symbols.${PS_VERSION}.nupkg packages
if errorlevel 1 EXIT /b 1
"""
}
}
}
stage('Checksum artifacts') {
steps {
script {
def checksummable = [
/* Binaries are signed
'build/**',
'SharedPackages/**',
*/
]
checksumutils = load("${autobuilder.commonscripts()}/checksum/utils.groovy")
checksumutils.generatelist(meta, checksummable)
}
}
}
stage('Classifying publishable artifacts') {
steps {
script {
def publishable = [
]
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
publishutils.generatelist(meta, publishable)
}
}
}
stage('Archiving artifacts') {
steps {
script {
def artifactlist = meta.generateartifacts(["bin/**,binKiosk/**,documentation/**,ildasm/**,Libraries/**, Atlas Release/**,LocalisationSDK/**"])
archiveArtifacts "${artifactlist}"
}
}
}
}
post {
always {
echo 'Post-build'
}
failure {
echo 'Failed build'
}
unstable {
echo 'Unstable build'
}
success {
echo 'Succeeded build'
}
}
}

108
packaging/debian.groovy Normal file
View file

@ -0,0 +1,108 @@
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 USR_BIN
String USR_LIB_ARCH
String LIB_FIRMWARE
String HTTP_DEV_DIV
String LIB_SYSTEMD
DebRootDefinition(String rootpath, String packagesourceroot, String packageprefix, String buildstamp) {
ROOTPATH = rootpath
PACKAGE_PREFIX = packageprefix
PACKAGE_FOLDER_NAME = packageprefix
PACKAGE_NAME = packageprefix + "_armhf.deb"
UNIQUE_PACKAGE_NAME = packageprefix + "_" + buildstamp + "_armhf.deb"
PACKAGE_SOURCE_ROOT = packagesourceroot
PACKAGE_SOURCE_FOLDER_NAME = "${ROOTPATH}/${PACKAGE_PREFIX}"
DEBPATH = "${ROOTPATH}/${PACKAGE_FOLDER_NAME}"
ETC = "${DEBPATH}/etc"
GIS_OPT_BIN = "${DEBPATH}/opt/gis/bin"
GIS_OPT_LIB = "${DEBPATH}/opt/gis/lib"
GIS_OPT_SCRIPTS_APP = "${DEBPATH}/opt/gis/scripts/app"
GIS_OPT_SCRIPTS_EL = "${DEBPATH}/opt/gis/scripts/el"
GIS_OPT_SCRIPTS_CONTROL = "${DEBPATH}/opt/gis/scripts/control"
GIS_OPT_WWW = "${DEBPATH}/opt/gis/www"
GIS_OPT_OTHER = "${DEBPATH}/opt/gis/other"
GIS_OPT_KERNEL = "${DEBPATH}/opt/gis/kernel"
GIS_OPT_LOGIC = "${DEBPATH}/opt/gis/logic"
GIS_OPT_PRINTHEAD = "${DEBPATH}/opt/gis/printhead"
USR_BIN = "${DEBPATH}/usr/bin"
USR_LIB_ARCH = "${DEBPATH}/usr/lib/arm-linux-gnueabihf"
LIB_FIRMWARE = "${DEBPATH}/lib/firmware"
HTTP_DEV_DIV = "${DEBPATH}/var/www/gis_dev"
LIB_SYSTEMD = "${DEBPATH}/lib/systemd"
}
}
def DebRootDefinition debDefinition(String rootpath, String packagesourceroot, String packageprefix, String buildstamp) {
return new DebRootDefinition(rootpath, packagesourceroot, packageprefix, buildstamp)
}
def buildPackage(String packageout, String uniquepackageout, DebRootDefinition packagedefs, String password) {
try {
sh """#!/bin/bash
# Exit if any command fails
set -xe
echo "${password}" | sudo -S echo
cp -v -r "${packagedefs.PACKAGE_SOURCE_ROOT}/${packagedefs.PACKAGE_SOURCE_FOLDER_NAME}"/* "${packagedefs.DEBPATH}"
sudo chmod -v -R 755 "${packagedefs.DEBPATH}"
sudo chown -v -R root: "${packagedefs.DEBPATH}"
mkdir -v -p "${packageout}"
echo "Building package:"
dpkg-deb -v --build "${packagedefs.DEBPATH}" "${packageout}/${packagedefs.PACKAGE_NAME}"
mkdir -v -p "${uniquepackageout}"
cp "${packageout}/${packagedefs.PACKAGE_NAME}" "${uniquepackageout}/${packagedefs.UNIQUE_PACKAGE_NAME}"
echo "Showing package:"
dpkg-deb --show "${packageout}/${packagedefs.PACKAGE_NAME}"
echo "Showing package contents:"
dpkg-deb --contents "${packageout}/${packagedefs.PACKAGE_NAME}"
echo "Showing package lintian output:"
lintian --suppress-tags dir-or-file-in-opt "${packageout}/${packagedefs.PACKAGE_NAME}" || true
sudo chown -R ${USER}: "${packagedefs.DEBPATH}"
"""
}
catch (Exception e) {
echo "Exception occurred"
sh """#!/bin/bash -v
echo "${password}" | sudo -S echo
sudo chown -R ${USER}: "${packagedefs.DEBPATH}"
exit 1
"""
}
}
return this;

View file

@ -0,0 +1,5 @@
// Put ${nl} into strings when wanting a newline
nl = System.properties['line.separator']
return this;

9
publish/.classpath Normal file
View file

@ -0,0 +1,9 @@
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
<classpathentry excluding="publish.groovy" kind="src" path=""/>
<classpathentry exported="true" kind="con" path="GROOVY_SUPPORT"/>
<classpathentry exported="true" kind="con" path="GROOVY_DSL_SUPPORT"/>
<classpathentry kind="lib" path="/home/dan/.sdkman/candidates/groovy/2.5.6/lib/groovy-json-2.5.6.jar"/>
<classpathentry kind="output" path=""/>
</classpath>

7
publish/.gitignore vendored Normal file
View file

@ -0,0 +1,7 @@
/do$_publish_closure4.class
/do$_resetfolders_closure1.class
/do$_resetfolders_closure2.class
/do$_resetfolders_closure3.class
/do$_stripgithistory_closure5.class
/do.class
/publish_item_select.class

View file

@ -1,17 +1,18 @@
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
<name>publish</name>
<name>publish_item_select</name>
<comment></comment>
<projects>
</projects>
<buildSpec>
<buildCommand>
<name>org.python.pydev.PyDevBuilder</name>
<name>org.eclipse.jdt.core.javabuilder</name>
<arguments>
</arguments>
</buildCommand>
</buildSpec>
<natures>
<nature>org.python.pydev.pythonNature</nature>
<nature>org.eclipse.jdt.groovy.core.groovyNature</nature>
<nature>org.eclipse.jdt.core.javanature</nature>
</natures>
</projectDescription>

View file

@ -0,0 +1,3 @@
eclipse.preferences.version=1
groovy.compiler.level=25
groovy.script.filters=**/*.dsld,y,**/*.gradle,n

View file

@ -1,53 +0,0 @@
import sys
import stat
from publishLibrary import CommonLibrary, VersionError,ReleaseFolderIssue, Copier, AtlasLayoutCopierPost2_0_14, AtlasSDKCopier, InkSystemUICopierPost2_0_19, AtlasUIReleaseNotesCopier
def main():
# All version number specific releases have been checked out already
(major, middle, minor) = CommonLibrary.readVersionNumber(CommonLibrary.softwareRelease)
print("Release version number: Major:", major, "Middle:", middle, "Minor:", minor)
try:
CommonLibrary.checkReleaseFolders()
except ReleaseFolderIssue:
print("Release folders are not correct")
sys.exit(1)
try:
tsHandle = open(CommonLibrary.transferScript, 'w')
except:
print("Failed to open transfer script file:", transferScript)
sys.exit(1)
try:
buildRoot = CommonLibrary.prepareBuildDirectory(tsHandle, CommonLibrary.softwareRelease)
except Exception as e:
print("Failed to build directory. Details:", e)
tsHandle.close()
sys.exit(1)
copiers = [
AtlasLayoutCopierPost2_0_14(),
AtlasSDKCopier(),
InkSystemUICopierPost2_0_19(),
AtlasUIReleaseNotesCopier(),
]
for copier in copiers:
print("Copying", copier.description())
try:
copier.transfer(buildRoot, CommonLibrary.softwareRelease)
except Exception as e:
print("A problem occurred while copying:", copier.description(), " Details:", e)
tsHandle.close()
sys.exit(1)
print("Showing built tree at:", buildRoot)
CommonLibrary.listdir(buildRoot)
tsHandle.close()
sys.exit(0)
if __name__ == "__main__":
sys.exit(main())

View file

@ -1,54 +0,0 @@
import sys
import stat
from publishLibrary import CommonLibrary, VersionError,ReleaseFolderIssue, Copier, AtlasLayoutCopierPost2_0_14, AtlasSDKCopier, InkSystemUICopierPost2_0_19, McsToolsCopierPost2_0_28, AtlasUIReleaseNotesCopier
def main():
# All version number specific releases have been checked out already
(major, middle, minor) = CommonLibrary.readVersionNumber(CommonLibrary.softwareRelease)
print("Release version number: Major:", major, "Middle:", middle, "Minor:", minor)
try:
CommonLibrary.checkReleaseFolders()
except ReleaseFolderIssue:
print("Release folders are not correct")
sys.exit(1)
try:
tsHandle = open(CommonLibrary.transferScript, 'w')
except:
print("Failed to open transfer script file:", transferScript)
sys.exit(1)
try:
buildRoot = CommonLibrary.prepareBuildDirectory(tsHandle, CommonLibrary.softwareRelease)
except Exception as e:
print("Failed to build directory. Details:", e)
tsHandle.close()
sys.exit(1)
copiers = [
AtlasLayoutCopierPost2_0_14(),
AtlasSDKCopier(),
InkSystemUICopierPost2_0_19(),
McsToolsCopierPost2_0_28(),
AtlasUIReleaseNotesCopier(),
]
for copier in copiers:
print("Copying", copier.description())
try:
copier.transfer(buildRoot, CommonLibrary.softwareRelease)
except Exception as e:
print("A problem occurred while copying:", copier.description(), " Details:", e)
tsHandle.close()
sys.exit(1)
print("Showing built tree at:", buildRoot)
CommonLibrary.listdir(buildRoot)
tsHandle.close()
sys.exit(0)
if __name__ == "__main__":
sys.exit(main())

174
publish/do.groovy Normal file
View file

@ -0,0 +1,174 @@
import groovy.io.FileType
markunstable = false
unstablereason = ""
summaryfolder = "${WORKSPACE}/summary"
summaryfile = "${summaryfolder}/summary.txt"
summarystring = ""
releaserepofolder = "${WORKSPACE}/releaserepos"
filteredreleaserepofolder = "${WORKSPACE}/filteredreleaserepos"
def resetfolders() {
dir(summaryfolder) {
deleteDir()
}
dir(releaserepofolder) {
deleteDir()
}
dir(filteredreleaserepofolder) {
deleteDir()
}
}
def productuniquefolder(releasemeta) {
return "${releasemeta.productinfo.productname}_${releasemeta.productinfo.subcomponentname}"
}
def uniquereleasefolder(String productline, String softwarerelease, releasemeta) {
return "Software/${productline} ${softwarerelease}/${productuniquefolder(releasemeta)}"
}
def uniqueabsoluterreleasefolder(String productline, String releaserepofolder, String softwarerelease, releasemeta) {
return "${releaserepofolder}/${uniquereleasefolder(productline, softwarerelease, releasemeta)}"
}
def preconditions() {
markunstable = false
unstablereason = ""
summarystring = ""
writeFile(file: summaryfile, text: "Publish summary: \n")
}
def setunstable(String reason) {
markunstable = true
unstablereason = reason
}
def summaryappend(String summary) {
def String currentsummarycontents = readFile(file: summaryfile)
writeFile(file: summaryfile, text: currentsummarycontents + summary)
summarystring += summary
}
def guessreporootsuffix(componentURL) {
def guess = componentURL.replaceFirst(/.*\/(.*).git/, '$1')
return guess
}
gh = load("${autobuilder.commonscripts()}/versioncontrol/git.groovy")
def getcomponentartifacts(releaseinfo, String repofolder, itempathstopublish) {
summaryappend("Artifacts: ")
def releasemeta = releaseinfo.meta
def String componentURL = releasemeta.releaseinfo.releaserepoURL
def String revision = "refs/tags/${releasemeta.buildstampinfo.buildstamp}_${releasemeta.jenkinsbuildinfo.buildnumber}"
def publishableitems = releasemeta.publishableinfo
def ArrayList<String> publishablepaths = new ArrayList<String>()
if (publishableitems.size() > 0) {
for (publishableitem in publishableitems) {
def String productuniquepublishableitem = "${productuniquefolder(releasemeta)}/${publishableitem.filepath}"
echo "publishableitem: ${productuniquepublishableitem}"
if (itempathstopublish.size() == 0 || productuniquepublishableitem in itempathstopublish) {
publishablepaths.add(publishableitem.filepath)
summaryappend("${publishableitem.filepath},")
}
}
}
if (publishablepaths.size() > 0) {
def reporootsuffix = guessreporootsuffix(componentURL)
gh.gitCheckoutAlt(componentURL, revision, repofolder, reporootsuffix, 1, true, publishablepaths) // Shallow clone
}
else {
summaryappend("None ")
}
}
def publish(hostedftpsiteinfo, String customer, String finalreleaserepofolder = releaserepofolder) {
summaryappend(" FTP operations: ")
def String ftproot = "${hostedftpsiteinfo.workingdirectory}${customer}"
dir(finalreleaserepofolder) {
summaryappend("FTP operations: Transferring to ${ftproot}")
sh """#!/bin/bash
ncftpput -u ${hostedftpsiteinfo.username} -p ${hostedftpsiteinfo.password} -R ${hostedftpsiteinfo.url} "${ftproot}" .
"""
summaryappend(", Transferred ")
}
}
def copydirectory(File dirFrom, File dirTo) {
if (!dirTo.exists()) {
dirTo.mkdirs();
}
dirFrom.eachFile(FileType.FILES) { File source ->
File target = new File(dirTo, source.getName())
target.bytes = source.bytes
}
dirFrom.eachFile(FileType.DIRECTORIES) { File source ->
File target = new File(dirTo, source.getName())
copyLargeDir(source, target)
}
}
def recallcomponent(String productline, releaseinfo, String softwarerelease, itempathstopublish) {
def releasemeta = releaseinfo.meta
def String uniquefolderforrepo = uniqueabsoluterreleasefolder(productline, releaserepofolder, softwarerelease, releasemeta)
summaryappend("${releasemeta.productinfo.productname} ${releasemeta.productinfo.subcomponentname}: ")
getcomponentartifacts(releaseinfo, uniquefolderforrepo, itempathstopublish)
summaryappend("\n")
}
def convertitemstopublish(String itemstopublishstring) {
def List paths = []
def String[] items = itemstopublishstring.split(',')
def String allpaths = ""
for(String item : items) {
def String[] pathitems = item.split('#')
def String path = "${pathitems[0]}_${pathitems[1]}/${pathitems[2]}"
paths.add(path)
allpaths += "${path}\n"
}
echo "Selected item to publish:\n${allpaths}"
return paths
}
// Publish selected items from a release to the customer folder on the ftp site
// itemstopublishstring is a comma-seperated set of strings in this format <ProductName>#<ComponentName>#<PathToPublishableItem>
def publishhierarchy(hostedftpsiteinfo, releasemeta, String itemstopublishstring, String customer, String softwarerelease, String maxdepth) {
int md = maxdepth.toInteger()
resetfolders()
preconditions()
def productline = releasemeta.productinfo.productname
// Walk the meta information to a max depth, looking for artifacts to publish
def componentReleaseInfoVersionUnique = releasemeta.releasewalkerversionunique(md)
echo "Version unique components:"
def String versionuniquecomponent = ""
for (key in componentReleaseInfoVersionUnique.keySet()) {
versionuniquecomponent += "${key}\n"
}
echo versionuniquecomponent
def itempathstopublish = convertitemstopublish(itemstopublishstring)
for (key in componentReleaseInfoVersionUnique.keySet()) {
def releaseinfo = componentReleaseInfoVersionUnique[key]
recallcomponent(productline, releaseinfo, softwarerelease, itempathstopublish)
}
gh.stripgithistory(releaserepofolder)
publish(hostedftpsiteinfo, customer)
return [summarystring, markunstable, unstablereason]
}
def publishhierarchy(hostedftpsiteinfo, releasemeta, String customer, String softwarerelease, String maxdepth) {
return publishhierarchy(hostedftpsiteinfo, releasemeta, "", customer, softwarerelease, maxdepth)
}
return this;

176
publish/package.groovy Normal file
View file

@ -0,0 +1,176 @@
pipeline {
agent { label "${AGENT_LABEL}" }
stages {
stage('Initial setup') {
steps {
script {
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
}
}
}
stage('Checkout dependencies') {
steps {
script {
configurationhelper = autobuilder.configurationhelper()
PYTHONURL = 'git@hydra:tools/python.git'
if (isUnix()) {
PYTHONBRANCH = "origin/3.6.3_linux"
}
else {
PYTHONBRANCH = "origin/3.6.3_windows"
}
PYTHONDIR = "${WORKSPACE}/python"
PYTHONROOTDIR = 'python'
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR, PYTHONROOTDIR)
if (isUnix()) {
env.PYTHON = "${PYTHONDIR}/usr/local/bin/python3"
}
else {
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
}
}
}
}
stage('Clean exports') {
steps {
script {
PACKAGEDEST = "${WORKSPACE}/package"
cleanfolders = [
PACKAGEDEST,
]
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
cleaner.clean(cleanfolders)
}
}
}
stage('Copying package artifacts') {
steps {
script {
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
packagemeta = importer.artifactimport(meta, PACKAGE_CREATE_JOB, PACKAGE_CREATE_JOB_SELECTOR, PACKAGEDEST)
PACKAGE_FOLDER = "${PACKAGEDEST}/package"
UNIQUE_PACKAGE_FOLDER = "${PACKAGEDEST}/uniquepackage"
}
}
}
stage('Aptly environment') {
steps {
script {
echo "Aptly config file is ${APTLY_CONFIG_FILE}"
sh """#!/bin/bash -v
aptly config show
if [ \$? -ne 0 ]; then exit 1; fi
"""
}
}
}
stage('Create repo - if not already there') {
steps {
script {
echo "Repo name is ${REPO_NAME}"
sh """#!/bin/bash -v
aptly repo -config="${APTLY_CONFIG_FILE}" -with-packages show "${REPO_NAME}"
if [ \$? -ne 0 ]; then
echo "aptly repo ${REPO_NAME} does not exist; Creating it"
aptly repo -config="${APTLY_CONFIG_FILE}" create "${REPO_NAME}"
if [ \$? -ne 0 ]; then exit 1; fi
fi
aptly repo -config="${APTLY_CONFIG_FILE}" -with-packages show "${REPO_NAME}"
if [ \$? -ne 0 ]; then exit 1; fi
"""
}
}
}
stage('Drop published repo - if any') {
steps {
script {
sh """#!/bin/bash -v
# This errors if the published repo exists already; Ignore it
aptly publish -config="${APTLY_CONFIG_FILE}" drop "${DISTRIBUTION}" "${PUBLISH_PATH_PREFIX}"
aptly publish -config="${APTLY_CONFIG_FILE}" list
if [ \$? -ne 0 ]; then exit 1; fi
"""
}
}
}
stage('Add/update package in repo') {
steps {
script {
echo "Unique package folder is ${UNIQUE_PACKAGE_FOLDER}"
sh """#!/bin/bash -v
aptly repo -config="${APTLY_CONFIG_FILE}" add "${REPO_NAME}" "${UNIQUE_PACKAGE_FOLDER}"
if [ \$? -ne 0 ]; then exit 1; fi
aptly repo -config="${APTLY_CONFIG_FILE}" show -with-packages "${REPO_NAME}"
if [ \$? -ne 0 ]; then exit 1; fi
"""
}
}
}
stage('Create snapshot') {
steps {
script {
echo "Snapshot name is ${SNAPSHOT_NAME}"
FULL_SNAPSHOT_NAME = "${REPO_NAME}_${SNAPSHOT_NAME}"
PACKAGE_VERSION_PREFIX = packagemeta.buildstampinfo.buildstampprefix
echo "Full Snapshot name is ${FULL_SNAPSHOT_NAME} containing packages of versions beginning with: ${PACKAGE_VERSION_PREFIX}"
// Convert prefix to regular expression
PACKAGE_VERSION_PREFIX_SPLIT = PACKAGE_VERSION_PREFIX.split("[.]")
PACKAGE_VERSION_REGEX = ''
i = 0
while(true) {
if (i == PACKAGE_VERSION_PREFIX_SPLIT.size() - 1) {
PACKAGE_VERSION_REGEX += PACKAGE_VERSION_PREFIX_SPLIT[i]
break;
}
PACKAGE_VERSION_REGEX += PACKAGE_VERSION_PREFIX_SPLIT[i]
PACKAGE_VERSION_REGEX += '\\.'
i++
}
sh """#!/bin/bash -v
# This errors if the snapshot exists already; Ignore it
aptly snapshot -config="${APTLY_CONFIG_FILE}" drop "${FULL_SNAPSHOT_NAME}"
aptly snapshot -config="${APTLY_CONFIG_FILE}" drop "All_${FULL_SNAPSHOT_NAME}"
aptly snapshot -config="${APTLY_CONFIG_FILE}" create "All_${FULL_SNAPSHOT_NAME}" from repo "${REPO_NAME}"
if [ \$? -ne 0 ]; then exit 1; fi
aptly snapshot filter -config="/home/repos/gis-aptly-config/gis.conf" "All_${FULL_SNAPSHOT_NAME}" "${FULL_SNAPSHOT_NAME}" 'Version (~ .*${PACKAGE_VERSION_REGEX}.*)'
if [ \$? -ne 0 ]; then exit 1; fi
aptly snapshot -config="${APTLY_CONFIG_FILE}" -with-packages show "${FULL_SNAPSHOT_NAME}"
if [ \$? -ne 0 ]; then exit 1; fi
"""
}
}
}
stage('Publish snapshot') {
steps {
script {
sh """#!/bin/bash -v
aptly publish -config="${APTLY_CONFIG_FILE}" -distribution="${DISTRIBUTION}" -component="${COMPONENT}" -gpg-key="${GPG_KEY_ID}" snapshot "${FULL_SNAPSHOT_NAME}" "${PUBLISH_PATH_PREFIX}"
if [ \$? -ne 0 ]; then exit 1; fi
aptly publish -config="${APTLY_CONFIG_FILE}" list
if [ \$? -ne 0 ]; then exit 1; fi
aptly publish -config="${APTLY_CONFIG_FILE}" show "${DISTRIBUTION}" "${PUBLISH_PATH_PREFIX}"
if [ \$? -ne 0 ]; then exit 1; fi
"""
}
}
}
}
post {
always {
echo 'Post-build'
}
failure {
echo 'Failed build'
}
unstable {
echo 'Unstable build'
}
success {
echo 'Succeeded build'
}
}
}

View file

@ -0,0 +1,179 @@
pipeline {
agent { label "${AGENT_LABEL}" }
stages {
stage('Initial setup') {
steps {
script {
autobuilderscript = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy")
meta = autobuilderscript.startnonbuild(this)
}
}
}
stage('Clean folders') {
steps {
script {
cleanfolders = [
]
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
cleaner.clean(cleanfolders)
}
}
}
stage('Checkout release repo') {
steps {
script {
configurationhelper = autobuilder.configurationhelper()
SOURCEURL = RELEASE_REPO
SOURCEREVISION = "origin/master"
SOURCEDIR = "${WORKSPACE}/whole"
configurationhelper.gitCheckoutAndRegister(meta, 'whole', SOURCEURL, SOURCEREVISION, SOURCEDIR, '', 0, false)
}
}
}
stage('Identify customer to publish to') {
steps {
script {
hostedftb = load("${autobuilder.commonscripts()}/remoteaccess/hostedftp.groovy")
def List<String> customers = hostedftb.getCustomerList()
timeout(time: 10, unit: 'MINUTES') {
customer = input(
message: 'Please select customer to publish to',
ok: 'Ok',
parameters: [
choice(name: 'customer', choices: customers, description: 'Which customer?')
]
)
echo "Chosen customer is: ${customer}"
}
}
}
}
stage('Identify software release to publish') {
steps {
script {
gh = load("${autobuilder.commonscripts()}/versioncontrol/git.groovy")
def allreleases = gh.gettaglist(SOURCEDIR)
def releases = new ArrayList<String>()
if (FILTER_REDUNDANT_RELEASES == 'false') {
echo("Showing all releases")
releases = allreleases
} else {
echo("Showing filtered releases")
for (release in allreleases) {
if (!release.toLowerCase().startsWith("superceded") &&
!release.toLowerCase().startsWith("erroneous") &&
!release.toLowerCase().startsWith("faulty") &&
!release.toLowerCase().startsWith("ignore") &&
!release.toLowerCase().startsWith("inmainline")) {
echo("Showing release: ${release}")
releases.add(release)
} else {
echo("Not showing release: ${release}")
}
}
}
timeout(time: 10, unit: 'MINUTES') {
release = input(
message: 'Please select the software version',
ok: 'Ok',
parameters: [
choice(name: 'release', choices: releases, description: 'Which software release?')
]
)
echo "Chosen software version is: ${release}"
}
}
}
}
stage('Checkout release repo at selected software version') {
steps {
script {
SOURCEURL = RELEASE_REPO
SOURCEREVISION = "refs/tags/${release}"
SOURCEDIR = "${WORKSPACE}/whole"
configurationhelper.gitCheckoutAndRegister(meta, 'whole', SOURCEURL, SOURCEREVISION, SOURCEDIR, '', 0, false)
}
}
}
stage('Get release artifact info') {
steps {
script {
def mfs = autobuilderscript.getmetafolderscript()
releasemeta = mfs.metafromfolder(SOURCEDIR)
}
}
}
stage('Select which items from software release to publish') {
steps {
script {
publishitems = load("${autobuilder.commonscripts()}/publish/publishitems.groovy")
timeout(time: 10, unit: 'MINUTES') {
def itemsobject = publishitems.createItemSelector(
'Select software items',
'Software items',
releasemeta,
ITEMSDEFAULTLIST,
MAX_META_DEPTH,
'20',
'PT_MULTI_SELECT')
selecteditems = input(
message: 'Select which items from the release are to be published',
ok: 'Ok',
parameters: [
itemsobject.multiSelect()
]
)
echo "Chosen items are: ${selecteditems}"
}
}
}
}
stage('Publish components') {
steps {
script {
def publisher = load("${autobuilder.commonscripts()}/publish/do.groovy")
def hostedftpsiteinfo = hostedftb.getHostedFTPSiteInfo()
(summarystring, markunstable, unstablereason) = publisher.publishhierarchy(hostedftpsiteinfo, releasemeta, selecteditems, customer, release, MAX_META_DEPTH)
if (markunstable) {
env.unstablereason = unstablereason
currentBuild.result = 'UNSTABLE'
}
}
}
}
stage('Archiving artifacts') {
steps {
script {
def artifactlist = meta.generateartifacts()
archiveArtifacts "summary/**,${artifactlist}"
}
}
}
stage('Summarise') {
steps {
script {
echo "Summary:\n${summarystring}\n"
if (env.unstablereason) {
echo "Instability reason: ${env.unstablereason}"
}
}
}
}
}
post {
always {
echo 'Post-build'
}
failure {
echo 'Failed build'
}
unstable {
echo 'Unstable build'
}
success {
echo 'Succeeded build'
}
}
}

View file

@ -1,42 +0,0 @@
if "%CUSTOMER%"=="None" echo No customer has been selected
if "%CUSTOMER%"=="None" exit /b 1
set TRANSFER_SCRIPT=transfer.txt
if NOT EXIST "%TRANSFER_SCRIPT%" echo No transfer file created
if NOT EXIST "%TRANSFER_SCRIPT%" exit /b 1
set FTP_CLIENT=%FTP_CLIENT_LOCATION%
set FTP_PROTOCOL=ftp://
set FTP_OPEN_CMD=%FTP_PROTOCOL%%FTP_USER%:%FTP_PASSWORD%@%FTP_URL%
set FTP_SCRIPT=ftp_script.txt
@echo off
echo.open %FTP_OPEN_CMD% > %FTP_SCRIPT%
echo.option echo on >> %FTP_SCRIPT%
echo.option confirm off >> %FTP_SCRIPT%
echo.option transfer binary >> %FTP_SCRIPT%
echo.option batch abort >> %FTP_SCRIPT%
echo.cd "%FTP_CUSTOMER_ROOT%" >> %FTP_SCRIPT%
echo.option batch continue >> %FTP_SCRIPT%
echo.mkdir "%CUSTOMER%" >> %FTP_SCRIPT%
echo.cd "%CUSTOMER%" >> %FTP_SCRIPT%
echo.mkdir "Software" >> %FTP_SCRIPT%
echo.cd "Software" >> %FTP_SCRIPT%
echo.option batch abort >> %FTP_SCRIPT%
echo.pwd >> %FTP_SCRIPT%
type "%TRANSFER_SCRIPT%" >> %FTP_SCRIPT%
echo.ls >> %FTP_SCRIPT%
echo.exit >> %FTP_SCRIPT%
@echo on
"%FTP_CLIENT%" /script=%FTP_SCRIPT%
IF ERRORLEVEL 1 exit /b 1

91
publish/publish.groovy Normal file
View file

@ -0,0 +1,91 @@
pipeline {
agent { label "${AGENT_LABEL}" }
stages {
stage('Initial setup') {
steps {
script {
autobuilderscript = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy")
meta = autobuilderscript.startbuild(this, PRODUCT_NAME, SUBCOMPONENT_NAME, RELEASE_REPO)
}
}
}
stage('Clean folders') {
steps {
script {
cleanfolders = [
]
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
cleaner.clean(cleanfolders)
}
}
}
stage('Checkout release repo') {
steps {
script {
configurationhelper = autobuilder.configurationhelper()
SOURCEURL = RELEASE_REPO
SOURCEREVISION = "refs/tags/${SOFTWARE_RELEASE}"
SOURCEDIR = "${WORKSPACE}/whole"
SOURCEROOTDIR = 'whole'
configurationhelper.gitCheckoutAndRegister(meta, 'whole', SOURCEURL, SOURCEREVISION, SOURCEDIR, SOURCEROOTDIR, 0, false)
}
}
}
stage('Get release artifact meta') {
steps {
script {
def mfs = autobuilderscript.getmetafolderscript()
releasemeta = mfs.metafromfolder(SOURCEDIR)
}
}
}
stage('Publish components') {
steps {
script {
def publisher = load("${autobuilder.commonscripts()}/publish/do.groovy")
def hostedftb = load("${autobuilder.commonscripts()}/remoteaccess/hostedftp.groovy")
def hostedftpsiteinfo = hostedftb.getHostedFTPSiteInfo()
(summarystring, markunstable, unstablereason) = publisher.publishhierarchy(hostedftpsiteinfo, releasemeta, ITEMS_TO_PUBLISH, CUSTOMER, SOFTWARE_RELEASE, MAX_META_DEPTH)
if (markunstable) {
env.unstablereason = unstablereason
currentBuild.result = 'UNSTABLE'
}
}
}
}
stage('Archiving artifacts') {
steps {
script {
def artifactlist = meta.generateartifacts()
archiveArtifacts "summary/**,${artifactlist}"
}
}
}
stage('Summarise') {
steps {
script {
echo "Summary:\n${summarystring}\n"
if (env.unstablereason) {
echo "Instability reason: ${env.unstablereason}"
}
}
}
}
}
post {
always {
echo 'Post-build'
}
failure {
echo 'Failed build'
}
unstable {
echo 'Unstable build'
}
success {
echo 'Succeeded build'
}
}
}

View file

@ -1,274 +0,0 @@
import os
import shutil
from abc import ABCMeta, abstractmethod
import sys
class CommonLibrary:
# Release Folder Release description
releaseDetails = {
"atlaslayout": ("atlas-layout", "Atlas Layout", ),
"atlassdk": ("atlas-sdk", "Atlas SDK", ),
"inksysui": ("ink-system-ui", "Ink System UI", ),
"atlasreleasenotes": ("atlas-ui-release-notes", "Atlas UI Release notes", ),
"atlasmcstools": ("atlas-layout", "Atlas MCS Tools Modules", ), # The MCS tools are stored in the atlas-layout releases git repo.
}
workspace = os.getenv("WORKSPACE", "").strip()
print("Workspace folder is: ", workspace)
if not workspace:
print("Workspace folder incorrect")
sys.exit(1)
softwareRelease = os.getenv("SOFTWARE_RELEASE", "").strip()
print("Software release to publish is:", softwareRelease)
if not softwareRelease:
print("No software release has not been specified")
sys.exit(1)
customer = os.getenv("CUSTOMER", "").strip()
print("Customer to publish to is:", customer)
if not customer:
print("No customer has not been specified")
sys.exit(1)
includeAtlas = os.getenv("INCLUDE_ATLAS", "false").strip().lower()
print("Include Atlas Layout in release:", includeAtlas)
if not includeAtlas:
print("No Atlas Layout include parameter has not been specified")
sys.exit(1)
includeInkSystemUI = os.getenv("INCLUDE_INK_SYSTEM_UI", "false").strip().lower()
print("Include Ink System UI in release:", includeInkSystemUI)
if not includeInkSystemUI:
print("No Ink System UI include parameter has not been specified")
sys.exit(1)
includeAtlasSDK = os.getenv("INCLUDE_ATLAS_SDK_TOOLS", "false").strip().lower()
print("Include Atlas SDK in release:", includeAtlasSDK)
if not includeAtlasSDK:
print("No Atlas SDK include parameter has not been specified")
sys.exit(1)
includeMCS = os.getenv("INCLUDE_ATLAS_MCS_TOOLS", "false").strip().lower()
print("Include Atlas MCS Tools modules in release:", includeMCS)
if not includeMCS:
print("No Atlas MCS Tools include parameter has not been specified")
sys.exit(1)
ftpCustomerRootDir = os.getenv("FTP_CUSTOMER_ROOT", "").strip()
print("FTP root directory:", ftpCustomerRootDir)
if not ftpCustomerRootDir:
print("No FTP root directory parameter has not been specified")
sys.exit(1)
ftpClientExe = os.getenv("FTP_CLIENT_LOCATION", "").strip()
print("FTP client executable:", ftpClientExe)
if not ftpClientExe:
print("FTP client executable parameter has not been specified")
sys.exit(1)
ftpURL = os.getenv("FTP_URL", "").strip()
print("FTP URL:", ftpURL)
if not ftpURL:
print("FTP URL parameter has not been specified")
sys.exit(1)
ftpUser = os.getenv("FTP_USER", "").strip()
print("FTP User:", ftpUser)
if not ftpUser:
print("FTP User parameter has not been specified")
sys.exit(1)
ftpPassword = os.getenv("FTP_PASSWORD", "").strip()
print("FTP Password: ********")
if not ftpPassword:
print("FTP Password parameter has not been specified")
sys.exit(1)
def readVersionNumber(versionString):
versionList = versionString.split(sep='.')
items = len(versionList)
if items < 3 or items > 4:
raise VersionError(versionString)
major = versionList[0]
middle = versionList[1]
minor = versionList[2]
return (major, middle, minor)
def removeReadonly(func, path, _):
"Clear the readonly bit and reattempt the removal"
os.chmod(path, stat.S_IWRITE)
func(path)
buildRootDir = os.path.join(workspace, "build")
def prepareBuildDirectory(transferScriptFile, softwareRelease):
# Make sure the build directories are cleaned away
buildRootDir = CommonLibrary.buildRootDir
if os.path.isdir(buildRootDir):
shutil.rmtree(buildRootDir, onerror=CommonLibrary.removeReadonly)
releaseFolder = "Atlas UI " + softwareRelease
buildRoot = os.path.join(buildRootDir, releaseFolder)
os.makedirs(buildRoot)
print("option batch continue", file = transferScriptFile)
print('mkdir "', releaseFolder, '"', file = transferScriptFile, sep='')
print("option batch abort", file = transferScriptFile)
print('synchronize remote "', buildRoot, '" "', releaseFolder, '"', file = transferScriptFile, sep='')
return buildRoot
def checkReleaseFolders():
for _, v in sorted(CommonLibrary.releaseDetails.items()):
(folder, description) = v
fullFolderPath = os.path.join(CommonLibrary.workspace, folder)
if os.path.isdir(fullFolderPath):
print("Release of", description, "is at folder:", fullFolderPath)
else:
print("Could not find folder:", fullFolderPath, " for release of:", description)
raise ReleaseFolderIssue
def listdir(rootdir):
for root, directories, filenames in os.walk(rootdir):
for directory in sorted(directories):
print(os.path.join(root, directory))
for filename in sorted(filenames):
print(os.path.join(root, filename))
transferScript = os.path.join(workspace, "transfer.txt")
class VersionError(Exception):
def __init__(self, versionString):
self._versionString = versionString
def __repr__(self):
return self._versionString
class ReleaseFolderIssue(Exception):
def __init__(self):
pass
class Copier:
__metaclass__ = ABCMeta
def __init__(self, component):
(self.releaseFolderPath, self.releaseDesc) = CommonLibrary.releaseDetails[component]
@abstractmethod
def transfer(self): pass
def description(self):
return self.releaseDesc
def makeDirectories(self, dirs):
print("Making directories:", dirs)
os.makedirs(dirs, exist_ok = True)
def copyFile(self, src, dest):
print("Copying from:", src, "to:", dest)
shutil.copyfile(src, dest)
class AtlasLayoutCopierPost2_0_14(Copier):
def __init__(self):
Copier.__init__(self, "atlaslayout")
def transfer(self, buildRoot, softwareRelease):
# Do a copy if required
if CommonLibrary.includeAtlas == "true":
# Source
srcRelPath = os.path.join(CommonLibrary.workspace, self.releaseFolderPath)
releaseInstaller = os.path.join(srcRelPath, "x64", "GIS Atlas 2", "DiskImages", "DISK1", "GIS Atlas Layout.exe")
# Destination
atlasLayoutBuildRoot = os.path.join(buildRoot, "GIS Atlas Layout Installer")
self.makeDirectories(atlasLayoutBuildRoot)
destName = os.path.join(atlasLayoutBuildRoot, "GIS Inkjet OS " + softwareRelease + " Atlas Installer.exe")
self.copyFile(releaseInstaller, destName)
class AtlasSDKCopier(Copier):
def __init__(self):
Copier.__init__(self, "atlassdk")
def transfer(self, buildRoot, softwareRelease):
# Do a copy if required
if CommonLibrary.includeAtlasSDK == "true":
# Source
srcRelPath = os.path.join(CommonLibrary.workspace, self.releaseFolderPath)
releaseInstaller = os.path.join(srcRelPath, "x64", "GIS Atlas SDK", "DiskImages", "DISK1", "GIS Atlas SDK.exe")
# Destination
atlasSDKBuildRoot = os.path.join(buildRoot, "GIS Atlas Tools SDK Installer")
self.makeDirectories(atlasSDKBuildRoot)
destName = os.path.join(atlasSDKBuildRoot, "GIS Atlas Tools SDK " + softwareRelease + " Installer.exe")
self.copyFile(releaseInstaller, destName)
class InkSystemUICopierPost2_0_19(Copier):
def __init__(self):
Copier.__init__(self, "inksysui")
def transfer(self, buildRoot, softwareRelease):
# Do a copy if required
if CommonLibrary.includeInkSystemUI == "true":
# Source
srcRelPath = os.path.join(CommonLibrary.workspace, self.releaseFolderPath)
releaseInstaller = os.path.join(srcRelPath, "x64", "GIS Ink System Configuration UI", "DiskImages", "DISK1", "GIS Atlas Ink System Configuration UI.exe")
# Destination
inkSystemConfigurationUIBuildRoot = os.path.join(buildRoot, "GIS Ink System UI Installer", "Configuration UI")
self.makeDirectories(inkSystemConfigurationUIBuildRoot)
destName = os.path.join(inkSystemConfigurationUIBuildRoot, "GIS Atlas Ink System Configuration UI " + softwareRelease + " Installer.exe")
self.copyFile(releaseInstaller, destName)
# Source
releaseInstaller = os.path.join(srcRelPath, "x64", "GIS Ink System Operator UI", "DiskImages", "DISK1", "GIS Atlas Ink System Operator UI.exe")
# Destination
inkSystemOperatorUIBuildRoot = os.path.join(buildRoot, "GIS Ink System UI Installer", "Operator UI")
self.makeDirectories(inkSystemOperatorUIBuildRoot)
destName = os.path.join(inkSystemOperatorUIBuildRoot, "GIS Atlas Ink System Operator UI " + softwareRelease + " Installer.exe")
self.copyFile(releaseInstaller, destName)
# Source
releaseInstaller = os.path.join(srcRelPath, "x64", "GIS Ink System Tool Modules", "DiskImages", "DISK1", "GIS Atlas Ink System Tool Modules.exe")
# Destination
inkSystemOperatorUIModuleBuildRoot = os.path.join(buildRoot, "GIS Ink System UI Installer", "Operator UI Module")
self.makeDirectories(inkSystemOperatorUIModuleBuildRoot)
destName = os.path.join(inkSystemOperatorUIModuleBuildRoot, "GIS Atlas Ink System Operator UI Module " + softwareRelease + " Installer.exe")
self.copyFile(releaseInstaller, destName)
class McsToolsCopierPost2_0_28(Copier):
def __init__(self):
Copier.__init__(self, "atlasmcstools")
def transfer(self, buildRoot, softwareRelease):
# Do a copy if required
if CommonLibrary.includeMCS == "true":
# Source
srcRelPath = os.path.join(CommonLibrary.workspace, self.releaseFolderPath)
releaseInstaller = os.path.join(srcRelPath, "x64", "GIS MCS Tool Modules", "DiskImages", "DISK1", "GIS Atlas MCS Tool Modules.exe")
# Destination
mcsToolsBuildRoot = os.path.join(buildRoot, "GIS Atlas MCS Tool Modues Installer")
self.makeDirectories(mcsToolsBuildRoot)
destName = os.path.join(mcsToolsBuildRoot, "GIS MCS Tool Modules " + softwareRelease + " Installer.exe")
self.copyFile(releaseInstaller, destName)
class AtlasUIReleaseNotesCopier(Copier):
def __init__(self):
Copier.__init__(self, "atlasreleasenotes")
def transfer(self, buildRoot, softwareRelease):
# Unconditionally copy release notes
# Source
srcRelPath = os.path.join(CommonLibrary.workspace, self.releaseFolderPath)
releaseInstaller = os.path.join(srcRelPath, "Release Notes.txt")
# Destination
releaseNotesBuildRoot = buildRoot
self.makeDirectories(releaseNotesBuildRoot)
destName = os.path.join(releaseNotesBuildRoot, "Release Notes.txt")
self.copyFile(releaseInstaller, destName)

127
publish/publishitems.groovy Normal file
View file

@ -0,0 +1,127 @@
import com.cwctravel.hudson.plugins.extended_choice_parameter.ExtendedChoiceParameterDefinition
class PublishableItemsSelection {
def script
def ArrayList<String> preselectedmenuitems
def ArrayList<String> menuitemdescriptions
def ArrayList<String> menuitemsfull
def ExtendedChoiceParameterDefinition multiselect
PublishableItemsSelection(script) {
this.script = script
preselectedmenuitems = new ArrayList<String>()
menuitemdescriptions = new ArrayList<String>()
menuitemsfull = new ArrayList<String>()
}
def init(
String name,
String description,
releasemeta,
String preselectedext,
String metalevelsstringext,
String visibleItemCountExt,
String controltype) {
outputSelectionfromPreselect(preselectedmenuitems, preselectedext)
def Integer metalevelsext = metalevelsstringext.toInteger()
def Integer visibleItemCount = visibleItemCountExt.toInteger()
def metaitems = releasemeta.releasewalkerunique(metalevelsext)
for (key in metaitems.keySet()) {
def releaseinfo = metaitems[key]
outputDescription(menuitemdescriptions, releaseinfo)
outputSelection(menuitemsfull, releaseinfo)
}
script.echo("name is: ${name}")
script.echo("description is: ${description}")
script.echo("menuitemsfull is: ${menuitemsfull}")
script.echo("preselectedmenuitems is: ${preselectedmenuitems}")
script.echo("menuitemdescriptions is: ${menuitemdescriptions}")
script.echo("visibleItemCount is: ${visibleItemCount}")
script.echo("controltype is: ${controltype}")
def seperator = ","
visibleItemCount = Math.min(visibleItemCount, menuitemsfull.size())
script.echo("visibleItemCount is now: ${visibleItemCount}")
multiselect = new ExtendedChoiceParameterDefinition(
name, // String name
controltype, // String type
menuitemsfull.join(seperator), // String value
"project name", // String projectName
"", // String propertyFile
"", // String groovyScript
"", // String groovyScriptFile
"", // String bindings
"", // String groovyClasspath
"", // String propertyKey
preselectedmenuitems.join(seperator),// String defaultValue
"", // String defaultPropertyFile
"", // String defaultGroovyScript
"", // String defaultGroovyScriptFile
"", // String defaultBindings
"", // String defaultGroovyClasspath
"", // String defaultPropertyKey
menuitemdescriptions.join(seperator),// String descriptionPropertyValue
"", // String descriptionPropertyFile
"", // String descriptionGroovyScript
"", // String descriptionGroovyScriptFile
"", // String descriptionBindings
"", // String descriptionGroovyClasspath
"", // String descriptionPropertyKey
"", // String javascriptFile
"", // String javascript
false, // boolean saveJSONParameterToFile
false, // boolean quoteValue
visibleItemCount, // int visibleItemCount
description, // String description
seperator) // String multiSelectDelimiter
}
def outputSelectionfromPreselect(menuitems, preselectedext) {
script.echo ("preselectext: ${preselectedext}")
def menuitemstemp = preselectedext.split(',')
script.echo ("Menuitemstemp: ${menuitemstemp}")
for (menuitem in menuitemstemp) {
menuitems.add(menuitem.trim())
}
}
def outputDescription(menuitems, releaseinfo) {
def meta = releaseinfo.meta
for (publishableitem in meta.publishableinfo) {
menuitems.add("${meta.productinfo.productname} ${meta.productinfo.subcomponentname} ${publishableitem.filepath}")
}
}
def outputSelection(menuitems, releaseinfo) {
def meta = releaseinfo.meta
for (publishableitem in meta.publishableinfo) {
menuitems.add("${meta.productinfo.productname}#${meta.productinfo.subcomponentname}#${publishableitem.filepath}")
}
}
def multiSelect() {
return multiselect
}
}
PublishableItemsSelection createItemSelector(
String name,
String description,
releasemeta,
String preselectedext,
String metalevelsstringext,
String visibleItemCountExt = '20',
String type = 'PT_CHECKBOX') { // Could also be "PT_MULTI_SELECT"
PublishableItemsSelection pis = new PublishableItemsSelection(this)
pis.init(name, description, releasemeta, preselectedext, metalevelsstringext, visibleItemCountExt, type)
return pis
}
return this;

View file

@ -1,8 +0,0 @@
REM Reset imports and exports folders
echo Removing previous imports and exports
del dir_built.txt
del tree_built.txt
del ftp_script.txt
del transfer.txt
rmdir /s /q imports
exit /b 0

27
publishing/utils.groovy Normal file
View file

@ -0,0 +1,27 @@
// The filepath must end in "<folder>/**" or "<folder>/" - Glob wildcard - as a git sparse checkout
def allowed(String filepath) {
if (filepath.endsWith('/**') || filepath.endsWith('/')) {
def files = findFiles glob: filepath
if (files.length > 0) {
return
} else {
error "There are no files/folders under the publishable item: ${filepath}"
}
}
error "The publishable item: ${filepath} does not end in <folder>/** or <folder>/ (for git sparse checkouts)"
}
// Generate a list of artifact files that are publishable to outside parties
def generatelist(meta, publishable) {
filelist = []
for (filepath in publishable) {
if (filepath != meta.METAARTIFACTS) {
allowed(filepath)
}
meta.addPublishable(filepath)
}
}
return this;

442
release/do.groovy Normal file
View file

@ -0,0 +1,442 @@
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.meta.releaseinfo.releaseitems) {
def filterpath = artifactfilter
if (buildinfo.offsetpath) {
filterpath = buildinfo.offsetpath + '/' + artifactfilter
}
// Copy relevant artifacts to temp folder
echo "Copying artifacts: ${filterpath} to ${tempfolder}"
try {
copyArtifacts(
filter: filterpath,
projectName: toplevelbuildmeta.jenkinsbuildinfo.buildjobname,
selector: [
$class: 'ParameterizedBuildSelector',
parameterName: "<SpecificBuildSelector plugin='copyartifact@1.41'><buildNumber>${toplevelbuildmeta.jenkinsbuildinfo.buildnumber}</buildNumber></SpecificBuildSelector>"
],
target: tempfolder
)
} catch (Exception e) {
echo "Exception occurred while copying artifacts from ${toplevelbuildmeta.jenkinsbuildinfo.buildjobname}: ${e.getMessage()}"
result = false
summaryappend("Does not exist:")
}
if (result) {
// Move relevant artifacts from temp folder to release position
def originalrootdir = tempfolder + "/" + buildinfo.offsetpath
dir(originalrootdir) {
sh("mv * ${repofolder}")
}
}
summaryappend("${artifactfilter},")
}
return result
}
def releasegitadd() {
// Add anything new
sh("git add .")
summaryappend("Add,")
}
def releasegitreset() {
// Add anything new
sh("git reset --hard")
sh("git clean -fdx")
summaryappend("Reset,")
}
def releasegitcommit(String buildstamp) {
sh("git commit -a -m ${buildstamp}")
summaryappend("Commit,")
}
// Determine if there has been a change by comparing the sha code in previous release meta and the build meta
def boolean checkforchange(buildmeta, previousreleasemeta) {
String buildsha = buildmeta.gitinfo.gitrevision
String previoussha = previousreleasemeta.gitinfo.gitrevision
def boolean shachanged = (buildsha != previoussha)
echo "buildsha: ${buildsha} previoussha: ${previoussha} changed: ${shachanged}"
String buildstamp = buildmeta.buildstampinfo.buildstamp
String previousbuildstamp = previousreleasemeta.buildstampinfo.buildstamp
def boolean buildstampchanged = (buildstamp != previousbuildstamp)
echo "buildstamp: ${buildstamp} previousbuildstamp: ${previousbuildstamp} changed: ${buildstampchanged}"
def boolean changed = (shachanged | buildstampchanged)
echo "changed: ${changed}"
return changed
}
def ArrayList<String> maketaglist(buildmeta, String buildstamp, String otherreleasetags) {
def ArrayList<String> taglist = new ArrayList<String>()
taglist.add(buildstamp)
def ArrayList<String> othertaglist = otherreleasetags.split(',')
for (othertagitem in othertaglist) {
if (othertagitem?.trim()) {
def componentothertagitem = "${othertagitem.trim()}_${buildmeta.productinfo.productname}_${buildmeta.productinfo.subcomponentname}"
taglist.add(componentothertagitem)
}
}
return taglist
}
def String releasegitgetshacode(String tag) {
def existingshacode = ""
// Check if tag exists already
def int gitrevparsestatus = sh(script: "git rev-parse \"${tag}\" >\"${gitrevparseoutputfile}\" 2>/dev/null", returnStatus: true)
if (gitrevparsestatus == 0) { // Tag exists
existingshacode = readFile(file: gitrevparseoutputfile).trim()
}
return existingshacode
}
def boolean releasegittag(String postcommitshacode, String tag) {
def boolean tagadded = false
// Check if tag exists already
def String existingshacode = releasegitgetshacode(tag)
if (existingshacode) { // Tag exists
if (existingshacode != postcommitshacode) { // If the existing tag is not associated with the one expected
// This is a problem - The tag is already at another position in git repo
setunstable("The release tag ${tag} has been used at another commit other than one expected - You must decide what to do with it - Not good practice to delete it or move it (Existing sha code: ${existingshacode} Post commit sha code: ${postcommitshacode})")
summaryappend("(${tag} - Could not add!)")
} else {
summaryappend("(${tag} - Already added)")
}
} else { // If tag does not exist already
// Tag
sh("git tag \"${tag}\"")
summaryappend("(${tag})")
tagadded = true
}
return tagadded
}
def boolean releasegittags(String postcommitshacode, ArrayList<String> taglist) {
boolean tagadded = false
summaryappend("Rel Tag ")
for (tag in taglist) {
if (releasegittag(postcommitshacode, tag)) {
tagadded = true
}
}
return tagadded
}
def boolean sourcegittag(String shacode, String tag) {
def boolean tagadded = false
// Check if tag exists already
def int gitrevparsestatus = sh(script: "git rev-parse \"${tag}\" >\"${gitrevparseoutputfile}\" 2>/dev/null", returnStatus: true)
if (gitrevparsestatus == 0) { // Tag exists
def existingshacode = readFile(file: gitrevparseoutputfile).trim()
if (existingshacode != shacode) { // If the existing tag is not associated with HEAD
// This is a problem - The tag is already at another position in git repo
setunstable("The source tag ${tag} has been used at another commit (${existingshacode}) - You must decide what to do with it - Not good practice to delete it or move it (Existing sha code: ${existingshacode} Post commit sha code: ${shacode})")
summaryappend("(${tag} - Could not add!)")
}
else {
summaryappend("(${tag} - Already added)")
}
}
else { // If tag does not exist already
// Tag
sh("git tag \"${tag}\" ${shacode}")
summaryappend("(${tag})")
tagadded = true
}
return tagadded
}
def sourcegittags(String buildsha, List taglist) {
boolean tagadded = false
summaryappend(",Src Tag ")
for (tag in taglist) {
if (sourcegittag(buildsha, tag)) {
tagadded = true
}
}
return tagadded
}
def releasegitpush(String dryrunpush ) {
sh("git remote -v")
if (dryrunpush == "true") {
sh("git push -n --tags origin master")
summaryappend(",Dry-Run-Push")
setunstable("The artifact(s) have not been pushed/saved (\"Dry run push\" parameter/option is selected)")
}
else {
sh("git push --tags origin master")
summaryappend(",Push")
}
}
def sourcegitpush(String dryrunpush ) {
sh("git remote -v")
if (dryrunpush == "true") {
sh("git push -n --tags")
summaryappend(",Src-Dry-Run-Push")
setunstable("The source tag(s) have not been pushed/saved (\"Dry run push\" parameter/option is selected)")
}
else {
sh("git push --tags")
summaryappend(",Src Push")
}
}
def boolean isalreadyreleased(buildmeta, tag) {
def boolean alreadyreleased = buildmeta.releaseinfo.released
if (alreadyreleased) {
echo "Component is already marked as released: ${alreadyreleased}"
} else {
String commitshacode = releasegitgetshacode(tag)
if (commitshacode) {
echo "Tag: ${tag} already exists in this repo therefore marking as already released"
alreadyreleased = true
} else {
alreadyreleased = false
}
}
return alreadyreleased
}
def gitrelease(buildmeta, previousreleasemeta, String releaserepo, String sourcerepo, String otherreleasetags, String dryrunpush) {
summaryappend(" Git operations: ")
def String buildstamptag = buildmeta.releasetag()
dir(releaserepo) {
def String precommitshacode = sh(script: "git rev-parse --verify HEAD", returnStdout: true).trim()
echo "Pre commit sha code: ${precommitshacode}"
def boolean alreadyreleased = isalreadyreleased(buildmeta, buildstamptag)
def String postcommitshacode
def boolean changed = false
if (alreadyreleased) {
summaryappend("Already-released,")
postcommitshacode = releasegitgetshacode(buildstamptag)
echo "Previous release sha code: ${postcommitshacode}"
} else {
releasegitadd()
changed = checkforchange(buildmeta, previousreleasemeta)
if (changed) {
releasegitcommit(buildstamptag)
} else {
releasegitreset()
summaryappend("No-commit,")
}
postcommitshacode = sh(script: "git rev-parse --verify HEAD", returnStdout: true).trim()
echo "Post commit sha code: ${postcommitshacode}"
}
ArrayList<String> taglist = maketaglist(buildmeta, buildstamptag, otherreleasetags)
def tagadded = releasegittags(postcommitshacode, taglist)
if (changed || tagadded) {
releasegitpush(dryrunpush)
}
}
dir(sourcerepo) {
def String srcbuildstamptag = buildmeta.globalreleasetag()
def String buildsha = buildmeta.gitinfo.gitrevision
if (buildsha) {
def ArrayList<String> srctaglist = maketaglist(buildmeta, srcbuildstamptag, otherreleasetags)
def tagadded = sourcegittags(buildsha, srctaglist)
if (tagadded) {
sourcegitpush(dryrunpush)
}
} else {
summaryappend(",No Src ")
}
}
}
def releasecomponent(toplevelbuildmeta, buildinfo, String otherreleasetags, String dryrunpush) {
def buildmeta = buildinfo.meta
def 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(buildmeta, String maxdepth, String otherreleasetags, String dryrunpush) {
def int md = maxdepth.toInteger()
resetfolders()
preconditions()
// Walk the meta information to a max depth, looking for components to release
def componentReleaseInfo = buildmeta.releasewalkerunique(md)
echo "Unique components:"
def String versioncomponent = ""
for (key in componentReleaseInfo.keySet()) {
versioncomponent += "${key}\n"
}
echo versioncomponent
// Walk the meta information to a max depth, looking for components to release
def componentReleaseInfoVersionUnique = buildmeta.releasewalkerversionunique(md)
echo "Version unique components:"
def String versionuniquecomponent = ""
for (key in componentReleaseInfoVersionUnique.keySet()) {
versionuniquecomponent += "${key}\n"
}
echo versionuniquecomponent
if (DO_INTEGRITY_CHECK == "true") {
if (componentReleaseInfo.size() != componentReleaseInfoVersionUnique.size()) {
error "There are 2 or more versions of the same component being used in this hierarchy: Is this correct?"
}
}
def toplevelid = buildmeta.componentidentifier()
// For each component
for (key in componentReleaseInfo.keySet()) {
def buildinfo = componentReleaseInfo[key]
if (toplevelid != key) {
releasecomponent(buildmeta, buildinfo, otherreleasetags, dryrunpush)
}
}
// Do the top level last
def toplevelbuildinfo = componentReleaseInfo[toplevelid]
releasecomponent(buildmeta, toplevelbuildinfo, otherreleasetags, dryrunpush)
return [summarystring, markunstable, unstablereason]
}
return this;

View file

@ -0,0 +1,12 @@
vc = load("${autobuilder.commonscripts()}/versioncontrol/git.groovy")
// Prove the existence of the release repo - otherwise there is a large wait to cycle the build to correct the meta data
def registerrepo(meta, String releaserepo) {
if (releaserepo?.trim()) {
vc.checkRepoExists(releaserepo)
}
meta.releaseinfo.set(releaserepo)
}
return this;

88
release/release.groovy Normal file
View file

@ -0,0 +1,88 @@
pipeline {
agent { label "${AGENT_LABEL}" }
stages {
stage('Initial setup') {
steps {
script {
autobuilderscript = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy")
meta = autobuilderscript.startbuild(this, PRODUCT_NAME, SUBCOMPONENT_NAME, RELEASE_REPO)
}
}
}
stage('Clean exports') {
steps {
script {
cleanfolders = [
"${WORKSPACE}/build_artifacts",
]
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
cleaner.clean(cleanfolders)
}
}
}
stage('Get build artifact meta') {
steps {
script {
BUILD_ARTIFACTS = "${WORKSPACE}/build_artifacts"
copyArtifacts(
filter: 'meta/**',
projectName: BUILD_JOB,
selector: [
$class: 'ParameterizedBuildSelector',
parameterName: BUILD_JOB_SELECTOR
],
target: BUILD_ARTIFACTS
)
def mfs = autobuilderscript.getmetafolderscript()
buildmeta = mfs.metafromfolder(BUILD_ARTIFACTS)
}
}
}
stage('Release components') {
steps {
script {
def releaser = load("${autobuilder.commonscripts()}/release/do.groovy")
// Place the top level build stamp on all
OTHER_RELEASE_TAGS = "${buildmeta.globalreleasetag()},${OTHER_RELEASE_TAGS}"
(summarystring, markunstable, unstablereason) = releaser.releasehierarchy(buildmeta, MAX_META_DEPTH, OTHER_RELEASE_TAGS, DRY_RUN_PUSH)
if (markunstable) {
env.unstablereason = unstablereason
currentBuild.result = 'UNSTABLE'
}
}
}
}
stage('Archiving artifacts') {
steps {
script {
def artifactlist = meta.generateartifacts()
archiveArtifacts "summary/**,${artifactlist}"
}
}
}
stage('Summarise') {
steps {
script {
echo "Summary:\n${summarystring}\n"
if (env.unstablereason) {
echo "Instability reason: ${env.unstablereason}"
}
}
}
}
}
post {
always {
echo 'Post-build'
}
failure {
echo 'Failed build'
}
unstable {
echo 'Unstable build'
}
success {
echo 'Succeeded build'
}
}
}

View file

@ -1,149 +0,0 @@
pipeline {
agent { label "${AGENT_LABEL}" }
stages {
stage('Initial setup') {
steps {
script {
configurationhelper = load("${WORKSPACE}/Common_scripts/configuration/configuration.gsh")
githelper = load("${WORKSPACE}/Common_scripts/versioncontrol/git.gsh")
echo "Uncomment me"
//configurationhelper.registerPipelineScriptConfiguration()
}
}
}
stage('Clean workspace') {
when {
expression {
env.CLEAN_WORKSPACE == "true"
}
}
steps {
// Save any script files that were loaded into the workspace at first and are required after cleaning the workspace
stash allowEmpty: true, includes: 'Common_scripts/**/*', name: 'Clean workspace stash', useDefaultExcludes: false
cleanWs()
unstash name: 'Clean workspace stash'
}
}
stage('Nothing to build check') {
when {
expression {
env.RELEASE_COMMIT == "false"
}
}
steps {
echo 'No installers to build'
script {
currentBuild.result = 'UNSTABLE'
}
}
}
stage('Checkout dependencies') {
when {
expression {
env.RELEASE_COMMIT == "true"
}
}
steps {
script {
PYTHONURL = 'git@hydra:tools/python.git'
PYTHONBRANCH = 'origin/3.6.3_windows'
PYTHONDIR = "${WORKSPACE}/python"
PYTHONROOTDIR = 'python'
configurationhelper.gitCheckoutAndRegister('python', PYTHONURL, PYTHONBRANCH, PYTHONDIR, PYTHONROOTDIR)
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
SOURCEURL = 'git@hydra:gis/Hmb_Js_Client.git'
SOURCEBRANCH = "${SOURCE_BRANCH}"
SOURCEDIR = "${WORKSPACE}\\jsclient"
SOURCEROOTDIR = 'jsclient'
configurationhelper.gitCheckoutAndRegister('jsclient', SOURCEURL, SOURCEBRANCH, SOURCEDIR, SOURCEROOTDIR)
env.SOURCE_PATH = "${SOURCEDIR}"
}
}
}
stage("Clean imports") {
steps {
script {
env.IMPORTSPATH = "${WORKSPACE}/imports"
}
dir("${IMPORTSPATH}") {
echo "Deleting directories in ${IMPORTSPATH}"
deleteDir()
}
}
}
stage("Import binaries and versions") {
when {
expression {
env.RELEASE_COMMIT == "true"
}
}
steps {
script {
projectImports = [
[ 'Build', "${BUILD_JOB}", "${IMPORTSPATH}", 'jsclient/**,version/**', false ],
]
for (projectImport in projectImports) {
(importName, sourceProject, destFolder, toCopy, checkImports) = projectImport
copyArtifacts excludes: '', filter: toCopy, fingerprintArtifacts: true, projectName: "${sourceProject}", selector: lastSuccessful(), target: "${destFolder}"
if (checkImports) {
env.importDest = destFolder
bat '''
"%PYTHON%" "%SOURCE_PATH%\\autobuild\\common\\fingerprint.py" -f "%importDest%\\pipeline\\hashes.txt" -v -p "%importDest%"
'''
}
}
}
}
}
stage("Release to git") {
when {
expression {
env.RELEASE_COMMIT == "true"
}
}
steps {
script {
bat '''
"%PYTHON34%" -u "%SOURCE_PATH%\\autobuild\\releasetogit\\conditional_add.py"
'''
}
}
}
stage('Check for unstable build') {
when {
expression {
env.RELEASE_COMMIT == "true"
}
}
steps {
script {
if (env.DRY_RUN_PUSH == "true") {
echo "Not pushing the content to git therefore marking building unstable"
currentBuild.result = 'UNSTABLE'
}
}
}
}
}
post {
always {
echo 'Post-build'
}
failure {
echo 'Failed build'
/*
step([$class: 'LogParserPublisher',
parsingRulesPath: 'GitRepository/autobuild/build/log parsing rules/vs.txt',
useProjectRule: true
])
*/
}
unstable {
echo 'Unstable build'
}
success {
echo 'Succeeded build'
}
}
}

View file

@ -1,150 +0,0 @@
pipeline {
agent { label "${AGENT_LABEL}" }
stages {
stage('Initial setup') {
steps {
script {
configurationhelper = load("${WORKSPACE}/Common_scripts/configuration/configuration.gsh")
githelper = load("${WORKSPACE}/Common_scripts/versioncontrol/git.gsh")
echo "Uncomment me"
//configurationhelper.registerPipelineScriptConfiguration()
}
}
}
stage('Clean workspace') {
when {
expression {
env.CLEAN_WORKSPACE == "true"
}
}
steps {
// Save any script files that were loaded into the workspace at first and are required after cleaning the workspace
stash allowEmpty: true, includes: 'Common_scripts/**/*', name: 'Clean workspace stash', useDefaultExcludes: false
cleanWs()
unstash name: 'Clean workspace stash'
}
}
stage('Nothing to build check') {
when {
expression {
env.RELEASE_COMMIT == "false"
}
}
steps {
echo 'No installers to build'
script {
currentBuild.result = 'UNSTABLE'
}
}
}
stage('Checkout dependencies') {
when {
expression {
env.RELEASE_COMMIT == "true"
}
}
steps {
script {
PYTHONURL = 'git@hydra:tools/python.git'
PYTHONBRANCH = 'origin/3.6.3_windows'
PYTHONDIR = "${WORKSPACE}/python"
PYTHONROOTDIR = 'python'
configurationhelper.gitCheckoutAndRegister('python', PYTHONURL, PYTHONBRANCH, PYTHONDIR, PYTHONROOTDIR)
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
SOURCEURL = 'git@hydra:gis/atlas_ui.git'
SOURCEBRANCH = "${SOURCE_BRANCH}"
SOURCEDIR = "${WORKSPACE}\\atlas_ui"
SOURCEROOTDIR = 'atlas_ui'
configurationhelper.gitCheckoutAndRegister('atlas_ui', SOURCEURL, SOURCEBRANCH, SOURCEDIR, SOURCEROOTDIR)
env.SOURCE_PATH = "${SOURCEDIR}"
}
}
}
stage("Clean imports") {
steps {
script {
env.IMPORTSPATH = "${WORKSPACE}/imports"
}
dir("${IMPORTSPATH}") {
echo "Deleting directories in ${IMPORTSPATH}"
deleteDir()
}
}
}
stage("Import binaries and versions") {
when {
expression {
env.RELEASE_COMMIT == "true"
}
}
steps {
script {
projectImports = [
[ 'Installers and Binaries', "${INSTALLER_BUILD_JOB}", "${IMPORTSPATH}/install", '**', true ],
[ 'Build', "${BUILD_JOB}", "${IMPORTSPATH}/build", 'version/**,pipeline/**', false ],
]
for (projectImport in projectImports) {
(importName, sourceProject, destFolder, toCopy, checkImports) = projectImport
copyArtifacts excludes: '', filter: toCopy, fingerprintArtifacts: true, projectName: "${sourceProject}", selector: lastSuccessful(), target: "${destFolder}"
if (checkImports) {
env.importDest = destFolder
bat '''
"%PYTHON%" "%SOURCE_PATH%\\autobuild\\common\\fingerprint.py" -f "%importDest%\\pipeline\\hashes.txt" -v -p "%importDest%"
'''
}
}
}
}
}
stage("Release to git") {
when {
expression {
env.RELEASE_COMMIT == "true"
}
}
steps {
script {
bat '''
"%PYTHON34%" -u "%WORKSPACE%\\atlas_ui\\autobuild\\releasetogit\\conditional_add.py"
'''
}
}
}
stage('Check for unstable build') {
when {
expression {
env.RELEASE_COMMIT == "true"
}
}
steps {
script {
if (env.DRY_RUN_PUSH == "true") {
echo "Not pushing the content to git therefore marking building unstable"
currentBuild.result = 'UNSTABLE'
}
}
}
}
}
post {
always {
echo 'Post-build'
}
failure {
echo 'Failed build'
/*
step([$class: 'LogParserPublisher',
parsingRulesPath: 'GitRepository/autobuild/build/log parsing rules/vs.txt',
useProjectRule: true
])
*/
}
unstable {
echo 'Unstable build'
}
success {
echo 'Succeeded build'
}
}
}

32
remoteaccess/ftp.groovy Normal file
View file

@ -0,0 +1,32 @@
import org.apache.commons.net.ftp.FTPClient
class FTPSiteInfo {
String url
String username
String password
String workingdirectory
FTPSiteInfo(String url, String username, String password, String workingdirectory) {
this.url = url
this.username = username
this.password = password
this.workingdirectory = workingdirectory
}
}
FTPSiteInfo createFTPSiteInfo(String url, String username, String password, String workingdirectory) {
FTPSiteInfo ftpsiteinfo = new FTPSiteInfo(url, username, password, workingdirectory)
return ftpsiteinfo
}
FTPClient createFTPClient(FTPSiteInfo ftpsiteinfo) {
FTPClient ftpclient = new FTPClient()
ftpclient.connect(ftpsiteinfo.url)
ftpclient.enterLocalPassiveMode()
ftpclient.login(ftpsiteinfo.username, ftpsiteinfo.password)
ftpclient.changeWorkingDirectory(ftpsiteinfo.workingdirectory)
return ftpclient
}
return this;

View file

@ -0,0 +1,28 @@
ftpremote = load("${autobuilder.commonscripts()}/remoteaccess/ftp.groovy")
def getHostedFTPSiteInfo() {
hostedftpsiteinfo =
ftpremote.createFTPSiteInfo("ftp.hostedftp.com",
"ftp@globalinkjetsystems.com",
"ramshorn42",
"/Customers/")
return hostedftpsiteinfo
}
def getCustomerList() {
def List<String> customerfilenames = new ArrayList<String>()
def List<String> customers = new ArrayList<String>()
def ftpsiteinfo = getHostedFTPSiteInfo()
def ftpclient = ftpremote.createFTPClient(ftpsiteinfo)
customerfilenames = ftpclient.listNames()
for(customer in customerfilenames) {
def String converted = new String(customer.getBytes("ISO-8859-1"), "UTF-8")
customers.add(converted)
}
ftpclient.disconnect()
return customers
}
return this;

View file

@ -1,206 +0,0 @@
pipeline {
agent { label "${AGENT_LABEL}" }
// Timeout becasue Resharper sometimes hangs indefinitely
options {
timeout(time: 1, unit:'HOURS')
}
stages {
stage('Initial setup') {
steps {
script {
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startbuild(this, PRODUCT_NAME, SUBCOMPONENT_NAME, RELEASE_REPO)
}
}
}
stage('Checkout dependencies') {
steps {
script {
configurationhelper = autobuilder.configurationhelper()
PYTHONURL = 'git@hydra:tools/python.git'
PYTHONBRANCH = 'origin/3.6.3_windows'
PYTHONDIR = "${WORKSPACE}/python"
PYTHONROOTDIR = 'python'
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR, PYTHONROOTDIR)
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
VERSTAMPINGURL = 'git@hydra:releases/ver_stamping_releases.git'
VERSTAMPINGREVISION = "refs/tags/${VERSION_STAMPING_VERSION}"
VERSTAMPINGDIR = "${WORKSPACE}/ver_stamping"
VERSTAMPINGROOTDIR = 'ver_stamping_releases'
configurationhelper.gitCheckoutAndRegister(meta, 'Version stamping', VERSTAMPINGURL, VERSTAMPINGREVISION, VERSTAMPINGDIR, VERSTAMPINGROOTDIR)
}
}
}
stage('Checkout source') {
steps {
script {
SOURCEURL = 'git@hydra:gis/atlas_ui.git'
SOURCEREVISION = SOURCE_REVISION
SOURCEDIR = "${WORKSPACE}\\atlas_ui"
SOURCEROOTDIR = 'atlas_ui'
configurationhelper.gitCheckoutAndRegister(meta, 'atlas_ui', SOURCEURL, SOURCEREVISION, SOURCEDIR, SOURCEROOTDIR, 0, false)
env.SOURCE_PATH = SOURCEDIR
env.JOBSCRIPTS = "${SOURCE_PATH}\\autobuild\\code_analysis"
env.JOBSCRIPTS_COMMON = "${SOURCE_PATH}\\autobuild\\common"
env.SRC = SOURCE_PATH
}
}
}
stage('Clean exports') {
steps {
script {
env.BUILDOUTPUT = "${WORKSPACE}/build"
env.PSBIN = "${WORKSPACE}/ps_bin"
env.ASBIN = "${WORKSPACE}/as_bin"
env.AULIB = "${WORKSPACE}/atlaslibraries"
env.TESTRESULTS = "${WORKSPACE}/testresults"
env.PSSOURCE = "${WORKSPACE}/newsw"
cleanfolders = [
BUILDOUTPUT,
"${WORKSPACE}/SharedPackages",
PSBIN,
ASBIN,
AULIB,
"${WORKSPACE}/binInk",
"${WORKSPACE}/documentation",
TESTRESULTS,
]
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
cleaner.clean(cleanfolders)
}
}
}
stage('Generating version info') {
steps {
script {
version = load("${autobuilder.commonscripts()}/versionnumbering/generate.groovy")
version.generate(meta, SOURCE_REVISION, SOURCE_PATH, BASEBUILDNUMBER)
}
}
}
stage('Import Atlas UI libraries') {
steps {
script {
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
libmeta = importer.artifactimport(meta,
ATLAS_UI_ARTIFACT_LOCATION,
ATLAS_UI_COMPILE_JOB,
ATLAS_UI_BUILD_SELECTOR,
ATLAS_UI_RELEASE_REPO,
ATLAS_UI_RELEASE_REVISION,
AULIB,
false)
}
}
}
stage('Import Print server to adjust version number') {
steps {
script {
def psartifactfiles = "meta/**"
psmeta = importer.artifactimport(meta,
PRINT_SERVER_ARTIFACT_LOCATION,
PRINT_SERVER_COMPILE_JOB,
PRINT_SERVER_BUILD_SELECTOR,
PRINT_SERVER_RELEASE_REPO,
PRINT_SERVER_RELEASE_REVISION,
PSBIN,
true,
psartifactfiles) // This should increment the version number
}
}
}
stage('Import Atlas services to adjust version number') {
steps {
script {
def asartifactfiles = "meta/**"
asmeta = importer.artifactimport(meta,
ATLAS_SERVICES_ARTIFACT_LOCATION,
ATLAS_SERVICES_COMPILE_JOB,
ATLAS_SERVICES_BUILD_SELECTOR,
ATLAS_SERVICES_RELEASE_REPO,
ATLAS_SERVICES_RELEASE_REVISION,
ASBIN,
true,
asartifactfiles)
}
}
}
stage('Version stamp files') {
steps {
script {
env.BUILD_STAMP=meta.buildstampinfo.buildstamp
env.BUILD_DATE=meta.jenkinsbuildinfo.builddate
env.AS_PACKAGE_VERSION=asmeta.buildstampinfo.buildstamp
bat """
call "${JOBSCRIPTS_COMMON}\\version_ink_ui_files.bat"
if errorlevel 1 exit /b 1
"""
}
}
}
stage('Analyse resharper') {
steps {
script {
env.SRC_REVISION=SOURCE_REVISION
bat """
call "${JOBSCRIPTS}\\build_and_analyse_ink_ui.bat"
if errorlevel 1 exit /b 1
"""
}
}
}
stage('Analysis') {
steps {
recordIssues enabledForFailure: true, tool: resharperInspectCode(pattern: 'results/atlas_ink_ui_resharper_results.xml'), qualityGates:[[threshold: 1000, type: 'TOTAL', unstable: true],[threshold: 1250, type: 'TOTAL', unstable: false]]
}
}
stage('Checksum artifacts') {
steps {
script {
def checksummable = [
/* Binaries are signed
'build/**',
'SharedPackages/**',
*/
]
checksumutils = load("${autobuilder.commonscripts()}/checksum/utils.groovy")
checksumutils.generatelist(meta, checksummable)
}
}
}
stage('Classifying publishable artifacts') {
steps {
script {
def publishable = [
]
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
publishutils.generatelist(meta, publishable)
}
}
}
stage('Archiving artifacts') {
steps {
script {
def artifactlist = meta.generateartifacts(["results/**"])
archiveArtifacts "${artifactlist}"
}
}
}
}
post {
always {
echo 'Post-build'
}
failure {
echo 'Failed build'
}
unstable {
echo 'Unstable build'
}
success {
echo 'Succeeded build'
}
}
}

View file

@ -1,208 +0,0 @@
pipeline {
agent { label "${AGENT_LABEL}" }
// Timeout becasue Resharper sometimes hangs indefinitely
options {
timeout(time: 1, unit:'HOURS')
}
stages {
stage('Initial setup') {
steps {
script {
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
}
}
}
stage('Checkout dependencies') {
steps {
script {
configurationhelper = autobuilder.configurationhelper()
PYTHONURL = 'git@hydra:tools/python.git'
PYTHONBRANCH = 'origin/3.6.3_windows'
PYTHONDIR = "${WORKSPACE}/python"
PYTHONROOTDIR = 'python'
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR, PYTHONROOTDIR)
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
VERSTAMPINGURL = 'git@hydra:releases/ver_stamping_releases.git'
VERSTAMPINGREVISION = "refs/tags/${VERSION_STAMPING_VERSION}"
VERSTAMPINGDIR = "${WORKSPACE}/ver_stamping"
VERSTAMPINGROOTDIR = 'ver_stamping_releases'
configurationhelper.gitCheckoutAndRegister(meta, 'Version stamping', VERSTAMPINGURL, VERSTAMPINGREVISION, VERSTAMPINGDIR, VERSTAMPINGROOTDIR)
}
}
}
stage('Checkout source') {
steps {
script {
SOURCEURL = 'git@hydra:gis/atlas_ui.git'
SOURCEREVISION = SOURCE_REVISION
SOURCEDIR = "${WORKSPACE}\\atlas_ui"
configurationhelper.gitCheckoutAndRegister(meta, 'atlas_ui', SOURCEURL, SOURCEREVISION, SOURCEDIR, '', 0, false)
env.SOURCE_PATH = SOURCEDIR
env.JOBSCRIPTS = "${SOURCE_PATH}\\autobuild\\code_analysis"
env.JOBSCRIPTS_COMMON = "${SOURCE_PATH}\\autobuild\\common"
env.SRC = SOURCE_PATH
}
}
}
stage('Clean exports') {
steps {
script {
env.BUILDOUTPUT = "${WORKSPACE}/build"
env.PSBIN = "${WORKSPACE}/ps_bin"
env.ASBIN = "${WORKSPACE}/as_bin"
env.PSSOURCE = "${WORKSPACE}/newsw"
cleanfolders = [
BUILDOUTPUT,
"${WORKSPACE}/SharedPackages",
PSBIN,
ASBIN,
"${WORKSPACE}/bin",
"${WORKSPACE}/binKiosk",
"${WORKSPACE}/documentation",
"${WORKSPACE}/ildasm",
"${WORKSPACE}/Libraries",
"${WORKSPACE}/Atlas Release",
"${WORKSPACE}/LocalisationSDK",
]
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
cleaner.clean(cleanfolders)
}
}
}
stage('Generating version info') {
steps {
script {
version = load("${autobuilder.commonscripts()}/versionnumbering/generate.groovy")
version.generate(meta, SOURCE_REVISION, SOURCE_PATH, BASEBUILDNUMBER)
}
}
}
stage('Import Print server dependencies') {
steps {
script {
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
def psartifactfiles = "meta/**,bin/x64/Release/Engine - Render.dll,bin/x64/Release/Engine - Render.lib,bin/x64/Release/Engine - Render.pdb,bin/x64/Release/TBarCode11_x64.dll,bin/x64/Release/GIS Utility - Toolbox.dll,bin/x64/Release/GIS Utility - Toolbox.lib,bin/x64/Release/GIS Utility - Toolbox.pdb,bin/x64/Release/zlib1.dll,bin/x64/Release/zlib1.lib,bin/x64/Release/zlib1.pdb,bin/x64/Release/GIS Utility - TCP-IP Comms.dll,bin/x64/Release/GIS Utility - TCP-IP Comms.lib,bin/x64/Release/GIS Utility - TCP-IP Comms.pdb,bin/x64/Release/Dialog - Tree Node Editor.dll,bin/x64/Release/Dialog - Tree Node Editor.lib,bin/x64/Release/Dialog - Tree Node Editor.pdb"
psmeta = importer.artifactimport(meta,
PRINT_SERVER_ARTIFACT_LOCATION,
PRINT_SERVER_COMPILE_JOB,
PRINT_SERVER_BUILD_SELECTOR,
PRINT_SERVER_RELEASE_REPO,
PRINT_SERVER_RELEASE_REVISION,
PSBIN,
true,
psartifactfiles)
}
}
}
stage('Checkout relevant Print server source') {
steps {
script {
def pssourceartifacts = "src/Engine Common"
def pssourceurl = psmeta.gitinfo.remoteurl
def pscommit = psmeta.gitinfo.gitrevision
configurationhelper.gitCheckoutAndRegister(meta, 'print_server_source', pssourceurl, pscommit, PSSOURCE, '', 0, false, pssourceartifacts)
}
}
}
stage('Import Atlas services dependencies') {
steps {
script {
def asartifactfiles = "meta/**,SharedPackages/**"
asmeta = importer.artifactimport(meta,
ATLAS_SERVICES_ARTIFACT_LOCATION,
ATLAS_SERVICES_COMPILE_JOB,
ATLAS_SERVICES_BUILD_SELECTOR,
ATLAS_SERVICES_RELEASE_REPO,
ATLAS_SERVICES_RELEASE_REVISION,
ASBIN,
true,
asartifactfiles)
}
}
}
stage('Version files') {
steps {
script {
env.BUILD_STAMP=meta.buildstampinfo.buildstamp
env.BUILD_DATE=meta.jenkinsbuildinfo.builddate
env.PS_VERSION="1.0.${psmeta.buildstampinfo.revision}.0"
env.PS_PACKAGE_VERSION=psmeta.buildstampinfo.buildstampprefix
env.AS_PACKAGE_VERSION=asmeta.buildstampinfo.buildstamp
bat """
call "${JOBSCRIPTS_COMMON}\\create_ps_nuget.bat"
if errorlevel 1 exit /b 1
call "${JOBSCRIPTS_COMMON}\\version_atlas_ui_files.bat"
if errorlevel 1 exit /b 1
"""
}
}
}
stage('Analyse resharper') {
steps {
script {
env.SRC_REVISION=SOURCE_REVISION
bat """
call "${JOBSCRIPTS}\\build_and_analyse_atlas_sdk.bat"
if errorlevel 1 exit /b 1
"""
}
}
}
stage('Analysis') {
steps {
recordIssues enabledForFailure: true, tool: resharperInspectCode(pattern: 'results/**'), qualityGates:[[threshold: 230, type: 'TOTAL', unstable: true],[threshold: 250, type: 'TOTAL', unstable: false]]
}
}
stage('Checksum artifacts') {
steps {
script {
def checksummable = [
/* Binaries are signed
'build/**',
'SharedPackages/**',
*/
]
checksumutils = load("${autobuilder.commonscripts()}/checksum/utils.groovy")
checksumutils.generatelist(meta, checksummable)
}
}
}
stage('Classifying publishable artifacts') {
steps {
script {
def publishable = [
]
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
publishutils.generatelist(meta, publishable)
}
}
}
stage('Archiving artifacts') {
steps {
script {
def artifactlist = meta.generateartifacts(["results/**"])
archiveArtifacts "${artifactlist}"
}
}
}
}
post {
always {
echo 'Post-build'
}
failure {
echo 'Failed build'
}
unstable {
echo 'Unstable build'
}
success {
echo 'Succeeded build'
}
}
}

View file

@ -1,208 +0,0 @@
pipeline {
agent { label "${AGENT_LABEL}" }
// Timeout becasue Resharper sometimes hangs indefinitely
options {
timeout(time: 1, unit:'HOURS')
}
stages {
stage('Initial setup') {
steps {
script {
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
}
}
}
stage('Checkout dependencies') {
steps {
script {
configurationhelper = autobuilder.configurationhelper()
PYTHONURL = 'git@hydra:tools/python.git'
PYTHONBRANCH = 'origin/3.6.3_windows'
PYTHONDIR = "${WORKSPACE}/python"
PYTHONROOTDIR = 'python'
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR, PYTHONROOTDIR)
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
VERSTAMPINGURL = 'git@hydra:releases/ver_stamping_releases.git'
VERSTAMPINGREVISION = "refs/tags/${VERSION_STAMPING_VERSION}"
VERSTAMPINGDIR = "${WORKSPACE}/ver_stamping"
VERSTAMPINGROOTDIR = 'ver_stamping_releases'
configurationhelper.gitCheckoutAndRegister(meta, 'Version stamping', VERSTAMPINGURL, VERSTAMPINGREVISION, VERSTAMPINGDIR, VERSTAMPINGROOTDIR)
}
}
}
stage('Checkout source') {
steps {
script {
SOURCEURL = 'git@hydra:gis/atlas_ui.git'
SOURCEREVISION = SOURCE_REVISION
SOURCEDIR = "${WORKSPACE}\\atlas_ui"
configurationhelper.gitCheckoutAndRegister(meta, 'atlas_ui', SOURCEURL, SOURCEREVISION, SOURCEDIR, '', 0, false)
env.SOURCE_PATH = SOURCEDIR
env.JOBSCRIPTS = "${SOURCE_PATH}\\autobuild\\code_analysis"
env.JOBSCRIPTS_COMMON = "${SOURCE_PATH}\\autobuild\\common"
env.SRC = SOURCE_PATH
}
}
}
stage('Clean exports') {
steps {
script {
env.BUILDOUTPUT = "${WORKSPACE}/build"
env.PSBIN = "${WORKSPACE}/ps_bin"
env.ASBIN = "${WORKSPACE}/as_bin"
env.PSSOURCE = "${WORKSPACE}/newsw"
cleanfolders = [
BUILDOUTPUT,
"${WORKSPACE}/SharedPackages",
PSBIN,
ASBIN,
"${WORKSPACE}/bin",
"${WORKSPACE}/binKiosk",
"${WORKSPACE}/documentation",
"${WORKSPACE}/ildasm",
"${WORKSPACE}/Libraries",
"${WORKSPACE}/Atlas Release",
"${WORKSPACE}/LocalisationSDK",
]
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
cleaner.clean(cleanfolders)
}
}
}
stage('Generating version info') {
steps {
script {
version = load("${autobuilder.commonscripts()}/versionnumbering/generate.groovy")
version.generate(meta, SOURCE_REVISION, SOURCE_PATH, BASEBUILDNUMBER)
}
}
}
stage('Import Print server dependencies') {
steps {
script {
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
def psartifactfiles = "meta/**,bin/x64/Release/Engine - Render.dll,bin/x64/Release/Engine - Render.lib,bin/x64/Release/Engine - Render.pdb,bin/x64/Release/TBarCode11_x64.dll,bin/x64/Release/GIS Utility - Toolbox.dll,bin/x64/Release/GIS Utility - Toolbox.lib,bin/x64/Release/GIS Utility - Toolbox.pdb,bin/x64/Release/zlib1.dll,bin/x64/Release/zlib1.lib,bin/x64/Release/zlib1.pdb,bin/x64/Release/GIS Utility - TCP-IP Comms.dll,bin/x64/Release/GIS Utility - TCP-IP Comms.lib,bin/x64/Release/GIS Utility - TCP-IP Comms.pdb,bin/x64/Release/Dialog - Tree Node Editor.dll,bin/x64/Release/Dialog - Tree Node Editor.lib,bin/x64/Release/Dialog - Tree Node Editor.pdb"
psmeta = importer.artifactimport(meta,
PRINT_SERVER_ARTIFACT_LOCATION,
PRINT_SERVER_COMPILE_JOB,
PRINT_SERVER_BUILD_SELECTOR,
PRINT_SERVER_RELEASE_REPO,
PRINT_SERVER_RELEASE_REVISION,
PSBIN,
true,
psartifactfiles)
}
}
}
stage('Checkout relevant Print server source') {
steps {
script {
def pssourceartifacts = "src/Engine Common"
def pssourceurl = psmeta.gitinfo.remoteurl
def pscommit = psmeta.gitinfo.gitrevision
configurationhelper.gitCheckoutAndRegister(meta, 'print_server_source', pssourceurl, pscommit, PSSOURCE, '', 0, false, pssourceartifacts)
}
}
}
stage('Import Atlas services dependencies') {
steps {
script {
def asartifactfiles = "meta/**,SharedPackages/**"
asmeta = importer.artifactimport(meta,
ATLAS_SERVICES_ARTIFACT_LOCATION,
ATLAS_SERVICES_COMPILE_JOB,
ATLAS_SERVICES_BUILD_SELECTOR,
ATLAS_SERVICES_RELEASE_REPO,
ATLAS_SERVICES_RELEASE_REVISION,
ASBIN,
true,
asartifactfiles)
}
}
}
stage('Version files') {
steps {
script {
env.BUILD_STAMP=meta.buildstampinfo.buildstamp
env.BUILD_DATE=meta.jenkinsbuildinfo.builddate
env.PS_VERSION="1.0.${psmeta.buildstampinfo.revision}.0"
env.PS_PACKAGE_VERSION=psmeta.buildstampinfo.buildstampprefix
env.AS_PACKAGE_VERSION=asmeta.buildstampinfo.buildstamp
bat """
call "${JOBSCRIPTS_COMMON}\\create_ps_nuget.bat"
if errorlevel 1 exit /b 1
call "${JOBSCRIPTS_COMMON}\\version_atlas_ui_files.bat"
if errorlevel 1 exit /b 1
"""
}
}
}
stage('Analyse resharper') {
steps {
script {
env.SRC_REVISION=SOURCE_REVISION
bat """
call "${JOBSCRIPTS}\\build_and_analyse_atlas.bat"
if errorlevel 1 exit /b 1
"""
}
}
}
stage('Analysis') {
steps {
recordIssues enabledForFailure: true, tool: resharperInspectCode(pattern: 'results/atlas_resharper_results.xml'), qualityGates:[[threshold: 1000, type: 'TOTAL', unstable: true],[threshold: 4500, type: 'TOTAL', unstable: false]]
}
}
stage('Checksum artifacts') {
steps {
script {
def checksummable = [
/* Binaries are signed
'build/**',
'SharedPackages/**',
*/
]
checksumutils = load("${autobuilder.commonscripts()}/checksum/utils.groovy")
checksumutils.generatelist(meta, checksummable)
}
}
}
stage('Classifying publishable artifacts') {
steps {
script {
def publishable = [
]
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
publishutils.generatelist(meta, publishable)
}
}
}
stage('Archiving artifacts') {
steps {
script {
def artifactlist = meta.generateartifacts(["results/**"])
archiveArtifacts "${artifactlist}"
}
}
}
}
post {
always {
echo 'Post-build'
}
failure {
echo 'Failed build'
}
unstable {
echo 'Unstable build'
}
success {
echo 'Succeeded build'
}
}
}

View file

@ -1,144 +0,0 @@
pipeline {
agent { label "${AGENT_LABEL}" }
stages {
stage('Initial setup') {
steps {
script {
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
}
}
}
stage('Checkout dependencies') {
steps {
script {
configurationhelper = autobuilder.configurationhelper()
PYTHONURL = 'git@hydra:tools/python.git'
PYTHONBRANCH = 'origin/3.6.3_windows'
PYTHONDIR = "${WORKSPACE}/python"
PYTHONROOTDIR = 'python'
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR, PYTHONROOTDIR)
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
VERSTAMPINGURL = 'git@hydra:releases/ver_stamping_releases.git'
VERSTAMPINGREVISION = "refs/tags/${VERSION_STAMPING_VERSION}"
VERSTAMPINGDIR = "${WORKSPACE}/ver_stamping"
VERSTAMPINGROOTDIR = 'ver_stamping_releases'
configurationhelper.gitCheckoutAndRegister(meta, 'Version stamping', VERSTAMPINGURL, VERSTAMPINGREVISION, VERSTAMPINGDIR, VERSTAMPINGROOTDIR)
}
}
}
stage('Checkout CCM Tools') {
steps {
script {
CCMSOURCEURL = 'git@hydra:tools/ccm.git'
CCMSOURCEDIR = "${WORKSPACE}\\ccm"
CCMSOURCEREVISION = CCM_SOURCE_REVISION
configurationhelper.gitCheckoutAndRegister(meta, 'ccm', CCMSOURCEURL, CCMSOURCEREVISION, CCMSOURCEDIR, '', 0, false)
env.CCM_SOURCE_PATH = CCMSOURCEDIR
env.CCM_SRC = CCM_SOURCE_PATH
}
}
}
stage('Checkout source') {
steps {
script {
SOURCEURL = 'git@hydra:gis/atlas_ui.git'
SOURCEREVISION = SOURCE_REVISION
SOURCEDIR = "${WORKSPACE}\\atlas_ui"
configurationhelper.gitCheckoutAndRegister(meta, 'atlas_ui', SOURCEURL, SOURCEREVISION, SOURCEDIR, '', 0, false)
env.SOURCE_PATH = SOURCEDIR
env.JOBSCRIPTS = "${SOURCE_PATH}\\autobuild\\code_analysis"
env.JOBSCRIPTS_COMMON = "${SOURCE_PATH}\\autobuild\\common"
env.SRC = SOURCE_PATH
}
}
}
stage('Clean exports') {
steps {
script {
env.BUILDOUTPUT = "${WORKSPACE}/results"
cleanfolders = [
BUILDOUTPUT
]
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
cleaner.clean(cleanfolders)
}
}
}
stage('Generating version info') {
steps {
script {
version = load("${autobuilder.commonscripts()}/versionnumbering/generate.groovy")
version.generate(meta, SOURCE_REVISION, SOURCE_PATH, BASEBUILDNUMBER)
}
}
}
stage('CCM Analysis') {
steps {
script {
env.SRC_REVISION=SOURCE_REVISION
bat """
rmdir /s /q "${BUILDOUTPUT}"
mkdir "${BUILDOUTPUT}"
"${CCM_SRC}/bin/CCM.exe" "${JOBSCRIPTS}/ccm.config" > "${BUILDOUTPUT}/atlasui_ccm.xml"
if errorlevel 1 exit /b 1
"""
}
}
}
stage('Analysis') {
steps {
recordIssues enabledForFailure: true, tool: ccm(pattern: 'results/**'), qualityGates:[[threshold: 150, type: 'TOTAL', unstable: true],[threshold: 200, type: 'TOTAL', unstable: false]]
}
}
stage('Checksum artifacts') {
steps {
script {
def checksummable = [
/* Binaries are signed
'build/**',
'SharedPackages/**',
*/
]
checksumutils = load("${autobuilder.commonscripts()}/checksum/utils.groovy")
checksumutils.generatelist(meta, checksummable)
}
}
}
stage('Classifying publishable artifacts') {
steps {
script {
def publishable = [
]
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
publishutils.generatelist(meta, publishable)
}
}
}
stage('Archiving artifacts') {
steps {
script {
def artifactlist = meta.generateartifacts(["results/**"])
archiveArtifacts "${artifactlist}"
}
}
}
}
post {
always {
echo 'Post-build'
}
failure {
echo 'Failed build'
}
unstable {
echo 'Unstable build'
}
success {
echo 'Succeeded build'
}
}
}

View file

@ -1,123 +0,0 @@
pipeline {
agent { label "${AGENT_LABEL}" }
stages {
stage('Initial setup') {
steps {
script {
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
}
}
}
stage('Checkout dependencies') {
steps {
script {
configurationhelper = autobuilder.configurationhelper()
SOURCEURL = 'git@hydra:gis/atlas_ui.git'
SOURCEREVISION = "${SOURCE_REVISION}".trim()
SOURCEROOTDIR = 'atlas_ui'
SOURCEDIR = "${WORKSPACE}/atlas_ui"
configurationhelper.gitCheckoutAndRegister(meta, SOURCEROOTDIR, SOURCEURL, SOURCEREVISION, SOURCEDIR, SOURCEROOTDIR, 0, false)
}
}
}
stage('Import Print server to adjust version number') {
steps {
script {
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
psartifactfiles = "meta/**"
importer.artifactimport(meta, PRINT_SERVER_ARTIFACT_LOCATION, PRINT_SERVER_COMPILE_JOB, PRINT_SERVER_BUILD_SELECTOR, PRINT_SERVER_RELEASE_REPO, PRINT_SERVER_RELEASE_REVISION, 'ps_bin', true, psartifactfiles)
}
}
}
stage('Import Atlas services to adjust version number') {
steps {
script {
asartifactfiles = "meta/**"
importer.artifactimport(meta, ATLAS_SERVICES_ARTIFACT_LOCATION, ATLAS_SERVICES_COMPILE_JOB, ATLAS_SERVICES_BUILD_SELECTOR, ATLAS_SERVICES_RELEASE_REPO, ATLAS_SERVICES_RELEASE_REVISION, 'as_bin', true, asartifactfiles)
}
}
}
stage('Atlas static analysis') {
parallel {
stage('Measure Atlas code complexity') {
steps {
script {
ccm = build job: "${ATLAS_CCM_ANALYSIS_JOB}", propagate: false
if(ccm.result.equals("UNSTABLE") || ccm.result.equals("FAILURE"))
{
currentBuild.result = ccm.result
}
}
}
}
stage('Perform Atlas UI Resharper Analysis') {
steps {
script {
atlas = build job: "${ATLAS_RESHARPER_ANALYSIS_JOB}", propagate: false
if(!currentBuild.result.equals("FAILURE"))
{
if(atlas.result.equals("UNSTABLE") || atlas.result.equals("FAILURE"))
{
currentBuild.result = atlas.result
}
}
}
}
}
stage('Perform Atlas SDK Resharper Analysis') {
steps {
script {
sdk = build job: "${ATLAS_SDK_RESHARPER_ANALYSIS_JOB}", propagate: false
if(!currentBuild.result.equals("FAILURE"))
{
if(sdk.result.equals("UNSTABLE") || sdk.result.equals("FAILURE"))
{
currentBuild.result = sdk.result
}
}
}
}
}
stage('Perform Atlas Ink UI Resharper Analysis') {
steps {
script {
ink = build job: "${ATLAS_INK_UI_RESHARPER_ANALYSIS_JOB}", propagate: false
if(!currentBuild.result.equals("FAILURE"))
{
if(ink.result.equals("UNSTABLE") || ink.result.equals("FAILURE"))
{
currentBuild.result = ink.result
}
}
}
}
}
}
}
}
post {
always {
echo 'Post-build'
}
failure {
echo 'FAILURE build'
/*
step([$class: 'LogParserPublisher',
parsingRulesPath: 'GitRepository/autobuild/build/log parsing rules/vs.txt',
useProjectRule: true
])
*/
}
unstable {
echo 'Unstable build'
}
success {
echo 'Succeeded build'
}
}
}

View file

@ -4,7 +4,7 @@ pipeline {
stage('Initial setup') {
steps {
script {
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startbuild(this, PRODUCT_NAME, SUBCOMPONENT_NAME, RELEASE_REPO)
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
}
}
}
@ -14,44 +14,36 @@ pipeline {
configurationhelper = autobuilder.configurationhelper()
PYTHONURL = 'git@hydra:tools/python.git'
if (isUnix()) {
PYTHONBRANCH = "origin/3.6.3_linux"
}
else {
PYTHONBRANCH = "origin/3.6.3_windows"
}
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"
}
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR)
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
CCMURL = 'git@hydra:tools/ccm.git'
CCMBRANCH = 'origin/master'
CCMDIR = "${WORKSPACE}/ccm"
configurationhelper.gitCheckoutAndRegister(meta, 'ccm', CCMURL, CCMBRANCH, CCMDIR)
CCM = "${CCMDIR}/bin/CCM.exe"
}
}
}
stage('Checkout source') {
steps {
script {
SOURCEURL = 'git@hydra:atlas-ui-modules/custom-modules.git'
SOURCEREVISION = SOURCE_REVISION
SOURCEDIR = "${WORKSPACE}\\custom_modules"
configurationhelper.gitCheckoutAndRegister(meta, 'custom_modules', SOURCEURL, SOURCEREVISION, SOURCEDIR, '', 0, false)
env.SOURCE_PATH = SOURCEDIR
env.JOBSCRIPTS = "${SOURCE_PATH}\\autobuild\\build"
env.JOBSCRIPTS_COMMON = "${SOURCE_PATH}\\autobuild\\common"
env.SRC = SOURCE_PATH
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') {
stage("Clean exports") {
steps {
script {
env.RELEASE_NOTES = "release_notes"
STATICANALYSIS = 'staticanalysis'
cleanfolders = [
RELEASE_NOTES,
STATICANALYSIS,
]
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
cleaner.clean(cleanfolders)
@ -66,23 +58,27 @@ pipeline {
}
}
}
stage('Copy release notes') {
stage('Static analysis') {
steps {
script {
dir("${SOURCEDIR}/releasenotes") {
fileOperations([fileCopyOperation(targetLocation: "${WORKSPACE}/${RELEASE_NOTES}", includes: '*.txt')])
def CCMOLDER = "${STATICANALYSIS}/ccm"
dir(CCMOLDER) {
echo "Executing: ${CCM} ${SRC} /xml /nummetrics=100 > ccm.xml"
if (isUnix()) {
sh """#!/bin/bash
find "${SRC}" -type f ! -name "*.cpp" -a ! -name "*.h" -a ! -name "*.hpp" -a ! -name "*.c" -exec rm -r {} \\;
# Uses mono
"${CCM}" "${SRC}" /xml /nummetrics=100 > ccm.xml
"""
} else {
bat """
"${CCM}" "${SRC}" /xml /nummetrics=100 > ccm.xml
"""
}
}
}
}
}
stage('Checksum artifacts') {
steps {
script {
def checksummable = [
"${RELEASE_NOTES}/**",
]
checksumutils = load("${autobuilder.commonscripts()}/checksum/utils.groovy")
checksumutils.generatelist(meta, checksummable)
recordIssues(tools: [
ccm(pattern: "**/ccm.xml", reportEncoding: 'UTF-8'),
])
}
}
}
@ -90,7 +86,6 @@ pipeline {
steps {
script {
def publishable = [
"${RELEASE_NOTES}/**",
]
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
publishutils.generatelist(meta, publishable)
@ -100,7 +95,8 @@ pipeline {
stage('Archiving artifacts') {
steps {
script {
def artifactlist = meta.generateartifacts(["${RELEASE_NOTES}/**"])
ArrayList<String> itemsForRelease = ["${STATICANALYSIS}/**"]
def artifactlist = meta.generateartifacts(itemsForRelease)
archiveArtifacts "${artifactlist}"
}
}

151
staticanalysis/cpd.groovy Normal file
View file

@ -0,0 +1,151 @@
pipeline {
agent { label AGENT_LABEL }
stages {
stage('Initial setup') {
steps {
script {
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
}
}
}
stage('Checkout dependencies') {
steps {
script {
configurationhelper = autobuilder.configurationhelper()
PYTHONURL = 'git@hydra:tools/python.git'
if (isUnix()) {
PYTHONBRANCH = 'origin/3.6.3_linux'
} else {
PYTHONBRANCH = 'origin/3.6.3_windows'
}
PYTHONDIR = "${WORKSPACE}/python"
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR)
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
JAVAURL = 'git@hydra:tools/openjdk.git'
if (isUnix()) {
JAVABRANCH = 'origin/openjdk-11.0.2_linux-x64_bin'
} else {
JAVABRANCH = 'origin/openjdk-11.0.2_windows-x64_bin'
}
JAVADIR = "${WORKSPACE}/java"
configurationhelper.gitCheckoutAndRegister(meta, 'java', JAVAURL, JAVABRANCH, JAVADIR)
JAVA = "${JAVADIR}/ver/bin"
if (isUnix()) {
env.PATH = JAVA + ':' + PATH
} else {
env.PATH = JAVA + ';' + PATH
}
PPDURL = 'git@hydra:tools/pmd.git'
PPDBRANCH = 'origin/master'
PPDDIR = "${WORKSPACE}/ppd"
configurationhelper.gitCheckoutAndRegister(meta, 'ppd', PPDURL, PPDBRANCH, PPDDIR)
PPD = "${PPDDIR}/bin"
}
}
}
stage('Checkout source') {
steps {
script {
SOURCEREVISION = "${SOURCE_REVISION}"
SOURCEDIR = "${WORKSPACE}/source"
configurationhelper.gitCheckoutAndRegister(meta, 'source', SOURCEURL, SOURCEREVISION, SOURCEDIR, '', 0, false)
SOURCE_PATH = "${SOURCEDIR}"
SRC = "${SOURCE_PATH}"
if (SOURCE_OFFSET_PATH) {
SRC += "/${SOURCE_OFFSET_PATH}"
}
}
}
}
stage("Clean exports") {
steps {
script {
STATICANALYSIS = 'staticanalysis'
cleanfolders = [
STATICANALYSIS,
]
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
cleaner.clean(cleanfolders)
}
}
}
stage('Generating version info') {
steps {
script {
version = load("${autobuilder.commonscripts()}/versionnumbering/generate.groovy")
version.generate(meta, SOURCE_REVISION, SOURCE_PATH)
}
}
}
stage('Static analysis') {
steps {
script {
def PPDFOLDER = "${STATICANALYSIS}/ppd"
def EXCLUDE_PARAM = ''
if (EXCLUDE_PATHS) {
EXCLUDE_PARAM = '--exclude "'
def exclude_path_list = EXCLUDE_PATHS.split(',')
for (exclude_path in exclude_path_list) {
EXCLUDE_PARAM += "${SRC}/${exclude_path.trim()},"
}
EXCLUDE_PARAM += '"'
}
if (isUnix()) {
sh """#!/bin/bash
set -ev
mkdir -p "${PPDFOLDER}"
export PMD_JAVA_OPTS=-Xmx65536m
"${PPD}/run.sh" cpd --minimum-tokens 100 --files "${SRC}" --language cpp --format xml ${EXCLUDE_PARAM} --failOnViolation false > "${PPDFOLDER}/cpd.xml"
"""
} else {
bat """
mkdir -p "${PPDFOLDER}"
set PMD_JAVA_OPTS=-Xmx2048m
"${PPD}/cpd.bat" --minimum-tokens 100 --files "${SRC}" --language cpp --format xml ${EXCLUDE_PARAM} --failOnViolation false > "${PPDFOLDER}/cpd.xml"
"""
}
recordIssues(tools: [
cpd(pattern: "**/cpd.xml", reportEncoding: 'UTF-8'),
])
}
}
}
stage('Classifying publishable artifacts') {
steps {
script {
def publishable = [
]
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
publishutils.generatelist(meta, publishable)
}
}
}
stage('Archiving artifacts') {
steps {
script {
ArrayList<String> itemsForRelease = ["${STATICANALYSIS}/**"]
def artifactlist = meta.generateartifacts(itemsForRelease)
archiveArtifacts "${artifactlist}"
}
}
}
}
post {
always {
echo 'Post-build'
}
failure {
echo 'Failed build'
}
unstable {
echo 'Unstable build'
}
success {
echo 'Succeeded build'
}
}
}

View file

@ -0,0 +1,113 @@
pipeline {
agent { label "${AGENT_LABEL}" }
stages {
stage('Initial setup') {
steps {
script {
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
}
}
}
stage('Checkout dependencies') {
steps {
script {
configurationhelper = autobuilder.configurationhelper()
PYTHONURL = 'git@hydra:tools/python.git'
PYTHONBRANCH = 'origin/3.6.3_windows'
PYTHONDIR = "${WORKSPACE}/python"
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR)
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
}
}
}
stage('Checkout source') {
steps {
script {
SOURCEREVISION = "${SOURCE_REVISION}"
SOURCEDIR = "${WORKSPACE}/source"
configurationhelper.gitCheckoutAndRegister(meta, 'source', SOURCEURL, SOURCEREVISION, SOURCEDIR, '', 0, false)
SOURCE_PATH = "${SOURCEDIR}"
env.SRC = "${SOURCE_PATH}/${SOURCE_OFFSET_PATH}"
}
}
}
stage("Clean exports") {
steps {
script {
STATICANALYSIS = 'staticanalysis'
cleanfolders = [
STATICANALYSIS,
]
cleaner = load("${autobuilder.commonscripts()}/clean/clean.groovy")
cleaner.clean(cleanfolders)
}
}
}
stage('Generating version info') {
steps {
script {
version = load("${autobuilder.commonscripts()}/versionnumbering/generate.groovy")
version.generate(meta, SOURCE_REVISION, SOURCE_PATH)
}
}
}
stage('Static analysis') {
steps {
script {
def CPPCHECKFOLDER = "${STATICANALYSIS}/cppcheck"
dir(CPPCHECKFOLDER) {
echo "Executing: ${CPPCHECK} --xml --xml-version=2 ${SRC} 2> cppcheck.xml"
if (isUnix()) {
sh """#!/bin/bash
set -e
"${CPPCHECK}" --xml --xml-version=2 "${SRC}" 2> cppcheck.xml
"""
} else {
bat """
"${CPPCHECK}" --xml --xml-version=2 "${SRC}" 2> cppcheck.xml
"""
}
}
recordIssues(tools: [
cppCheck(pattern: "**/cppcheck.xml", reportEncoding: 'UTF-8'),
])
}
}
}
stage('Classifying publishable artifacts') {
steps {
script {
def publishable = [
]
publishutils = load("${autobuilder.commonscripts()}/publishing/utils.groovy")
publishutils.generatelist(meta, publishable)
}
}
}
stage('Archiving artifacts') {
steps {
script {
ArrayList<String> itemsForRelease = ["${STATICANALYSIS}/**"]
def artifactlist = meta.generateartifacts(itemsForRelease)
archiveArtifacts "${artifactlist}"
}
}
}
}
post {
always {
echo 'Post-build'
}
failure {
echo 'Failed build'
}
unstable {
echo 'Unstable build'
}
success {
echo 'Succeeded build'
}
}
}

View file

@ -1,44 +0,0 @@
pipeline {
agent { label "VirtualBoxHost" }
stages {
stage('Checkout test utilites') {
steps {
checkout([$class: 'GitSCM',
branches: [[name: 'origin/master']],
doGenerateSubmoduleConfigurations: false,
extensions: [[$class: 'CleanBeforeCheckout'], [$class: 'RelativeTargetDirectory', relativeTargetDir: 'Utilities']],
submoduleCfg: [], userRemoteConfigs: [[url: 'git@hydra:gistest/Utilities.git']]])
}
}
stage('USE_CONFIG as true') {
when {
expression {
"${USE_CONFIG}" == "true"
}
}
steps {
script {
sh '''
python3.6 Utilities/nodeState/node.py -n ${NODE_NAME} -c ${CONFIG}
'''
}
}
}
stage('USE_CONFIG as false') {
when {
expression {
"${USE_CONFIG}" == "false"
}
}
steps {
script {
sh '''
python3.6 Utilities/nodeState/node.py -n ${NODE_NAME}
'''
}
}
}
}
}

View file

@ -1,23 +0,0 @@
pipeline {
agent { label "VirtualBoxHost" }
stages {
stage('Checkout test utilites') {
steps {
checkout([$class: 'GitSCM',
branches: [[name: 'origin/master']],
doGenerateSubmoduleConfigurations: false,
extensions: [[$class: 'CleanBeforeCheckout'], [$class: 'RelativeTargetDirectory', relativeTargetDir: 'Utilities']],
submoduleCfg: [], userRemoteConfigs: [[url: 'git@hydra:gistest/Utilities.git']]])
}
}
stage('Check available TE licences') {
steps {
script {
sh '''
python3.6 Utilities/TE_licence_checker/licence_checker.py -m ${MAX_TE_LICENCES} -t ${TIMEOUT}
'''
}
}
}
}
}

View file

@ -1,24 +0,0 @@
pipeline {
agent { label "VirtualBoxHost" }
stages {
stage('Checkout test utilites') {
steps {
checkout([$class: 'GitSCM',
branches: [[name: 'origin/master']],
doGenerateSubmoduleConfigurations: false,
extensions: [[$class: 'CleanBeforeCheckout'], [$class: 'RelativeTargetDirectory', relativeTargetDir: 'Utilities']],
submoduleCfg: [], userRemoteConfigs: [[url: 'git@hydra:gistest/Utilities.git']]])
}
}
stage('Node dispatch') {
steps {
script {
sh '''
python3.6 Utilities/dispatcher/node_dispatcher.py -l ${LABEL} -j ${JENKINSJOB}
'''
}
}
}
}
}

View file

@ -1,157 +0,0 @@
pipeline {
agent { label "${AGENT_LABEL}" }
stages {
stage('Checkout test utilites') {
steps {
checkout([$class: 'GitSCM',
branches: [[name: 'origin/master']],
doGenerateSubmoduleConfigurations: false,
extensions: [[$class: 'CleanBeforeCheckout'], [$class: 'RelativeTargetDirectory', relativeTargetDir: 'Utilities']],
submoduleCfg: [], userRemoteConfigs: [[url: 'git@hydra:gistest/Utilities.git']]])
}
}
stage ('Wait for available node. Max 60min') {
steps {
script {
env.NODE = sh(script: "python3.6 Utilities/dispatcher/node_dispatcher.py -l 'FreshInstallationTest'", returnStdout: true)
}
echo "Available Node: $env.NODE"
}
}
stage ('Check VM state') {
steps{
script{
sh '''#!/bin/bash
echo "Check VM state"
runningVMs="$(vboxmanage list runningvms | grep $NODE)"
if [ -z "$runningVMs" ]; then exit 0; else exit 1;fi
'''
}
}
}
stage ('Revert snapshot') {
steps{
sh '''#!/bin/bash
echo "Revert snapshot"
VBoxManage snapshot $NODE restore "clean"
'''
}
}
stage ('Start VM') {
steps{
sh '''#!/bin/bash
echo "Start VM"
vboxmanage startvm $NODE --type headless
'''
}
}
stage ('Wait till VM is up and running') {
steps{
sh '''#!/bin/bash
echo "Wait up to 5 min till VM is up and running. "
vboxmanage guestproperty wait $NODE SysprepArgs --timeout 300000
'''
}
}
stage ('Change Node to JNLP') {
steps{
sh '''#!/bin/bash
echo "Change Node to JNLP"
'''
script {
res = build(job: "Check_Node_Status", propagate: false,
parameters:[
string(name: 'NODE_NAME', value: "${NODE}"),
string(name: 'CONFIG', value: "jnlp.xml"),
booleanParam(name: 'USE_CONFIG', value: "true"),
]).result
if (res != 'SUCCESS') {
currentBuild.result = 'FAILED'
error "Failed to change node status. Exiting pipeline"
}
}
}
}
stage ('Restart Jenkins Slave on VM'){
steps{
sh '''#!/bin/bash
echo "Stop Jenkins Slave on VM"
VBoxManage --nologo guestcontrol $NODE run --exe "c:\\Users\\jenkins_user\\Documents\\elevate.exe" --timeout 30000 --username Jenkins_user --password "ramshorn42" -- elevate /c /w net stop jenkinsslave-C__Jk
'''
sh '''#!/bin/bash
echo "Start Jenkins Slave on VM"
VBoxManage --nologo guestcontrol $NODE run --exe "c:\\Users\\jenkins_user\\Documents\\elevate.exe" --timeout 30000 --username Jenkins_user --password "ramshorn42" -- elevate /c /w net start jenkinsslave-C__Jk
'''
}
}
stage ('Check Node status') {
steps{
sh '''#!/bin/bash
echo "Check Node status"
'''
script {
res = build(job: "Check_Node_Status", propagate: false,
parameters:[
string(name: 'NODE_NAME', value: "${NODE}"),
]).result
if (res != 'SUCCESS') {
currentBuild.result = 'FAILED'
error "${NODE} is offline for Jenkins. Exiting pipeline"
}
}
}
}
stage ('Install GIS software') {
steps{
script {
FreshInstallJob = build(job: "${FRESHINSTALL_TEST_JOB}", propagate: false,
parameters:[
string(name: 'AGENT_LABEL', value: "${NODE}"),
string(name: 'ATLAS_INSTALLER_JOB', value: "${ATLAS_INSTALLER_JOB}"),
string(name: 'MCS_INSTALLER_JOB', value: "${MCS_INSTALLER_JOB}"),
string(name: 'ATLAS_PROJECT', value: "${ATLAS_PROJECT}"),
string(name: 'TESTLIST', value: "${TESTLIST}"),
string(name: 'TEST_COMPLETE_EXECUTE', value: "TE"),
string(name: 'ATLAS_REGRESSION_TEST_REVISION', value: "${ATLAS_REGRESSION_TEST_REVISION}"),
string(name: 'LOG_FOLDER', value: "Test_Output"),
])
if (FreshInstallJob.result != 'SUCCESS') {
currentBuild.result = 'FAILED'
}
currentBuild.description = "<br>" + "<a href="+FreshInstallJob.absoluteUrl +">FreshInstallTest</a>"
}
}
}
}
post {
always {
sh '''#!/bin/bash
echo "PowerOff VM"
VBoxManage controlvm $NODE poweroff
'''
}
failure {
sh '''#!/bin/bash
echo "Check VM state"
runningVMs="$(vboxmanage list runningvms | grep $NODE)"
if [ -z "$runningVMs" ]; then exit 0; else exit 0;fi
'''
sh '''#!/bin/bash
echo "Disconnecting $NODE"
curl -X POST http://surtsey/computer/$NODE/doDisconnect --basic -u test_user:ramshorn42
'''
}
unstable {
sh '''#!/bin/bash
echo "Post unstable"
'''
}
success {
sh '''#!/bin/bash
echo "Post success"
echo "Disconnecting $NODE"
curl -X POST http://surtsey/computer/$NODE/doDisconnect --basic -u test_user:ramshorn42
'''
}
}
}

View file

@ -1,203 +0,0 @@
pipeline {
agent { label "${AGENT_LABEL}" }
stages {
stage ("Initial Setup") {
steps{
script {
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
}
}
}
stage ("Checkout dependencies") {
steps {
script{
configurationhelper = autobuilder.configurationhelper()
RESULT_SOURCE_URL = "git@hydra:gistestresults/test_results.git"
RESULT_SOURCE_REVISION = "origin/master"
RESULT_SOURCE_DIR = "${WORKSPACE}/${HISTORY_FOLDER}"
configurationhelper.gitCheckoutAndRegister(meta, "TestResults", RESULT_SOURCE_URL, RESULT_SOURCE_REVISION, RESULT_SOURCE_DIR, "", 0, false)
CORE_SOURCE_URL = "git@hydra:gistest/giscorelite.git"
CORE_SOURCE_REVISION = "${GISCORE}"
CORE_SOURCE_DIR = "${WORKSPACE}/GisCore"
configurationhelper.gitCheckoutAndRegister(meta, "TestCore", CORE_SOURCE_URL, CORE_SOURCE_REVISION, CORE_SOURCE_DIR, "", 0, false)
CORE_SOURCE_URL = "git@hydra:gistest/Utilities.git"
CORE_SOURCE_REVISION = "origin/master"
CORE_SOURCE_DIR = "${WORKSPACE}/Utilities"
configurationhelper.gitCheckoutAndRegister(meta, "TestCore", CORE_SOURCE_URL, CORE_SOURCE_REVISION, CORE_SOURCE_DIR, "", 0, false)
PYTHONURL = 'git@hydra:tools/python.git'
if (isUnix()) {
PYTHONBRANCH = 'origin/3.6.3_linux'
} else {
PYTHONBRANCH = 'origin/3.6.3_windows'
}
PYTHONDIR = "${WORKSPACE}/python"
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR)
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
}
}
}
stage('Set Description'){
steps{
script{
currentBuild.displayName = ATLAS_INSTALLER_JOB.split("_")[1]
currentBuild.description = TESTLIST + "<br> node: ${env.NODE_NAME}"
}
}
}
stage('Checkout test scripts') {
steps {
script {
TEST_SOURCE_URL = "git@hydra:gis/atlaskiosksdk_test.git"
TEST_SOURCE_REVISION = "${ATLAS_REGRESSION_TEST_REVISION}"
TEST_SOURCE_DIR = "${WORKSPACE}/testscripts"
configurationhelper.gitCheckoutAndRegister(meta, "TestScripts", TEST_SOURCE_URL, TEST_SOURCE_REVISION, TEST_SOURCE_DIR, "", 0, false)
}
}
}
stage('Generating version info') {
steps {
script {
version = load("${autobuilder.commonscripts()}/versionnumbering/generate.groovy")
version.generate(meta, TEST_SOURCE_REVISION, TEST_SOURCE_DIR )
}
}
}
stage ("Force clean artifacts"){
steps {
script{
bat """
call GisCore/jobscripts/reset_imports_and_exports.bat
call GisCore/jobscripts/create_hwtest_shortpath_output.bat
if errorlevel 1 exit /b 1
"""
}
}
}
stage("Copy artifacts") {
steps {
script {
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
echo "Take the Atlas Server installer from the selected build job."
ATLAS_SERVER_ARTIFACT_PROJECT = "${MCS_INSTALLER_JOB}"
ATLAS_SERVER_ARTIFACT_FOLDER = "${WORKSPACE}/imports/mcs"
ATLAS_SERVER_ARTIFACT_FILTER = "core_installer/installers/*.exe ,meta/**"
ATLAS_SERVER_ARTIFACT_SELECTOR = "${MCS_INSTALLER_SELECTOR}"
ATLAS_SERVER_APPLICATION = importer.artifactimport(meta, ATLAS_SERVER_ARTIFACT_PROJECT, ATLAS_SERVER_ARTIFACT_SELECTOR, ATLAS_SERVER_ARTIFACT_FOLDER, true, ATLAS_SERVER_ARTIFACT_FILTER)
echo "Copied Atlas Server installer"
echo "Take the Print Server installer from the selected build job."
PRINT_SERVER_ARTIFACT_PROJECT = "${PRINTSERVER_INSTALLER_JOB}"
PRINT_SERVER_ARTIFACT_FOLDER = "${WORKSPACE}/imports/printserver"
PRINT_SERVER_ARTIFACT_FILTER = "installers/installers/ALL/*.exe ,meta/**"
PRINT_SERVER_ARTIFACT_SELECTOR = "${PRINTSERVER_INSTALLER_SELECTOR}"
PRINT_SERVER_APPLICATION = importer.artifactimport(meta, PRINT_SERVER_ARTIFACT_PROJECT, PRINT_SERVER_ARTIFACT_SELECTOR, PRINT_SERVER_ARTIFACT_FOLDER, true, PRINT_SERVER_ARTIFACT_FILTER)
echo "Copied Print Server installer"
echo "Take the Atlas UI installer from the selected build job."
ATLAS_UI_ARTIFACT_PROJECT = "${ATLAS_INSTALLER_JOB}"
ATLAS_UI_ARTIFACT_FOLDER = "${WORKSPACE}/imports/atlas"
ATLAS_UI_ARTIFACT_FILTER = "atlas_pro_installers/installers/**/*.exe, ink_ui_installers/installers/**/*.exe ,meta/**"
ATLAS_UI_ARTIFACT_SELECTOR = "${ATLAS_INSTALLER_SELECTOR}"
ATLAS_UI_APPLICATION = importer.artifactimport(meta, ATLAS_UI_ARTIFACT_PROJECT, ATLAS_UI_ARTIFACT_SELECTOR, ATLAS_UI_ARTIFACT_FOLDER, true, ATLAS_UI_ARTIFACT_FILTER)
echo "Copied Atlas UI installer"
}
}
}
stage('Save environment variable(s) to file for TestExecute bug') {
steps {
script {
bat '''
set WORKSPACE > "%SystemRoot%/Temp/environment-variables-from-jenkins.txt"
'''
}
}
}
stage('Check available TE Licences'){
steps{
script {
res = build(job: "Check_TE_Licence", propagate: false).result
if (res != 'SUCCESS') {
currentBuild.result = 'FAILED'
error "No more available Test Execute licences. Stopping pipeline."
}
}
}
}
stage('Test loop') {
steps {
script {
failureCount = 0
String[] tests
tests = "${TESTLIST}".split(",")
tests.each {
testcompletetest generateMHT: true, launchType: 'lcItem', project: "${ATLAS_PROJECT}", suite: "testscripts/UITests/FreshInstallSuite/FreshInstallSuite.pjs", test: "${it}", useTCService: true, userName: 'jenkins_user', userPassword: 'ramshorn42', useActiveSession: true, executorType: "TE", useTimeout: true, timeout: '3600', actionOnErrors: 'MAKE_UNSTABLE'
}
}
}
}
stage("Create test results in JSON"){
steps{
script{
rc =bat (script:"""
%WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\testscripts\\UITests\\Utils\\HistoryStructure.py --url ${env.BUILD_URL} --ws_path ${env.WORKSPACE} --mcs_path "%WORKSPACE%\\imports\\mcs\\core_installer\\installers" --ps2_path "%WORKSPACE%\\imports\\printserver\\installers\\installers\\ALL" --aui_pro_path "%WORKSPACE%\\imports\\atlas\\atlas_pro_installers\\installers\\GIS Atlas Professional" --aui_pro4ps_path "%WORKSPACE%\\imports\\atlas\\atlas_pro_installers\\installers\\GIS Atlas Professional for Print Server" --ink_path "%WORKSPACE%\\imports\\atlas\\ink_ui_installers\\installers\\GIS Atlas Ink System Configuration UI"
""",
returnStatus: true
)
if (rc == 1){
unstable('FAILED to process results')
}
}
}
}
stage("Archive Test History"){
steps{
script{
rc =bat (script:"""
set HistoryFail=0
pushd %HISTORY_FOLDER%
${env.PYTHON} GitCyclicPush.py
if %errorlevel% neq 0 (set HistoryFail=1)
popd
if %HistoryFail% neq 0 (
exit /b 1
)
""",
returnStatus: true
)
if (rc == 1){
unstable('FAILED to process history')
}
}
}
}
stage("Archive test artifacts"){
steps{
script{
def artifactlist = meta.generateartifacts(["TestSuite/**","${ATLAS_SERVER_ARTIFACT_FOLDER}/meta/**","${LOG_FOLDER}/**","GisCore/**"])
archiveArtifacts "${artifactlist}"
}
}
}
}
post {
failure {
bat " %WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\Utilities\\sendEmail\\emailnotification.py -t TC -j ${env.BUILD_URL} -n ${env.JOB_NAME} -s FAILED"
}
success {
bat " %WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\Utilities\\sendEmail\\emailnotification.py -t TC -j ${env.BUILD_URL} -n ${env.JOB_NAME} -s SUCCESS"
}
unstable {
bat " %WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\Utilities\\sendEmail\\emailnotification.py -t TC -j ${env.BUILD_URL} -n ${env.JOB_NAME} -s FAILED"
}
}
}

View file

@ -1,204 +0,0 @@
def CheckForTestFailures (TestObject) {
if (TestObject.result == 'UNSTABLE'){
//currentBuild.result = 'UNSTABLE'
unstable("Tests Failed")
}
else if (TestObject.result == 'SUCCESS'){
echo("Tests Passed")
}
else{
//currentBuild.result = 'FAILURE'
unstable("Tests Job Failure! Investigate Job/Slave Setup")
}
}
pipeline {
agent { label "${AGENT_LABEL}" }
stages {
stage('Initial setup') {
steps {
script {
OPERATOR = 'and not'
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startnonbuild(this)
subJobs = []
}
}
}
stage ("Checkout test results history dependencies") {
steps {
script{
configurationhelper = autobuilder.configurationhelper()
RESULT_SOURCE_URL = "git@hydra:gistestresults/test_results.git"
RESULT_SOURCE_REVISION = "origin/master"
RESULT_SOURCE_DIR = "${WORKSPACE}/test_results"
configurationhelper.gitCheckoutAndRegister(meta, "TestResults", RESULT_SOURCE_URL, RESULT_SOURCE_REVISION, RESULT_SOURCE_DIR, "", 0, false)
PYTHONURL = 'git@hydra:tools/python.git'
if (isUnix()) {
PYTHONBRANCH = 'origin/3.6.3_linux'
} else {
PYTHONBRANCH = 'origin/3.6.3_windows'
}
PYTHONDIR = "${WORKSPACE}/python"
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR)
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
}
}
}
stage('Check if AtlasEngineer'){
steps{
script{
if ("${ATLAS_ENGINEER}" == "true") {
OPERATOR = 'and'
}
else {
OPERATOR = 'and not'
}
}
}
}
stage('Atlas Operator tests') {
parallel {
stage('Perform Rename tests.') {
steps {
script {
if ("${RUN_RENAME_TESTS}" == "true"){
RenameTestJob = build (
job: ATLAS_UI_META_JOB,
parameters: [
string(name: 'MCS_BINARIES_JOB', value: MCS_BINARIES_JOB),
string(name: 'PRINT_SERVER_RENDER_FILES', value: PRINT_SERVER_RENDER_FILES),
string(name: 'ATLAS_BINARIES_JOB', value: ATLAS_BINARIES_JOB),
string(name: 'ATLAS_REGRESSION_TEST_REVISION', value: ATLAS_REGRESSION_TEST_REVISION),
string(name: 'TAG', value: '@RenameTests ' + OPERATOR + ' @AtlasEngineer'),
],
propagate: false
)
CheckForTestFailures(RenameTestJob)
RenameTestJob_URL = "<br>" + "<a href="+RenameTestJob.absoluteUrl +">RenameTest</a>"
subJobs<<[ RenameTestJob, "RenameTestsResults", false, ]
}
else{
RenameTestJob_URL = "<br>"}
}
}
}
stage('Perform All tests.') {
steps {
script {
if ("${RUN_ALL_TESTS}" == "true"){
AllTestJob = build (
job: ATLAS_UI_META_JOB,
parameters: [
string(name: 'MCS_BINARIES_JOB', value: MCS_BINARIES_JOB),
string(name: 'PRINT_SERVER_RENDER_FILES', value: PRINT_SERVER_RENDER_FILES),
string(name: 'ATLAS_BINARIES_JOB', value: ATLAS_BINARIES_JOB),
string(name: 'ATLAS_REGRESSION_TEST_REVISION', value: ATLAS_REGRESSION_TEST_REVISION),
string(name: 'TAG', value: '@AllTests ' + OPERATOR + ' @AtlasEngineer'),
],
propagate: false
)
CheckForTestFailures(AllTestJob)
AllTestJob_URL = "<br>" + "<a href="+AllTestJob.absoluteUrl +">AllTest</a>"
subJobs<<[ AllTestJob, "AllTestsResults", false, ]
}
else{
AllTestJob_URL = "<br>"}
}
}
}
stage('Perform Save and Discard tests.') {
steps {
script {
if ("${RUN_SAVEANDDISCARD_TESTS}" == "true"){
SaveAndDiscardTestJob = build (
job: ATLAS_UI_META_JOB,
parameters: [
string(name: 'MCS_BINARIES_JOB', value: MCS_BINARIES_JOB),
string(name: 'PRINT_SERVER_RENDER_FILES', value: PRINT_SERVER_RENDER_FILES),
string(name: 'ATLAS_BINARIES_JOB', value: ATLAS_BINARIES_JOB),
string(name: 'ATLAS_REGRESSION_TEST_REVISION', value: ATLAS_REGRESSION_TEST_REVISION),
string(name: 'TAG', value: '@SaveAndDiscard ' + OPERATOR + ' @AtlasEngineer'),
],
propagate: false
)
CheckForTestFailures(SaveAndDiscardTestJob)
SaveAndDiscardTestJob_URL = "<br>" + "<a href="+SaveAndDiscardTestJob.absoluteUrl +">SaveAndDiscardTest</a>"
subJobs<<[ SaveAndDiscardTestJob, "SaveAndDiscardTestsResults", false, ]
}
else{
SaveAndDiscardTestJob_URL = "<br>"}
}
}
}
stage('Perform Sanity tests') {
steps {
script {
if ("${RUN_SANITY_TESTS}" == "true"){
SanityTestJob = build (
job: ATLAS_UI_META_JOB,
parameters: [
string(name: 'MCS_BINARIES_JOB', value: MCS_BINARIES_JOB),
string(name: 'PRINT_SERVER_RENDER_FILES', value: PRINT_SERVER_RENDER_FILES),
string(name: 'ATLAS_BINARIES_JOB', value: ATLAS_BINARIES_JOB),
string(name: 'ATLAS_REGRESSION_TEST_REVISION', value: ATLAS_REGRESSION_TEST_REVISION),
string(name: 'TAG', value: '@SanityTests ' + OPERATOR + ' @AtlasEngineer'),
],
propagate: false
)
CheckForTestFailures(SanityTestJob)
SanityTestJob_URL = "<br>" + "<a href="+SanityTestJob.absoluteUrl +">SanityTest</a>"
subJobs<<[ SanityTestJob, "CoreTestsResults", false, ]
}
else{
SanityTestJob_URL = "<br>"}
}
}
}
}
}
stage('Set Description'){
steps{
script{
currentBuild.description = SanityTestJob_URL + SaveAndDiscardTestJob_URL + RenameTestJob_URL + AllTestJob_URL
}
}
}
stage('Accumulate artifacts') {
steps {
script {
artifacthelper = load("${autobuilder.commonscripts()}/artifacts/metaexport.groovy")
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
artifactFolders = artifacthelper.combineSubjobArtifacts(meta, importer, subJobs)
}
}
}
stage('Archiving artifacts') {
steps {
script {
def artifactlist = meta.generateartifacts(artifactFolders)
archiveArtifacts "${artifactlist}"
}
}
}
}
post {
always {
echo 'Post-build'
}
failure {
echo 'Failed build'
}
unstable {
echo 'Unstable build'
}
success {
echo 'Succeeded build'
}
}
}

View file

@ -1,172 +0,0 @@
pipeline {
agent { label "${AGENT_LABEL}" }
stages {
stage ('Cleaning Test_Output') {
steps{
bat'''if exist %WORKSPACE%\\Test_Output rmdir /s /q %WORKSPACE%\\Test_Output'''
}
}
stage ('Cleaning imports') {
steps{
bat'''if exist %WORKSPACE%\\imports rmdir /s /q %WORKSPACE%\\imports'''
}
}
stage('Clean workspace') {
when {
expression {
"${CLEAN_WORKSPACE}" == "true"
}
}
steps {
cleanWs()
}
}
stage("checkout python"){
steps{
checkout([$class: 'GitSCM',
branches: [[name: 'origin/3.6.3_windows']],
doGenerateSubmoduleConfigurations: false,
extensions: [[$class: 'CleanBeforeCheckout'], [$class: 'RelativeTargetDirectory', relativeTargetDir: 'python']],
submoduleCfg: [], userRemoteConfigs: [[url: 'git@hydra:tools/python.git']]])
script{
env.PYTHON = "${WORKSPACE}/python/ver/python.exe"
}
}
}
stage('Checkout source') {
steps {
checkout([$class: 'GitSCM',
branches: [[name: 'origin/${TEST_BRANCH}']],
doGenerateSubmoduleConfigurations: false,
extensions: [[$class: 'CleanBeforeCheckout'], [$class: 'RelativeTargetDirectory', relativeTargetDir: 'testscripts']],
submoduleCfg: [], userRemoteConfigs: [[url: 'git@hydra:gis/atlaskiosksdk_test.git']]])
}
}
stage('Checkout GisCore') {
steps {
checkout([$class: 'GitSCM',
branches: [[name: 'origin/${GISCORE_BRANCH}']],
doGenerateSubmoduleConfigurations: false,
extensions: [[$class: 'CleanBeforeCheckout'], [$class: 'RelativeTargetDirectory', relativeTargetDir: 'GisCore']],
submoduleCfg: [], userRemoteConfigs: [[url: 'git@hydra:gistest/giscorelite.git']]])
}
}
stage('Checkout test utilites') {
steps {
checkout([$class: 'GitSCM',
branches: [[name: 'origin/master']],
doGenerateSubmoduleConfigurations: false,
extensions: [[$class: 'CleanBeforeCheckout'], [$class: 'RelativeTargetDirectory', relativeTargetDir: 'Utilities']],
submoduleCfg: [], userRemoteConfigs: [[url: 'git@hydra:gistest/Utilities.git']]])
}
}
stage("Clean imports") {
steps {
script {
env.IMPORTSPATH = "${WORKSPACE}/imports"
}
dir("${IMPORTSPATH}") {
deleteDir()
}
}
}
stage("Clean exports") {
steps {
dir("${WORKSPACE}/uilogs") {
deleteDir()
}
dir("${WORKSPACE}/version") {
deleteDir()
}
dir("${WORKSPACE}/pipeline") {
deleteDir()
}
}
}
stage('Import artifacts') {
steps {
script {
MCS = "${IMPORTSPATH}/mcs"
echo "Obtaining MCS artifacts from ${MCS_BINARIES_JOB} job and placing at folder: ${MCS}"
copyArtifacts filter: 'build/publish/**', projectName: "${MCS_BINARIES_JOB}", selector: lastSuccessful(), target: "${MCS}"
copyArtifacts filter: 'bin/x64/Release/Engine - Render.dll,bin/x64/Release/TBarCode11_x64.dll,bin/x64/Release/GIS Utility - Toolbox.dll,bin/x64/Release/zlib1.dll,bin/x64/Release/TECIT.TBarCode.dll', flatten: true, projectName: "${PRINT_SERVER_RENDER_FILES}", selector: lastSuccessful(), target: "${MCS}/build/publish/"
ATLAS = "${IMPORTSPATH}/atlas"
echo "Obtaining Atlas artifacts from ${ATLAS_BINARIES_JOB} job and placing at folder: ${ATLAS}"
copyArtifacts filter: 'bin/**,LocalisationSDK/**,version/**', projectName: "${ATLAS_BINARIES_JOB}", selector: lastSuccessful(), target: "${ATLAS}"
KIOSK = "${IMPORTSPATH}/kiosk"
echo "Obtaining Atlas KIOSK artifacts from ${ATLAS_BINARIES_JOB} job and placing at folder: ${KIOSK}"
copyArtifacts filter: 'binKiosk/**,LocalisationSDK/**,version/**', projectName: "${ATLAS_BINARIES_JOB}", selector: lastSuccessful(), target: "${KIOSK}"
}
}
}
stage ('Copy the kiosk tool files for Atlas Production') {
steps {
script {
bat '''
"%WORKSPACE%/testscripts/UITests/SetupScripts/copy_atlas_production.bat"
'''
}
}
}
stage('Save environment variable(s) to file for TestExecute bug') {
steps {
script {
bat '''
set WORKSPACE > "%SystemRoot%/Temp/environment-variables-from-jenkins.txt"
'''
}
}
}
stage('Create a VPIRender.Server.bat') {
steps {
script {
bat '''
echo "C:/Program Files/dotnet/dotnet.exe" "%WORKSPACE%/imports/mcs/build/publish/VpiRender.Server.dll" --owner localhost:5000 > "%WORKSPACE%/imports/mcs/build/publish/VpiRender.Server.bat"
'''
}
}
}
stage('Check available TE Licences'){
steps{
script {
res = build(job: "Check_TE_Licence", propagate: false).result
if (res != 'SUCCESS') {
currentBuild.result = 'FAILED'
error "No more available Test Execute licences. Stopping pipeline."
}
}
}
}
stage('Test loop') {
steps {
script {
failureCount = 0
String[] tests
powershell(returnStdout: true, script: '$names = @("dotnet", "Atlas Professional for Print Server", "Atlas Professional", "GIS Print Server 2", "AtlasKioskSDK", "pythonw"); foreach ($item in $names) {Get-Process -Name $item | Stop-Process}')
testcompletetest generateMHT: true, launchType: 'lcTags', project: "AtlasMCSProject", suite: "testscripts/UITests/AtlasTestSuite/AtlasTestSuite.pjs", tags: "${TAG}", useTCService: true, userName: 'jenkins_user', userPassword: 'ramshorn42', useActiveSession: true, executorType: "TE", timeout: '14400', useTimeout: true, actionOnErrors: 'MAKE_FAILED'
}
}
}
}
post {
always {
bat " %WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\testscripts\\UITests\\Utils\\HistoryStructure.py --url ${env.BUILD_URL} --ws_path ${env.WORKSPACE}"
}
failure {
bat " %WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\Utilities\\sendEmail\\emailnotification.py -t TC -j ${env.BUILD_URL} -n ${env.JOB_NAME} -s FAILED"
}
success {
bat " %WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\Utilities\\sendEmail\\emailnotification.py -t TC -j ${env.BUILD_URL} -n ${env.JOB_NAME} -s SUCCESS"
}
unstable {
bat " %WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\Utilities\\sendEmail\\emailnotification.py -t TC -j ${env.BUILD_URL} -n ${env.JOB_NAME} -s FAILED"
}
}
}

View file

@ -1,240 +0,0 @@
pipeline {
agent { label "${AGENT_LABEL}" }
stages {
stage ("Initial Setup") {
steps{
script {
meta = load("${WORKSPACE}/autobuild/Common_scripts/autobuilder.groovy").startbuild(this, PRODUCT_NAME, SUBCOMPONENT_NAME, RELEASE_REPO)
}
}
}
stage ("Checkout dependencies") {
steps {
script{
configurationhelper = autobuilder.configurationhelper()
RESULT_SOURCE_URL = "git@hydra:gistestresults/test_results.git"
RESULT_SOURCE_REVISION = "origin/master"
RESULT_SOURCE_DIR = "${WORKSPACE}/${HISTORY_FOLDER}"
configurationhelper.gitCheckoutAndRegister(meta, "TestResults", RESULT_SOURCE_URL, RESULT_SOURCE_REVISION, RESULT_SOURCE_DIR, "", 0, false)
CORE_SOURCE_URL = "git@hydra:gistest/giscorelite.git"
CORE_SOURCE_REVISION = "${GISCORE}"
CORE_SOURCE_DIR = "${WORKSPACE}/GisCore"
configurationhelper.gitCheckoutAndRegister(meta, "TestCore", CORE_SOURCE_URL, CORE_SOURCE_REVISION, CORE_SOURCE_DIR, "", 0, false)
CORE_SOURCE_URL = "git@hydra:gistest/Utilities.git"
CORE_SOURCE_REVISION = "origin/master"
CORE_SOURCE_DIR = "${WORKSPACE}/Utilities"
configurationhelper.gitCheckoutAndRegister(meta, "TestCore", CORE_SOURCE_URL, CORE_SOURCE_REVISION, CORE_SOURCE_DIR, "", 0, false)
PYTHONURL = 'git@hydra:tools/python.git'
if (isUnix()) {
PYTHONBRANCH = 'origin/3.6.3_linux'
} else {
PYTHONBRANCH = 'origin/3.6.3_windows'
}
PYTHONDIR = "${WORKSPACE}/python"
configurationhelper.gitCheckoutAndRegister(meta, 'python', PYTHONURL, PYTHONBRANCH, PYTHONDIR)
env.PYTHON = "${PYTHONDIR}/ver/python.exe"
}
}
}
stage('Set Description'){
steps{
script{
if (TAG.endsWith("and @AtlasEngineer")) {
currentBuild.displayName = "KIOSK: " + ATLAS_BINARIES_JOB.split("_")[1] + " " + TAG.minus("and @AtlasEngineer")
}
else{
currentBuild.displayName = ATLAS_BINARIES_JOB.split("_")[1] + " " + TAG.minus("and not @AtlasEngineer")
}
currentBuild.description = "node: ${env.NODE_NAME}"
}
}
}
stage('Checkout test scripts') {
steps {
script {
TEST_SOURCE_URL = "git@hydra:gis/atlaskiosksdk_test.git"
TEST_SOURCE_REVISION = "${ATLAS_REGRESSION_TEST_REVISION}"
TEST_SOURCE_DIR = "${WORKSPACE}/testscripts"
configurationhelper.gitCheckoutAndRegister(meta, "TestScripts", TEST_SOURCE_URL, TEST_SOURCE_REVISION, TEST_SOURCE_DIR, "", 0, false)
}
}
}
stage('Generating version info') {
steps {
script {
version = load("${autobuilder.commonscripts()}/versionnumbering/generate.groovy")
version.generate(meta, TEST_SOURCE_REVISION, TEST_SOURCE_DIR )
}
}
}
stage ("Force clean artifacts"){
steps {
script{
bat """
call GisCore/jobscripts/reset_imports_and_exports.bat
call GisCore/jobscripts/create_hwtest_shortpath_output.bat
if errorlevel 1 exit /b 1
"""
}
}
}
stage("Copy artifacts") {
steps {
script {
importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
echo "Take the Atlas Server artifacts from the selected build job."
ATLAS_SERVER_ARTIFACT_PROJECT = "${MCS_BINARIES_JOB}"
ATLAS_SERVER_ARTIFACT_FOLDER = "${WORKSPACE}/imports/mcs"
ATLAS_SERVER_ARTIFACT_SELECTOR = "${ATLAS_SERVER_ARTIFACT_SELECTOR}"
ATLAS_SERVER_ARTIFACT_FILTER = "build/publish/**,meta/**"
ATLAS_SERVER_ARTIFACT_EXCLUDES = "**/*.pdb,**/*.lib,**/*.html,**/*.aspx,**/*.php"
ATLAS_SERVER_APPLICATION = importer.artifactimport(meta, ATLAS_SERVER_ARTIFACT_PROJECT, ATLAS_SERVER_ARTIFACT_SELECTOR, ATLAS_SERVER_ARTIFACT_FOLDER, true, ATLAS_SERVER_ARTIFACT_FILTER,ATLAS_SERVER_ARTIFACT_EXCLUDES)
echo "Copied Atlas Server Artifacts"
echo "Take the Print Server artifacts from the selected build job."
PRINT_SERVER_ARTIFACT_PROJECT = "${PRINT_SERVER_RENDER_FILES}"
PRINT_SERVER_ARTIFACT_FOLDER = "${WORKSPACE}/imports/mcs/build/publish/"
PRINT_SERVER_ARTIFACT_SELECTOR = "${PRINT_SERVER_ARTIFACT_SELECTOR}"
PRINT_SERVER_ARTIFACT_FILTER = "bin/x64/Release/Engine - Render.dll,bin/x64/Release/TBarCode11_x64.dll,bin/x64/Release/GIS Utility - Toolbox.dll,bin/x64/Release/zlib1.dll,bin/x64/Release/TECIT.TBarCode.dll,meta/**"
PRINT_SERVER_ARTIFACT_EXCLUDES = "**/*.pdb,**/*.lib,**/*.html,**/*.aspx,**/*.php"
PRINT_SERVER_APPLICATION = importer.artifactimport(meta, PRINT_SERVER_ARTIFACT_PROJECT, PRINT_SERVER_ARTIFACT_SELECTOR, PRINT_SERVER_ARTIFACT_FOLDER, true, PRINT_SERVER_ARTIFACT_FILTER, PRINT_SERVER_ARTIFACT_EXCLUDES)
echo "Copied Print Server Render Artifacts"
echo "Take the Atlas UI artifacts from the selected build job."
ATLAS_UI_ARTIFACT_PROJECT = "${ATLAS_BINARIES_JOB}"
ATLAS_UI_ARTIFACT_FOLDER = "${WORKSPACE}/imports/atlas"
ATLAS_UI_ARTIFACT_SELECTOR = "${ATLAS_UI_ARTIFACT_SELECTOR}"
ATLAS_UI_ARTIFACT_FILTER = "bin/**,LocalisationSDK/**,,meta/**"
ATLAS_UI_ARTIFACT_EXCLUDES = "**/*.pdb,**/*.lib,**/*.html,**/*.aspx,**/*.php"
ATLAS_UI_APPLICATION = importer.artifactimport(meta, ATLAS_UI_ARTIFACT_PROJECT, ATLAS_UI_ARTIFACT_SELECTOR, ATLAS_UI_ARTIFACT_FOLDER, true, ATLAS_UI_ARTIFACT_FILTER,ATLAS_UI_ARTIFACT_EXCLUDES)
echo "Copied Atlas UI Artifacts"
echo "Take the Atlas KIOS artifacts from the selected build job."
ATLAS_KIOSK_ARTIFACT_PROJECT = "${ATLAS_BINARIES_JOB}"
ATLAS_KIOSK_ARTIFACT_FOLDER = "${WORKSPACE}/imports/kiosk"
ATLAS_KIOSK_ARTIFACT_SELECTOR = "${ATLAS_UI_ARTIFACT_SELECTOR}"
ATLAS_KIOSK_ARTIFACT_FILTER = "binKiosk/**,LocalisationSDK/**,,meta/**"
ATLAS_KIOSK_ARTIFACT_EXCLUDES = "**/*.pdb,**/*.lib,**/*.html,**/*.aspx,**/*.php"
ATLAS_KIOSK_APPLICATION = importer.artifactimport(meta, ATLAS_KIOSK_ARTIFACT_PROJECT, ATLAS_KIOSK_ARTIFACT_SELECTOR, ATLAS_KIOSK_ARTIFACT_FOLDER, true, ATLAS_KIOSK_ARTIFACT_FILTER,ATLAS_KIOSK_ARTIFACT_EXCLUDES)
echo "Copied Atlas KIOS Artifacts"
}
}
}
stage ('Copy the kiosk tool files for Atlas Production') {
steps {
script {
bat '''
"%WORKSPACE%/testscripts/UITests/SetupScripts/copy_atlas_production.bat"
'''
}
}
}
stage('Save environment variable(s) to file for TestExecute bug') {
steps {
script {
bat '''
set WORKSPACE > "%SystemRoot%/Temp/environment-variables-from-jenkins.txt"
'''
}
}
}
stage('Create a VPIRender.Server.bat') {
steps {
script {
bat '''
echo "C:/Program Files/dotnet/dotnet.exe" "%WORKSPACE%/imports/mcs/build/publish/VpiRender.Server.dll" --owner localhost:5000 > "%WORKSPACE%/imports/mcs/build/publish/VpiRender.Server.bat"
'''
}
}
}
stage('Check available TE Licences'){
steps{
script {
res = build(job: "Check_TE_Licence", propagate: false).result
if (res != 'SUCCESS') {
currentBuild.result = 'FAILED'
error "No more available Test Execute licences. Stopping pipeline."
}
}
}
}
stage('Test loop') {
steps {
script {
failureCount = 0
String[] tests
powershell(returnStdout: true, script: '$names = @("dotnet", "Atlas Professional for Print Server", "Atlas Professional", "GIS Print Server 2", "AtlasKioskSDK", "pythonw"); foreach ($item in $names) {Get-Process -Name $item | Stop-Process}')
testcompletetest generateMHT: true, launchType: 'lcTags', project: "${ATLAS_PROJECT}", suite: "testscripts/UITests/${ATLAS_SUITE}/${ATLAS_SUITE}.pjs", tags: "${TAG}", useTCService: true, userName: 'jenkins_user', userPassword: 'ramshorn42', useActiveSession: true, executorType: "${TEST_COMPLETE_EXECUTE}", timeout: '14400', useTimeout: true, actionOnErrors: 'MAKE_FAILED'
}
}
}
stage("Create test results in JSON"){
steps{
script{
rc =bat (script:"""
%WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\testscripts\\UITests\\Utils\\HistoryStructure.py --url ${env.BUILD_URL} --ws_path ${env.WORKSPACE}
""",
returnStatus: true
)
if (rc == 1){
unstable('FAILED to process results')
}
}
}
}
stage("Archive Test History"){
steps{
script{
rc =bat (script:"""
set HistoryFail=0
pushd %HISTORY_FOLDER%
${env.PYTHON} GitCyclicPush.py
if %errorlevel% neq 0 (set HistoryFail=1)
popd
if %HistoryFail% neq 0 (
exit /b 1
)
""",
returnStatus: true
)
if (rc == 1){
unstable('FAILED to process history')
}
}
}
}
stage("Archive test artifacts"){
steps{
script{
def artifactlist = meta.generateartifacts(["TestSuite/**","${ATLAS_SERVER_ARTIFACT_FOLDER}/meta/**","${LOG_FOLDER}/**","GisCore/**"])
archiveArtifacts "${artifactlist}"
}
}
}
}
post {
always {
powershell(returnStdout: true, script: '$names = @("dotnet", "Atlas Professional for Print Server", "Atlas Professional", "GIS Print Server 2", "AtlasKioskSDK", "pythonw"); foreach ($item in $names) {Get-Process -Name $item | Stop-Process}')
}
failure {
bat " %WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\Utilities\\sendEmail\\emailnotification.py -t TC -j ${env.BUILD_URL} -n ${env.JOB_NAME} -s FAILED"
}
success {
bat " %WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\Utilities\\sendEmail\\emailnotification.py -t TC -j ${env.BUILD_URL} -n ${env.JOB_NAME} -s SUCCESS"
}
unstable {
bat " %WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\Utilities\\sendEmail\\emailnotification.py -t TC -j ${env.BUILD_URL} -n ${env.JOB_NAME} -s FAILED"
}
}
}

View file

@ -1,149 +0,0 @@
pipeline {
agent { label "${AGENT_LABEL}" }
stages {
stage ('Cleaning Test_Output') {
steps{
bat'''if exist %WORKSPACE%\\Test_Output rmdir /s /q %WORKSPACE%\\Test_Output'''
}
}
stage ('Cleaning imports') {
steps{
bat'''if exist %WORKSPACE%\\imports rmdir /s /q %WORKSPACE%\\imports'''
}
}
stage('Clean workspace') {
when {
expression {
"${CLEAN_WORKSPACE}" == "true"
}
}
steps {
cleanWs()
}
}
stage("checkout python"){
steps{
checkout([$class: 'GitSCM',
branches: [[name: 'origin/3.6.3_windows']],
doGenerateSubmoduleConfigurations: false,
extensions: [[$class: 'CleanBeforeCheckout'], [$class: 'RelativeTargetDirectory', relativeTargetDir: 'python']],
submoduleCfg: [], userRemoteConfigs: [[url: 'git@hydra:tools/python.git']]])
script{
env.PYTHON = "${WORKSPACE}/python/ver/python.exe"
}
}
}
stage('Checkout source') {
steps {
checkout([$class: 'GitSCM',
branches: [[name: 'origin/${TEST_BRANCH}']],
doGenerateSubmoduleConfigurations: false,
extensions: [[$class: 'CleanBeforeCheckout'], [$class: 'RelativeTargetDirectory', relativeTargetDir: 'testscripts']],
submoduleCfg: [], userRemoteConfigs: [[url: 'git@hydra:gis/atlaskiosksdk_test.git']]])
}
}
stage('Checkout GisCore') {
steps {
checkout([$class: 'GitSCM',
branches: [[name: 'origin/MCSRepo']],
doGenerateSubmoduleConfigurations: false,
extensions: [[$class: 'CleanBeforeCheckout'], [$class: 'RelativeTargetDirectory', relativeTargetDir: 'GisCore']],
submoduleCfg: [], userRemoteConfigs: [[url: 'git@hydra:gistest/giscorelite.git']]])
}
}
stage('Checkout test utilites') {
steps {
checkout([$class: 'GitSCM',
branches: [[name: 'origin/master']],
doGenerateSubmoduleConfigurations: false,
extensions: [[$class: 'CleanBeforeCheckout'], [$class: 'RelativeTargetDirectory', relativeTargetDir: 'Utilities']],
submoduleCfg: [], userRemoteConfigs: [[url: 'git@hydra:gistest/Utilities.git']]])
}
}
stage("Clean imports") {
steps {
script {
env.IMPORTSPATH = "${WORKSPACE}/imports"
}
dir("${IMPORTSPATH}") {
deleteDir()
}
}
}
stage("Clean exports") {
steps {
dir("${WORKSPACE}/uilogs") {
deleteDir()
}
dir("${WORKSPACE}/version") {
deleteDir()
}
dir("${WORKSPACE}/pipeline") {
deleteDir()
}
}
}
stage('Import artifacts') {
steps {
script {
env.PRINTSERVER = "${IMPORTSPATH}/printserver"
echo "Obtaining Print server artifacts from ${PRINT_SERVER_BINARIES_JOB} job and placing at folder: ${PRINTSERVER}"
copyArtifacts filter: 'bin/x64/Release/*.exe, bin/x64/Release/*.dll', projectName: "${PRINT_SERVER_BINARIES_JOB}", selector: lastSuccessful(), target: "${PRINTSERVER}"
ATLAS = "${IMPORTSPATH}/atlas"
echo "Obtaining Atlas artifacts from ${ATLAS_BINARIES_JOB} job and placing at folder: ${ATLAS}"
copyArtifacts filter: 'bin/**,LocalisationSDK/**,version/**', projectName: "${ATLAS_BINARIES_JOB}", selector: lastSuccessful(), target: "${ATLAS}"
}
}
}
stage('Save environment variable(s) to file for TestExecute bug') {
steps {
script {
bat '''
set WORKSPACE > "%SystemRoot%/Temp/environment-variables-from-jenkins.txt"
'''
}
}
}
stage('Check available TE Licences'){
steps{
script {
res = build(job: "Check_TE_Licence", propagate: false).result
if (res != 'SUCCESS') {
currentBuild.result = 'FAILED'
error "No more available Test Execute licences. Stopping pipeline."
}
}
}
}
stage('Test loop') {
steps {
script {
failureCount = 0
String[] tests
tests = "${TESTLIST}".split(",")
tests.each {
powershell(returnStdout: true, script: '$names = @("dotnet", "Atlas Professional for Print Server", "Atlas Professional", "GIS Print Server 2", "AtlasKioskSDK", "pythonw"); foreach ($item in $names) {Get-Process -Name $item | Stop-Process}')
testcompletetest generateMHT: true, launchType: 'lcItem', project: "AtlasPrintServerProject", suite: "testscripts/UITests/AtlasTestSuite/AtlasTestSuite.pjs", test: "${it}", useTCService: true, userName: 'jenkins_user', userPassword: 'ramshorn42', useActiveSession: true, executorType: "TE", useTimeout: true, timeout: '10800', actionOnErrors: 'MAKE_FAILED'
}
}
}
}
}
post {
failure {
bat " %WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\Utilities\\sendEmail\\emailnotification.py -t TC -j ${env.BUILD_URL} -n ${env.JOB_NAME} -s FAILED"
}
success {
bat " %WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\Utilities\\sendEmail\\emailnotification.py -t TC -j ${env.BUILD_URL} -n ${env.JOB_NAME} -s SUCCESS"
}
unstable {
bat " %WORKSPACE%\\python\\ver\\python.exe %WORKSPACE%\\Utilities\\sendEmail\\emailnotification.py -t TC -j ${env.BUILD_URL} -n ${env.JOB_NAME} -s FAILED"
}
}
}

8
textutils/subst.groovy Normal file
View file

@ -0,0 +1,8 @@
def substitute(String filepath, pattern, String subst) {
fileText = readFile(file: filepath, encoding: 'UTF-8')
def converted = fileText.replaceAll(pattern, subst)
writeFile(file: filepath, text: converted, encoding: 'UTF-8')
}
return this;

View file

@ -0,0 +1,25 @@
{
"version": "1.0",
"components": [
"Microsoft.VisualStudio.Workload.ManagedDesktop",
"Microsoft.VisualStudio.Workload.NativeDesktop",
"Microsoft.VisualStudio.Workload.NetWeb",
"Microsoft.VisualStudio.Workload.NetCoreTools",
"microsoft.net.componentgroup.targetingpacks.common",
"microsoft.componentgroup.blend",
"microsoft.visualstudio.component.entityframework",
"microsoft.visualstudio.component.debugger.justintime",
"microsoft.visualstudio.component.wcf.tooling",
"microsoft.visualstudio.component.vc.diagnostictools",
"microsoft.visualstudio.component.vc.cmake.project",
"microsoft.visualstudio.component.vc.testadapterforboosttest",
"microsoft.visualstudio.component.vc.testadapterforgoogletest",
"microsoft.visualstudio.component.vc.atlmfc",
"microsoft.visualstudio.component.appinsights.tools",
"microsoft.visualstudio.component.diagnostictools",
"microsoft.visualstudio.componentgroup.web.cloudtools",
"microsoft.visualstudio.component.aspnet45",
"microsoft.visualstudio.component.webdeploy",
"microsoft.visualstudio.component.nuget.buildtools"
]
}

376
versioncontrol/git.groovy Normal file
View file

@ -0,0 +1,376 @@
import hudson.plugins.git.*
import hudson.plugins.git.extensions.*
import hudson.plugins.git.extensions.impl.*
clh = load("${autobuilder.commonscripts()}/commandline/commandline.groovy")
def boolean isShallowClonedRepo(String gitrootpath) {
def boolean isshallowclone = true
dir( gitrootpath) {
if (isUnix()) {
isshallowclone = sh(returnStdout: true, script: "git rev-parse --is-shallow-repository").trim().toBoolean()
}
else {
isshallowclone = bat(returnStdout: true, script: "@git rev-parse --is-shallow-repository").trim().toBoolean()
}
echo "Repo at ${gitrootpath} is shallow cloned: ${isshallowclone}"
}
return isshallowclone
}
String getGitInfo(String workingSetRootPath) {
dir(workingSetRootPath) {
return clh.getCommandOutput('git rev-parse HEAD')
}
}
ArrayList<String> gettaglist(String workingSetRootPath) {
ArrayList<String> taglist = new ArrayList<String>()
dir(workingSetRootPath) {
def tagliststring = clh.getCommandOutput('git tag --sort=-version:refname')
taglist = tagliststring.split('\\n')
}
return taglist
}
@NonCPS
def ArrayList<SparseCheckoutPath> sparsecheckoutconfig(ArrayList<String> paths) {
ArrayList<SparseCheckoutPath> sparsecheckoutpaths = new ArrayList<SparseCheckoutPath>()
for (path in paths) {
sparsecheckoutpaths.add(new SparseCheckoutPath(path))
}
return sparsecheckoutpaths
}
def String uniquereporootname(String gitURL) {
def uniquename = gitURL.replaceAll("[^A-Za-z0-9]", "_")
echo "Unique reporoot name for URL: ${gitURL} is: ${uniquename}"
return uniquename
}
// The REPO_ROOT is a folder where a cache of git checkouts can be kept - each subfolder name is unique to a particular git repo
def String checkouttoreporoot(String gitURL) {
def String reporootsubfolder
def String reporootenv = env.REPO_ROOT
if (!reporootenv) {
reporootsubfolder = ""
echo "To improve Git performance: Define the REPO_ROOT enviroment to a path where a cache of git repositories can be placed on this slave"
} else {
def reporootname = uniquereporootname(gitURL)
reporootsubfolder = "${reporootenv}/${reporootname}"
if (!fileExists(reporootsubfolder)) {
echo "Checking out ${gitURL} to ${reporootsubfolder}"
checkout([
$class: 'GitSCM',
userRemoteConfigs: [
[url: gitURL]
],
branches: [
[name: 'origin/master']
],
doGenerateSubmoduleConfigurations: false,
extensions: [
[$class: 'GitLFSPull'],
[$class: 'CleanBeforeCheckout'],
[$class: 'CheckoutOption', timeout: 180],
[$class: 'RelativeTargetDirectory', relativeTargetDir: reporootsubfolder],
],
submoduleCfg: [],
])
} else {
echo "Found ${gitURL} checked out at ${reporootsubfolder}"
/*
dir(reporootsubfolder) {
if (isUnix()) {
sh """
git status
if [ \$? -ne 0 ]; then exit 1; fi
"""
} else {
bat """
git status
if errorlevel 1 EXIT /b 1
"""
}
}
*/
}
}
return reporootsubfolder
}
def checkgitlfsinstall() {
if (isUnix()) {
sh """
git lfs install
if [ \$? -ne 0 ]; then exit 1; fi
"""
} else {
bat """
git lfs install
if errorlevel 1 EXIT /b 1
"""
}
}
//No credentials specified
//Cloning the remote Git repository
//Cloning repository git@hydra:print-server-releases/print_server_whole.git
//> git init /home/jenkins_user/jenkins/jobs/Print_Server_publish_to_customer/ws/whole # timeout=10
//Using reference repository: /home/jenkins_user/reporoot/git_hydra_print_server_releases_print_server_whole_git
//Fetching upstream changes from git@hydra:print-server-releases/print_server_whole.git
// > git --version # timeout=10
// > git fetch --tags --progress git@hydra:print-server-releases/print_server_whole.git +refs/heads/*:refs/remotes/origin/* # timeout=120
// > git config remote.origin.url git@hydra:print-server-releases/print_server_whole.git # timeout=10
// > git config --add remote.origin.fetch +refs/heads/*:refs/remotes/origin/* # timeout=10
// > git config remote.origin.url git@hydra:print-server-releases/print_server_whole.git # timeout=10
// Cleaning workspace
// > git rev-parse --verify HEAD # timeout=10
// No valid HEAD. Skipping the resetting
// > git clean -fdx # timeout=10
// Fetching upstream changes from git@hydra:print-server-releases/print_server_whole.git
// > git fetch --tags --progress git@hydra:print-server-releases/print_server_whole.git +refs/heads/*:refs/remotes/origin/* # timeout=120
// > git rev-parse refs/tags/2.10180.7389.21125_7^{commit} # timeout=10
// > git rev-parse refs/remotes/origin/refs/tags/2.10180.7389.21125_7^{commit} # timeout=10
// Checking out Revision 64cac35e9a7603c060135f61f91b3f809bbdf160 (refs/tags/2.10180.7389.21125_7)
// Enabling Git LFS pull
// > git config core.sparsecheckout # timeout=10
// > git checkout -f 64cac35e9a7603c060135f61f91b3f809bbdf160 # timeout=120
// > git config --get remote.origin.url # timeout=10
// > git lfs pull origin # timeout=120
// Commit message: "2.10180.7389.21125_7"
// > git rev-list --no-walk 64cac35e9a7603c060135f61f91b3f809bbdf160 # timeout=10
// > git rev-parse --is-inside-work-tree # timeout=10
// Fetching changes from the remote Git repository
// > git config remote.origin.url git@hydra:releases/print-server-installer.git # timeout=10
// Cleaning workspace
// > git rev-parse --verify HEAD # timeout=10
// Resetting working tree
// > git reset --hard # timeout=10
// > git clean -fdx # timeout=10
// Using shallow fetch with depth 1
// Fetching upstream changes from git@hydra:releases/print-server-installer.git
// > git --version # timeout=10
// > git fetch --tags --progress git@hydra:releases/print-server-installer.git +refs/heads/*:refs/remotes/origin/* --depth=1 # timeout=120
// > git rev-parse refs/remotes/origin/master^{commit} # timeout=10
// > git rev-parse refs/remotes/origin/origin/master^{commit} # timeout=10
// Checking out Revision d0788d22622862e441c5995a22629846573c39f3 (refs/remotes/origin/master)
// Enabling Git LFS pull
// > git config core.sparsecheckout # timeout=10
// > git read-tree -mu HEAD # timeout=10
// > git checkout -f d0788d22622862e441c5995a22629846573c39f3 # timeout=120
// > git config --get remote.origin.url # timeout=10
// > git lfs pull origin # timeout=120
// Commit message: "2.10180.7389.21125_3"
// > git rev-list --no-walk d0788d22622862e441c5995a22629846573c39f3 # timeout=10
def String lfsinstallandreporoot(String gitURL) {
checkgitlfsinstall()
return checkouttoreporoot(gitURL)
}
def showsparseitemlist(ArrayList<String> sparseitemlist = new ArrayList<String>()) {
if (!sparseitemlist.isEmpty()) {
def itemstring = "Items in sparse item list:\n"
for (item in sparseitemlist) {
itemstring += item + "\n"
}
echo itemstring
}
}
def docheckout(String gitURL, String revision, int cloneDepth, String reporootpath, boolean shallowClone, String targetDir, sparseitemlist) {
checkout([
$class: 'GitSCM',
userRemoteConfigs: [
[url: gitURL]
],
branches: [
[name: revision]
],
doGenerateSubmoduleConfigurations: false,
extensions: [
[$class: 'GitLFSPull'],
[$class: 'CleanBeforeCheckout'],
[$class: 'CloneOption', depth: cloneDepth, noTags: false, reference: reporootpath, shallow: shallowClone, timeout: 120],
[$class: 'CheckoutOption', timeout: 120],
[$class: 'RelativeTargetDirectory', relativeTargetDir: targetDir],
[$class: 'SparseCheckoutPaths', sparseCheckoutPaths: sparsecheckoutconfig(sparseitemlist)],
],
submoduleCfg: [],
])
}
// gitCheckout (below) cannot handle sparse checkout and lfs at the moment - see https://issues.jenkins-ci.org/browse/JENKINS-43427 - see gitCheckoutAlt()
def gitCheckout(String gitURL, String revision, String targetDir, String repoRootSuffix = "", int cloneDepth = 1, boolean shallowClone = true, ArrayList<String> sparseitemlist = new ArrayList<String>()) {
def String reporootpath = lfsinstallandreporoot(gitURL)
showsparseitemlist(sparseitemlist)
docheckout(gitURL, revision, cloneDepth, reporootpath, shallowClone, targetDir, sparseitemlist)
}
def gitinit(String targetDir, String reporootpath) {
if (!fileExists("${targetDir}/.git")) { // Git folder does not already exist
echo "git init ${targetDir}"
if (isUnix()) {
sh """
git init "${targetDir}"
"""
} else {
bat """
git init "${targetDir}"
"""
}
}
echo "Writing ${reporootpath}/.git/objects to ${targetDir}/.git/objects/info/alternates"
dir("${targetDir}/.git/objects/info") {
writeFile(file: 'alternates', text: "${reporootpath}/.git/objects")
}
}
def setlfsfetchinclude(String targetDir, ArrayList<String> sparseitemlist) {
def String sparseitemliststring = ""
if (!sparseitemlist.isEmpty()) {
for (item in sparseitemlist) {
sparseitemliststring += "${item},"
}
echo "git config lfs.fetchinclude ${sparseitemliststring}"
dir(targetDir) {
if (isUnix()) {
sh """
git config lfs.fetchinclude "${sparseitemliststring}"
"""
} else {
bat """
git config lfs.fetchinclude "${sparseitemliststring}"
"""
}
}
}
}
def gitsparserestore(String targetDir) {
echo "Clean out full fetch; Force a sparse fetch"
dir(targetDir) {
if (isUnix()) {
sh """
git rm -rf . > /dev/null
git clean -fxd > /dev/null
git reset --hard > /dev/null
"""
} else {
bat """
git rm -rf . 2> nul
git clean -fxd 2> nul
git reset --hard 2> nul
"""
}
}
}
def List convertSparseItemsString(String itemstopublish) {
def List sparsepaths = []
boolean nonempty = itemstopublish?.trim()
if (nonempty) {
def String[] items = itemstopublish.trim().split(',')
def String allpaths = ""
for(String item : items) {
sparsepaths.add(item)
allpaths += "${item}\n"
}
echo "Selected item to publish:\n${allpaths}"
}
return sparsepaths
}
def gitCheckoutAlt(String gitURL, String revision, String targetDir, String repoRootSuffix = "", int cloneDepth = 1, boolean shallowClone = true, ArrayList<String> sparseitemlist = new ArrayList<String>()) {
echo "Performing alternative checkout"
def String reporootpath = lfsinstallandreporoot(gitURL)
showsparseitemlist(sparseitemlist)
if (!sparseitemlist.isEmpty()) {
gitinit(targetDir, reporootpath)
setlfsfetchinclude(targetDir, sparseitemlist)
}
docheckout(gitURL, revision, cloneDepth, reporootpath, shallowClone, targetDir, sparseitemlist)
if (!sparseitemlist.isEmpty()) {
gitsparserestore(targetDir)
}
}
def checkRepoExists(String gitURL) {
def int result = 0
if (isUnix()) {
result = sh( script: """
git ls-remote "${gitURL}" CHECK_GIT_REMOTE_URL_REACHABILITY
""",
returnStatus: true
)
} else {
result = bat( script: """
@git ls-remote "${gitURL}" CHECK_GIT_REMOTE_URL_REACHABILITY
""",
returnStatus: true
)
}
echo "git ls-remote return result: ${result}"
if (result > 0) {
error("The release repo: ${gitURL} cannot be found. Please ensure this exists before building")
} else {
echo "The release repo: ${gitURL} exists"
}
}
String getSHAFromVersion(String versionFolder) {
dir (versionFolder) {
srcRevision = readFile("gitrevision.txt").trim()
}
return srcRevision
}
boolean checkAllVersionsAgree(java.util.LinkedHashMap versions) {
def keys = versions.keySet()
if (keys.size() < 1) {
return false
}
if (keys.size() == 1) {
return true
}
else {
version = ""
for (key in keys) {
nextversion = versions.get(key)
if (version == "") {
version = nextversion
}
if (nextversion != version) {
return false
}
}
}
return true
}
def stripgithistory(String rootfolder) {
echo "Stripping git history out of ${rootfolder}"
dir(rootfolder) {
if (isUnix()) {
sh """#!/bin/bash
pwd
find . -type d -name ".git" | xargs -iXX rm -rf XX
find . -name ".gitignore" | xargs -iXX rm -rf XX
find . -name ".gitmodules" | xargs -iXX rm -rf XX
find . -iname ".gitattributes" | xargs -iXX rm -rf XX
find . -iname "*@tmp" | xargs -iXX rm -rf XX
"""
} else {
echo "Not supporting git stripping in Windows at the moment"
}
}
}
return this

View file

@ -0,0 +1,23 @@
def stamp(convertdetails) {
for (convertdetail in convertdetails) {
def filetoconvert = convertdetail[0]
def pattern = convertdetail[1]
def replacement = convertdetail[2]
//echo "Converting any instances of pattern: ${pattern} with replacement: ${replacement} in file: ${filetoconvert}"
def stampscript = "${autobuilder.commonscripts()}/versionstamping/versionstamper.py"
//echo "Using python: ${PYTHON} and script: ${stampscript}"
if (isUnix()) {
sh """
"${PYTHON}" -u "${stampscript}" -f "${filetoconvert}" -p "${pattern}" -s "${replacement}"
"""
}
else {
bat """
"${PYTHON}" -u "${stampscript}" -f "${filetoconvert}" -p "${pattern}" -s "${replacement}"
"""
}
}
}
return this;

View file

@ -0,0 +1,169 @@
gh = load("${autobuilder.commonscripts()}/versioncontrol/git.groovy")
def int maxversionnumber() {
def int MAXVERSIONNUMBER = 65535
return MAXVERSIONNUMBER
}
int incrementrevision(int current, int increment) {
def int newrevision = (current + increment) % (maxversionnumber() + 1)
echo "Current revision: ${current} Increment: ${increment} New revision: ${newrevision}"
return newrevision
}
def getGitRevision(String gitrootpath, int basebuildnumber) {
def int adjustedchangecount
def String gitrevision
def String remoteinfo
def String remoteurl
def boolean isShallowCloned = gh.isShallowClonedRepo(gitrootpath)
if (isShallowCloned) {
error("Cannot generate a version number from a shallow cloned repo at ${gitrootpath}")
}
dir( gitrootpath) {
def int changecount = 0
if (isUnix()) {
changecount = sh(returnStdout: true, script: "git rev-list HEAD --count").trim().toInteger()
}
else {
changecount = bat(returnStdout: true, script: "@git rev-list HEAD --count").trim().toInteger()
}
echo "Change count: ${changecount}"
def int mvnp1 = maxversionnumber() + 1
basebuildnumber = (basebuildnumber < 0) ? mvnp1 - (basebuildnumber.abs() % mvnp1) : basebuildnumber
adjustedchangecount = incrementrevision(changecount, basebuildnumber)
echo "Adjusted change count: ${adjustedchangecount}"
if (isUnix()) {
gitrevision = sh(returnStdout: true, script: "git rev-parse HEAD").trim()
}
else {
gitrevision = bat(returnStdout: true, script: "@git rev-parse HEAD").trim()
}
echo "Revision: ${gitrevision}"
if (isUnix()) {
remoteinfo = sh(returnStdout: true, script: "git remote show origin").trim()
}
else {
remoteinfo = bat(returnStdout: true, script: "@git remote show origin").trim()
}
echo "Remote info: ${remoteinfo}"
if (isUnix()) {
remoteurl = sh(returnStdout: true, script: "git config --get remote.origin.url").trim()
}
else {
remoteurl = bat(returnStdout: true, script: "@git config --get remote.origin.url").trim()
}
echo "Remote URL: ${remoteurl}"
}
return [adjustedchangecount, gitrevision, remoteinfo, remoteurl]
}
// Handle:
// origin/master
// origin/2.0.x
def getVersionPrefix(String sourcebranch, boolean droptrailingdot = false) {
echo "Determining version number prefix from source branch name: ${sourcebranch}"
sourcebranch = sourcebranch.toLowerCase()
def defaultversionprefix = "0.30000.0."
def splits = sourcebranch.split('/')
if (splits.size() < 1) {
echo "Source branch name is invalid. Defaulting to: ${defaultversionprefix}"
return defaultversionprefix
}
def mastertypeversionprefix = "0.20000.0."
sourcebranch = splits.last()
if (sourcebranch.toLowerCase().find("master") != null) {
echo "Source branch name has 'master' in it. Defaulting to: ${mastertypeversionprefix}"
return mastertypeversionprefix
}
def splits2 = sourcebranch.split('\\.')
if (splits2.size() < 1) {
def thirdpartyversionprefix = "0.25000.0."
echo "Source branch name has no dots in it (eg. 1.9.2). Defaulting to: ${thirdpartyversionprefix}"
return thirdpartyversionprefix
}
for (split in splits2) {
if (split == "x") {
echo "Source branch name has '.x' or 'x.' in it. Defaulting to: ${mastertypeversionprefix}"
return mastertypeversionprefix
}
}
def integerstrings = sourcebranch.findAll(/\d+/)
def integers = []
for (integerstring in integerstrings) {
int integer = integerstring.toInteger()
integer = integer % (maxversionnumber() + 1)
integers.add(integer)
}
def versionprefix = ""
if (integers.size() < 1) {
echo "This source branch name has no numbers in its name so defaulting to: ${defaultversionprefix}"
versionprefix = defaultversionprefix
}
else {
def int integernumbercount = 0
for (integer in integers) {
versionprefix += integer + "."
integernumbercount += 1
if (integernumbercount > 2) {
break
}
}
if (integernumbercount == 0) {
echo "No leading numbers were found in source branch name so defaulting to: ${defaultversionprefix}"
versionprefix = defaultversionprefix
}
else if (integernumbercount == 1) {
versionprefix += "0.0."
}
else if (integernumbercount == 2) {
versionprefix += "0."
}
}
if (droptrailingdot == true) {
versionprefix = versionprefix.substring(0, versionprefix.length() - 1);
}
echo "Determined version prefix to be: ${versionprefix}"
return versionprefix
}
String generate(meta, String sourcerevision, String sourcepath, int basebuildnumber = 1000) {
def int gitrevisioncount
def String gitrevision
def String remoteinfo
def String remoteurl
(gitrevisioncount, gitrevision, remoteinfo, remoteurl) = getGitRevision(sourcepath, basebuildnumber)
def versionprefix = getVersionPrefix(sourcerevision)
def buildstamp = versionprefix + gitrevisioncount.toString()
echo "Build stamp is: ${buildstamp}"
meta.gitinfo.set(sourcepath, sourcerevision, gitrevision, remoteurl, remoteinfo)
meta.buildstampinfo.set(versionprefix, gitrevisioncount, buildstamp)
return buildstamp
}
String generate(meta, String sourcerevision, String sourcepath, String basebuildnumber) {
def int bbn = basebuildnumber.trim().toInteger()
return generate(meta, sourcerevision, sourcepath, bbn)
}
String copyfrom(meta, othermeta) {
meta.gitinfo = othermeta.gitinfo
meta.buildstampinfo = othermeta.buildstampinfo
return meta.buildstampinfo.buildstamp
}
return this;

17
versionstamping/.project Normal file
View file

@ -0,0 +1,17 @@
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
<name>versionstamping</name>
<comment></comment>
<projects>
</projects>
<buildSpec>
<buildCommand>
<name>org.python.pydev.PyDevBuilder</name>
<arguments>
</arguments>
</buildCommand>
</buildSpec>
<natures>
<nature>org.python.pydev.pythonNature</nature>
</natures>
</projectDescription>

View file

@ -0,0 +1,8 @@
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<?eclipse-pydev version="1.0"?><pydev_project>
<pydev_pathproperty name="org.python.pydev.PROJECT_SOURCE_PATH">
<path>/${PROJECT_DIR_NAME}</path>
</pydev_pathproperty>
<pydev_property name="org.python.pydev.PYTHON_PROJECT_VERSION">python 3.0</pydev_property>
<pydev_property name="org.python.pydev.PYTHON_PROJECT_INTERPRETER">python35</pydev_property>
</pydev_project>

View file

@ -0,0 +1,38 @@
import argparse
import sys
import shutil
from builtins import FileNotFoundError
def main(argv):
parser = argparse.ArgumentParser(description="Look for version number pattern in file and replace with autobuild version number")
# Call once arguments to allow or disallow something
parser.add_argument('-f', '--filetoconvert', help='The file to convert')
parser.add_argument('-p', '--pattern', default='0.30000.0.0', help='The pattern to search for and replace')
parser.add_argument('-s', '--substitute', help='The new version number that will substitute the pattern')
args = parser.parse_args(argv)
filetoconvert = args.filetoconvert
pattern = args.pattern
substitute = args.substitute
print("Converting 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:]))