Jenkins China

The Jenkins AI expert is live!

Tue, 27 May 2025 00:00:00 +0000

Screenshots:

Using the Latest Version of a Gradle Dependency

Sat, 04 Nov 2023 00:00:00 +0000

If you configure a dependency in Gradle without specifying a version, the build fails with an error saying the dependency cannot be found. But when you have a lot of dependencies, you also have to trawl the repository one by one to see what the latest version of each library is.

So does Gradle support using the latest version of a dependency directly?

The answer is yes, though gradle’s documentation doesn’t flag it in any prominent place.

The trick is to put a plus sign + in the version field, and gradle will work out the latest version automatically and download it.

Once everything is pointed at the latest version, you can then work through the few remaining dependency-conflict errors from the log, which saves a great deal of effort.

Distinguishing the three different levels of dependencies in Gradle

Sat, 04 Nov 2023 00:00:00 +0000

Gradle is a very flexible and powerful build system, but its concepts are relatively complex. As long as you grasp the core and keep the distinctions straight, it will not feel confusing.

Does the build script below look hard to understand?

buildscript {
    repository for build script dependencies
    repositories {
        mavenCentral()
    }
    // build script dependencies
    dependencies {
        classpath 'com.android.tools.build:gradle:4.2.0'
    }
}
repositories {
    mavenCentral()
    jcenter()
    google()
}
dependencies {
    implementation 'com.google.guava:guava:30.1-jre'
    testImplementation 'junit:junit:4.13.2'
}  
plugins {
      id 'com.android.application'
      id 'org.jetbrains.kotlin.jvm' version '1.5.10'
}

DevOps involves a great many tools, and every one of them comes with lengthy documentation; rote memorization will not get you anywhere. The right path is to understand the terminology of the core concepts, tell the different objects apart, and grasp what the designers had in mind, until you reach the point where it all feels “a matter of course” and “naturally so”.

There are three principal entities in Gradle: gradle itself, the project (the one to be built with gradle), and the build script (the one written with gradle).

Because Gradle is an extensible build system, its build scripts are executable scripts as well, rather than the xml markup language used by Ant and Maven; so both of them have dependencies.

Of course, the project has dependencies too.

gradle’s own dependencies are called plugins: they extend gradle’s own functionality, just as IDEA has plugins and Jenkins has plugins. They are declared with plugins.

The project’s dependencies do not directly provide functionality; rather, the code you write in the project needs to rely on these libraries. They are declared with dependencies.

The gradle build script is declared with buildscript — the name says it all.

Once these concepts are clear, take another look at the build script below with comments added, and it becomes very easy to understand!

// build script configuration  
buildscript {
    repository for build script dependencies
    repositories {
        mavenCentral()
    }
    // build script dependencies
    dependencies {
        classpath 'com.android.tools.build:gradle:4.2.0'
    }
}
// repository for project dependencies
repositories {
    mavenCentral()
    jcenter()
    google()
}
// project dependencies configuration
dependencies {
    implementation 'com.google.guava:guava:30.1-jre'
    testImplementation 'junit:junit:4.13.2'
}  
// plugins that the gradle build tool depends on
plugins {
      id 'com.android.application'
      id 'org.jetbrains.kotlin.jvm' version '1.5.10'
}

Should Creating a Pipeline Be Called Setting Up, Configuring, or Developing?

Sat, 05 Aug 2023 00:00:00 +0000

Setting Up
Configuring
Developing
Summary

In the field of software development and continuous integration/delivery, Jenkins is a very popular tool for automating build, test and deployment processes. A Jenkins pipeline is a powerful mechanism that can automate the entire software delivery process by defining a series of stages, steps and conditions. However, when describing the process of creating a pipeline, which word should we use to describe it: setting up, configuring, or developing?

Setting Up

First, let’s look at the word “setting up”. Setting up is usually used to describe the process of building a framework or infrastructure. In this case, using “setting up” to describe the creation of a Jenkins pipeline is appropriate. The process of creating a pipeline is like setting up a framework: you need to define the pipeline’s structure, stages and steps. By choosing the right plugins and configuration options, you can set up a complete pipeline for automated software delivery. This process is similar to building the frame of a house and then filling it in with concrete content and logic.

Configuring

On the other hand, the word “configuring” emphasizes the process of defining a pipeline by filling in forms, selecting options and setting parameters. Through Jenkins’ graphical interface, you can configure each stage, step and condition, as well as define the rules for building and deploying. This process is more like configuring a system than building one from scratch. Therefore, using “configuring” to describe the creation of a Jenkins pipeline is accurate as well.

