Maven builds can resolve dependencies, deploy artifacts and publish build-info to Artifactory.
The minimum Maven version supported is 3.3.9
The deployment to Artifacts is triggered both by the deploy and install phases.
To run Maven builds with Artifactory from your Pipeline script, you first need to create an Artifactory server instance, as described at the beginning of this article.
Here's an example:
def server = Artifactory.server 'my-server-id'
The next step is to create an Artifactory Maven Build instance:
def rtMaven = Artifactory.newMavenBuild()
Now let's define where the Maven build should download its dependencies from. Let's say you want the release dependencies to be resolved from the 'libs-release' repository and the snapshot dependencies from the 'libs-snapshot' repository. Both repositories are located on the Artifactory server instance you defined above. Here's how you define this, using the Artifactory Maven Build instance we created:
rtMaven.resolver server: server, releaseRepo: 'libs-release', snapshotRepo: 'libs-snapshot'
Now let's define where our build artifacts should be deployed to. Once again, we define the Artifactory server and repositories on the 'rtMaven' instance:
rtMaven.deployer server: server, releaseRepo: 'libs-release-local', snapshotRepo: 'libs-snapshot-local'
By default, all the build artifacts are deployed to Artifactory. In case you want to deploy only some artifacts, you can filter them based on their names, using the 'addInclude' method. In the following example, we are deploying only artifacts with names that start with 'frog'
You can also exclude artifacts from being deployed. In the following example, we are deploying all artifacts, except for those that are zip files:
And to make things more interesting, you can combine both methods. For example, to deploy all artifacts with names that start with 'frog', but are not zip files, do the following:
If you'd like to add custom properties to the deployed artifacts, you can do that as follows:
rtMaven.deployer.addProperty("status", "in-qa").addProperty("compatibility", "1", "2", "3")
By default, 3 threads will be used for uploading the maven artifacts. You can modify the number of threads used as follows:
rtMaven.deployer.threads = 6
In some cases, you want to disable artifacts deployment to Artifactory or make the deployment conditional. Here's how you do it:
rtMaven.deployer.deployArtifacts = false
In case you'd like to use the Maven Wrapper for this build, add this:
rtMaven.useWrapper = true
To select a Maven installation for our build, we should define a Maven Tool through Jenkins Manage, and then, set the tool name as follows:
rtMaven.tool = 'maven tool name'
Instead of using rtMaven.tool, you can set the path to the Maven installation directory using the MAVEN_HOME environment variable as follows:
env.MAVEN_HOME = '/tools/apache-maven-3.3.9'
Here's how you define Maven options for your build:
rtMaven.opts = '-Xms1024m -Xmx4096m'
In case you'd like Maven to use a different JDK than your build agent's default, no problem.
Simply set the JAVA_HOME environment variable to the desired JDK path (the path to the directory above the bin directory, which includes the java executable).
Here's you do it:
env.JAVA_HOME = 'full/path/to/JDK'
OK, we're ready to run our build. Here's how we define the pom file path (relative to the workspace) and the Maven goals. The deployment to Artifactory is performed during the 'install' phase:
def buildInfo = rtMaven.run pom: 'maven-example/pom.xml', goals: 'clean install'
The above method runs the Maven build. Notice that the method returns a buildInfo instance, which can be later published to Artifactory.
In some cases though, you'd like to pass an existing buildInfo instance to be used by the build. This can come in handy is when you want to set custom build name or build number on the build-info instance, or when you'd like to aggregate multiple builds into the same build-info instance. Here's how you pass an existing build-info instance to the rtMaven.run method:
rtMaven.run pom: 'maven-example/pom.xml', goals: 'clean install', buildInfo: existingBuildInfo
By default, the build artifacts will be deployed to Artifactory, unless rtMaven.deployer.deployArtifacts property was set to false. This can come in handy in two cases:
You do not wish to publish the artifacts.
You'd like to publish the artifacts later down the road. Here's how you can publish the artifacts at a later stage:
Make sure to use the same buildInfo instance you received from the rtMaven.run method. Also make sure to run the above method on the same agent that ran the rtMaven.run method, because the artifacts were built and stored on the file-system of this agent.
By default, Maven uses the local Maven repository inside the .m2 directory under the user home. In case you'd like Maven to create the local repository in your job's workspace, add the -Dmaven.repo.local=.m2 system property to the goals value as shown here:
def buildInfo = rtMaven.run pom: 'maven-example/pom.xml', goals: 'clean install -Dmaven.repo.local=.m2'
What about the build-info?
The build-info has not yet been published to Artifactory, but it is stored locally in the 'buildInfo' instance returned by the 'run' method. You can now publish it to Artifactory as follows:
You can also merge multiple buildInfo instances into one buildInfo instance and publish it to Artifactory as one build, as described in the Publishing Build-Info to Artifactory section in this article.