本文转载自利用 Java 操作 Jenkins API 实现对 Jenkins 的控制详解

导语

由于最近工作需要利用 Jenkins 远程 API 操作 Jenkins 来完成一些列操作,就抽空研究了下如何利用 JAVA 操作 Jenkins API,实现对 Jenkins Job、View等等的增、删、改、查操作。

系统环境:

  • Java 版本:1.8
  • Jenkins 版本:2.172

参考及项目地址:

Jenkins API

Jenkins API 简介

Jenkins 远程 API 能够通过 Http 协议远程调用相关命令操作 Jenkins 进行 Jenkins 视图、任务、插件、构建信息、任务日志信息、统计信息等,非常容易与其配合更好的完成 CI/CD 工作。

Jenkins API 格式

Jenkins API 总共有三种格式,分别为:

  • JSON API
  • XML API
  • Python API

Jenkins 查看 API 信息

可以用浏览器打开你的 Jenkins UI 界面,然后 URL 地址栏后面追加 “/api/json” 或者 “/api/xml” ,效果如下:

  • “JenkinsURL/api/json” 显示:
<hudson _class='hudson.model.Hudson'>
<assignedLabel>
<name>master</name>
</assignedLabel>
<mode>NORMAL</mode>
<nodeDescription>Jenkins的master节点</nodeDescription>
<nodeName></nodeName>
<numExecutors>1</numExecutors>
<job _class='org.jenkinsci.plugins.workflow.job.WorkflowJob'>
<name>deploy-test2</name>
<url>http://127.0.0.1:8080/jenkins/job/deploy-test2/</url>
<color>red</color>
</job>
<job _class='org.jenkinsci.plugins.workflow.job.WorkflowJob'>
<name>test-job</name>
<url>http://127.0.0.1:8080/jenkins/job/test-job/</url>
<color>blue</color>
</job>
<quietingDown>false</quietingDown>
<slaveAgentPort>50000</slaveAgentPort>
<unlabeledLoad _class='jenkins.model.UnlabeledLoadStatistics'></unlabeledLoad>
<useCrumbs>false</useCrumbs>
<useSecurity>true</useSecurity>
<view _class='hudson.model.AllView'>
<name>all</name>
<url>http://127.0.0.1:8080/jenkins/</url>
</view>
</hudson>
  • “JenkinsURL/api/xml” 显示:
{
"_class": "hudson.model.Hudson",
"assignedLabels": [
{
"name": "master"
}
],
"mode": "NORMAL",
"nodeDescription": "Jenkins的master节点",
"nodeName": "",
"numExecutors": 1,
"description": null,
"jobs": [
{
"_class": "org.jenkinsci.plugins.workflow.job.WorkflowJob",
"name": "deploy-test2",
"url": "http://127.0.0.1:8080/jenkins/job/deploy-test2/",
"color": "red"
},
{
"_class": "org.jenkinsci.plugins.workflow.job.WorkflowJob",
"name": "test-job",
"url": "http://127.0.0.1:8080/jenkins/job/test-job/",
"color": "blue"
}
],
"overallLoad": {},
"primaryView": {
"_class": "hudson.model.AllView",
"name": "all",
"url": "http://127.0.0.1:8080/jenkins/"
},
"quietingDown": false,
"slaveAgentPort": 50000,
"unlabeledLoad": {
"_class": "jenkins.model.UnlabeledLoadStatistics"
},
"useCrumbs": false,
"useSecurity": true,
"views": [
{
"_class": "hudson.model.AllView",
"name": "all",
"url": "http://192.168.2.11:8080/jenkins/"
}
]
}

还可以访问 View、Job等 API 信息,例如:

  • View API: /view//api/json
  • Job API: /job//api/xml
  • build API: /job///

调用接口前对 Jenkins 参数调整

关闭 CSRF

由于在调用 Jenkins 中,操作执行 Job 一些命令时会用到 Post 方式命令,所以需要关闭 Jenkins 的 CSRF 选项。

关闭 系统管理->全局安全配置->跨站请求伪造保护 选项

系统设置中和 jenkins 地址一致

设置 系统管理->系统设置->Jenkins Location 的 URL 和 Jenkins 访问地址保持一致

使用 Java 调用 Jenkins API 示例

下面将演示如何通过 Java 调用 Jenkins API 来对 Jenkins 进行操作,在注释中有详细描述,就不在外面一步步说明了。