Developing

Finally, the word “developing” emphasizes the process of defining a pipeline with code. Jenkins provides support for a DSL (Domain Specific Language) and other programming languages, enabling you to define pipelines programmatically. By writing pipeline scripts, you can implement more complex logic and custom flow control. This process is similar to developing an application or software, so using “developing” to describe the creation of a pipeline is appropriate too.

Summary

In summary, we can draw the conclusion that the creation of a pipeline can be called “setting up”, can be called “configuring”, and can even be called “developing”. Which word you choose depends on which aspect you want to emphasize. If you care more about the technical nature of the creation process and the code-writing side of it, then “developing” or “setting up” may be more appropriate. If you care more about the configuration and settings side of the creation process, then “configuring” may be more appropriate.

Whichever word you choose, what matters is understanding the process of creating a Jenkins pipeline and how to achieve automated software delivery by defining pipelines. Whether you set up, configure or develop pipelines, Jenkins’ powerful features and flexibility will bring a more efficient and reliable delivery process to your project.

Jenkins Release Types and How to Choose One

Thu, 29 Jun 2023 00:00:00 +0000

Introduction to Jenkins
Jenkins releases
How to choose a Jenkins release

Introduction to Jenkins

Jenkins is a popular open-source continuous integration and delivery tool. It provides an extensible plugin ecosystem and can be used to automate the building, testing and deployment of software projects.

Jenkins releases

Jenkins releases fall into the following types:

LTS release: a Long-Term Support (LTS) release, published once every 12 weeks. These releases are extensively tested and validated and come with long-term support, and they are usually used in production environments. The LTS release cycle is relatively long, so LTS releases are comparatively stable and reliable.

Weekly release: a release published on a regular (weekly) basis. These releases contain the latest features and improvements, but may not be as stable as LTS releases. Weekly releases suit users who want to try out the newest features, but they are not recommended for production environments.

How to choose a Jenkins release

Which Jenkins release you choose depends on your needs and your use case:

If you want to use Jenkins in a production environment and have high requirements for stability and reliability, choose an LTS release. These releases have been tested and validated over a long period and have been widely adopted and used, so they offer better stability and reliability.
If you want to try the latest features and improvements and are less concerned about stability, you can choose a Weekly release. These releases contain the newest features and improvements, but there may be some unknown issues.

Whichever release you choose, it is advisable to validate and evaluate it in a test environment to make sure it meets your needs and expectations. In addition, upgrading to the latest release regularly is good practice, as it gives you the latest features and improvements and keeps the system secure and stable.

Jenkins FAQ Collection (Part 8)

Wed, 20 May 2020 00:00:00 +0000

Question 36: What is the relationship between Hudson and Jenkins?
Question 37: What are the similarities and differences between Jenkins plugins and shared libraries? When should I use a plugin and when should I use a shared library?
Question 38: Can Jenkins do everything?
Question 39: What is the relationship between slave, node, and agent, and are there any differences?
Question 40: How does Jenkins integrate with tools such as Ant and Maven?

Question 36: What is the relationship between Hudson and Jenkins?

Answer: Both are open-source continuous integration tools written in Java.

In fact, Jenkins is a fork of Hudson.

Hudson was started by Sun Microsystems in 2004, and its first version was released on java.net in 2005.

Starting in 2007, Hudson gradually took over the leading position held by CruiseControl and other open-source build tools.

At the 2008 JavaOne conference, it won the Duke’s Choice Award in the developer solutions category.

In November 2010, Oracle’s acquisition of Sun brought up the question of Hudson’s ownership.

Between the main project contributors and Oracle, although many agreements were reached, one key issue was the trademark name “Hudson”.

In December 2010, Oracle asserted that it owned the name and the right to apply for the trademark.

Therefore, on January 11, 2011, a vote was called to change the project name from “Hudson” to “Jenkins”.

On January 29, 2011, the proposal was approved by a community vote, and the Jenkins project was created.

On February 1, 2011, Oracle stated that it intended to continue developing Hudson, and considered Jenkins merely a branch rather than a rename.

As a result, Jenkins and Hudson went on as two independent projects, each considering the other a branch of itself.

By December 2013, Jenkins on GitHub had 567 project members and about 1,100 public repositories, compared with 32 project members and 17 public repositories for Hudson.

Today the differences between the two are greater still; Jenkins has clearly surpassed Hudson across the board.

