JetBrains TeamCity Blog

As you might know, TeamCity comes with such feature as build tags – do not confuse with supported VCS tags, because that’s an entirely different story. You can assign any number of tags for a single build, and then use them to organize your build history, or quickly navigate to the tagged builds. There is nothing tricky about that, but one might ask himself when these tags can be helpful.

Well, here is an example. Suppose, after some time of developing, your project manager decides, that you’ve finally got a stable build that can be considered a release candidate, or eap. He can mark this build with “EAP” tag, and thus, guys from QA won’t need to search through the whole build history to find the build they should carefully look at. They’ll just need to filter the history by this tag, or simply type “EAP” in the search field.


You can also leave a comment on any build, providing some extra notes about it; and just as with the tags, you can later on search for the build by the comment. Hope, you’ll like it.
Feedback is appreciated as usual.

In the upcoming TeamCity 5.1 we’ve added an often requested feature - artifact packaging.

As you probably already know, in TeamCity you can easily configure artifact upload to the server. Later, from a build page, you can download all artifacts of the build. You can specify both directories and individual files as artifacts. The syntax for this is rather simple.

Build artifacts enable another really popular feature - custom reports. The essence of the feature is that if your build produces a report, viewable in a browser (any HTML/Text/Image/PDF), you can integrate this build report into the TeamCity interface. Report files are sent to TeamCity as artifacts, and you configure the report view in the TeamCity UI. One of the interesting things about custom reporting is that TeamCity can extract individual report files from ZIP-packaged archives. So if your report is a big directory with hundreds of files, you better zip them first before sending (to speedup the upload process).

Before TeamCity 5.1, you needed to zip the files in your build script. This required writing an Ant or NAnt task which prepared corresponding archive file. Unfortunately, not all build runners allow creating zip files.

In TeamCity 5.1, artifacts can be packed without modification of your build scripts. Just use archive suffix in your target path, and that’s it:

  testng-report => testng.zip
  **/src/**/*.java => sources/all-java-files.tgz

You can use suffixes zip, jar, war, tgz, tar.gz to specify type of the archive. For jar and war archives, the file format is just zip.

And as you would have expected, if you use tar/gz packaging on a UNIX system, TeamCity preserves file mode of the files, username, and group.

You can try artifact packaging in the just opened TeamCity 5.1 EAP builds.

Hope you’ll like these bits of syntax-sugar, and please share your feedback!

If you have ever dealt with .NET code coverage for NUnit tests, you surely know that it is quite a tricky thing to configure: you need to read docs to properly set up launching a command line coverage tool in your build script; read more docs and configure how reports should be gathered; then read docs again and specify all the needed arguments to be passed… well, not a task anyone would like to deal with.

Now imagine that you can forget all that tangled routine and spend more time doing whatever you like. That’s because starting with TeamCity 5.0 configuring coverage execution with NUnit becomes easy as pie.

All you need to do is to select the preferred coverage tool when creating or editing Build Configuration — NCover and PartCover are at your disposal; and specify its parameters. That’s it!

Just a few clicks to make TeamCity automatically add necessary arguments to NUnit tests, and ensure you’ll be able to view the results in the TeamCity. Enjoy!

Code Coverage Results

Code Coverage Summary

Coverage Graph

Technorati tags: TeamCity, JetBrains, continuous integration, build management, NCover, PartCover, NUnit, agile development

Great news, everyone — we just released the next EAP build for TeamCity 5.0! What did we include in this build? One major brand new feature, some updates for already introduced features, and some enhancements — our traditional set for EAPs. Here’s the brief list of what you’ll find in this one:

• First of all, we introduce build configuration templates. The goal of this major feature is to get rid of duplicating the build configuration settings. Of course, you can copy build configuration that seems most suitable, and use it as a base for a new one. However, in case something changes, you will still need to make same modifications in all similar build configurations. Now all you have to do is create a template (template actually has the same settings as a regular build configuration) and then associate any number of build configurations with this template. Any change in the template will affect all of the build configurations associated with it.
• UI for Amazon EC2 settings: now you can edit Amazon cloud profiles from the web UI, without editing configuration files manually.
• Enhanced My Changes page: you can see not only builds running with your change but also new tests already failed in these builds.
• Dependency trigger on Maven artifact: this new kind of dependency trigger will start a build if a specified Maven artifact changes.
• Plus some more improvements including support for Oracle 11, widened set of details displayed for disconnected build agent, UI enhancements, etc.