本示例项目 Github 地址:https://github.com/my-dlq/blog-example/tree/master/jenkins-api-demo

Maven 引入工具

在 Jenkins Github 中查找到已经有人做了封装调用 Jenkins API 的工具 Jar,这里只需要我们 Maven 中引入这个工具 java-client-api,就可以方便的调用 Jenkins API 了。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion> <groupId>club.mydlq</groupId>
<artifactId>jenkins-api-demo</artifactId>
<version>0.0.1</version>
<name>jenkins-api-demo</name>
<description>jenkins api demo</description> <properties>
<java.version>1.8</java.version>
</properties> <dependencies>
<!--jenkins-java-client-->
<dependency>
<groupId>com.offbytwo.jenkins</groupId>
<artifactId>jenkins-client</artifactId>
<version>0.3.8</version>
</dependency>
</dependencies> </project>

连接 Jenkins 工具类

此类主要用于连接 Jenkins

JenkinsConnect.java

import com.offbytwo.jenkins.JenkinsServer;
import com.offbytwo.jenkins.client.JenkinsHttpClient;
import java.net.URI;
import java.net.URISyntaxException; /**
* 连接 Jenkins
*/
public class JenkinsConnect { private JenkinsConnect(){} // 连接 Jenkins 需要设置的信息
static final String JENKINS_URL = "http://192.168.2.11:8080/jenkins/";
static final String JENKINS_USERNAME = "admin";
static final String JENKINS_PASSWORD = "123456"; /**
* Http 客户端工具
*
* 如果有些 API 该Jar工具包未提供,可以用此Http客户端操作远程接口,执行命令
* @return
*/
public static JenkinsHttpClient getClient(){
JenkinsHttpClient jenkinsHttpClient = null;
try {
jenkinsHttpClient = new JenkinsHttpClient(new URI(JENKINS_URL), JENKINS_USERNAME, JENKINS_PASSWORD);
} catch (URISyntaxException e) {
e.printStackTrace();
}
return jenkinsHttpClient;
} /**
* 连接 Jenkins
*/
public static JenkinsServer connection() {
JenkinsServer jenkinsServer = null;
try {
jenkinsServer = new JenkinsServer(new URI(JENKINS_URL), JENKINS_USERNAME, JENKINS_PASSWORD);
} catch (URISyntaxException e) {
e.printStackTrace();
}
return jenkinsServer;
}
}

操作视图

此类主要用于操作 Jenkins 中的 View

ViewApi.java