In addition, perhaps out of a dislike of Oracle, as Java developers we naturally ought to support and use Jenkins.

From the logos of the two projects you can also see the kinship between them — both are two old men. Later Hudson was donated by Oracle to the Eclipse Foundation, so the Hudson old man has an Eclipse halo.

Hudson has stopped development and has not released a new version for years (the latest version was released in 2016), while the Jenkins community and development are exceptionally active, and Jenkins 2.x has extended it into the CD domain.

Jenkins 1 is already the most widely used CI/CD tool on the market today.

Question 37: What are the similarities and differences between Jenkins plugins and shared libraries? When should I use a plugin and when should I use a shared library?

Answer: A shared library is a feature that only Pipeline-type jobs can use.

Plugins focus on extending the functionality of the Jenkins system itself, and their scope is broader. For example, defining new job types (Pipeline itself is implemented through a plugin), new parameter types, new trigger types, new SCM types, new notification types, new authorization strategies, new cloud types, and so on.

Plugins can also define new build steps, which can be configured graphically in freestyle jobs and invoked through a DSL by optimizing compatibility with Pipeline jobs.

Pipeline also has a dedicated API for defining new DSL steps (which can only be invoked through code).

Plugins are written in Java and shared libraries are written in Groovy, and a shared library can in turn call the DSL steps provided by plugins.

Using a plugin requires installing the plugin package on the Jenkins master before it takes effect; to upgrade it, you also need to restart the master.

A shared library, by contrast, only needs its address to be configured in Jenkins before it can be used, and you can specify different branches to use. Changes to shared library code take effect in real time.

As a best practice, plugins provide generic tool-level steps (the building blocks), and shared libraries implement functional steps (assembling the blocks), combining steps and sharing them across multiple Jenkins jobs. It is similar to the relationship between an API and an APP.

Question 38: Can Jenkins do everything?

Answer: Be clear that Jenkins is an automation server. It can automate your operations, and automation mainly consists of three parts. The first is trigger automation: a Jenkins job can be triggered automatically according to certain rules, for example on a schedule, or when a change is committed to the code repository, or when the contents of the code repository change, and so on. The second is execution automation; the third is notification automation. The second part is defined by users themselves, and what makes Jenkins convenient is that it supports various ways of invoking automation scripts, such as ant, maven, sh, bat, powershell, python, groovy, and so on. The automation scripts themselves are something users have to write. Only after your operations have been reworked so that they can be carried out by automation scripts can you connect them to Jenkins and have it run them automatically. So a Jenkins engineer should be very familiar with automation principles and with the various automation scripting languages and automation tools, and should provide suggestions and guidance for the team’s automation work.

Question 39: What is the relationship between slave, node, and agent, and are there any differences?

Answer: Conceptually they are basically the same. agent can be seen as the new name for slave (because slave carries the meaning of “slave”…). In terms of usage, as Pipeline keywords they differ slightly. In scripted pipeline, node is used to specify the execution node; in declarative pipeline, the agent keyword is used, and under the agent keyword there are further keywords such as node, docker, and kubernetes.

Question 40: How does Jenkins integrate with tools such as Ant and Maven?

Answer: There are two ways to use this kind of build tool in Jenkins.

One is to pre-configure it in the Jenkins Global Tool Configuration, setting the tool name and path, and specifying the name when using it. The advantage of this approach is that Jenkins can automatically install the build tool on the agent machine and add the executable file to the PATH directory. The inconvenient part is that it requires pre-configuration, and when using it you need to explicitly specify the name; automatic installation also requires the machine to be able to access the external network.

The other approach is to install the corresponding tool in advance directly on the agent machine and configure its executable file into the system PATH directory. The advantage of this approach is that you can use the ant and mvn commands directly. The disadvantage is that it requires pre-installation, but it can also avoid job execution failures caused by a machine being unable to access the external network. Pre-installation also makes the agent environment more controllable. In practice, agent machines need a number of tools installed anyway, and this has been automated. Adding one more tool makes little difference to the workload.

If the Jenkins environment has external network access and Ant and Maven both use the default configuration (repository addresses, etc.), you can use the first approach. In other cases, the second approach is recommended.

This article was first published on the WeChat public account “DevOps持续交付” (DevOps Continuous Delivery), account ID: devopscd. You are welcome to follow.

Jenkinsclient Tutorial Series: Viewing Basic Information (Part 2)

Sun, 17 May 2020 00:00:00 +0000