For detailed list of changes, please refer to the complete Release notes for today’s TeamCity EAP.

Download the new EAP build, give it a try and use it, and send your feedback to us — we always wait for it at our issue tracker and online forum.
And last, but not the least: please don’t forget to back up your data before upgrade.

Wish you happy building!
The JetBrains TeamCity team

Technorati tags: TeamCity, JetBrains, IntelliJ IDEA, Eclipse, continuous integration, build management, EAP, early access program, agile development, Maven, Configuration template, Amazon EC2

Seems just yesterday we’d opened Early Access Program for TeamCity 5.0, and we’re on air again, and with good news! Here is the new EAP release, which incorporates some delicious features and improvements that, we hope, will tempt you to try them in practice:

• Initial support for virtual agents based on Amazon EC2 service.
• Command line tool for Remote runs.
• Backup & Restore via web UI to simplify TeamCity maintenance.
• Simplified creation of Maven build configurations: just provide URL to your project pom file, and TeamCity will take care of the rest.
• Run build with custom artifact dependencies: if your build has artifact dependencies, you can now choose specific builds to depend on.
• History by agent: view a history of builds that were run on a particular build agent.
• All data shown on the Single change status page is now sorted by tabs: Tests, Builds and Files.
• In Audit log, you can now filter the list of registered activities by user. In addition, new activity types are available for browsing.
• Automatically fetched Project Keys for Jira issue tracker.
• Test connection to specified issue tracker in the issue tracker settings dialog.
• Code coverage improvements.
• and a bit more…

View complete Release notes and download new EAP build. Please back up your data before upgrade.

By the way, you still have a chance to vote for features and suggest new ones at our issue tracker and online forum. Your feedback will be most welcome!

Wish you happy building!
The JetBrains TeamCity team

Technorati tags: TeamCity, JetBrains, IntelliJ IDEA, Eclipse, continuous integration, build management, EAP, early access program, agile development, Visual Studio, Issue tracker integration, Amazon EC2, Code coverage

Truly great news, everyone! Today we announce the opening of TeamCity 5.0 Early Access Program.

We’ve been working hard and we believe it’s time to present you some of TeamCity’s brand new features and enhancements to make your day a bit brighter.
So here goes a brief list of what you’ll find in this first TeamCity 5.0 EAP:

• Issue Tracker integration — out-of-the-box integration with JIRA, Bugzilla, and Charisma (it’s a new issue tracker by JetBrains)
• New code coverage engine for Java — IntelliJ IDEA built-in coverage
• Built-in support for seamless integration with NCover and PartCover for .NET coverage
• Single page to monitor status of a particular change across all of the build configurations
• Customizable UI for artifact-based (report) tabs
• Archived Projects — one click to sort out non-active projects
• Audit and Server logs — let you browse various users activity and server events via web UI
• Eclipse and Visual Studio IDE plug-ins improvements
• Enhanced Rake Runner with new test frameworks support
• Experimental support for Sybase DB engine
• and more niceties…

Quite a list, don’t you think? Just give these features a try, and, who knows?, you might get a taste for them!
If you’d like to get more information and try new features, view detailed Release notes and download the build. Of course, we remind you to back up your data before upgrade.

By the way, don’t hesitate and take a chance to influence the development process — vote for features and suggest new ones at our issue tracker and online forum. We greatly appreciate and eagerly wait for your feedback!

Wish you happy building!
The JetBrains TeamCity team

Technorati tags: TeamCity, JetBrains, IntelliJ IDEA, Eclipse, continuous integration, build management, EAP, early access program, agile development, Visual Studio, Issue tracker integration, Sybase, NCover, PartCover, Code coverage

Now TeamCity is equipped with a new feature designed to improve your project ROI and raise team motivation. It allows you to automatically charge developers for broken builds, abusing hardware resources, and more.
 
The charging feature provides a web UI where administrators can customize conversion rates and charging rules, as well as the list of accepted credit cards and payment methods.
 
To start improving your project bottom-line today, click here to learn more and download the latest TeamCity build.
 
As always, we are eager to hear your feedback. We also recommend backing up your data before you upgrade.
 
Enjoy your profitable building!
 
The JetBrains Team

