Get TeamCity artifacts using HTTP, Ant, Gradle and Maven

JetBrains

In a world of Java build tools there are several options to download and use binaries produced by TeamCity build configurations. You can use plain HTTP request, Ant + Ivy, Gradle and Maven to do so. This post provides working examples for each of these options.

Build Configuration “id”

Before you retrieve artifacts of any build configuration you need to know its "id" which can be seen in a browser when corresponding configuration is browsed. As an example, we can take IntelliJ IDEA Community Edition project hosted at teamcity.jetbrains.com. Its “Community Dist” build configuration provides a number of artifacts which we’re going to use in the examples that follow. And as can be seen on the screenshot below, its "id" is "bt343".

HTTP

Anonymous HTTP access is probably the easiest way to fetch TeamCity artifacts, the URL to do so is:

http://host/guestAuth/repository/download/<btN>/<buildNumber>/<artifactName>

Fot this request to work 3 parameters need to be specified:

• btN

  Build configuration "id", as mentioned above.

• buildNumber

  Build number or one of predefined constants: "lastSuccessful", "lastPinned", or "lastFinished". For example, you can download periodic IDEA builds from last successful TeamCity execution.

• artifactName

  Name of artifact like "ideaIC-118.SNAPSHOT.win.zip". Can also take a form of "artifactName!archivePath" for reading archive’s content, like IDEA’s build file. You can get a list of all artifacts produced in a certain build by requesting a special "teamcity-ivy.xml" artifact generated by TeamCity.

Ant + Ivy

All artifacts published to TeamCity are accompanied by "teamcity-ivy.xml" Ivy descriptor, effectively making TeamCity an Ivy repository. The code below downloads "core/annotations.jar" from IDEA distribution to "download/ivy" directory:

"ivyconf.xml"

[sourcecode language=”xml”]
<ivysettings>
<settings defaultResolver=’teamcity-repo’/>
<resolvers>
<url name=’teamcity-repo’ alwaysCheckExactRevision=’yes’ checkmodified=’true’>
<ivy pattern=’http://teamcity.jetbrains.com/guestAuth/repository/download/[module]/[revision]/teamcity-ivy.xml’/>
<artifact pattern=’http://teamcity.jetbrains.com/guestAuth/repository/download/[module]/[revision]/[artifact](.[ext])’/>
</url>
</resolvers>
</ivysettings>
[/sourcecode]

"ivy.xml"

[sourcecode language=”xml”]
<ivy-module version="1.3">
<info organisation="com.jetbrains" module="idea"/>
<dependencies>
<dependency org="org" name="bt343" rev="lastSuccessful">
<include name="core/annotations" ext="jar"/>
</dependency>
</dependencies>
</ivy-module>
[/sourcecode]

"build.xml"

[sourcecode language=”xml”]
<project name="teamcity-download" default="download" xmlns:ivy="antlib:org.apache.ivy.ant">
<target name="download" xmlns:ivy="antlib:org.apache.ivy.ant">
<taskdef uri="antlib:org.apache.ivy.ant" resource="org/apache/ivy/ant/antlib.xml"/>
<ivy:configure file = "${basedir}/ivyconf.xml"/>
<ivy:resolve file = "${basedir}/ivy.xml"/>
<ivy:retrieve pattern = "${basedir}/download/ivy/[artifact].[ext]"/>
</target>
</project>
[/sourcecode]

Gradle

Identically to Ivy example above it is fairly easy to retrieve TeamCity artifacts with Gradle due to its built-in Ivy support. In addition to downloading the same jar file to "download/gradle" directory with a custom Gradle task we can use it as "compile" dependency for our Java class, importing IDEA’s @NotNull annotation:

"Test.java"

[sourcecode language=”java”]
import org.jetbrains.annotations.NotNull;

public class Test
{
private final String data;
public Test ( @NotNull String data ){ this.data = data; }
}
[/sourcecode]

"build.gradle"