1. Easter Egg — APP Mode
2. Show the Jenkins Server Version
3. Show the Current User
4. Show the Plugin List
5. Show the Job List
6. Show the Queue List
7. Show the Node List
8. Show the Credentials List

Once Jenkinsclient is configured, you can operate Jenkins through commands.

The command format of jenkinsclient is:

jenkins GROUP | COMMAND

GROUP refers to a group of commands. For example, job is a group command, and it provides the following commands:

jenkins job build   //build a job
jenkins job copy    //copy a job
jenkins job create  //create a job
jenkins job delete  //delete a job
jenkins job disable //disable a job
jenkins job enable  //enable a job
jenkins job has     //check whether a job already exists
jenkins job info    //show job information
jenkins job ls      //show the job list
jenkins job rename  //rename a job
jenkins job xml     //show the contents of a job's config.xml

Today we’ll skip group commands for now and start with the top-level COMMANDs. These commands are mostly used to view various kinds of information.

1. Easter Egg — APP Mode

APP mode lets you operate Jenkins in a standalone window. It feels just like using an app.

Command:

jenkins app

Video demo:

2. Show the Jenkins Server Version

Command:

jenkins version

Output:

ming@tangmingdeMacBook-Pro:~$ jenkins version
Jenkins server version: 2.234

3. Show the Current User

Command:

jenkins version

Output:

ming@tangmingdeMacBook-Pro:~$ jenkins whoami
ming

4. Show the Plugin List

Command:

jenkins plugins

Output:

ming@tangmingdeMacBook-Pro:~$ jenkins plugins
Plugin name                         Type                                                                  Version
--------                            --------                                                              --------
pam-auth                            PAM Authentication plugin                                             1.6
blueocean-i18n                      i18n for Blue Ocean                                                   1.23.2
blueocean-events                    Events API for Blue Ocean                                             1.23.2
authentication-tokens               Authentication Tokens API Plugin                                      1.3
matrix-auth                         Matrix Authorization Strategy Plugin                                  2.6.1
jquery-detached                     JavaScript GUI Lib: jQuery bundles (jQuery and jQuery UI) plugin      1.2.1
workflow-api                        Pipeline: API                                                         2.40
token-macro                         Token Macro Plugin                                                    2.12
pipeline-utility-steps              Pipeline Utility Steps                                                2.5.0
pipeline-model-definition           Pipeline: Declarative                                                 1.6.0
blueocean-pipeline-api-impl         Pipeline implementation for Blue Ocean                                1.23.2
pipeline-model-declarative-agent    Pipeline: Declarative Agent API                                       1.1.1
pipeline-config-history             Pipeline Configuration History Plugin                                 1.6
credentials                         Credentials Plugin                                                    2.3.7
workflow-multibranch                Pipeline: Multibranch                                                 2.21
bouncycastle-api                    bouncycastle API Plugin                                               2.18
htmlpublisher                       HTML Publisher plugin                                                 1.23
jackson2-api                        Jackson 2 API Plugin                                                  2.11.0
workflow-scm-step                   Pipeline: SCM Step                                                    2.11
git-client                          Jenkins Git client plugin                                             3.2.1
windows-slaves                      WMI Windows Agents Plugin                                             1.6
ui-samples-plugin                   Jenkins UI sample plugin                                              2.0
handlebars                          JavaScript GUI Lib: Handlebars bundle plugin                          1.1.1
pipeline-model-extensions           Pipeline: Declarative Extension Points API                            1.6.0
lockable-resources                  Lockable Resources plugin                                             2.8
ace-editor                          JavaScript GUI Lib: ACE Editor bundle plugin                          1.1
cloudbees-folder                    Folders Plugin                                                        6.12
handy-uri-templates-2-api           Handy Uri Templates 2.x API Plugin                                    2.1.8-1.0
pipeline-input-step                 Pipeline: Input Step                                                  2.11
pipeline-milestone-step             Pipeline: Milestone Step                                              1.3.1
workflow-cps                        Pipeline: Groovy                                                      2.80
workflow-job                        Pipeline: Job                                                         2.39
blueocean-jwt                       JWT for Blue Ocean                                                    1.23.2
mailer                              Jenkins Mailer Plugin                                                 1.32
docker-java-api                     Docker API Plugin                                                     3.1.5.2
pipeline-graph-analysis             Pipeline Graph Analysis Plugin                                        1.10
ws-cleanup                          Jenkins Workspace Cleanup Plugin                                      0.38
pipeline-stage-step                 Pipeline: Stage Step                                                  2.3
github-branch-source                GitHub Branch Source Plugin                                           2.7.1
blueocean                           Blue Ocean                                                            1.23.2
blueocean-display-url               Display URL for Blue Ocean                                            2.3.1
blueocean-core-js                   Blue Ocean Core JS                                                    1.23.2
blueocean-commons                   Common API for Blue Ocean                                             1.23.2
pubsub-light                        Jenkins Pub-Sub "light" Bus                                           1.13
jira                                Jenkins Jira plugin                                                   3.0.15
docker-commons                      Docker Commons Plugin                                                 1.16
blueocean-dashboard                 Dashboard for Blue Ocean                                              1.23.2
blueocean-jira                      JIRA Integration for Blue Ocean                                       1.23.2
git-server                          Jenkins GIT server Plugin                                             1.9
blueocean-git-pipeline              Git Pipeline for Blue Ocean                                           1.23.2
ldap                                LDAP Plugin                                                           1.24
workflow-basic-steps                Pipeline: Basic Steps                                                 2.20
blueocean-bitbucket-pipeline        Bitbucket Pipeline for Blue Ocean                                     1.23.2
kubernetes-credentials              Kubernetes Credentials Plugin                                         0.6.2
resource-disposer                   Resource Disposer Plugin                                              0.14
google-oauth-plugin                 Google OAuth Credentials plugin                                       1.0.0
subversion                          Jenkins Subversion Plug-in                                            2.13.1
display-url-api                     Display URL API                                                       2.3.2
http_request                        HTTP Request Plugin                                                   1.8.26
apache-httpcomponents-client-4-api  Jenkins Apache HttpComponents Client 4.x API Plugin                   4.5.10-2.0
git                                 Jenkins Git plugin                                                    4.2.2
workflow-step-api                   Pipeline: Step API                                                    2.22
pipeline-rest-api                   Pipeline: REST API Plugin                                             2.13
plain-credentials                   Plain Credentials Plugin                                              1.7
kubernetes-client-api               Kubernetes Client API Plugin                                          4.9.1-1
github                              GitHub plugin                                                         1.30.0
sse-gateway                         Server Sent Events (SSE) Gateway Plugin                               1.23
email-ext                           Email Extension Plugin                                                2.69
pipeline-github-lib                 Pipeline: GitHub Groovy Libraries                                     1.0
pipeline-model-api                  Pipeline: Model API                                                   1.6.0
variant                             Variant Plugin                                                        1.3
log-file-filter                     Log File Filter Plugin                                                1.11
momentjs                            JavaScript GUI Lib: Moment.js bundle plugin                           1.1.1
branch-api                          Branch API Plugin                                                     2.5.6
durable-task                        Durable Task Plugin                                                   1.34
blueocean-config                    Config API for Blue Ocean                                             1.23.2
kubernetes                          Kubernetes plugin                                                     1.25.7
ssh-slaves                          SSH Build Agents plugin                                               1.31.2
workflow-cps-global-lib             Pipeline: Shared Groovy Libraries                                     2.16
pipeline-stage-view                 Pipeline: Stage View Plugin                                           2.13
pipeline-type-parser-steps          Pipeline Type Parser Steps                                            1.0
command-launcher                    Command Agent Launcher Plugin                                         1.4
favorite                            Favorite                                                              2.3.2
localization-support                Localization Support Plugin                                           1.1
timestamper                         Timestamper                                                           1.11.3
workflow-aggregator                 Pipeline                                                              2.6
jdk-tool                            Oracle Java SE Development Kit Installer Plugin                       1.4
pipeline-keep-running-step          Pipeline Keep Running Step                                            1.0
github-api                          GitHub API Plugin                                                     1.111
blueocean-pipeline-editor           Blue Ocean Pipeline Editor                                            1.23.2
oauth-credentials                   OAuth Credentials plugin                                              0.4
blueocean-web                       Web for Blue Ocean                                                    1.23.2
ant                                 Ant Plugin                                                            1.11
junit                               JUnit Plugin                                                          1.29
docker-workflow                     Docker Pipeline                                                       1.23
blueocean-rest-impl                 REST Implementation for Blue Ocean                                    1.23.2
ssh-credentials                     SSH Credentials Plugin                                                1.18.1
blueocean-personalization           Personalization for Blue Ocean                                        1.23.2
build-timeout                       Build Timeout                                                         1.19.1
mercurial                           Jenkins Mercurial plugin                                              2.10
docker-plugin                       Docker plugin                                                         1.2.0
jsch                                Jenkins JSch dependency plugin                                        0.1.55.2
matrix-project                      Matrix Project Plugin                                                 1.14
blueocean-rest                      REST API for Blue Ocean                                               1.23.2
cloudbees-bitbucket-branch-source   Bitbucket Branch Source Plugin                                        2.8.0
trilead-api                         Trilead API Plugin                                                    1.0.6
script-security                     Script Security Plugin                                                1.72
workflow-durable-task-step          Pipeline: Nodes and Processes                                         2.35
scm-api                             SCM API Plugin                                                        2.6.3
mapdb-api                           MapDB API Plugin                                                      1.0.9.0
blueocean-github-pipeline           GitHub Pipeline for Blue Ocean                                        1.23.2
structs                             Structs Plugin                                                        1.20
jenkins-design-language             Jenkins Design Language                                               1.23.2
pipeline-stage-tags-metadata        Pipeline: Stage Tags Metadata                                         1.6.0
antisamy-markup-formatter           OWASP Markup Formatter Plugin                                         2.0
credentials-binding                 Credentials Binding Plugin                                            1.23
gradle                              Gradle Plugin                                                         1.36
workflow-support                    Pipeline: Supporting APIs                                             3.4
pipeline-build-step                 Pipeline: Build Step                                                  2.12
blueocean-autofavorite              Autofavorite for Blue Ocean                                           1.2.4
blueocean-pipeline-scm-api          Pipeline SCM API for Blue Ocean                                       1.23.2
localization-zh-cn                  Localization: Chinese (Simplified)                                    1.0.14