import com.offbytwo.jenkins.JenkinsServer;
import com.offbytwo.jenkins.client.JenkinsHttpClient;
import com.offbytwo.jenkins.model.View;
import java.io.IOException; /**
* View(视图) 相关操作
*
* 例如对视图的增、删、改、查等操作
*/
public class ViewApi { // Jenkins 对象
private JenkinsServer jenkinsServer;
// http 客户端对象
private JenkinsHttpClient jenkinsHttpClient; /**
* 构造方法中调用连接 Jenkins 方法
*/
ViewApi() {
JenkinsApi jenkinsApi = new JenkinsApi();
// 连接 Jenkins
jenkinsServer = JenkinsConnect.connection();
// 设置客户端连接 Jenkins
jenkinsHttpClient = JenkinsConnect.getClient();
} /**
* 创建视图
*/
public void createView() {
try {
// 创建一个 xml 字符串,里面设置一个 view 描述信息
String xml = "<listView _class=\"hudson.model.ListView\">\n" +
"<description>用于测试的视图</description>\n" +
"</listView>";
// 创建 view
jenkinsServer.createView("test-view", xml);
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 获取视图基本信息
*/
public void getView() {
try {
// 视图名
String viewName = "test-view";
// 获取视图基本信息
View view = jenkinsServer.getView(viewName);
System.out.println(view.getName());
System.out.println(view.getUrl());
System.out.println(view.getDescription());
// 获取视图xml信息
String viewXml = jenkinsHttpClient.get("/view/" + viewName + "/api/xml");
System.out.println(viewXml);
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 获取视图配置 XML 信息
*/
public void getViewConfig() {
try {
// 视图名
String viewName = "test-view";
// 获取视图配置xml信息
String viewConfigXml = jenkinsHttpClient.get("/view/" + viewName + "/config.xml");
System.out.println(viewConfigXml);
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 更新视图信息
*/
public void updateView() {
try {
// 创建一个 xml 字符串,里面设置一个要修改的某些字段,具体xml可以到jenkins查看
// 例如,下面xml文件是从地址:https://Jenkins-IP/jenkins/view/test-view/config.xml 获取的
String xml = "<hudson.model.ListView>\n" +
"<name>test-view</name>\n" +
"<description>用于测试的视图1111</description>\n" +
"<filterExecutors>false</filterExecutors>\n" +
"<filterQueue>false</filterQueue>\n" +
"<properties class=\"hudson.model.View$PropertyList\"/>\n" +
"<jobNames>\n" +
"<comparator class=\"hudson.util.CaseInsensitiveComparator\"/>\n" +
"</jobNames>\n" +
"<jobFilters/>\n" +
"<columns>\n" +
"<hudson.views.StatusColumn/>\n" +
"<hudson.views.WeatherColumn/>\n" +
"<hudson.views.JobColumn/>\n" +
"<hudson.views.LastSuccessColumn/>\n" +
"<hudson.views.LastFailureColumn/>\n" +
"<hudson.views.LastDurationColumn/>\n" +
"<hudson.views.BuildButtonColumn/>\n" +
"<hudson.plugins.favorite.column.FavoriteColumn plugin=\"favorite@2.3.2\"/>\n" +
"</columns>\n" +
"<recurse>false</recurse>\n" +
"</hudson.model.ListView>";
jenkinsServer.updateView("test-view", xml);
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 删除视图
*/
public void deleteView() {
try {
String viewName = "test-view";
jenkinsHttpClient.post("/view/" + viewName + "/doDelete");
} catch (IOException e) {
e.printStackTrace();
}
} public static void main(String[] args) {
ViewApi viewApi = new ViewApi();
// 创建视图
//viewApi.createView();
// 获取视图信息
//viewApi.getView();
// 获取视图配置xml信息
//viewApi.getViewConfig();
// 更新视图信息
//viewApi.updateView();
// 删除视图
//viewApi.deleteView();
}
}

操作任务

此类主要用于操作 Jenkins 中的 Job

JobApi.java

import com.offbytwo.jenkins.JenkinsServer;
import com.offbytwo.jenkins.client.JenkinsHttpClient;
import com.offbytwo.jenkins.model.Build;
import com.offbytwo.jenkins.model.Job;
import com.offbytwo.jenkins.model.JobWithDetails;
import com.offbytwo.jenkins.model.MavenJobWithDetails;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map; /**
* Job(任务) 相关操作
*
* 例如对任务的增、删、改、查等操作
*/
public class JobApi { // Jenkins 对象
private JenkinsServer jenkinsServer;
// http 客户端对象
private JenkinsHttpClient jenkinsHttpClient; /**
* 构造方法中调用连接 Jenkins 方法
*/
JobApi() {
JenkinsApi jenkinsApi = new JenkinsApi();
// 连接 Jenkins
jenkinsServer = JenkinsConnect.connection();
// 设置客户端连接 Jenkins
jenkinsHttpClient = JenkinsConnect.getClient();
} /**
* 创建 Job
*/
public void ceateJob(){
try {
/**创建一个流水线任务,且设置一个简单的脚本**/
// 创建 Pipeline 脚本
String script = "node(){ \n" +
"echo 'hello world!' \n" +
"}";
// xml配置文件,且将脚本加入到配置中
String xml = "<flow-definition plugin=\"workflow-job@2.32\">\n" +
"<description>测试项目</description>\n" +
"<definition class=\"org.jenkinsci.plugins.workflow.cps.CpsFlowDefinition\" plugin=\"workflow-cps@2.66\">\n" +
"<script>" + script + "</script>\n" +
"<sandbox>true</sandbox>\n" +
"</definition>\n" +
"</flow-definition>";
// 创建 Job
jenkinsServer.createJob("test-job",xml);
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 更新 Job
*
* 更改之前创建的无参数Job,更改其为参数Job
*/
public void updateJob(){
try {
/**
* 更改一个流水线任务,让一个无参数的任务变成带参数任务
*/
// 创建 Pipeline 脚本,用一个key变量
String script = "node(){ \n" +
"echo \"${key}\" \n" +
"}";
// xml配置文件,且将脚本加入到配置中
String xml = "<flow-definition plugin=\"workflow-job@2.32\">\n" +
"<actions/>\n" +
"<description>测试项目</description>\n" +
"<keepDependencies>false</keepDependencies>\n" +
"<properties>\n" +
"<hudson.model.ParametersDefinitionProperty>\n" +
"<parameterDefinitions>\n" +
"<hudson.model.StringParameterDefinition>\n" +
"<name>key</name>\n" +
"<description>用于测试的字符变量</description>\n" +
"<defaultValue>hello</defaultValue>\n" +
"<trim>false</trim>\n" +
"</hudson.model.StringParameterDefinition>\n" +
"</parameterDefinitions>\n" +
"</hudson.model.ParametersDefinitionProperty>\n" +
"</properties>\n" +
"<definition class=\"org.jenkinsci.plugins.workflow.cps.CpsFlowDefinition\" plugin=\"workflow-cps@2.66\">\n" +
"<script>" + script + "</script>\n" +
"<sandbox>true</sandbox>\n" +
"</definition>\n" +
"<disabled>false</disabled>\n" +
"</flow-definition>";
// 创建 Job
jenkinsServer.updateJob("test-job",xml);
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 获取 Job 基本信息
*/
public void getJob(){
try {
// 获取 Job 信息
JobWithDetails job = jenkinsServer.getJob("test-job");
// 获取 Job 名称
System.out.println(job.getName());
// 获取 Job URL
System.out.println(job.getUrl());
// 获取 Job 下一个 build 编号
System.out.println(job.getNextBuildNumber());
// 获取 Job 显示的名称
System.out.println(job.getDisplayName());
// 输出 Job 描述信息
System.out.println(job.getDescription());
// 获取 Job 下游任务列表
System.out.println(job.getDownstreamProjects());
// 获取 Job 上游任务列表
System.out.println(job.getUpstreamProjects());
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 获取 Maven Job 信息
*/
public void getMavenJob(){
try {
// 获取 Job 信息
MavenJobWithDetails job = jenkinsServer.getMavenJob("test-job");
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 获取 Job 列表
*/
public void getJobList(){
try {
// 获取 Job 列表
Map<String,Job> jobs = jenkinsServer.getJobs();
for (Job job:jobs.values()){
System.out.println(job.getName());
}
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 获取 View 名称获取 Job 列表
*/
public void getJobListByView(){
try {
// 获取 Job 列表
Map<String,Job> jobs = jenkinsServer.getJobs("all");
for (Job job:jobs.values()){
System.out.println(job.getName());
}
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 查看 Job XML 信息
*/
public void getJobConfig(){
try {
String xml = jenkinsServer.getJobXml("test-job");
System.out.println(xml);
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 执行无参数 Job build
*/
public void buildJob(){
try {
jenkinsServer.getJob("test-job").build();
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 执行带参数 Job build
*/
public void buildParamJob(){
try {
/**
* 例如,现有一个job,拥有一个字符参数"key"
* 现在对这个值进行设置,然后执行一个输出这个值的脚本
*/
// 设置参数值
Map<String,String> param = new HashMap<>();
param.put("key","hello world!");
// 执行 build 任务
jenkinsServer.getJob("test-job").build(param);
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 停止最后构建的 Job Build
*/
public void stopLastJobBuild(){
try {
// 获取最后的 build 信息
Build build = jenkinsServer.getJob("test-job").getLastBuild();
// 停止最后的 build
build.Stop();
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 删除 Job
*/
public void deleteJob(){
try {
jenkinsServer.deleteJob("test-job");
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 禁用 Job
*/
public void disableJob(){
try {
jenkinsServer.disableJob("test-job");
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 启用 Job
*/
public void enableJob(){
try {
jenkinsServer.enableJob("test-job");
} catch (IOException e) {
e.printStackTrace();
}
} public static void main(String[] args) {
JobApi jobApi = new JobApi();
// 创建 Job
jobApi.ceateJob();
// 构建无参数的 Job
jobApi.buildJob();
// 构建带参数的 Job
jobApi.buildParamJob();
// 停止最后构建的 Job Build
jobApi.stopLastJobBuild();
// 更新 Job
jobApi.updateJob();
// 获取 Job 信息
jobApi.getJob();
// 获取 Maven 项目 Job
jobApi.getMavenJob();
// 获取 Job 配置xml
jobApi.getJobConfig();
// 获取全部 Job 列表
jobApi.getJobList();
// 根据 view 名称获取 Job 列表
jobApi.getJobListByView();
// 禁用 Job
jobApi.disableJob();
// 启用 Job
jobApi.enableJob();
// 删除 Job
jobApi.deleteJob();
} }

操作编译

此类主要用于操作 Jenkins 中的 Build

JobBuildApi.java

import com.offbytwo.jenkins.JenkinsServer;
import com.offbytwo.jenkins.client.JenkinsHttpClient;
import com.offbytwo.jenkins.helper.Range;
import com.offbytwo.jenkins.model.*;
import java.io.IOException;
import java.util.List; /**
* Job Build(任务构建) 相关操作
*
* 例如对任务 Build 相关的信息进行获取操作、例如获取构建日志
*/
public class JobBuildApi { // Jenkins 对象
private JenkinsServer jenkinsServer;
// http 客户端对象
private JenkinsHttpClient jenkinsHttpClient; /**
* 构造方法中调用连接 Jenkins 方法
*/
JobBuildApi() {
JenkinsApi jenkinsApi = new JenkinsApi();
// 连接 Jenkins
jenkinsServer = JenkinsConnect.connection();
// 设置客户端连接 Jenkins
jenkinsHttpClient = JenkinsConnect.getClient();
} /**
* 获取 Job 最后的 Build
*/
public void getJobLastBuild(){
try {
// 获取 Job 信息
JobWithDetails job = jenkinsServer.getJob("test-job");
// 获得最后编译信息
Build lastBuild = job.getLastBuild();
// 获取最后成功的编译信息
Build lastSuccessfulBuild = job.getLastSuccessfulBuild();
// 获取最后事变的编译信息
Build lastFailedBuild = job.getLastFailedBuild();
// 获取最后完成的编译信息
Build lastCompletedBuild = job.getLastCompletedBuild();
// 获取最后稳定的编译信息
Build lastStableBuild = job.getLastStableBuild();
// 获取最后不稳定的编译信息
Build lastUnstableBuild = job.getLastUnstableBuild();
// 获取最后未成功的编译信息
Build lastUnsuccessfulBuild = job.getLastUnsuccessfulBuild();
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 获取 Job 首次 Build
*/
public void getJobFirstBuild(){
try {
// 获取 Job 信息
JobWithDetails job = jenkinsServer.getJob("test-job");
// 获得首次编译信息
Build firstBuild = job.getFirstBuild();
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 根据 Job Build 编号获取编译信息
*/
public void getJobByNumber(){
try {
// 获取 Job 信息
JobWithDetails job = jenkinsServer.getJob("test-job");
// 根据
Build numberBuild = job.getBuildByNumber(1);
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 获取全部 Job Build列表
*/
public void getJobBuildListAll(){
try {
// 获取 Job 信息
JobWithDetails job = jenkinsServer.getJob("test-job");
// 获取全部 Build 信息
List<Build> builds = job.getAllBuilds();
for (Build build:builds){
System.out.println(build.getNumber());
}
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 获取 Job 一定范围的 Build 列表
*/
public void getJobBuildListRange(){
try {
// 获取 Job 信息
JobWithDetails job = jenkinsServer.getJob("test-job");
// 设定范围
Range range = Range.build().from(1).to(2);
System.err.println(range.getRangeString());
// 获取一定范围的 Build 信息
List<Build> builds = job.getAllBuilds(range);
for (Build build:builds){
System.out.println(build.getNumber());
}
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 获取 Build 基本信息
*/
public void getJobBuildInfo(){
try {
// 获取 Job 信息
JobWithDetails job = jenkinsServer.getJob("test-job");
// 这里用最后一次编译来示例
Build build = job.getLastBuild();
// 获取构建的 URL 地址
System.out.println(build.getUrl());
// 获取构建编号
System.out.println(build.getNumber());
// 获取测试报告
//build.getTestReport();
// 获取测试结果
//build.getTestResult();
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 获取 Build 详细信息
*/
public void getJobBuildDetailInfo(){
try {
// 获取 Job 信息
JobWithDetails job = jenkinsServer.getJob("test-job");
// 这里用最后一次编译来示例
BuildWithDetails build = job.getLastBuild().details();
// 获取构建的显示名称
System.out.println(build.getDisplayName());
// 获取构建的参数信息
System.out.println(build.getParameters());
// 获取构建编号
System.out.println(build.getNumber());
// 获取构建结果,如果构建未完成则会显示为null
System.out.println(build.getResult());
// 获取执行构建的活动信息
System.out.println(build.getActions());
// 获取构建持续多少时间(ms)
System.out.println(build.getDuration());
// 获取构建开始时间戳
System.out.println(build.getTimestamp());
// 获取构建头信息,里面包含构建的用户,上游信息,时间戳等
List<BuildCause> buildCauses = build.getCauses();
for (BuildCause bc:buildCauses){
System.out.println(bc.getUserId());
System.out.println(bc.getShortDescription());
System.out.println(bc.getUpstreamBuild());
System.out.println(bc.getUpstreamProject());
System.out.println(bc.getUpstreamUrl());
System.out.println(bc.getUserName());
}
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 获取 Build Log 日志信息
*/
public void getJobBuildLog(){
try {
// 获取 Job 信息
JobWithDetails job = jenkinsServer.getJob("test-job");
// 这里用最后一次编译来示例
BuildWithDetails build = job.getLastBuild().details();
// 获取构建的日志,如果正在执行构建,则会只获取已经执行的过程日志 // Text格式日志
System.out.println(build.getConsoleOutputText());
// Html格式日志
System.out.println(build.getConsoleOutputHtml()); // 获取部分日志,一般用于正在执行构建的任务
ConsoleLog consoleLog = build.getConsoleOutputText(0);
// 获取当前日志大小
System.out.println(consoleLog.getCurrentBufferSize());
// 是否已经构建完成,还有更多日志信息
System.out.println(consoleLog.getHasMoreData());
// 获取当前截取的日志信息
System.out.println(consoleLog.getConsoleLog());
}catch (IOException e) {
e.printStackTrace();
}
} /**
* 获取正在执行构建任务的日志信息
*/
public void getBuildActiveLog(){
try {
// 这里用最后一次编译来示例
BuildWithDetails build = jenkinsServer.getJob("test-job").getLastBuild().details();
// 当前日志
ConsoleLog currentLog = build.getConsoleOutputText(0);
// 输出当前获取日志信息
System.out.println(currentLog.getConsoleLog());
// 检测是否还有更多日志,如果是则继续循环获取
while (currentLog.getHasMoreData()){
// 获取最新日志信息
ConsoleLog newLog = build.getConsoleOutputText(currentLog.getCurrentBufferSize());
// 输出最新日志
System.out.println(newLog.getConsoleLog());
currentLog = newLog;
// 睡眠1s
Thread.sleep(1000);
}
}catch (IOException | InterruptedException e) {
e.printStackTrace();
}
} public static void main(String[] args) {
JobBuildApi jobBuildApi = new JobBuildApi();
// 获取 Job 最后的 Build
jobBuildApi.getJobLastBuild();
// 获取 Job 首次 Build
jobBuildApi.getJobFirstBuild();
// 根据 Job Build 编号获取编译信息
jobBuildApi.getJobByNumber();
// 获取 Build 全部列表
jobBuildApi.getJobBuildListAll();
// 获取一定范围的 Build 列表
jobBuildApi.getJobBuildListRange();
// 获取 Build 基本信息
jobBuildApi.getJobBuildInfo();
// 获取 Build 详细信息
jobBuildApi.getJobBuildDetailInfo();
// 获取 Build Log 日志信息
jobBuildApi.getJobBuildLog();
// 获得正在执行的编译 Log 日志信息
jobBuildApi.getBuildActiveLog();
}
}

其它 Jenkins 相关操作

此类主要用于操作 Jenkins 中的基本信息,例如关闭 Jenkins、获取 Jenkins 插件信息等。

JenkinsApi.java

import java.io.IOException;
import com.offbytwo.jenkins.JenkinsServer;
import com.offbytwo.jenkins.model.*;
import java.util.List;
import java.util.Map; /**
* 获取 Jenkins 相关信息
*
* 例如获取插件信息、获取Label信息、关闭Jenkins等
*/
public class JenkinsApi { // Jenkins 对象
private JenkinsServer jenkinsServer; /**
* 构造方法中调用连接 Jenkins 方法
*/
JenkinsApi(){
jenkinsServer = JenkinsConnect.connection();
} /**
* 获取主机信息
*/
public void getComputerInfo() {
try {
Map<String, Computer> map = jenkinsServer.getComputers();
for (Computer computer : map.values()) {
// 获取当前节点-节点名称
System.out.println(computer.details().getDisplayName());
// 获取当前节点-执行者数量
System.out.println(computer.details().getNumExecutors());
// 获取当前节点-执行者详细信息
List<Executor> executorList = computer.details().getExecutors();
// 查看当前节点-是否脱机
System.out.println(computer.details().getOffline());
// 获得节点的全部统计信息
LoadStatistics loadStatistics = computer.details().getLoadStatistics();
// 获取节点的-监控数据
Map<String, Map> monitorData = computer.details().getMonitorData();
//......
}
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 重启 Jenkins
*/
public void restart() {
try {
jenkinsServer.restart(true);
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 安全重启 Jenkins
*/
public void safeRestart() {
try {
jenkinsServer.safeRestart(true);
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 安全结束 Jenkins
*/
public void safeExit() {
try {
jenkinsServer.safeExit(true);
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 关闭 Jenkins 连接
*/
public void close() {
jenkinsServer.close();
} /**
* 根据 Label 查找代理节点信息
*/
public void getLabelNodeInfo() {
try {
LabelWithDetails labelWithDetails = jenkinsServer.getLabel("jnlp-agent");
// 获取标签名称
System.out.println(labelWithDetails.getName());
// 获取 Cloud 信息
System.out.println(labelWithDetails.getClouds());
// 获取节点信息
System.out.println(labelWithDetails.getNodeName());
// 获取关联的 Job
System.out.println(labelWithDetails.getTiedJobs());
// 获取参数列表
System.out.println(labelWithDetails.getPropertiesList());
// 是否脱机
System.out.println(labelWithDetails.getOffline());
// 获取描述信息
System.out.println(labelWithDetails.getDescription());
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 判断 Jenkins 是否运行
*/
public void isRunning() {
boolean isRunning = jenkinsServer.isRunning();
System.out.println(isRunning);
} /**
* 获取 Jenkins 插件信息
*/
public void getPluginInfo(){
try {
PluginManager pluginManager =jenkinsServer.getPluginManager();
// 获取插件列表
List<Plugin> plugins = pluginManager.getPlugins();
for (Plugin plugin:plugins){
// 插件 wiki URL 地址
System.out.println(plugin.getUrl());
// 版本号
System.out.println(plugin.getVersion());
// 简称
System.out.println(plugin.getShortName());
// 完整名称
System.out.println(plugin.getLongName());
// 是否支持动态加载
System.out.println(plugin.getSupportsDynamicLoad());
// 插件依赖的组件
System.out.println(plugin.getDependencies());
}
} catch (IOException e) {
e.printStackTrace();
}
} public static void main(String[] args) {
// 创建 JenkinsApi 对象,并在构造方法中连接 Jenkins
JenkinsApi jenkinsApi = new JenkinsApi();
// 重启 Jenkins
//jenkinsApi.restart();
// 安全重启 Jenkins
//jenkinsApi.safeRestart();
// 获取节点信息
//jenkinsApi.getComputerInfo();
// 安全结束 Jenkins
//jenkinsApi.safeExit();
// 关闭 Jenkins 连接
//jenkinsApi.close();
// 获取 Label 节点信息
//jenkinsApi.getLabelNodeInfo();
// 查看 Jenkins 是否允许
//jenkinsApi.isRunning();
// 获取 Jenkins 插件信息
//jenkinsApi.getPluginInfo();
} }

利用 Java 操作 Jenkins API 实现对 Jenkins 的控制详解的更多相关文章

  1. windows下Redis安装及利用java操作Redis

    一.windows下Redis安装 1.Redis下载 下载地址:https://github.com/MicrosoftArchive/redis 打开下载地址后,选择版本 然后选择压缩包 下载 R ...

  2. 利用JAVA操作Redis---demo

    package com.js.ai.modules.pointwall.interfac; import java.util.HashMap; import java.util.Iterator; i ...

  3. c#调用js,以及js调用C#里的函数, c#自己生成js代码,实现对web的控制

    using mshtml;using System;using System.Collections.Generic;using System.Linq;using System.Security.P ...

  4. (转)java之Spring(IOC)注解装配Bean详解

    java之Spring(IOC)注解装配Bean详解   在这里我们要详细说明一下利用Annotation-注解来装配Bean. 因为如果你学会了注解,你就再也不愿意去手动配置xml文件了,下面就看看 ...

  5. Java NIO 的前生今世 之四 NIO Selector 详解

    Selector Selector 允许一个单一的线程来操作多个 Channel. 如果我们的应用程序中使用了多个 Channel, 那么使用 Selector 很方便的实现这样的目的, 但是因为在一 ...

  6. 史上!最最最简洁明了的 Java JDK 安装目录及其子目录含义 10分钟详解 - 精简归纳

    Java JDK 安装目录及其子目录含义 10分钟详解 - 精简归纳 JERRY_Z. ~ 2020 / 8 / 30 转载请注明出处!️ 目录 Java JDK 安装目录及其子目录含义 10分钟详解 ...

  7. 深入浅出 Java JDK 安装目录及其子目录含义 10分钟详解 - 精简归纳

    Java JDK 安装目录及其子目录含义 10分钟详解 - 精简归纳 JERRY_Z. ~ 2020 / 8 / 30 转载请注明出处!️ 目录 Java JDK 安装目录及其子目录含义 10分钟详解 ...

  8. 《手把手教你》系列技巧篇(二十七)-java+ selenium自动化测试- quit和close的区别(详解教程)

    1.简介 尽管有的小伙伴或者童鞋们觉得很简单,不就是关闭退出浏览器,但是宏哥还是把两个方法的区别说一下,不然遇到坑后根本不会想到是这里的问题. 2.源码 本文介绍webdriver中关于浏览器退出操作 ...

  9. 《手把手教你》系列技巧篇(三十八)-java+ selenium自动化测试-日历时间控件-下篇(详解教程)

    1.简介 理想很丰满现实很骨感,在应用selenium实现web自动化时,经常会遇到处理日期控件点击问题,手工很简单,可以一个个点击日期控件选择需要的日期,但自动化执行过程中,完全复制手工这样的操作就 ...

随机推荐

  1. require.js 入门学习 (share)

    以下内容转自阮一峰老师的网络日志:http://www.ruanyifeng.com/blog/2012/11/require_js.html 更多学习资源: require.js官网:http:// ...

  2. decimal类型保留两位小数

    oj.PriceTop =Math.Round(Convert.ToDecimal(reader["PriceTop"]),2);

  3. 随机获取Mysql数据表的一条或多条记录

    随机获得Mysql数据表的一条或多条记录有很多方法,下面我就以users(userId,userName,password......)表(有一百多万条记录)为例,对比讲解下几个方法效率问题: sel ...

  4. Android JSON,Gson,fastjson实现比较

    activity_main.xml <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android&qu ...

  5. 【原创】Libjpeg 库使用心得(一) JPEG图像DCT系数的获取和访问

    [原创]继续我的项目研究,现在采用Libjpeg库函数来进行处理,看了库函数之后发现C语言被这些人用的太牛了,五体投地啊...废话不多说,下面就进入正题. Libjpeg库在网上下载还是挺方便的,这里 ...

  6. oracle decode函数的用法

    含义解释: decode(字段,值1,返回值1,值2,返回值2,...值n,返回值n,缺省值) 用法如下:IF 字段=值1 返回 返回值1ELSIF 字段=值2 返回 返回值2 ......ELSIF ...

  7. 小议 - 来自《XX时代XX公司》的笔试编程题目

    经过几天的雾霾,魔都终于放晴了.哥投了几天的简历,希望找到一份.NET开发方面的岗位.也收到了几个面试邀请.这不应Ge老师的要求,选了个良辰吉日,带着身份证,学位证怀揣着2B青年的梦想来这个XX公司面 ...

  8. \(?0\d{2}[) -]?\d{8}正则表达式的解释

    正则表达式30分钟出现了这样一个正则表达式:(?0\d{2}[) -]?\d{8} "("和")"也是元字符,所以需要转义. ?匹配零或一次 (? 表示 出现( ...

  9. js实现带上传进度的文件上传

    //获取文件筐的文件集合 var files = document.getElementById("file1").files; //创建FormData对象 相当于参数集合 存储 ...

  10. liunx本地网卡流量监控

    作者:邓聪聪 公司网络异常,由于可监控设备有限,无法快速读取网络异常的设备,所以找到了这个办法,部署在服务端用以解决网络突发异常流量故障的查找! 环境:CentOS release 6.8 Linux ...