From ab3516d23dbe1987e910de8ff63f6e8732bcc52d Mon Sep 17 00:00:00 2001 From: Dan Hawkins Date: Wed, 2 Mar 2022 13:29:36 +0000 Subject: [PATCH] Squashed 'Common_scripts/' changes from 0326879..b70fe5f b70fe5f Remove debug release filtering 3730461 Debug release filtering db92ee3 Debug release filtering 2393146 Use releasetag script 54bf29f Attempt to separate dependent products and sub-components 3c4de23 Debugging script d93f942 Debugging script caf71e3 Debugging script c993ecc Debugging script 2e5b6b2 Debugging script 0ad763c Debugging script d5a178b Debugging script 01d91a7 Debugging script d2a22db Debugging script 30ac58d Debugging script 490b37b Debugging script 2939eaf Debugging script 35d3862 Debugging script defc807 Debugging script f2e3e52 Debugging script b5e2894 Debugging script c2faf8a Debugging script fa199eb Debugging script d418e5a Debugging script f34fb2e Debugging script 04e947c Debugging script 48d7b0f Debugging script 38b562b Debugging script ac5e7cd Debugging script 1d3f184 Debugging script b187d23 Debugging script 1131865 Debugging script 68cbc00 Debugging script 5771490 Debugging ed17de0 Debugging b1bc540 Debugging e6c6fcf Debugging 57eeaf4 Comment out code to debug later a576d64 Script reorg 32a3aed Supply release tag processing 01ce780 Supply release tag processing af3e22d Supply release tag processing b7c5a66 Supply release tag processing 4fbe1d9 Supply release tag processing 44b1e13 Supply release tag processing af3c041 Supply release tag processing 8b361de Supply release tag processing 89736f0 Supply release tag processing 70d569c Supply release tag processing d2b8d1b Supply release tag processing ce33f59 Supply release tag processing 88cba3b Supply release tag processing 80bc64e Supply release tag processing 6488203 Supply release tag processing c2b27a8 Merge commit 'cd98f833a8db023604d045d9343f18f3a423da5c' 704e499 Start adding dependencies 940a8d5 Start adding dependencies 4a46b8f Build up a tag map 0ca7886 Build up a tag map 3dbdf85 Build up a tag map fb72031 Build up a tag map be599cb Build up a tag map 462b177 Build up a tag map 453a14a Build up a tag map c5f01d0 Build up a tag map 11826a4 Get list of tags for each product release repo 3981ece Filter long name releases from version selection cad2d4e Filter long name releases from version selection 8bd075f Filter long name releases from version selection 20c5648 Merge commit '6633e04d0257e6d52427b2ff761c8a5625196346' as 'Common_scripts' 9a31beb Remove folder 2767e8a Rename folder a5ee31d New files 2c6a90d New files e5d8c38 Merge commit 'c1344e90845db3aa76de5f3d0fc93abb462f8782' as 'Commons_scripts' c1344e9 Squashed 'Commons_scripts/' content from commit 0326879 9171d4d Initial commit e5bca0d Initial commit git-subtree-dir: Common_scripts git-subtree-split: b70fe5f7bd258ba0c3be2eaeebb12403e01c460b --- meta/folder.groovy | 8 ++ product/info.groovy | 217 ++++++++++++++++++++++++++++++++ publish/promptingpublish.groovy | 34 ++--- release/tag.groovy | 39 ++++++ versioncontrol/git.groovy | 23 ++++ 5 files changed, 305 insertions(+), 16 deletions(-) create mode 100644 product/info.groovy create mode 100644 release/tag.groovy 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()