diff --git a/artifacts/metaexport.groovy b/artifacts/metaexport.groovy index 043c4de..67d13c3 100644 --- a/artifacts/metaexport.groovy +++ b/artifacts/metaexport.groovy @@ -1,8 +1,6 @@ // 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, subJobs) { - def importer = load("${autobuilder.commonscripts()}/import/importer.groovy") - +def combineSubjobArtifacts(meta, importer, subJobs) { def ArrayList artifactFolders = new ArrayList() for (subJob in subJobs) { def subJobObject = subJob[0] diff --git a/autobuilder.groovy b/autobuilder.groovy index 63ca2de..1256394 100644 --- a/autobuilder.groovy +++ b/autobuilder.groovy @@ -1,9 +1,7 @@ // Assume that WORKSPACE environment variable is set autobuildroot = "${WORKSPACE}/autobuild" - commonscriptsroot = "${autobuildroot}/Common_scripts" - metafolderscript = null def conditionalclean(doclean = "${CLEAN_WORKSPACE}" == "true") { @@ -32,7 +30,7 @@ def getmetafolderscript() { } // Start up boilderplate -def start(script, productname = PRODUCT_NAME, subcomponentname = SUBCOMPONENT_NAME, jirakey = JIRA_KEY, releaserepo = RELEASE_REPO, String repoRootSuffix = "", autobuildpath = autobuildroot, commonscriptspath = commonscriptsroot) { +def startbuild(script, String productname = PRODUCT_NAME, String subcomponentname = SUBCOMPONENT_NAME, String releaserepo = RELEASE_REPO, String autobuildpath = autobuildroot, String commonscriptspath = commonscriptsroot) { echo "Starting...." autobuildroot = autobuildpath @@ -42,13 +40,13 @@ def start(script, productname = PRODUCT_NAME, subcomponentname = SUBCOMPONENT_NA conditionalclean() def meta = getmetafolderscript().metareset(script) - meta.productinfo.set(productname, subcomponentname, jirakey) + 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") - rr.registerrepo(meta, releaserepo, repoRootSuffix) + rr.registerrepo(meta, releaserepo) def ch = load("${commonscripts()}/configuration/configuration.groovy") ch.registerPipelineScriptConfiguration(meta) @@ -56,6 +54,11 @@ def start(script, productname = PRODUCT_NAME, subcomponentname = SUBCOMPONENT_NA 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...." @@ -67,7 +70,7 @@ def startnonbuild(script, autobuildpath = autobuildroot, commonscriptspath = com conditionalclean() def meta = getmetafolderscript().metareset(script) - meta.productinfo.set("Non-build-product", "Non-build-subcomponent", "Non-build-jira-key") + 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()) diff --git a/copy/logic.groovy b/copy/logic.groovy index 5c82688..4d5291c 100644 --- a/copy/logic.groovy +++ b/copy/logic.groovy @@ -57,4 +57,4 @@ pipeline { echo 'Succeeded build' } } -} +} \ No newline at end of file diff --git a/differences/dometahierarchy.groovy b/differences/dometahierarchy.groovy index 2e94820..2475f36 100644 --- a/differences/dometahierarchy.groovy +++ b/differences/dometahierarchy.groovy @@ -35,6 +35,7 @@ class DifferenceRecord { String sha String type String mergeinfo + String squashinfo List jiraticketinfo String comment @@ -47,6 +48,7 @@ class DifferenceRecord { sha = "" type = "" mergeinfo = "" + squashinfo = "" jiraticketinfo = [] comment = "" } @@ -140,7 +142,6 @@ def String getcomponent(meta) { } def getgitlogdifferences(String gitrootfolder, String earlyrevision, String laterrevision, boolean tripledot = false) { - def differencerecords = [] def String releaseexpression if (tripledot) { releaseexpression = earlyrevision + "..." + laterrevision @@ -167,6 +168,16 @@ def extractsha(String line) { 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) @@ -303,7 +314,35 @@ def extractreverts(String line) { return [false, [], line] } -def DifferenceRecord fillrecord(meta, 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 @@ -317,41 +356,49 @@ def DifferenceRecord fillrecord(meta, line) { (sha, line2) = extractsha(line) dr.sha = sha - - (result, mergeinfo) = extractmerges(line2) + + (result, squashinfo) = extractsquashes(line2) if (result) { - dr.type = "Merge" - dr.mergeinfo = mergeinfo + dr.type = "Squash" + dr.squashinfo = squashinfo + squashrecords = fillsquashrecords(sourcepath, sha) + differencerecords.addAll(squashrecords) } else { - (result, jiraticketinfo, comment) = extractreverts(line2) + (result, mergeinfo) = extractmerges(line2) if (result) { - dr.type = "Revert" - dr.jiraticketinfo = jiraticketinfo - dr.comment = comment + dr.type = "Merge" + dr.mergeinfo = mergeinfo } else { - (result, jiraticketinfo, comment) = extractjiraticketinfo(line2) + (result, jiraticketinfo, comment) = extractreverts(line2) if (result) { - dr.type = "Ticketed" + dr.type = "Revert" dr.jiraticketinfo = jiraticketinfo dr.comment = comment } else { - dr.type = "Unticketed" - dr.comment = line2 + (result, jiraticketinfo, comment) = extractjiraticketinfo(line2) + if (result) { + dr.type = "Ticketed" + dr.jiraticketinfo = jiraticketinfo + dr.comment = comment + } else { + dr.type = "Unticketed" + dr.comment = line2 + } } } } - - return dr + differencerecords.add(dr) + return differencerecords } -def List processtext(meta, String text) { +def List processtext(meta, String text, String sourcepath) { def List differencerecords = [] text.split('\n').each { def line = it if (line?.trim()) { - def DifferenceRecord dr = fillrecord(meta, line.trim()) - differencerecords.add(dr) + def List drs = fillrecord(meta, line.trim(), sourcepath) + differencerecords.addAll(drs) //echo "${dr.dump()}" } } @@ -371,7 +418,7 @@ def getdifferencerecords(earlymeta, latermeta, String sourcepath) { 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) + differencerecords = processtext(earlymeta, differencetext, sourcepath) if (earlyrevision == laterrevision) { summaryappend(" No change") } @@ -395,6 +442,28 @@ def addedcomponent(latermetaitems, key) { summaryappend("Added ") } +class SquashReportRecord { + String comment + int duplicates + + SquashReportRecord() { + comment = '' + duplicates = 0 + } +} + +def squashreport(String reportsubfolder, String title, LinkedHashMap squashes, boolean iscomponent = true) { + dir(reportsubfolder) { + def String squashlist = "${title}\nSquash list:\n" + def squashessorted = squashes.sort() + for (asquash in squashessorted) { + def SquashReportRecord s = asquash.value + squashlist += "${s.comment} (${s.duplicates})\n" + } + writeFile(file: "squashlist.txt", text: squashlist) + } +} + class MergeReportRecord { String comment int duplicates @@ -547,12 +616,25 @@ def differencerecordsreport(String reportsubfolder, String title, differencereco 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)) { @@ -665,6 +747,7 @@ def boolean report(meta, title, differencerecords, boolean iscomponent = true) { 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) @@ -720,8 +803,8 @@ def comparehierarchy(meta, String earlymetafolder, String latermetafolder, Strin echo "Comparing product meta hierarchy from folders: ${earlymetafolder} and ${latermetafolder} to a depth of ${md}. Exporting summary to ${summaryfolder}" - def earlymeta = meta.importrelated(earlymetafolder) - def latermeta = meta.importrelated(latermetafolder) + def earlymeta = meta.importrelated(true, earlymetafolder) + def latermeta = meta.importrelated(true, latermetafolder) def earlymetaitems = earlymeta.releasewalkerunique(md) def latermetaitems = latermeta.releasewalkerunique(md) diff --git a/import/importer.groovy b/import/importer.groovy index a8b64f5..41f5118 100644 --- a/import/importer.groovy +++ b/import/importer.groovy @@ -1,36 +1,122 @@ gh = load("${autobuilder.commonscripts()}/versioncontrol/git.groovy") versiongenerator = load("${autobuilder.commonscripts()}/versionnumbering/generate.groovy") -def artifactimport(meta, String jenkinsjob, int buildnumber, String destpath, boolean incrementversionnumber = true, String filter = '**', String excludes = '', boolean fingerprint = false) { - copyArtifacts( - filter: filter, - excludes: excludes, - fingerprintArtifacts: fingerprint, - projectName: jenkinsjob.trim(), - selector: specific(buildnumber.toString()), - target: destpath - ) - def importedmeta = meta.importrelated(destpath) - if (incrementversionnumber) { - meta.buildstampinfo.changerevision(versiongenerator.incrementrevision(meta.buildstampinfo.revision, importedmeta.buildstampinfo.revision)) +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_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, + 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_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) { + m_incrementversionnumber = incrementversionnumber + } + + void setfilter(String filter) { + m_filter = filter.trim() + } + + void setexcludes(String excludes) { + m_excludes = excludes.trim() + } + + void setfingerprint(boolean fingerprint) { + m_fingerprint = fingerprint + } + + void setnested(boolean nested) { + m_nested = nested + } + + 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) } - return importedmeta } -def artifactimport(meta, String jenkinsjob, String buildselector, String destpath, boolean incrementversionnumber = true, String filter = '', String excludes = '', boolean fingerprint = false) { +ImportOptions getNewImportOptions() { + return new ImportOptions(this) +} + +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 + } + copyArtifacts( - filter: filter, - excludes: excludes, - fingerprintArtifacts: fingerprint, - projectName: jenkinsjob.trim(), + filter: importoptions.m_filter, + excludes: importoptions.m_excludes, + fingerprintArtifacts: importoptions.m_fingerprint, + projectName: importoptions.m_jobname, selector: [ $class: 'ParameterizedBuildSelector', - parameterName: buildselector + parameterName: importoptions.m_buildnumberorselector ], target: destpath ) - def importedmeta = meta.importrelated(destpath) - if (incrementversionnumber) { + 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 @@ -42,16 +128,20 @@ def rewritemetafileasreleased(meta, String filepath) { meta.saveJsonSerialised(filepath) } -publisher = load("${autobuilder.commonscripts()}/publish/do.groovy") -def hierarchyartifactimportfromrepo(meta, String repo, String revision, String destpath, boolean incrementversionnumber = true, String filter = '', String excludes = '', boolean fingerprint = false) { - def rooturl = repo.trim() - def rootrevision = revision.trim() +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}" - def ArrayList sparseitemlist = gh.convertSparseItemsString(filter) + def ArrayList sparseitemlist = gh.convertSparseItemsString(importoptions.m_filter) gh.gitCheckoutAlt(rooturl, rootrevision, destpath, "", 1, true, sparseitemlist) - def importedmeta = meta.importrelated(destpath, rooturl, rootrevision, gh.getGitInfo(destpath)) + def importedmeta = meta.importrelated(importoptions.m_appendtoparentmeta, destpath, rooturl, rootrevision, gh.getGitInfo(destpath)) relatedimportinfo = importedmeta.getassociated() echo "Cloning associated repos" @@ -76,47 +166,120 @@ def hierarchyartifactimportfromrepo(meta, String repo, String revision, String d echo "Marking root meta as released and rewriting meta file: ${metafilepath}" rewritemetafileasreleased(importedmeta, metafilepath) - if (incrementversionnumber) { + if (importoptions.m_incrementversionnumber) { meta.buildstampinfo.changerevision(versiongenerator.incrementrevision(meta.buildstampinfo.revision, importedmeta.buildstampinfo.revision)) } return importedmeta } -def artifactimportfromrepo(meta, String repo, String revision, String destpath, boolean incrementversionnumber = true, String filter = '', String excludes = '', boolean fingerprint = false) { - def rooturl = repo.trim() - def rootrevision = revision.trim() +def artifactimportfromrepo(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 release repo: ${rooturl}, revision: ${rootrevision} at folder: ${destpath}" - def ArrayList sparseitemlist = gh.convertSparseItemsString(filter) + def ArrayList sparseitemlist = gh.convertSparseItemsString(importoptions.m_filter) gh.gitCheckoutAlt(rooturl, rootrevision, destpath, "", 1, true, sparseitemlist) - def importedmeta = meta.importrelated(destpath, rooturl, rootrevision, gh.getGitInfo(destpath)) + 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 (incrementversionnumber) { + if (importoptions.m_incrementversionnumber) { meta.buildstampinfo.changerevision(versiongenerator.incrementrevision(meta.buildstampinfo.revision, importedmeta.buildstampinfo.revision)) } return importedmeta } -def artifactimport(meta, String source, String jenkinsjob, buildnumberorselector, String repo, String revision, String destpath, boolean incrementversionnumber = true, String filter = '', String excludes = '', boolean fingerprint = false, boolean nested = false) { - switch (source) { - case "Jenkins job artifact": - case "Jenkins job artefact": - return artifactimport(meta, jenkinsjob, buildnumberorselector, destpath, incrementversionnumber, filter, excludes, fingerprint) - case "Release repository": - if (nested) { - return hierarchyartifactimportfromrepo(meta, repo, revision, destpath, incrementversionnumber, filter, excludes, fingerprint) +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, repo, revision, destpath, incrementversionnumber, filter, excludes, fingerprint) + return artifactimportfromrepo(meta, importoptions, destpath) default: error("Unknown type of artifact source: ${source}") } return meta } +// Deprecated (use above) +def artifactimport(meta, + String sourceselect, + String jenkinsjob, + buildnumberorselector, + String repo, + String revision, + String destpath, + boolean incrementversionnumber = true, + String filter = '', + String excludes = '', + boolean fingerprint = false, + boolean nested = false) { + echo "DEPRECATED method: artifactimport(meta, String source, String jenkinsjob, buildnumberorselector, String repo, String revision, String destpath ...)" + def importoptions = getNewImportOptions() + + importoptions.source(sourceselect, jenkinsjob, buildnumberorselector, repo, revision) + importoptions.setincrementversionnumber(incrementversionnumber) + importoptions.setfilter(filter) + importoptions.setexcludes(excludes) + importoptions.setfingerprint(fingerprint) + importoptions.setnested(nested) + + return artifactimport(meta, importoptions, destpath) +} + +// Deprecated (use above) +def artifactimport(meta, + String buildjob, + int buildnumber, + String destpath, + boolean incrementversionnumber = true, + String filter = '**', + String excludes = '', + boolean fingerprint = false) { + echo "DEPRECATED method: artifactimport(meta, String buildjob, int buildnumber, String destpath, ...)" + def importoptions = getNewImportOptions() + + importoptions.jenkinsjob(buildjob, " ${buildnumber}") + importoptions.setincrementversionnumber(incrementversionnumber) + importoptions.setfilter(filter) + importoptions.setexcludes(excludes) + importoptions.setfingerprint(fingerprint) + + return artifactimport(meta, importoptions, destpath) +} + +// Deprecated (use above) +def artifactimport(meta, + String buildjob, + buildnumberorselector, + String destpath, + boolean incrementversionnumber = true, + String filter = '', + String excludes = '', + boolean fingerprint = false) { + echo "DEPRECATED method: artifactimport(meta, String buildjob, buildnumberorselector, String destpath, ...)" + def importoptions = getNewImportOptions() + + importoptions.jenkinsjob(buildjob, buildnumberorselector) + importoptions.setincrementversionnumber(incrementversionnumber) + importoptions.setfilter(filter) + importoptions.setexcludes(excludes) + importoptions.setfingerprint(fingerprint) + + return artifactimport(meta, importoptions, destpath) +} + return this; diff --git a/install/installhelper.groovy b/install/installhelper.groovy index 6fcdc6c..96a8b2e 100644 --- a/install/installhelper.groovy +++ b/install/installhelper.groovy @@ -23,10 +23,10 @@ def copyToFinalPosition(String pathToIntermediate, String finalBaseFolder, Strin } // Given details about artifacts to import and details of installers to build, import artifacts that are required -def Map artifactsImporter(meta, artifactDetails, installerDetails) { +def Map artifactsImporter(meta, importer, artifactDetails, installerDetails) { artifactFetched = [:] - def importer = load("${autobuilder.commonscripts()}/import/importer.groovy") + def importoptions = importer.getNewImportOptions() for (installer in toBuild) { def artifactKeys = installerDetails.get(installer)[1] if (artifactKeys instanceof java.lang.String) { @@ -35,7 +35,12 @@ def Map artifactsImporter(meta, artifactDetails, installerDetails) { for (artifactKey in artifactKeys) { (sourceProject, sourceselector, destFolder, incrementversionnumber, toCopy, notToCopy, binariesFolders) = artifactDetails.get(artifactKey) if (artifactFetched.get(artifactKey) == null) { - def importmeta = importer.artifactimport(meta, sourceProject, sourceselector, destFolder, incrementversionnumber, toCopy, notToCopy) + importoptions.jenkinsjob(sourceProject, sourceselector) + importoptions.setincrementversionnumber(incrementversionnumber) + importoptions.setfilter(toCopy) + importoptions.setexcludes(notToCopy) + + def importmeta = importer.artifactimport(meta, importoptions, destFolder) artifactFetched.put(artifactKey, importmeta) } } diff --git a/meta/folder.groovy b/meta/folder.groovy index 40f03aa..96c9626 100644 --- a/meta/folder.groovy +++ b/meta/folder.groovy @@ -22,16 +22,14 @@ abstract class GISJsonSerialised implements Serializable { class ProductInfo extends GISJsonSerialised { String productname String subcomponentname - String jirakey - ProductInfo(script, productname = "", subcomponentname = "", jirakey = "") { + ProductInfo(script, productname = "", subcomponentname = "") { super(script) this.productname = productname this.subcomponentname = subcomponentname - this.jirakey = jirakey } - void set(String productname, String subcomponentname, String jirakey) { + void set(String productname, String subcomponentname) { // Make sure the fields can be used in git tags def int pstatus = 0 if (script.isUnix()) { @@ -55,20 +53,17 @@ class ProductInfo extends GISJsonSerialised { } this.productname = productname this.subcomponentname = subcomponentname - this.jirakey = jirakey } void deserialiseJson(rawmeta) { productname = rawmeta['productname'] subcomponentname = rawmeta['subcomponentname'] - jirakey = rawmeta['jirakey'] } LinkedHashMap serialisationdata() { def data = [ 'productname' : productname, 'subcomponentname' : subcomponentname, - 'jirakey' : jirakey, ] return data } @@ -605,7 +600,7 @@ class MetaInfo extends GISJsonSerialised { return METAFOLDERNAME + "/" + METAFILENAME } - MetaInfo importrelated(String destpath, String givenRepo = 'Unknown', String givenRevision = 'Unknown', String givenSHA = 'Unknown') { + 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) @@ -618,7 +613,9 @@ class MetaInfo extends GISJsonSerialised { } RelatedMetaInfo rmi = new RelatedMetaInfo(script, adjustedpath, mi) - associatedmeta.add(rmi) + if (appendtoparentmeta) { + associatedmeta.add(rmi) + } return mi } diff --git a/release/registerrepo.groovy b/release/registerrepo.groovy index bd6a528..f565706 100644 --- a/release/registerrepo.groovy +++ b/release/registerrepo.groovy @@ -2,7 +2,7 @@ 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, String repoRootSuffix = "") { +def registerrepo(meta, String releaserepo) { if (releaserepo?.trim()) { vc.checkRepoExists(releaserepo) }