Technorati tags: TeamCity, continuous integration, build management, agile development, JetBrains, IntelliJ IDEA, Eclipse, MS Visual Studio 2005, MS Visual Studio 2008, Mono

TeamCity has always provided a number of places and ways for monitoring changes which the team made:

• pop-up on the Projects page showing pending changes or those being built at the moment
• Recent history on the build configuration Overview page
• different types of notifications
• Change Log of the build configuration containing the records of all entries of changes which were committed.

In TeamCity 4.0 we made a number of improvements in the Change Log tab design helping to focus on what is the most important and letting you to:

• specify the range of changes you want to view by providing the range of builds
• show the builds where developers’ changes got into
• view changes which were made by a particular developer - the feature is available since TeamCity 4.1 EAP

Hope you will find these new Change Log features useful in your daily chores.

Before trying TeamCity 4.1 EAP we recommend you to backup your database as usual.

Technorati tags: TeamCity, continuous integration, build management, agile development, JetBrains, IntelliJ IDEA, Eclipse, MS Visual Studio 2005, MS Visual Studio 2008

With this post we open a series of publications devoted to the description of use cases and peculiarities of dependent builds in TeamCity 4.0.

So first of all, let's dig into the issue of why you may need using dependencies in your software building system. Today's IT companies tend to develop more and more complex software solutions while trying to constantly keep the quality of the product on a high level and move on faster. In a situation like this inter-project dependencies management can become an important factor for delivering successful products within a tough time frame. So, using TeamCity’s dependencies can help you:

• run custom environment-specific builds.
• create frequent builds to catch all possible issues earlier.
• optimize your hardware resources spreading the work between several machines (Build agents) running in parallel or in sequence.

In general, when specifying dependencies, you just divide a single build procedure into several parts that can be run on different Build agents setting a subordination of one build configuration on a different one. So, specifying dependencies in TeamCity you simply create rules stating that, for example, builds of the A build configuration depend on the build of the B build configuration.

TeamCity let's you specify two different types of dependencies for your builds; these are snapshot and artifact dependencies.

Snapshot dependency is a dependency of a build configuration on a different one which ensures that both builds use the same sources, and these sources revisions correspond to the same moment of time. If a build is queued and there is no dependent build for the same sources snapshot, the necessary dependent build automatically gets into TeamCity's build queue.

Artifact dependencies provide you with convenient means to use the output (artifacts) of one build in a different one. When your set up the artifact dependency, the required artifacts are downloaded to the agent before a build starts. Any time later you can then take a look at what artifacts were used in a build or what build used artifacts of the current build on a Dependencies tab of the Build Results page.

To specify dependencies in your project, navigate to the Administration, then create/edit build configuration and then select Dependencies.

Technorati tags: TeamCity, dependent build, dependency, artifact, continuous integration, build management, agile development, JetBrains, IntelliJ IDEA, Eclipse, MS Visual Studio 2005, MS Visual Studio 2008

The Search feature has existed in TeamCity for quite a while and in version 4.0 we’ve made a number of improvements in it to provide you with smarter and easier information retrieval experience, say, find the info on particular issues or tests you have fixed recently, learn about the result of integration of a particular revision into the VCS, and much more.

After you have installed and started running TeamCity, it aggregates different projects-related information in the background making it available for search. Employing a power of a well-known Lucene engine TeamCity adds many features to help you save your time and make searching more intuitive, in particular:

• using partial (starts-with) match, so you don’t need to type the whole VeryLongName anymore,
• searching all build information from tags up to concrete file revisions, making simple one-word queries work,
• matching all terms by default, so you can easily narrow your search results,
• adding handy shortcuts and magic patterns to form a concise query.

For more details on what information is available for querying and how to create complex search queries, please refer to TeamCity on-line documentation and watch a short demo which covers some advanced search techniques for finding:

• a group of issues mentioned in commit comments using fuzzy search,
• all builds created during a particular period,
• build configurations that run specific test,
• build of a particular configuration containing an exact file revision.

Please note that some of enhanced search features are available only within EAP of TeamCity 4.0.1 so don’t miss your chance to participate in it.

Technorati tags: TeamCity, search, pre-tested commit, personal build, remote run, JetBrains, IntelliJ IDEA, Eclipse, continuous integration, build management, agile development, MS Visual Studio 2005, MS Visual Studio 2008