One of the interesting discussions during SCALE 10x was about using Jenkins as a piece of a bigger software. This person was interested in using Jenkins to run some business analysis operations, and wanted to have a separate interface for business oriented people. This is actually an emerging but common theme I hear from many users. Another company in San Jose actually built the workflow engine that uses Jenkins as a piece in a bigger application (aside from the actual build and test, this workflow involves reviews, approvals, etc.), and GitHub Janky can be classified as one such app, too.
This is something I always believed in — that every piece of software needs to be usable but a layer above. Or put another way, every software should be usable as a library.
So in this post I'm going to discuss various ways you can programmatically drive Jenkins.
Let's start with the REST API of Jenkins. For most of the data Jenkins renders as HTML, you can access its XML version and JSON version (as well as a few other formats, like Python literal fragment.) You do this by adding /api to the page (see http://ci.jenkins-ci.org/api for example.) Those pages discusss other REST API where applicable. For example, you can POST to a certain URL and it'll create/update job definitions, etc.
If you are going to use REST API, you might find the auto-discovery for Jenkins useful. You can discover Jenkins on the local subnet via UDP broadcast, or DNS multi-cast. There's also a distinctive HTTP header "Jenkins-Version" on the top page of Jenkins that allows your application to verify that it's talking to a real Jenkins server, as well as an instance ID that allows you to identify Jenkins instanecs. These featuers allow you to build smarter applications.
For Jenkins protected by some authentication mechanism, you can use the user name + API key in the HTTP basic auth (and I want to add OAuth support here.)
REST API is great -- its programming language agnostic. It is also convenient that neither the server nor the client has to trust each other. But those APIs are bound by the request/response oriented nature of the HTTP protocol.
Another great integration point for Jenkins is the CLI. This uses the same underlying technology that drives master/slave architecture, which enables your command line clients to be a lot more intelligent. For example, REST API exposes an URL that you can post to get a build started. But the equivalent command in CLI can have you block until the build is complete (and exit code indicates the status), or run the polling first and proceed to build only when the polling detects a change, or allow you to perform a parameterized build with multiple file uploads very easily. For protected Jenkins, CLI supports SSH public key authentication to securely authenticate the client.
A slightly different version of the CLI is "Jenkins as SSH server". Jenkins speaks the server side of the SSH protocol, and allows regular SSH clients to execute a subset of CLI commands. In this way, you don't need a Java runtime installed on the client side to drive Jenkins.
These two integration APIs are often much easier to script than REST API.
Those APIs are available for non-privileged users, and they are great for small scale integrations. But for more sophisticated integration needs, we have additional APIs.
One is the REST API access to the Groovy console, which allows administrator users to run arbitrary Groovy scripts inside the Jenkins master JVM (and you can submit this script as POST payload, and get the response back as the HTTP response). This allows you to tap into all the Jenkins object models. Unlike the REST API, in this way you can ship the computation, so in one round-trip you can do a lot. You can do the same with CLI, which also lets you access stdin/stdout of the CLI.
The other sophisticated integration API I wanted to talk about is the remoting API that does Java RPC (not to be confused with the remote API, which is the synonym for the REST API). The remoting API is the underlying protocol that we use for master/slave communications, and it revolves around the notion of shipping a closure (and code associated with it) from one JVM to another, executing it, and getting the result back. If your application runs elsewhere, you can establish the remoting API channel with Jenkins master, then prepare a Callable object. You can then have Jenkins master execute this closure, and the result is sent back to your JVM.
There's an example of this available. You bootstrap this in the same way the CLI client talks to the master, then you "upgrade" the communication channel by activating the remote code download support (which requires the administrator privilege, for obvious reasons).
The great thing about this is that your data structure is rich Java object model all the way, and you never have to translate your data to externalizable serialization data format like XML or JSON. This greatly simplifies your program.
I think this list covers all the major integration APIs that Jenkins offers. If you are building any interesting applications that use Jenkins as a building block, please share your experience so that we can make it better!
Jenkins Founder, Elite Developer & Architect