Jenkins 3: Text Input & Validation

Our builder UI is progressing: today we will add a text box with nice defaults and add input validation to it.

Jenkins Tutorials

For a list of all jenkins related tutorials see Jenkins Tutorials Overview.

Source code for this tutorial is available on github as a single zip archive, as a Team Project Set or you can browse the files online.

Step 1: The Text Box

Adding a text box is as simple as adding the checkbox before. Add a new entry to the config.jelly file:

 <f:entry title="Custom build message" field="buildMessage">
  <f:textbox />
 </f:entry>

Make sure you use a unique ID for field. Then add the new field to your builder by adding it to the constructor and create a getter for it:

public class HelloBuilder extends Builder implements SimpleBuildStep {

 private String fBuildMessage;

 @DataBoundConstructor
 public HelloBuilder(boolean failBuild, String buildMessage) {
  fFailBuild = failBuild;
  fBuildMessage = buildMessage;
 }

 @Override
 public void perform(Run<?, ?> run, FilePath workspace, Launcher launcher, TaskListener listener)
   throws InterruptedException, IOException {
  listener.getLogger().println(getBuildMessage());
  
  if (isFailBuild())
   throw new AbortException("Build error forced by plugin settings");
 }

 public String getBuildMessage() {
  return fBuildMessage;
 }
}

All done, give it a try!

Step 2: Default Value

Some example data might help our users when filling out the buid parameters. Therefore lets provide a nice default value. This is done by adding a default attribute to the textbox:

<f:textbox default="${descriptor.getDefaultBuildMessage()}" />

We could have provided the default text directly in the attribute data. Instead we decided to fetch the default dynamically from the Descriptor class. No magic data binding here, so we need to implement the method:

 public static final class Descriptor extends BuildStepDescriptor<Builder> {
  
  public String getDefaultBuildMessage() {
   return "This is a great build";
  }
 }

Step 3: Input Validation

Having no build message would result in an empty log file, which is not what we want. With input validation we can force users to enter some text to the input box. Validation is done by providing a validator in the Descriptor class:

 public static final class Descriptor extends BuildStepDescriptor<Builder> {

  public FormValidation doCheckBuildMessage(@QueryParameter String buildMessage) {
   if (buildMessage.isEmpty())
    return FormValidation.error("Please provide a build message.");
   else if (buildMessage.trim().isEmpty())
    return FormValidation.error("White space is not sufficient for a build message.");
   else
    return FormValidation.ok();
  }
 }

The method name needs to stick to the pattern doCheck<Parameter>. Normally you would only provide the parameter in question to that method (again the parameter name needs to match your field ID) but if needed you could add parameters for other fields of the builder. This comes in handy when parameters depend on each other.

Jenkins 2: A Builder Plugin & Some Jelly

In the previous tutorial we did the basic setup for jenkins plugin development. Now we will try to create a plugin that actually runs a build step.

Jenkins Tutorials

For a list of all jenkins related tutorials see Jenkins Tutorials Overview.

Source code for this tutorial is available on github as a single zip archive, as a Team Project Set or you can browse the files online.

Step 1: The Basic Builder

Maven allows to create a nice template for a builder plugin by calling

mvn archetype:generate -Dfilter=io.jenkins.archetypes:

then select the hello-world-plugin. But as we want to do it the hard way, we will add every single bit on our own and continue with the empty project from our previous tutorial.

The first thing we need is a class to implement our builder. Lets create a simple one. Create a new class com.codeandme.jenkins.builder.HelloBuilder:

package com.codeandme.jenkins.builder;

import java.io.IOException;

public class HelloBuilder extends Builder implements SimpleBuildStep {

 @DataBoundConstructor
 public HelloBuilder() {
 }

 @Override
 public void perform(Run<?, ?> run, FilePath workspace, Launcher launcher, TaskListener listener)
   throws InterruptedException, IOException {
  listener.getLogger().println("This is the Hello plugin!");
 }

 @Symbol("hello")
 @Extension
 public static final class Descriptor extends BuildStepDescriptor<Builder> {

