firmware_tools/autobuild/Common_scripts/import/importer.groovy
2023-01-08 14:01:08 +00:00

382 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
boolean m_showdetails
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,
showdetails = false) {
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
m_showdetails = showdetails
}
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, java.util.LinkedHashMap selector) {
m_script.echo("Jenkins job: ${jobname} Selector (${selector.getClass()}): ${selector}")
m_jobname = jobname.trim()
m_buildnumberorselector = selector
setsourceselect('Jenkins job artifact')
}
void jenkinsjob(String jobname, String buildnumberorselector) {
m_script.echo("Jenkins job: ${jobname} Selector (String): ${buildnumberorselector}")
m_jobname = jobname.trim()
// Yuk - nasty
// https://javadoc.jenkins.io/plugin/copyartifact/hudson/plugins/copyartifact/BuildSelector.html
// This selects buildselector class based on what is in the string parameter
if (buildnumberorselector.contains('<SpecificBuildSelector')) {
m_script.echo("Prebuilt specific build selector")
m_buildnumberorselector = [
$class: 'ParameterizedBuildSelector',
parameterName: "${buildnumberorselector}"
]
} else if (buildnumberorselector.contains('<StatusBuildSelector')) {
m_script.echo("Prebuilt status build selector")
m_buildnumberorselector = [
$class: 'ParameterizedBuildSelector',
parameterName: "${buildnumberorselector}"
]
} else if (buildnumberorselector.contains('<stable>')) {
m_script.echo("Constructing status build selector")
m_buildnumberorselector = [
$class: 'ParameterizedBuildSelector',
parameterName: "<StatusBuildSelector plugin='copyartifact@1.46.2'>${buildnumberorselector}</StatusBuildSelector>"
]
} else {
m_script.echo("Constructing specific build selector")
m_buildnumberorselector = [
$class: 'ParameterizedBuildSelector',
parameterName: "<SpecificBuildSelector plugin='copyartifact@1.46.2'><buildNumber>${buildnumberorselector}</buildNumber></SpecificBuildSelector>"
]
}
setsourceselect('Jenkins job artifact')
}
void jenkinsjob(String jobname, int buildnumberorselector) {
m_script.echo("Jenkins job: ${jobname} Selector (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)
}
void showdetails(boolean showdetails) {
m_showdetails = showdetails
}
}
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}"
int offset = 0
for(def collectedmeta in collectedmetalist) {
def relatedmeta = collectedmeta.metainfo
def relatedoffsetpath = collectedmeta.accumulatedpath
def cloneurl = relatedmeta.releaseinfo.releaserepoURL
// The first entry in the list is the highest parent in the meta tree so use the tag provided in the import options
// This is because the revision that is recalled here could have been renamed since it was created during the release process
def clonerevision = (offset == 0) ? rootrevision : "refs/tags/${relatedmeta.releasetag()}"
def clonepath = "${destpath}/${relatedoffsetpath}"
if (relatedmeta.componentidentifier() != '_' &&
cloneurl != '') {
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)
} else {
echo "Not importing component that would be placed at path: ${clonepath}"
}
offset += 1
}
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) {
if (importoptions.m_showdetails) {
echo "Importing artifacts:\nImport options:\n${importoptions.show()}\nto: ${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
}
// 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
echo "Parent meta indicates it is released: ${parentmeta.releaseinfo.released}"
echo "Child meta indicates it is released: ${childmeta.releaseinfo.released}"
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 = artifactimport(meta, importoptions, destinationfolder)
} else {
error("Could not find meta associated with child: Product: ${childproduct} Sub-component: ${childsubcomponent}")
}
return childmeta2
}
return this;