diff --git a/meta/folder.groovy b/meta/folder.groovy index 6715145..ac3d0dd 100644 --- a/meta/folder.groovy +++ b/meta/folder.groovy @@ -913,6 +913,14 @@ class MetaInfo extends GISJsonSerialised { String componentidentifier() { return productinfo.productname + "_" + productinfo.subcomponentname } + + String productvariant() { + if (!productinfo.variant) { + return productinfo.productname + } else { + return productinfo.productname + "_" + productinfo.variant + } + } String componentversionuniqueidentifier() { return componentidentifier() + "_" + buildstampinfo.buildstamp diff --git a/product/info.groovy b/product/info.groovy new file mode 100644 index 0000000..3d7bc30 --- /dev/null +++ b/product/info.groovy @@ -0,0 +1,217 @@ + +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) + script.echo("results is: ${results.dump()}") + 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 tags + private ArrayList productdependencies + private ArrayList productcomponents + + def ProductRelease(String sha, String builddate, ArrayList tags) { + this.sha = sha + this.builddate = builddate + this.tags = tags + this.productdependencies = new ArrayList() + this.productcomponents = new ArrayList() + } + + 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 releases + + def ProductParsed(String productvariant) { + scanstate = State.UNPARSED + this.productvariant = productvariant + this.releases = new ArrayList() + } + + def markparsed() { + scanstate = State.PARSED + } + + def boolean parsed() { + return (scanstate == State.PARSED) + } + + def addProductRelease(ProductRelease productrelease) { + releases.add(productrelease) + } +} + +def addProductEntry(LinkedHashMap products, + String productvariant, + String releaserepo) { + def productparsed + if (products.get(releaserepo) == null) { // Use the first entry name only + productparsed = new ProductParsed(productvariant) + products.put(releaserepo, productparsed) + } else { + productparsed = products.get(releaserepo) + } + return productparsed +} + +def parseproductdependencies(LinkedHashMap products, + 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') { + if (meta.productvariant() != containingproductvariant) { // Don't add myself + addProductEntry(products, + meta.productvariant(), + meta.releaseinfo.releaserepoURL) + productrelease.addProductDependency(pd) + } + } else if (meta.productvariant() != containingproductvariant) { + addProductEntry(products, + 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 products, + String productrepo, + String productreleasefolder) { + def LinkedHashMap> shatagmap = gh.getremoteshatagmap(productrepo) + def String productvariant + def ProductParsed pp + + def ArrayList productreleases = new ArrayList() + shatagmap.each { sha, tags -> + def importoptions = importer.getNewImportOptions() + importoptions.releaserepo(productrepo, sha) + importoptions.setfilter('meta/**') + def productreleasemeta = importer.artifactimport(meta, + importoptions, + productreleasefolder) + + if (!productvariant) { + productvariant = productreleasemeta.productvariant() + pp = addProductEntry(products, + productvariant, productrepo) + } + + def productrelease = new ProductRelease(sha, + productreleasemeta.jenkinsbuildinfo.builddate, + tags) + parseproductdependencies(products, + productreleasemeta, + productreleasefolder, + productvariant, + productrelease) + pp.addProductRelease(productrelease) + } + pp.markparsed() +} + +def iterateinitialproductrepos(initialproductcollection, + LinkedHashMap productcollection, + String productreleasefolder) { + for (productrepo in initialproductcollection.ProductReleaseRepos) { + echo "Querying ${productrepo}" + parseproductrepo(productcollection, + productrepo, + productreleasefolder) + } + while( true ) { + boolean allparsed = true + productcollection.each { releaserepo, productparsed -> + if (!productparsed.parsed()) { + allparsed = false + parseproductrepo(productcollection, + releaserepo, + productreleasefolder) + } + } + if (allparsed) break + } +} + +def LinkedHashMap getNewProductCollection() { + return new LinkedHashMap() +} + + +return this \ No newline at end of file diff --git a/publish/promptingpublish.groovy b/publish/promptingpublish.groovy index ce6a805..49d9421 100644 --- a/publish/promptingpublish.groovy +++ b/publish/promptingpublish.groovy @@ -52,27 +52,29 @@ pipeline { stage('Identify software release to publish') { steps { script { + rt = load("${autobuilder.commonscripts()}/release/tag.groovy") gh = load("${autobuilder.commonscripts()}/versioncontrol/git.groovy") def allreleases = gh.gettaglist(SOURCEDIR) def releases = new ArrayList() - if (FILTER_REDUNDANT_RELEASES == 'false') { - echo("Showing all releases") - releases = allreleases - } else { - echo("Showing filtered releases") - for (release in allreleases) { - if (!release.toLowerCase().startsWith("superceded") && - !release.toLowerCase().startsWith("superseded") && - !release.toLowerCase().startsWith("erroneous") && - !release.toLowerCase().startsWith("faulty") && - !release.toLowerCase().startsWith("ignore") && - !release.toLowerCase().startsWith("inmainline")) { - echo("Showing release: ${release}") - releases.add(release) - } else { - echo("Not showing release: ${release}") + for (release in allreleases) { + def boolean canadd = true + if (FILTER_REDUNDANT_RELEASES == 'true') { + def results = rt.startswithspecialprefix(release) + if (results.prefixfound) { + canadd = false } } + if (FILTER_LONGNAME_RELEASES == 'true') { + if (release.findAll(/[a-zA-Z]/)) { + canadd = false + } + } + if (canadd) { + echo("Showing release: ${release}") + releases.add(release) + } else { + echo("Not showing release: ${release}") + } } timeout(time: 10, unit: 'MINUTES') { release = input( diff --git a/release/tag.groovy b/release/tag.groovy new file mode 100644 index 0000000..6155e7f --- /dev/null +++ b/release/tag.groovy @@ -0,0 +1,39 @@ + +def startswithspecialprefix(String releasetag) { + def RELEASETAG_PREFIXES = [ + 'superceded' : 'Misspelt - Indicates a later release has superseded the release with this prefix', + 'superseded' : 'Indicates a later release has superseded the release with this prefix', + 'erroneous' : 'The release was released unintentionally', + 'faulty' : 'The release was found to have a serious fault', + 'ignore' : 'The release should be ignored', + 'inmainline' : 'This release was associated with development branch which has now been merged into mainline', + ] + + def RELEASETAG_PREFIX_SEPERATOR = '_' + + def boolean hasspecialprefix = false + def String releasetagprefix = '' + def String prefixfound = '' + def String prefixmeaning = '' + def String tagwithoutprefix = releasetag + + for (def prefix in RELEASETAG_PREFIXES.keySet()) { + def meaning = RELEASETAG_PREFIXES.get(prefix) + if (releasetag.toLowerCase().startsWith(prefix)) { + prefixfound = prefix + hasspecialprefix = true + prefixmeaning = meaning + tagwithoutprefix = releasetag[(prefix.size() + 1)..-1] + break + } + } + + def results = [ 'hasspecialprefix' : hasspecialprefix, + 'prefixfound' : prefixfound, + 'tagwithoutprefix' : tagwithoutprefix, + 'meaning' : prefixmeaning, + ] + return results +} + +return this diff --git a/versioncontrol/git.groovy b/versioncontrol/git.groovy index a22054b..61378b5 100644 --- a/versioncontrol/git.groovy +++ b/versioncontrol/git.groovy @@ -34,6 +34,29 @@ ArrayList gettaglist(String workingSetRootPath) { return taglist } +LinkedHashMap> getremoteshatagmap(String repositoryURL) { + def shatagliststring = clh.getCommandOutput("git ls-remote --tags --sort=-version:refname ${repositoryURL}") + def shataglist = shatagliststring.split('\\n') + + LinkedHashMap> shatagmap = new LinkedHashMap>() + for (shatag in shataglist) { + def shatagfields = shatag.split('\\t') + def sha = shatagfields[0].trim() + def tag = shatagfields[1].trim() + echo "sha: ${sha} tag: ${tag}" + if (shatagmap.get(sha) == null) { + def ArrayList taglist = new ArrayList() + taglist.add(tag) + shatagmap.put(sha, taglist) + } else { + def taglist = shatagmap.get(sha) + taglist.add(tag) + shatagmap.put(sha, taglist) + } + } + return shatagmap +} + @NonCPS def ArrayList sparsecheckoutconfig(ArrayList paths) { ArrayList sparsecheckoutpaths = new ArrayList()