262 lines
No EOL
9.3 KiB
Groovy
262 lines
No EOL
9.3 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 ProductParsed addProductEntry(LinkedHashMap<String, ProductParsed> productcollection,
|
|
String productvariant,
|
|
String releaserepo) {
|
|
def ProductParsed productparsed
|
|
|
|
if (productvariant && releaserepo) {
|
|
if (productcollection.get(releaserepo) == null) { // Use the first entry name only
|
|
echo "Adding product variant: ${productvariant} releaserepo: ${releaserepo}"
|
|
productparsed = new ProductParsed(productvariant)
|
|
productcollection.put(releaserepo, productparsed)
|
|
} else {
|
|
echo "Already added product variant: ${productvariant}"
|
|
}
|
|
productparsed = productcollection.get(releaserepo)
|
|
} else {
|
|
echo "Not adding product variant: ${productvariant} releaserepo: ${releaserepo}"
|
|
}
|
|
return productparsed
|
|
}
|
|
|
|
def parseproductdependencies(LinkedHashMap<String, ProductParsed> productcollection,
|
|
productreleasemeta,
|
|
String productreleasefolder,
|
|
String containingproductvariant,
|
|
ProductRelease productrelease) {
|
|
def dependentmeta = productreleasemeta.getassociated(productreleasefolder)
|
|
|
|
for (meta in dependentmeta) {
|
|
def pd = new ProductDependency(this,
|
|
rt,
|
|
meta.productvariant(),
|
|
meta.releasetag(),
|
|
meta.releaseinfo.releaserepoURL)
|
|
pd.setreleasestate()
|
|
if (meta.productinfo.subcomponentname == 'WHOLE' && meta.productvariant() != '') {
|
|
if (meta.productvariant() != containingproductvariant) { // Don't add myself
|
|
addProductEntry(productcollection,
|
|
meta.productvariant(),
|
|
meta.releaseinfo.releaserepoURL)
|
|
productrelease.addProductDependency(pd)
|
|
}
|
|
} else if (meta.productvariant() != containingproductvariant && meta.productvariant() != '') {
|
|
addProductEntry(productcollection,
|
|
meta.productvariant(),
|
|
meta.releaseinfo.releaserepoURL)
|
|
productrelease.addProductDependency(pd)
|
|
} else {
|
|
def pc = new ProductComponent(meta.productinfo.subcomponentname,
|
|
meta.releasetag(),
|
|
meta.releaseinfo.releaserepoURL)
|
|
productrelease.addProductComponent(pc)
|
|
}
|
|
}
|
|
}
|
|
|
|
def parseproductrepo(LinkedHashMap<String, ProductParsed> productcollection,
|
|
String productrepo,
|
|
String productreleasefolder) {
|
|
dir(productreleasefolder) {
|
|
deleteDir()
|
|
sh """#!/bin/bash
|
|
git init
|
|
git config remote.origin.url ${productrepo}
|
|
git config advice.detachedHead false
|
|
git sparse-checkout init
|
|
git sparse-checkout set meta/*
|
|
git pull -t
|
|
"""
|
|
}
|
|
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,
|
|
productvariant,
|
|
productrepo)
|
|
if (pp) {
|
|
echo "Productvariant: ${pp.productvariant} created"
|
|
} else {
|
|
echo "No product entry added/associated with ${productvariant}"
|
|
}
|
|
}
|
|
|
|
if (pp) {
|
|
def productrelease = new ProductRelease(sha,
|
|
productreleasemeta.jenkinsbuildinfo.builddate,
|
|
tags)
|
|
echo "Productrelease: ${productrelease.sha} created"
|
|
parseproductdependencies(productcollection,
|
|
productreleasemeta,
|
|
productreleasefolder,
|
|
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,
|
|
LinkedHashMap<String, ProductParsed> productcollection,
|
|
String productreleasefolder) {
|
|
for (productrepo in initialproductcollection.ProductReleaseRepos) {
|
|
echo "Querying ${productrepo}"
|
|
parseproductrepo(productcollection,
|
|
productrepo,
|
|
productreleasefolder)
|
|
}
|
|
while( true ) {
|
|
boolean allparsed = true
|
|
echo "Parsing extra products"
|
|
productcollection.each { releaserepo, productparsed ->
|
|
if (!productparsed.parsed()) {
|
|
echo "Querying unparsed ${productparsed.productvariant}"
|
|
allparsed = false
|
|
parseproductrepo(productcollection,
|
|
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 |