  @Override
  public boolean isApplicable(Class<? extends AbstractProject> aClass) {
   return true;
  }

  @Override
  public String getDisplayName() {
   return "Code & Me - Hello World";
  }
 }
}

Jenkins expects the constructor to be augmented with the @DataBoundConstructor annotation. Later we will add our build parameters to it.

The perform() method is the heart of our implementation. This is where we define what the build step should actually do. In this tutorial we focus on the definition, not the execution so we are just printing some log message to detect that our build step got triggered.

Now lets put our focus on the Descriptor class. It actually describes what our plugin looks like, what parameter it uses and whether the user input is valid or not. You need to use a static class as a descriptor and augment it with the @Extension annotation to allow jenkins to detect it automatically.

isApplicable() might be the most important one as it denotes if ou plugin is usable for the current project type.

Start a jenkins test server using

mvn hpi:run -Djetty.port=8090

Create a new Freestyle Project and add your custom build step to it. Then execute the job and browse the log for our log message.

Build Considerations

When writing a plugin it is vital to understand which parts of the plugin do get executed on the master and which ones on a slave machine. The java code we just wrote does get executed on the master only. Even when a job is executed on a slave machine, the perform() method still gets executed on master. Therefore we cannot use classic java libraries like NIO or the ProcessBuilder to access and execute stuff on the slave. Instead we need to use abstractions like the workspace and the launcher parameters we get from Jenkins. These objects will take care to delegate IO calls or program executions to the slave.

Make sure you always keep focus which parts of your code get executed where.

Step 2: Basic UI

Next we need a *.jelly file to describe how the UI should look like. Therefore create a new package in src/main/resources named com.codeandme.jenkins.builder.HelloBuilder. That is right, the package equals the class name of our builder class. Then create a config.jelly file inside that package:

<?jelly escape-by-default='true'?>
<j:jelly xmlns:j="jelly:core" xmlns:st="jelly:stapler" xmlns:d="jelly:define" xmlns:l="/lib/layout" xmlns:t="/lib/hudson" xmlns:f="/lib/form">

 <f:block>
  <h1>Code &amp; Me Productions</h1>
  <p>We build the best <i>hellos</i> in the world</p>
 </f:block>

</j:jelly>

Inside the jelly definition we can use plain HTML code. Run your test instance again to see your changes in your project configuration view.

Step 3: Checkbox Input

Time to add some input. All build parameters need at least 2 steps of implementation: first we need to define the UI in the config.jelly file, then we need to define the parameters in the java class. Optionally we may add additional checks in the Descriptor class.

To define the UI for the checkbox we add following code to our jelly file:

 <f:entry title="Fail this build" field="failBuild">
  <f:checkbox />
 </f:entry>

This will create a label using the title field and a checkbox on the right side of the label. The field name is important as this is the ID of our field which we now use in the Java code:

public class HelloBuilder extends Builder implements SimpleBuildStep {

 private boolean fFailBuild;

 @DataBoundConstructor
 public HelloBuilder(boolean failBuild) {
  fFailBuild = failBuild;
 }

 @Override
 public void perform(Run<?, ?> run, FilePath workspace, Launcher launcher, TaskListener listener)
   throws InterruptedException, IOException {
  listener.getLogger().println("This is the Hello plugin!");

  if (isFailBuild())
   throw new AbortException("Build error forced by plugin settings");
 }

 public boolean isFailBuild() {
  return fFailBuild;
 }
}

The new parameter needs to be added to our constructor. Make sure you use the same name as in the jelly file. Additionally we need a getter for our parameter. It will be queried to populate the UI when you configure your job and when the job gets executed. Jenkins expects the name of the getter to match the field name of your jelly file.

During the build we evaluate our parameter and throw an AbortException in case our builder is expected to fail.

Step 4: Adding Help

Lots of parameters in Jenkins plugins show a help button on the righthand side of the form. These buttons automatically appear when corresponding help files exist in the right location.

A general help file for the builder named help.html needs to be placed next to the config.jelly file. You may add any arbitrary HTML content there, with no need to use <html> or <body> tags.