5. Show the Job List

Command:

jenkins jobs

Output:

ming@tangmingdeMacBook-Pro:~$ jenkins jobs
Job name                      Type                          Link
--------                      --------                      --------
f1                            Folder                        http://localhost:83/job/f1/
f2                            Folder                        http://localhost:83/job/f2/
freestyle-job                 FreeStyleProject              http://localhost:83/job/freestyle-job/
job2                          FreeStyleProject              http://localhost:83/job/job2/
pipeline-project              WorkflowJob                   http://localhost:83/job/pipeline-project/
test_toFloat                  WorkflowJob                   http://localhost:83/job/test_toFloat/
test_toJson                   WorkflowJob                   http://localhost:83/job/test_toJson/
f1/job1                       WorkflowJob                   http://localhost:83/job/f1/job/job1/
f1/job2                       WorkflowJob                   http://localhost:83/job/f1/job/job2/
f2/job2                       WorkflowJob                   http://localhost:83/job/f2/job/job2/

6. Show the Queue List

Command:

jenkins queues

Output:

Job ID	Job link                                              	Cause

7. Show the Node List

Command:

jenkins nodes

Output:

Node name                     Architecture        Swap space          Memory space        Temp space          Disk space
--------                      --------            --------            --------            --------            --------            
(master)                      Linux (amd64)       1024.0/1024.0 MB    1872.38/3938.3 MB   43664 MB            43664 MB

8. Show the Credentials List

Command:

jenkins creds

Output:

