firmware_tools/autobuild/Common_scripts/product/info.groovy
2022-04-21 13:49:36 +01:00

302 lines
No EOL
12 KiB
Groovy

importer = load("${autobuilder.commonscripts()}/import/importer.groovy")
gh = load("${autobuilder.commonscripts()}/versioncontrol/git.groovy")
rt = load("${autobuilder.commonscripts()}/release/tag.groovy")
class ProductDependency {
private script
private rtscript
private String productvariant
private String releaserepo
private String presplitreleasetag
private String releasetag
private String releasestate
def ProductDependency(script,
rtscript,
String productvariant,
String presplitreleasetag,
String releaserepo) {
this.script = script
this.rtscript = rtscript
this.productvariant = productvariant
this.releaserepo = releaserepo
this.presplitreleasetag = presplitreleasetag
this.releasetag = ''
this.releasestate = ''
}
def setreleasestate() {
def LinkedHashMap results = rtscript.startswithspecialprefix(presplitreleasetag)
if (results.hasspecialprefix) {
releasetag = results.tagwithoutprefix
releasestate = results.prefixfound
} else {
releasetag = results.tagwithoutprefix
releasestate = ''
}
}
}
class ProductComponent {
private String componentname
private String releaserepo
private String releasetag
def ProductComponent(String componentname, String releasetag, String releaserepo) {
this.componentname = componentname
this.releaserepo = releaserepo
this.releasetag = releasetag
}
}
class ProductRelease {
private String sha
private String builddate
private ArrayList<String> tags
private ArrayList<ProductDependency> productdependencies
private ArrayList<ProductComponent> productcomponents
def ProductRelease(String sha, String builddate, ArrayList<String> tags) {
this.sha = sha
this.builddate = builddate
this.tags = tags
this.productdependencies = new ArrayList<ProductDependency>()
this.productcomponents = new ArrayList<ProductComponent>()
}
def addProductDependency(ProductDependency dependency) {
productdependencies.add(dependency)
}
def addProductComponent(ProductComponent component) {
productcomponents.add(component)
}
}
class ProductParsed {
enum State {
UNPARSED,
PARSED,
}
private State scanstate
private String productvariant
private ArrayList<ProductRelease> releases
def ProductParsed(String productvariant) {
scanstate = State.UNPARSED
this.productvariant = productvariant
this.releases = new ArrayList<ProductRelease>()
}
def markparsed() {
scanstate = State.PARSED
}
def markparseerror() {
scanstate = State.PARSED
}
def boolean parsed() {
return (scanstate == State.PARSED)
}
def addProductRelease(ProductRelease productrelease) {
releases.add(productrelease)
}
}
def String translateproductvariant(productvarianttranslation,
String releaserepo,
String productvariant) {
def translatedproductvariant = productvarianttranslation.get(releaserepo)
if (translatedproductvariant != null) {
echo "Translating product variant: ${productvariant} to: ${translatedproductvariant}"
return translatedproductvariant
}
return productvariant
}
def ProductParsed addProductEntry(LinkedHashMap<String, ProductParsed> productcollection,
productvarianttranslation,
String productvariant,
String releaserepo) {
def ProductParsed productparsed
if (productvariant && releaserepo) {
if (productcollection.get(releaserepo) == null) { // Use the first entry name only
echo "Adding product entry: releaserepo: ${releaserepo} (product variant: ${productvariant})"
def translatedproductvariant = translateproductvariant(productvarianttranslation,
releaserepo,
productvariant)
productparsed = new ProductParsed(translatedproductvariant)
productcollection.put(releaserepo, productparsed)
} else {
echo "Already added product entry: releaserepo: ${releaserepo} (product variant: ${productvariant})"
}
productparsed = productcollection.get(releaserepo)
} else {
echo "Not adding product entry: releaserepo: ${releaserepo} (product variant: ${productvariant})"
}
return productparsed
}
def parseproductdependencies(LinkedHashMap<String, ProductParsed> productcollection,
productvarianttranslation,
productreleasemeta,
String productreleasefolder,
String containingproductvariant,
ProductRelease productrelease) {
def dependentmeta = productreleasemeta.getassociated(productreleasefolder)
for (meta in dependentmeta) {
def translatedproductvariant = translateproductvariant(productvarianttranslation,
meta.releaseinfo.releaserepoURL,
meta.productvariant())
if (translatedproductvariant && meta.productinfo.subcomponentname) {
def pd = new ProductDependency(this,
rt,
translatedproductvariant,
meta.releasetag(),
meta.releaseinfo.releaserepoURL)
pd.setreleasestate()
if (meta.productinfo.subcomponentname == 'WHOLE' && translatedproductvariant) {
if (translatedproductvariant != containingproductvariant) { // Don't add myself
addProductEntry(productcollection,
productvarianttranslation,
translatedproductvariant,
meta.releaseinfo.releaserepoURL)
productrelease.addProductDependency(pd)
}
} else {
def pc = new ProductComponent(meta.productinfo.subcomponentname,
meta.releasetag(),
meta.releaseinfo.releaserepoURL)
productrelease.addProductComponent(pc)
}
} else {
echo "Ignoring unnamed dependency in ${productreleasemeta.productvariant()}"
}
}
}
def parseproductrepo(LinkedHashMap<String, ProductParsed> productcollection,
productvarianttranslation,
String productrepo,
String productreleasefolder) {
def boolean productrepogood = true
echo "Querying repo: ${productrepo}"
dir(productreleasefolder) {
deleteDir()
def returnstatus = sh(script: """#!/bin/bash
git init
if [ \$? -ne 0 ]; then exit 1; fi
git config remote.origin.url ${productrepo}
if [ \$? -ne 0 ]; then exit 1; fi
git config advice.detachedHead false
if [ \$? -ne 0 ]; then exit 1; fi
git sparse-checkout init
if [ \$? -ne 0 ]; then exit 1; fi
git sparse-checkout set meta/*
if [ \$? -ne 0 ]; then exit 1; fi
git pull -t
if [ \$? -ne 0 ]; then exit 1; fi
""",
returnStatus: true)
if (returnstatus > 0) {
dir('meta') {
deleteDir()
}
echo "Couldn't clone repository: ${productrepo} correctly"
productrepogood = false
}
}
if (productrepogood) {
def LinkedHashMap<String, ArrayList<String>> shatagmap = gh.getremoteshatagmap(productrepo)
def String productvariant
def ProductParsed pp
shatagmap.each { sha, tags ->
//echo "Sha: ${sha} has tags: ${tags}"
dir(productreleasefolder) {
def returnstatus = sh(script: """#!/bin/bash
git checkout ${sha}
""",
returnStatus: true)
if (returnstatus > 0) {
dir('meta') {
deleteDir()
}
}
}
def productreleasemeta = meta.importrelated(false, productreleasefolder)
if (!productvariant) {
productvariant = productreleasemeta.productvariant()
pp = addProductEntry(productcollection,
productvarianttranslation,
productvariant,
productrepo)
if (pp) {
echo "Product variant created for: ${productrepo} name: ${pp.productvariant}"
} else {
echo "No product entry added/associated with ${productrepo} name: ${productvariant}"
}
}
if (pp) {
def productrelease = new ProductRelease(sha,
productreleasemeta.jenkinsbuildinfo.builddate,
tags)
echo "Productrelease: ${productrelease.sha} created"
parseproductdependencies(productcollection,
productvarianttranslation,
productreleasemeta,
productreleasefolder,
pp.productvariant,
productrelease)
echo "Productrelease: ${productrelease.sha} added to Productvariant: ${pp.productvariant}"
pp.addProductRelease(productrelease)
}
}
if (pp) {
pp.markparsed()
echo "Productvariant: ${pp.productvariant} parsed"
}
}
}
def iterateinitialproductrepos(initialproductcollection,
productvarianttranslation,
LinkedHashMap<String, ProductParsed> productcollection,
String productreleasefolder) {
for (productrepo in initialproductcollection.ProductReleaseRepos) {
parseproductrepo(productcollection,
productvarianttranslation,
productrepo,
productreleasefolder)
}
while( true ) {
boolean allparsed = true
echo "Parsing extra products"
productcollection.each { releaserepo, productparsed ->
if (!productparsed.parsed()) {
allparsed = false
parseproductrepo(productcollection,
productvarianttranslation,
releaserepo,
productreleasefolder)
} else {
echo "Parsed already ${productparsed.productvariant}"
}
}
if (allparsed) {
echo "All parsed"
break
}
}
}
def LinkedHashMap<String, ProductParsed> getNewProductCollection() {
return new LinkedHashMap<String, ProductParsed>()
}
return this