To provide help for our checkbox we create another help file named help-failBuild.html. See the pattern? We again use the field ID and Jenkins figures out the rest.

Instead of a plain HTML files we could also provide jelly files following the same name pattern.

Changes like adding help or beautifying jelly files can be done without restarting our test instance. Simply change the file and reload the page in your webbrowser of your test instance.

Further reading

Good documentation on writing forms seems to be rare on the internet. To me the best choice seems to find an existing plugin and browse the source code for reference. At least a list of all control types is available online.

Jenkins 1: IDE Setup and an Empty Plugin

I recently started to write my first Jenkins plugin and I thought I share the experience with you. For that reason I started a new series of tutorials.

Today we are building a simple Jenkins plugin using Eclipse. The basic steps of this tutorial are extracted from the Jenkins Plugin Tutorial.

Jenkins Tutorials

For a list of all jenkins related tutorials see Jenkins Tutorials Overview.

Source code for this tutorial is available on github as a single zip archive, as a Team Project Set or you can browse the files online.

Prerequisites

As you are interested in writing a plugin for Jenkins I expect that you have a rough idea what Jenkins is used for and how to administer it.

While our build environment allows to run a test instance of Jenkins with our plugin enabled I also liked to have a 'real' Jenkins instance available to test my plugins. Therefore I use docker to quickly get started with a woking Jenkins installation.

Once you have installed docker (extended tutorial for debian), you can download the latest Jenkins container by using

docker pull jenkins/jenkins:lts

Now run your container using

docker run -p 8080:8080 -p 50000:50000 -v jenkins_home:/var/jenkins_home jenkins/jenkins:lts

After the startup process your server is reachable via http://localhost:8080/.

To manage containers use commands

docker container ls
docker container stop <container name>

Step 1: Maven configuration

We will need maven installed and ready for creating the project, building and testing it, so make sure you have set it up correctly.

Maven needs some configuration ready to learn about jenkins plugins, therefore you need to adapt the configuration file slightly. On linux change ~/.m2/settings.xml, on windows modify/create %USERPROFILE%\.m2\settings.xml and set following content:

<settings>
 <pluginGroups>
  <pluginGroup>org.jenkins-ci.tools</pluginGroup>
 </pluginGroups>

 <profiles>
  <!-- Give access to Jenkins plugins -->
  <profile>
   <id>jenkins</id>
   <activation>
    <activeByDefault>true</activeByDefault>
   </activation>
   <repositories>
    <repository>
     <id>repo.jenkins-ci.org</id>
     <url>https://repo.jenkins-ci.org/public/</url>
    </repository>
   </repositories>
   <pluginRepositories>
    <pluginRepository>
     <id>repo.jenkins-ci.org</id>
     <url>https://repo.jenkins-ci.org/public/</url>
    </pluginRepository>
   </pluginRepositories>
  </profile>
 </profiles>
 <mirrors>
  <mirror>
   <id>repo.jenkins-ci.org</id>
   <url>https://repo.jenkins-ci.org/public/</url>
   <mirrorOf>m.g.o-public</mirrorOf>
  </mirror>
 </mirrors>
</settings>

Hint: On windows I had to remove the settings file <maven install folder>\conf\settings.xml as it was used in favor of my profile settings.

Step 2: Create the plugin skeleton

To create the initial project open a shell and execute:

mvn archetype:generate -Dfilter=io.jenkins.archetypes:empty-plugin

You will be asked some questions how your plugin should be configurated:

[INFO] Scanning for projects...
[INFO]                                                                         
[INFO] ------------------------------------------------------------------------
[INFO] Building Maven Stub Project (No POM) 1
[INFO] ------------------------------------------------------------------------
[INFO] 
[INFO] >>> maven-archetype-plugin:3.0.1:generate (default-cli) > generate-sources @ standalone-pom >>>
[INFO] 
[INFO] <<< maven-archetype-plugin:3.0.1:generate (default-cli) < generate-sources @ standalone-pom <<<
[INFO] 
[INFO] --- maven-archetype-plugin:3.0.1:generate (default-cli) @ standalone-pom ---
[INFO] Generating project in Interactive mode
[INFO] No archetype defined. Using maven-archetype-quickstart (org.apache.maven.archetypes:maven-archetype-quickstart:1.0)
Choose archetype:
1: remote -> io.jenkins.archetypes:empty-plugin (Skeleton of a Jenkins plugin with a POM and an empty source tree.)
Choose a number or apply filter (format: [groupId:]artifactId, case sensitive contains): : 1
Choose io.jenkins.archetypes:empty-plugin version: 
1: 1.0
2: 1.1
3: 1.2
4: 1.3
5: 1.4
Choose a number: 5: 
[INFO] Using property: groupId = unused
Define value for property 'artifactId': builder.hello
Define value for property 'version' 1.0-SNAPSHOT: : 
[INFO] Using property: package = unused
Confirm properties configuration:
groupId: unused
artifactId: builder.hello
version: 1.0-SNAPSHOT
package: unused
 Y: : 
[INFO] ----------------------------------------------------------------------------
[INFO] Using following parameters for creating project from Archetype: empty-plugin:1.4
[INFO] ----------------------------------------------------------------------------
[INFO] Parameter: groupId, Value: unused
[INFO] Parameter: artifactId, Value: builder.hello
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] Parameter: package, Value: unused
[INFO] Parameter: packageInPathFormat, Value: unused
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] Parameter: package, Value: unused
[INFO] Parameter: groupId, Value: unused
[INFO] Parameter: artifactId, Value: builder.hello
[INFO] Project created from Archetype in dir: ~/Eclipse/codeandme.blogspot.com/ws/builder.hello
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 36.202 s
[INFO] Finished at: 2018-11-27T20:34:15+01:00
[INFO] Final Memory: 16M/169M
[INFO] ------------------------------------------------------------------------

We just created the basic skeleton files and could start working right away. But as we want to do it the eclipse way we need to convert the project to a proper eclipse project. Therefore change into the created project directory and execute:

mvn -DdownloadSources=true -DdownloadJavadocs=true -DoutputDirectory=target/eclipse-classes eclipse:eclipse

The first run might take some time as maven has to fetch tons of dependencies. So sit back and enjoy the show...

Once this step is done we can import our project using the Eclipse import wizard using File / Import... and then select General/Existing Projects into Workspace. On the following page select the project folder that was created by maven.

Step 3: Update configuration files

The created pom.xml file for our plugin provides a good starting point for development. Typically you might want to update it a little before you actually start coding. Fields like name, description, license should be pretty clear. More interesting is

    <properties>
        <jenkins.version>2.7.3</jenkins.version>
        <java.level>7</java.level>
    </properties>

Upgrading the java level to 8 should be pretty safe these days. Further Jenkins 2.7.3 is really outdated. To check out which versions are available you may browse the jenkins artifactory server. Open the jenkins-war node and search for a version you would like to use.

I further adapt the .project file and remove the groovyNature as this would trigger install requests for groovy support in eclipse. As we are going to write java code, we do not need groovy.

Step 4: Build & Deploy the Plugin

To build your plugin simply run

mvn package

This will build and test your package. Further it creates an installable *.hpi package in the com.codeandme.jenkins.helloworld/target folder.

Step 5: Test the plugin in a test instance

To see your plugin in action you might want to execute it in a test instance of Jenkins. Maven will help us to set this up:

mvn hpi:run -Djetty.port=8090

After the boot phase, open up your browser and point to http://localhost:8090/jenkins to access your test instance.

Debugging is also quite simple, just add environment settings to setup your remote debugger. On Windows this would be:

set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,address=8000,suspend=n

On Linux use

export MAVEN_OPTS="-Xdebug -Xrunjdwp:transport=dt_socket,server=y,address=8000,suspend=n"

Then you should be able to setup a Remote Java Application debug configuration in Eclipse.

Writing a simple builder will be our next step, stay tuned for the next tutorial.