在促销/推广步骤中删除jenkins [英] Delete jenkins builds during Promote / promotion step
问题描述
Jenkins ：版本1.525
Jenkins服务器URL ： http://my.jenkins.server.com:9040
Linux Red Hat 5.3
Artifactory ：免费版本
Artifactory服务器网址： http：//my.artifactory.server：8081 / Artifactory
我成功能够在Jenkins中构建并将工件上传到各自存储库下的Artifactory服务器。
$ b 当构建发生时，工件（ProjectA-1.0.0.25.tar.gz）在libs-snapshot-local下进入Artifactory库。这里1.0.0表示应用程序/ jenkins作业的给定版本的主要版本，次要版本和临时版本：本例中的ProjectA。可以说25是构建编号
b
$ b当开发项目中的ProjectA构建稳定时，我们将该应用程序发行版的特定版本提升为INT或任何其他更高版本环境（QA / PrePROD等）。
在此推广过程中，我们只选择哪个版本来推广和使用Jenkins Promoted Build Plugin，我们能够成功完成。
现在，我们需要的是：
- 在升级过程中，我想调用一个Groovy脚本，该脚本将在ProjectA-1.0之后的ProjectA版本1.0.0中从Jenkins和Artifactory（libs-snapshot-local）删除所有Jenkins版本.0.25.tar.gz已成功升级为INT。促销部分现在工作正常;我需要的是一个Groovy脚本，它将删除Jenkins中的Jenkins构建版本（1.0.0.1到1.0.0.24和> = 1.0.0.25）以及Artifactory存储库（libs-snapshot-local）中的相关构件。
我们公司的想法是，一旦发布版本的构建被提升为应用程序，所有其他我们拥有的构建/构件（在Jenkins / Artifactory中） - 我们想要使用Groovy脚本永久删除。有人会问，如果我想推广一个不同的版本＃;在我们的例子中，我们不需要这个。简单的规则是，如果有人宣传ProjectA-1.0.0.25.tar.gz，那么删除其中build / artifact不是1.0.0.25的Jenkins和Artifactory中的ProjectA的构建/工件，并继续使用新版本1.1.0。
具有以下功能的脚本非常棒。
1.使用属性文件（jenkins.properties / artifactory.properties） - 它将包含一些有关主机名/用户名/密码等的变量（如有）。
2.使用REST API执行删除操作一个给定的应用程序/工作，并给予释放（对于EX 1.0.0）
3.可以用于Jenkins / Artifactory删除 - 如果在命令提示符下，我说使用这个（詹金斯）属性文件 - 或者说（Artifatory） - 在这两种情况下，应用程序和它的发布价值都是一样的。
4.我们知道，为了将构建推广到INT（使用Jenkins推广插件），我们将永远仅在libs-snapshot-release中从Jenkins服务器和Artifactory服务器删除。
现在如果有人将升级到QA（稍后），那么artifactory存储库将是（libs-stage-local）
换句话说，我们应该调用Groovy脚本，传递一些变量/值（REST）并告诉要删除哪个应用程序/作业以及它的构建版本是什么版本。然后，它将删除除用户将传递的所有构建（即1.0.0.25）之外的所有构建。
我对Groovy /使用REST API做新手这是Jenkins / Artifactory的删除工作。如果某人已经有任何脚本可以完成这种活动，并且可以共享，我会根据自己的设置对其进行调整，并在促销阶段查看是否可以看到上述行为。我在获得这个脚本的工作版本方面有一些时间紧迫，希望能够执行相同任务的一些脚本代码（而不是伟大的人告诉我要通过大文档/链接，我知道这会使我成为Groovy中更好的编码器但它会延迟这篇文章的全部目的）。
非常感谢。
最终答案：这包括使用Artifactor的REST API调用从Artifactory中删除构建工件。这个脚本将删除给定版本/版本的Jenkins / Artifactory构建/工件（有时候会这样 - 一个给定的Jenkins作业可以为例如2.75.0.1,2.75.0.2,2.75.0.3创建多个版本/版本构建。 ...，2.75.0.54,2.76.0.1,2.76.0.2，...，2.76.0.16,2.76.1.1,2.76.1.2，...，2.76.1.5）。在这种情况下，对于该作业的每个新版本，我们从1新鲜开始构建＃。如果您必须删除除一/全部以外的所有构建（根据自己的需要稍微更改脚本），并且不要更改旧版/其他版本构建，请使用以下脚本。
Scriptler目录链接： http：// scriptlerweb .appspot.com / script / show / 103001
享受！
/ *** BEGIN META {
name：批量删除除了给定的内部版本编号外，
comment：作业和给定的构建函数，只删除给定发布版本（Mminterim）的所有构建，除了用户提供的版本。有时Jenkins作业使用Build Name setter插件，同样的作业生成2.75.0.1和2.76.0.43，
parameters：['jobName'，'releaseVersion'，'buildNumber']，
core：1.409，
authors：[
{name： Arun Sangal - Maddys版本}
]
} END META ** /
导入groovy.json。*
导入jenkins.model。*;
导入hudson.model.Fingerprint.RangeSet;
导入hudson.model.Job;
导入hudson.model.Fingerprint;
//如果（！artifactoryURL）抛出新异常（artifactoryURL not provided）
if（！artifactoryUser）抛出新的参数，这些应该作为参数传递给脚本
例外（artifactoryUser not provided）
如果（！artifactoryPassword）抛出新的异常（artifactoryPassword not provided）
def authString =$ {artifactoryUser}：$ {artifactoryPassword}。getBytes（）。 encodeBase64（）。toString（）
def artifactorySettings = [artifactoryURL：artifactoryURL，authString：authString]
$ b $如果（！jobName）抛出新异常（jobName not provided）
如果（！buildNumber）抛出新的异常（buildNumber not provided）
$ b $ def lastBuildNumber = buildNumber.toInteger（） - 1;
def nextBuildNumber = buildNumber.toInteger（）+ 1;
def jij = jenkins.model.Jenkins.instance.getItem（jobName）;
$ b $ def promotedBuildRange = new Fingerprint.RangeSet（）
promoteBuildRange.add（buildNumber.toInteger（））
def promoteBuildsList = jij.getBuilds（promotedBuildRange）
assert promoteBuildsList .size（）== 1
def promoteBuild = promoteBuildsList [0]
// Jenkins作品的发布/版本 - 例如，如果你在Jenkins中使用Build namesetter插件获取构建2.75.0.1，2.75.0.2，..，2.75.0.15等
//并且随着时间的推移，将版本/版本值（2.75.0）更改为更新的值，即2.75.1或2.76.0并开始从＃1开始构建这个新版本。
def releaseVersion = promoteBuild.getDisplayName（）。split（\\\。）[0..2] .join（。）
println
println（ - Jenkins Job_Name：$ {jobName} - 版本：$ {releaseVersion} - 保留内部版本号：$ {buildNumber}）;
println
/ **从artifactory中删除指定的构建及其构件* /
def deleteBuildFromArtifactory（String jobName，int deleteBuildNumber，Map< String，String> artifactorySettings） {
println##删除>>>>>>>>>： - $ {jobName}：$ {deleteBuildNumber} from artifactory
def artifactSearchUri = api / build / $ {jobName}？buildNumbers = $ {deleteBuildNumber}& artifacts = 1
def conn =$ {artifactorySettings ['artifactoryURL']} / $ {artifactSearchUri}。toURL（）。openConnection （）
conn.setRequestProperty（Authorization，Basic+ artifactorySettings ['authString']）;
conn.setRequestMethod（DELETE）
if（conn.responseCode！= 200）{
println无法从artifactory中为$ {jobName} / $ {deleteBuildNumber}删除构建工件：$ {conn.responseCode} - $ {conn.responseMessage}
}
}
/ **删除指定范围内与releaseVersion * / $匹配的所有版本b $ b def deleteBuildsInRange（String buildRange，String releaseVersion，Job theJob，Map< String，String> artifactorySettings）{
def range = RangeSet.fromString（buildRange，true）;
theJob.getBuilds（范围）.each {
if（it.getDisplayName（）。find（/ $ {releaseVersion}。* /））{
println##删除>> ;>>>>>>>：+ it.getDisplayName（）;
deleteBuildFromArtifactory（theJob.name，it.number，artifactorySettings）
it.delete（）;
$ b //在升级的版本号之前删除所有匹配的版本
deleteBuildsInRange（1 - $ {lastBuildNumber}， releaseVersion，jij，artifactorySettings）
//删除升级版本号后的所有匹配版本
deleteBuildsInRange（$ {nextBuildNumber} - $ {jij.nextBuildNumber}，releaseVersion，jij， artifactorySettings）
println
println（ - 为上述版本成功删除了版本：$ {releaseVersion}）
println
Jenkins: Version 1.525
Jenkins Server URL: http://my.jenkins.server.com:9040
Linux Red Hat 5.3
Artifactory: Free version
Artifactory Server URL: http://my.artifactory.server:8081/Artifactory
I'm successfully able to build in Jenkins and upload artifacts to my Artifactory server under a respective repository.
When a build occurs, the artifacts (ProjectA-1.0.0.25.tar.gz) goes to Artifactory under libs-snapshot-local repository. Here 1.0.0 is denoting Major, minor and interim version of a given release for an application/jenkins job: "ProjectA" in this case. Lets say 25 is the build number
When ProjectA build gets stable in Development, we promote a given build of that application release to INT or any other higher environment (QA/PrePROD etc).
During this promotion process, we just select which build to promote and using Jenkins Promoted Build Plugin, we are able to do it successfully.
Now, what we need is:
- During the promote process, I want to call a Groovy script, which will delete all Jenkins builds from Jenkins and Artifactory (libs-snapshot-local) for ProjectA's release 1.0.0 after "ProjectA-1.0.0.25.tar.gz" is successfully promoted to INT. Promotion part is working fine right now; All I need is a Groovy script which will delete Jenkins builds (1.0.0.1 to 1.0.0.24 and >= 1.0.0.25) in Jenkins and its associated artifacts from Artifactory repository (libs-snapshot-local).
Idea in our company is, once a release version's build is promoted for an application, all other builds / artifacts we have (in Jenkins/Artifactory) - we want to delete forever using a Groovy script. Someone will ask, what if I want to promote a different build#; well in our case, we dont want that. Simple rule is, if someone promotes ProjectA-1.0.0.25.tar.gz, then, delete ProjectA's builds / artifacts in Jenkins and Artifactory where build/artifact is other than 1.0.0.25 and continue with new release 1.1.0
The script with the following capability would be great.
1. Use property files (jenkins.properties / artifactory.properties) - which will contains some variables about hostname/username/password etc if any.
2. Use REST API to perform the deletion for a given application/job and given release (for ex 1.0.0)
3. Can be used for both Jenkins/Artifactory deletion - if at command prompt, I say use this (Jenkins) property file -or that (Artifatory) - as in both cases, application and its release value will be same.
4. We know that for promoting a build to INT (using Jenkins promote plugin), we'll always delete from Jenkins server and from Artifactory server only at libs-snapshot-release.
Now if someone does promotion to QA (at a later time), then artifactory repository will be (libs-stage-local)
In other words, we should call the Groovy script, pass some variables/values (REST) and tell which application/job to delete and what build release version it's. Then, it'll delete all builds except the one which a user will pass (i.e. 1.0.0.25)
I'm new to both Groovy / using REST API for doing this "deletion" piece of work for Jenkins/Artifactory. If someone already has any sample script that does this kind of activity and if you can share, I'll tweak it according to my settings and see if I can see the above mentioned behaviour during promotion step. I have some time crunch in getting a working version of this script, would appreciate some script code doing the same task (instead of great people telling me to go through big documentations/links, I know that'll make me a better coder in Groovy but it'll delay the whole purpose for this post).
Thanks a lot.
FINAL Answer: This includes deleting the build artifacts from Artifactory as well using Artifactor's REST API call. This script will delete Jenkins/Artifactory builds/artifacts of a given Release/Version (as sometimes over the time - a given Jenkins job can create multiple release / version builds for ex: 2.75.0.1, 2.75.0.2, 2.75.0.3,....,2.75.0.54, 2.76.0.1, 2.76.0.2, ..., 2.76.0.16, 2.76.1.1, 2.76.1.2, ...., 2.76.1.5). In this case, for every new release of that job, we start the build# from 1 fresh. If you have to delete the all builds except one / even all (change the script a little bit for your own needs) and don't change older/other release builds, then use the following script.
Scriptler Catalog link: http://scriptlerweb.appspot.com/script/show/103001
Enjoy!
/*** BEGIN META {
"name" : "Bulk Delete Builds except the given build number",
"comment" : "For a given job and a given build numnber, delete all builds of a given release version (M.m.interim) only and except the user provided one. Sometimes a Jenkins job use Build Name setter plugin and same job generates 2.75.0.1 and 2.76.0.43",
"parameters" : [ 'jobName', 'releaseVersion', 'buildNumber' ],
"core": "1.409",
"authors" : [
{ name : "Arun Sangal - Maddys Version" }
]
} END META **/
import groovy.json.*
import jenkins.model.*;
import hudson.model.Fingerprint.RangeSet;
import hudson.model.Job;
import hudson.model.Fingerprint;
//these should be passed in as arguments to the script
if(!artifactoryURL) throw new Exception("artifactoryURL not provided")
if(!artifactoryUser) throw new Exception("artifactoryUser not provided")
if(!artifactoryPassword) throw new Exception("artifactoryPassword not provided")
def authString = "${artifactoryUser}:${artifactoryPassword}".getBytes().encodeBase64().toString()
def artifactorySettings = [artifactoryURL: artifactoryURL, authString: authString]
if(!jobName) throw new Exception("jobName not provided")
if(!buildNumber) throw new Exception("buildNumber not provided")
def lastBuildNumber = buildNumber.toInteger() - 1;
def nextBuildNumber = buildNumber.toInteger() + 1;
def jij = jenkins.model.Jenkins.instance.getItem(jobName);
def promotedBuildRange = new Fingerprint.RangeSet()
promotedBuildRange.add(buildNumber.toInteger())
def promoteBuildsList = jij.getBuilds(promotedBuildRange)
assert promoteBuildsList.size() == 1
def promotedBuild = promoteBuildsList[0]
// The release / version of a Jenkins job - i.e. in case you use "Build name" setter plugin in Jenkins for getting builds like 2.75.0.1, 2.75.0.2, .. , 2.75.0.15 etc.
// and over the time, change the release/version value (2.75.0) to a newer value i.e. 2.75.1 or 2.76.0 and start builds of this new release/version from #1 onwards.
def releaseVersion = promotedBuild.getDisplayName().split("\\.")[0..2].join(".")
println ""
println("- Jenkins Job_Name: ${jobName} -- Version: ${releaseVersion} -- Keep Build Number: ${buildNumber}");
println ""
/** delete the indicated build and its artifacts from artifactory */
def deleteBuildFromArtifactory(String jobName, int deleteBuildNumber, Map<String, String> artifactorySettings){
println " ## Deleting >>>>>>>>>: - ${jobName}:${deleteBuildNumber} from artifactory"
def artifactSearchUri = "api/build/${jobName}?buildNumbers=${deleteBuildNumber}&artifacts=1"
def conn = "${artifactorySettings['artifactoryURL']}/${artifactSearchUri}".toURL().openConnection()
conn.setRequestProperty("Authorization", "Basic " + artifactorySettings['authString']);
conn.setRequestMethod("DELETE")
if( conn.responseCode != 200 ) {
println "Failed to delete the build artifacts from artifactory for ${jobName}/${deleteBuildNumber}: ${conn.responseCode} - ${conn.responseMessage}"
}
}
/** delete all builds in the indicated range that match the releaseVersion */
def deleteBuildsInRange(String buildRange, String releaseVersion, Job theJob, Map<String, String> artifactorySettings){
def range = RangeSet.fromString(buildRange, true);
theJob.getBuilds(range).each {
if ( it.getDisplayName().find(/${releaseVersion}.*/)) {
println " ## Deleting >>>>>>>>>: " + it.getDisplayName();
deleteBuildFromArtifactory(theJob.name, it.number, artifactorySettings)
it.delete();
}
}
}
//delete all the matching builds before the promoted build number
deleteBuildsInRange("1-${lastBuildNumber}", releaseVersion, jij, artifactorySettings)
//delete all the matching builds after the promoted build number
deleteBuildsInRange("${nextBuildNumber}-${jij.nextBuildNumber}", releaseVersion, jij, artifactorySettings)
println ""
println("- Builds have been successfully deleted for the above mentioned release: ${releaseVersion}")
println ""
这篇关于在促销/推广步骤中删除jenkins的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
