導語
由於最近工作需要利用 Jenkins 遠程 API 操作 Jenkins 來完成一些列操作，就抽空研究了下如何利用 JAVA 操作 Jenkins API，實現對 Jenkins Job、View等等的增、刪、改、查操作。
系統環境：
- Java 版本：1.8
- Jenkins 版本：2.172
參考及項目地址：
- 本示例項目 Github 地址：https://github.com/my-dlq/blog-example/tree/master/jenkins/jenkins-api-demo
- Jenkins API wiki 地址：https://wiki.jenkins.io/display/JENKINS/Remote+access+API
- Jenkins-Java-Client Github 地址：https://github.com/jenkinsci/java-client-api
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();
}
}