firmware_tools/Common_scripts/import/importer.groovy
2022-01-13 13:39:13 +00:00

396 lines
16 KiB
Groovy

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
}
String show() {
return """m_incrementversionnumber: ${m_incrementversionnumber}
m_filter: ${m_filter}
m_excludes: ${m_excludes}
m_fingerprint: ${m_fingerprint}
m_nested: ${m_nested}
m_flatten: ${m_flatten}
m_includemetainfilter: ${m_includemetainfilter}
m_clean: ${m_clean}
m_appendtoparentmeta: ${m_appendtoparentmeta}
m_sourceselect: ${m_sourceselect}
m_jobname: ${m_jobname}
m_buildnumberorselector: ${m_buildnumberorselector}
m_repo: ${m_repo}
m_revision: ${m_revision}
"""
}
void setsourceselect(String sourceselect) {
sourceselect = sourceselect.trim()
switch (sourceselect) {
case 'Jenkins job artefact':
m_sourceselect = 'Jenkins job artifact'
break
case 'Jenkins job artifact':
case 'Release repository':
m_sourceselect = sourceselect
break
default:
m_script.error("Unknown type of artifact source select: ${sourceselect}")
}
}
void setincrementversionnumber(boolean incrementversionnumber = true) {
m_incrementversionnumber = incrementversionnumber
}
void setfilter(String filter) {
m_filter = filter.trim()
}
void setexcludes(String excludes) {
m_excludes = excludes.trim()
}
void setfingerprint(boolean fingerprint = true) {
m_fingerprint = fingerprint
}
void setnested(boolean nested = true) {
m_nested = nested
}
void flattenimports(boolean flatten = true) {
m_flatten = flatten
}
void includemetainfilter(boolean includemetainfilter = true) {
m_includemetainfilter = includemetainfilter
}
void clean(boolean clean = true) {
m_clean = clean
}
void setappendtoparentmeta(boolean appendtoparentmeta) {
m_appendtoparentmeta = appendtoparentmeta
}
void jenkinsjob(String jobname, String buildnumberorselector) {
m_jobname = jobname.trim()
m_buildnumberorselector = [
$class: 'ParameterizedBuildSelector',
parameterName: buildnumberorselector
]
setsourceselect('Jenkins job artifact')
}
void jenkinsjob(String jobname, int buildnumberorselector) {
m_jobname = jobname.trim()
m_buildnumberorselector = [
$class: 'ParameterizedBuildSelector',
parameterName: "<SpecificBuildSelector plugin='copyartifact@1.46.2'><buildNumber>${buildnumberorselector}</buildNumber></SpecificBuildSelector>"
]
setsourceselect('Jenkins job artifact')
}
void releaserepo(String repo, String revision) {
m_repo = repo.trim()
m_revision = revision.trim()
setsourceselect('Release repository')
}
void source(String sourceselect, String jobname, String buildnumberorselector, String repo, String revision) {
jenkinsjob(jobname, buildnumberorselector)
releaserepo(repo, revision)
setsourceselect(sourceselect)
}
}
ImportOptions getNewImportOptions() {
return new ImportOptions(this)
}
def formFilter(ImportOptions importoptions) {
def String filter = importoptions.m_filter
if (filter != '') {
if (importoptions.m_includemetainfilter) {
filter = 'meta/**,' + filter
}
}
echo "Import options filter is: ${filter}"
return filter
}
def conditionalClean(ImportOptions importoptions, String destpath) {
if (importoptions.m_clean) {
echo "Cleaning ${destpath}"
dir(destpath) {
deleteDir()
}
}
}
def artifactimportfrombuildjob(meta, ImportOptions importoptions, String destpath) {
if (importoptions.m_sourceselect != 'Jenkins job artifact') {
error("Import options settings have not been set for: Jenkins job artifact")
return
}
conditionalClean(importoptions, destpath)
echo "Build selector type: ${importoptions.m_buildnumberorselector.getClass()}"
echo "Importing artifacts from job: ${importoptions.m_jobname} selector: ${importoptions.m_buildnumberorselector.toString()}"
copyArtifacts(
filter: formFilter(importoptions),
excludes: importoptions.m_excludes,
fingerprintArtifacts: importoptions.m_fingerprint,
projectName: importoptions.m_jobname,
selector: importoptions.m_buildnumberorselector,
flatten: importoptions.m_flatten,
target: destpath
)
def importedmeta = meta.importrelated(importoptions.m_appendtoparentmeta, destpath)
if (importoptions.m_incrementversionnumber) {
meta.buildstampinfo.changerevision(versiongenerator.incrementrevision(meta.buildstampinfo.revision, importedmeta.buildstampinfo.revision))
}
return importedmeta
}
def rewritemetafileasreleased(meta, String filepath) {
// Modify the meta info to say that is has already been released
meta.markreleased()
meta.saveJsonSerialised(filepath)
}
def hierarchyartifactimportfromrepo(meta, ImportOptions importoptions, String destpath) {
if (importoptions.m_sourceselect != 'Release repository') {
error("Import options settings have not been set for: Release repository")
return
}
def rooturl = importoptions.m_repo
def rootrevision = importoptions.m_revision
echo "Cloning root release repo: ${rooturl}, revision: ${rootrevision} at folder: ${destpath}"
conditionalClean(importoptions, destpath)
def ArrayList<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))
echo "Getting associated metadata from path: ${destpath}"
def collectedmetalist = importedmeta.getassociated(destpath)
for(def collectedmeta in collectedmetalist) {
echo "Collection meta item: ${collectedmeta.metainfo.componentversionuniqueidentifier()} offset path: ${collectedmeta.accumulatedpath}"
}
echo "Cloning associated repos inside path: ${destpath}"
for(def collectedmeta in collectedmetalist) {
def relatedmeta = collectedmeta.metainfo
def relatedoffsetpath = collectedmeta.accumulatedpath
def cloneurl = relatedmeta.releaseinfo.releaserepoURL
def clonerevision = "refs/tags/${relatedmeta.releasetag()}"
def clonepath = "${destpath}/${relatedoffsetpath}"
echo "Cloning release repo: ${cloneurl}, revision: ${clonerevision} at folder: ${clonepath}"
gh.gitCheckoutAlt(cloneurl, clonerevision, clonepath, "", 1, true, [])
gh.stripgithistory(clonepath)
def metafilepath = "${clonepath}${relatedmeta.metafilepath()}"
echo "Marking related meta as released and rewriting meta file: ${metafilepath}"
rewritemetafileasreleased(relatedmeta, metafilepath)
}
gh.stripgithistory(destpath)
def metafilepath = "${destpath}/${meta.metafilepath()}"
echo "Marking root meta as released and rewriting meta file: ${metafilepath}"
rewritemetafileasreleased(importedmeta, metafilepath)
if (importoptions.m_incrementversionnumber) {
meta.buildstampinfo.changerevision(versiongenerator.incrementrevision(meta.buildstampinfo.revision, importedmeta.buildstampinfo.revision))
}
return importedmeta
}
def artifactimportfromrepo(meta, ImportOptions importoptions, String destpath) {
if (importoptions.m_sourceselect != 'Release repository') {
error("Import options settings have not been set for: Release repository")
return
}
conditionalClean(importoptions, destpath)
def rooturl = importoptions.m_repo
def rootrevision = importoptions.m_revision
echo "Cloning release repo: ${rooturl}, revision: ${rootrevision} at folder: ${destpath}"
def ArrayList<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 importoptions, String destpath) {
echo "Importing artifacts: Import options:\n${importoptions.show()}\n to: ${destpath}"
switch (importoptions.m_sourceselect) {
case 'Jenkins job artifact':
case 'Jenkins job artefact':
return artifactimportfrombuildjob(meta, importoptions, destpath)
case 'Release repository':
if (importoptions.m_nested) {
return hierarchyartifactimportfromrepo(meta, importoptions, destpath)
}
return artifactimportfromrepo(meta, importoptions, destpath)
default:
error("Unknown type of artifact source: ${source}")
}
return meta
}
// Deprecated (use above)
def artifactimport(meta,
String sourceselect,
String jenkinsjob,
buildnumberorselector,
String repo,
String revision,
String destpath,
boolean incrementversionnumber = true,
String filter = '',
String excludes = '',
boolean fingerprint = false,
boolean nested = false) {
echo "DEPRECATED method: artifactimport(meta, String source, String jenkinsjob, buildnumberorselector, String repo, String revision, String destpath ...)"
def importoptions = importer.getNewImportOptions()
importoptions.source(sourceselect, jenkinsjob, buildnumberorselector, repo, revision)
importoptions.setincrementversionnumber(incrementversionnumber)
importoptions.setfilter(filter)
importoptions.setexcludes(excludes)
importoptions.setfingerprint(fingerprint)
importoptions.setnested(nested)
return artifactimport(meta, importoptions, destpath)
}
// Deprecated (use above)
def artifactimport(meta,
String buildjob,
int buildnumber,
String destpath,
boolean incrementversionnumber = true,
String filter = '**',
String excludes = '',
boolean fingerprint = false) {
echo "DEPRECATED method: artifactimport(meta, String buildjob, int buildnumber, String destpath, ...)"
def importoptions = importer.getNewImportOptions()
importoptions.jenkinsjob(buildjob, "<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 = importer.getNewImportOptions()
importoptions.jenkinsjob(buildjob, buildnumberorselector)
importoptions.setincrementversionnumber(incrementversionnumber)
importoptions.setfilter(filter)
importoptions.setexcludes(excludes)
importoptions.setfingerprint(fingerprint)
return artifactimport(meta, importoptions, destpath)
}
// Import the artifacts of a named child component found below parent meta's hierarchy
def artifactimport(meta,
parentmeta,
String parentmetapath,
String childproduct,
String childsubcomponent,
ImportOptions importoptions,
String destinationfolder) {
// Import from parent meta
def childmeta = meta.getNewMetaObject()
def childmeta2
echo "Finding meta associated with child: Product: ${childproduct} Sub-component: ${childsubcomponent}"
echo "From parent meta identifier: ${parentmeta.componentidentifier()} and parent meta path: ${parentmetapath}"
def findresults = parentmeta.findAssociatedMeta(parentmetapath, childproduct, childsubcomponent)
if (findresults.matchfound) {
childmeta = findresults.matchedmetaitem.metainfo
if (importoptions.m_sourceselect == 'Release repository' || childmeta.releaseinfo.released) {
importoptions.releaserepo(childmeta.releaseinfo.releaserepoURL, childmeta.releasetag())
} else {
importoptions.jenkinsjob(childmeta.jenkinsbuildinfo.buildjobname, childmeta.jenkinsbuildinfo.buildnumber)
}
childmeta2 = importer.artifactimport(meta, importoptions, destinationfolder)
} else {
error("Could not find meta associated with child: Product: ${childproduct} Sub-component: ${childsubcomponent}")
}
return childmeta2
}
return this;