[sourcecode language=”groovy”]
apply plugin: ‘java’

repositories {
ivy {
ivyPattern ‘http://teamcity.jetbrains.com/guestAuth/repository/download/[module]/[revision]/teamcity-ivy.xml’
artifactPattern ‘http://teamcity.jetbrains.com/guestAuth/repository/download/[module]/[revision]/[artifact](.[ext])’
}
}

dependencies {
compile ( ‘org:bt343:lastSuccessful’ ){
artifact {
name = ‘core/annotations’
type = ‘jar’
}
}
}

task copyJar( type: Copy ) {
from configurations.compile
into "${ project.projectDir }/download/gradle"
}
[/sourcecode]

Maven

One of the ways to use Maven with TeamCity is by setting up an Artifactory repository manager and its TeamCity plugin. This way artifacts produced by your builds are deployed to Artifactory and can be served from there as from any other remote Maven repository.

However, you can still use TeamCity artifacts in Maven without any additional setups. "ivy-maven-plugin" bridges two worlds allowing you to plug Ivy resolvers into Maven’s runtime environment, download dependencies required and add them to corresponding "compile" or "test" scopes.

We can compile the same Java source from the Gradle example but using Maven this time.

"pom.xml"

[sourcecode language=”xml”]
<?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/maven-v4_0_0.xsd">

<modelVersion>4.0.0</modelVersion>
<groupId>com.test</groupId>
<artifactId>maven</artifactId>
<packaging>jar</packaging>
<version>0.1-SNAPSHOT</version>
<name>[${project.groupId}:${project.artifactId}:${project.version}]</name>
<description>Ivy Maven plugin example</description>

<build>
<plugins>
<plugin>
<groupId>com.github.goldin</groupId>
<artifactId>ivy-maven-plugin</artifactId>
<version>0.2.5</version>
<executions>
<execution>
<id>get-ivy-artifacts</id>
<goals>
<goal>ivy</goal>
</goals>
<phase>initialize</phase>
<configuration>
<ivyconf>${project.basedir}/ivyconf.xml</ivyconf>
<ivy>${project.basedir}/ivy.xml</ivy>
<dir>${project.basedir}/download/maven</dir>
<scope>compile</scope>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>
[/sourcecode]

When this plugin runs it resolves IDEA annotations artifact using the same "ivyconf.xml" and "ivy.xml" files we’ve seen previously, copies it to "download/maven" directory and adds to "compile" scope so our Java sources can compile.

GitHub Project

All examples demonstrated are available in the GitHub project. Feel free to clone and run it:

[sourcecode language=”bash”]
git clone git://github.com/evgeny-goldin/teamcity-download-examples.git
cd teamcity-download-examples
chmod +x run.sh dist/ant/bin/ant gradlew dist/maven/bin/mvn
./run.sh
[/sourcecode]

Resources

The links below can provide you with more details:

• TeamCity – Patterns For Accessing Build Artifacts
• TeamCity – Accessing Server by HTTP
• TeamCity – Configuring Artifact Dependencies Using Ant Build Script
• Gradle – Ivy repositories
• "ivy-maven-plugin"

The list above covers options available for Java build tools. In addition to that, you can always download TeamCity artifacts using product’s Web UI or NuGet support. Which ways do you use? Would you like to see a better support for tools we have mentioned or those we didn’t? Let us know! As always, your feedback is very appreciated.

Subscribe to TeamCity Blog updates

Subscribe form

By submitting this form, I agree to the JetBrains Privacy Policy Notification icon

By submitting this form, I agree that JetBrains s.r.o. ("JetBrains") may use my name, email address, and location data to send me newsletters, including commercial communications, and to process my personal data for this purpose. I agree that JetBrains may process said data using third-party services for this purpose in accordance with the JetBrains Privacy Policy. I understand that I can revoke this consent at any time in my profile. In addition, an unsubscribe link is included in each email.

Submit

Thanks, we've got you!