ID                                       Name                           Type                                                         Description
94e00416-20d6-4fdf-8a38-8d799684a7ee     user1/******                   <class 'jenkinsapi.credential.UsernamePasswordCredential'>   
6d369c60-67b1-4820-ba7e-ab640df1eac1     user2/****** (user2 describe)  <class 'jenkinsapi.credential.UsernamePasswordCredential'>   user2 describe
user3                                    user3/******                   <class 'jenkinsapi.credential.UsernamePasswordCredential'>   
ming                                     ming (ming)                    <class 'jenkinsapi.credential.SSHKeyCredential'>             ming

This tutorial series will cover these commands in detail, so stay tuned!

Jenkinsclient Tutorial Series: Introduction and Installation (Part 1)

Sun, 17 May 2020 00:00:00 +0000

Introduction to jenkinsclient
Jenkinsclient features
Installation
Upgrade
Quick start
- Configure server information
- View help information

Introduction to jenkinsclient

Jenkinsclient is a powerful, open-source, cross-platform Jenkins command-line client. It provides a Docker-style command line for users to operate Jenkins.

Jenkinsclient is written in Python, and the project source code is open-sourced under China’s Mulan Open Source License. You can view it on Gitee and Github.

Gitee: https://gitee.com/hummerstudio/jenkinsclient

Github: https://github.com/hummerstudio/jenkinsclient

Project homepage: https://pypi.org/project/jenkinsclient

Jenkinsclient features

Feature 1: Open source

As mentioned above, the Jenkinsclient project source code is open-sourced under China’s Mulan Open Source License. Contributions, code submissions, issue reports, documentation, spreading the word, and sharing are all very welcome.

Feature 2: Cross-platform

From the very beginning of development, Jenkinsclient was positioned as cross-platform, and in the end Python was chosen for the implementation.

Windows, Linux, Mac, and Unix all have Python runtime environments, which guarantees that Jenkinsclient can be used across platforms.

Feature 3: Multi-instance support

Jenkinsclient supports multiple Jenkins instances.

You can use the jenkins config generate command to generate a configuration file, configure information for multiple Jenkins servers in it, and use the use field to specify the server operated on by default.

Feature 4: Simple and easy to use

To achieve simple and easy-to-use command-line operations, Jenkinsclient did a great deal of technology selection work at the design stage.

My goal was to design a Docker-style command line. Put simply, operations are expressed with commands/keywords rather than the traditional approach of operating through arguments/options.

For example, to start a docker container, we use:

docker container start CONTAINER

For jenkinsclient, for something like triggering a job, I wanted the command line to look like this:

jenkins job build JOB_NAME

By contrast, a traditional-style command-line implementation would look like this:

jenkins job -b JOB_NAME

Or like this:

jenkins-job build JOB_NAME

Python has several libraries for developing command-line tools, but most of them can only produce traditional-style command-line tools. After careful screening and writing demos, I chose Fire. Fire fully meets the requirements above.

Now, with Jenkinsclient, you can perform Jenkins operations with natural command-line syntax like this:

jenkins jobs                          // show the job list
jenkins job build JOB_NAME            // trigger a Jenkins job
jenkins job disable JOB_NAME          // disable a Jenkins job
jenkins job enable JOB_NAME           // enable a Jenkins job

jenkins plugins                       // show the plugin list
jenkins plugin install PLUGIN_NAME    // install a plugin
jenkins plugin uninstall PLUGIN_NAME  // uninstall a plugin
jenkins plugin search KEY_WORD        // search for a plugin

Feature 5: Powerful

The architecture of Jenkinsclient is designed to give it the ability to implement every Jenkins-related operation. The major features implemented so far are:

Configure Jenkins server information
Manage Jenkins nodes
Manage Jenkins plugins
Manage Jenkins credentials
Manage Jenkins jobs
Manage Jenkins queues
Manage Jenkins executors
Manage Jenkins builds

This covers essentially every kind of operable Jenkins resource.

Installation

The simplest way is to install jenkinsclient, which is hosted on PyPI, with pip. Just use the following command:

pip3 install jenkinsclient

You can also download the source code, unzip it, enter the root directory, and install it manually with the setuptools tool:

python setup.py install

Upgrade

pip3 install -U jenkinsclient

Quick start

Configure server information

Use jenkins config generate to configure Jenkins server information.

This command generates a template configuration file for jenkinsclient, and then you need to fill in the actual values.

View help information

Try typing jenkins jobs to view all jobs on the Jenkins server.

Try typing jenkins plugins to view all plugins on the Jenkins server.

For more commands, you can type jenkins.

Or type jenkins <command-group> to display the help information for a command group. For example, to view the help information for the Jenkins job management commands:

jenkins job

To view the help information for the Jenkins plugin management commands:

jenkins plugin

This tutorial series will introduce these commands in detail, so stay tuned!

Processes Started by Jenkins Always Exit After the Build? Use the keepRunning Step for an Elegant Fix

Mon, 04 May 2020 00:00:00 +0000

Background
Solution
Project Information

Background

Starting a process through Jenkins is a fairly common scenario in real-world work.

But under normal circumstances, a process started by a Jenkins job is killed by Jenkins once the build finishes.

This is determined by Jenkins’ process tree management mechanism.

We can work around it by changing the value of a variable, but that approach has a few drawbacks:

It is not intuitive — even after it works, you cannot tell how the problem was solved;
It is hard to think of solving the problem this way.
Poor readability is in fact a problem that should be avoided as much as possible while writing code.

Solution

The pipeline-keep-running-step-plugin plugin provides a more intuitive keepRunning step, offering an elegant solution to this problem.

With the keepRunning step, the name tells you exactly what it does, so the readability problem is solved.

Using it is simple as well. To start tomcat, for example, this is all you need:

keepRunning {
    sh '/usr/local/apache-tomact/bin/startup.sh
}

Project Information

Open source project home page: https://github.com/hummerstudio/pipeline-keep-running-step-plugin

hpi plugin package download: https://github.com/hummerstudio/pipeline-keep-running-step-plugin/releases

The Automation Revolution and DevOps

Mon, 20 Apr 2020 00:00:00 +0000

First-Generation Automation
Second-Generation Automation
Third-Generation Automation
What Is the Fourth Generation of Automation?
Back to DevOps

Automation is a revolutionary concept and technology.

First-Generation Automation

The first generation of automation is the automation of the heaven-and-earth system: the growth of all things.

Heaven supplies energy as yang, earth takes form as yin; the ancient sages observed this and put it to use. Following the four seasons and adapting to local conditions is what is called wu wei (non-action). Wu wei is not inaction — it is acting in accordance with nature.

The automation of this generation has three elements: heaven, earth and man.

Weather reflects the intensity and total amount of the solar energy supplied. The changes of weather divide broadly into the four seasons and finely into the twenty-four solar terms. Terrain differs from place to place, so one adapts to local conditions; and people must sow, water, fertilize and feed at the right time and in the right place, as if playing in concert with heaven and earth — hence human harmony.

Although heaven and earth are already automated, from the human point of view it still takes the right action at the right moment for all things to grow as humans intend.

Second-Generation Automation

The second generation of automation is machine automation. From this generation onward, automation is man-made.

Machine automation did not begin in modern times; the ancient waterwheel, for instance, was an automated machine powered by water.

But what brought a truly revolutionary change in efficiency was the arrival of industrial machines powered by electricity in the modern era.

Electricity is man-made, produced at first mainly by burning coal and oil; only then did humanity truly have a concept and awareness of energy.

It was also at this point that humanity went from submitting to nature and opening up wasteland to destroying nature and extracting minerals.

Speaking of the human being, the body is yin and consciousness is yang. When yang reaches its extreme, yin is born; when intellect reaches its extreme, ingenious devices are born.

Coal mines and oil wells burn to generate and supply power, and iron and metals are smelted into form: this is the yin and yang of the “heaven and earth” of second-generation automation.

The second generation of automation does not replace the first; rather, it plays two major roles.

First, it acts on the products of first-generation automation, reprocessing them;

second, it in turn upgrades first-generation automation, using machines to create small local natures.

Third-Generation Automation

The third generation of automation is logic automation. From this generation onward, automation moves from the concrete into the abstract.

The automation of logic is the automation of the capacity to judge, and its product is software.

Likewise, the third generation of automation does not replace the second; it too plays two major roles.

First, on the basis of the products of second-generation automation (hardware), it builds a vast new world of software;

second, it in turn upgrades second-generation automation, making hardware programmable.

In the distinction between form and intent, form is yin and intent is yang. When yin reaches its extreme, yang is born. When matter reaches its extreme, intelligence and ingenuity are born.

It is also from this generation onward that automation moves from things to people. The journey of “creating humans” begins.

The second generation of automation replaced human physical labor; the third generation is beginning to replace human consciousness itself. Note the two kinds of “action”: one is the body’s outward “action”, the other is the body’s inward “action”.

What Is the Fourth Generation of Automation?

Think about it differently: what does the next generation of automation begin to replace in humans? It should be replacing human sensation. Put them in order of precedence, and it should first replace human “perception”.

“Feeling” and “perception” are not the same thing; only with perception is there feeling. For example, perception covers sight, hearing, smell, taste and touch, while feeling covers spatial sense, the sense of cold and heat, emotion, the sense of pain and so on.

Perception is reception; feeling is response.

Among the five perceptions, put them in order of precedence again, and it should be human “sight” that is replaced. This is machine vision, a branch of artificial intelligence. Progress on “hearing” is good as well — that is, “speech recognition”.

Self-driving cars are an attempt to generate “feeling” on top of machine vision; voice assistants, for now, only respond to commands or vague commands, and still have a long way to go before true “feeling”.

It is foreseeable that completely covering the five perceptions will still take a very long time.

Completely covering the five feelings, on the other hand, means the birth of “human-like” robots. That will take even longer.

Back to DevOps

DevOps is a form of automation too: automation for the entire software lifecycle. It arose out of third-generation automation and will drive humanity more quickly into the fourth generation of automation; it can be compared to second-generation automation.

The difference is that one acts on the virtual space of software, the other on the physical space of reality.

For a software development company, a fully realized DevOps platform is like an internal industrial revolution and efficiency revolution.