JetBrains TeamCity Blog

When running your builds, TeamCity selects between the build agents taking into account a whole set of different factors and parameters. First and foremost, it tries to run the build on the fastest available build agent based on builds history of a build configuration on this agent. And since the available build runners depend on environment where the agent is running, TeamCity chooses an agent having required a build runner.

Until recently it was possible to run the build on desired build agent only from the web interface by, for example, clicking the Run button and selecting the desired agent from the list. The Run configuration policy, which we have told you some time ago, allows to make TeamCity create builds of some build configurations only on specific build agents. As a result, TeamCity will create builds of the build configuration only on specific build agents no matter if they are initiated:

• manually (either from the web interface or using the pre-tested commit)
• automatically when the changes appear in the version control system
• periodically (a time-based trigger is enabled)

With TeamCity plugin for IntelliJ IDEA you can now opt to select one or several build agents to run your personal build on. Such approach allows you to test your changes with more granularly under:

• desired platforms,
• operating systems,
• databases,
• environment variables.

which are specified for the build agent available in your company’s build grid:

The latest builds with the updated IntelliJ IDEA plugin are available at our EAP page.

We hope you will greatly enjoy the feature and use it on a daily basis.

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

The release of TeamCity 4.0 is not far away, and you have a chance to try a number of its cool new features right now:

• “same sources” dependencies between the build configurations ensuring your build starts only after the build it depends on is run and finished
• “history builds” getting the desired changes from the list of the latest ones
• enhanced search allowing to find builds by their status text, VCS label, test name, trigger name, changes committer and more
• multiple user interface changes including redesigned Change Log and others

Download the latest EAP build, read new features description in the release notes and familiarize with the list of fixed issues.

And, as usual, we urge you to backup your data before upgrade to a new version.

Wish you a happy building and eagerly wait for your feedback!
The JetBrains TeamCity Team

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

Great news for users of TeamCity 3.x and earlier versions! We are glad to announce the availability of TeamCity 3.1.2. This minor release brings yet more enhancements, including:

• Database migration tool improvements
• Version control integration fixes for VSS, CVS, and StarTeam
• Support of Subversion 1.5 working copy format for Microsoft Visual Studio and Eclipse plugins (Subclipse versions 1.2.x and 1.4.x are now supported)
• Better performance and numerous other fixes

 
Download TeamCity 3.1.2.
 
And, as always, we urge you to backup your data before upgrading to a new version.

 
Wishing you a happy building!
The JetBrains TeamCity Team

Technorati tags: TeamCity, 3.1.2, JetBrains, IntelliJ IDEA, Eclipse, MS Visual Studio, continuous integration, build management, agile development, vcs, pre-tested commit

Among many other plans for the forthcoming TeamCity 4.0 release, we want to extend the list of supported version control systems, and this time we bring you the long-waited Mercurial.

At the moment Mercurial support is implemented via a plugin enabling:

• server-mode checkout
• collection of developer’s changes
• checkout rules support and checkout on the server

In our nearest plans are remote run, checkout on the build agent, and bundling the plugin into TeamCity installation package.

The plugin it is compatible with TeamCity 3.1.x and TeamCity 4.0 EAP builds. Meanwhile, you can download plugin files at our public demo server. Look for TeamCity Plugins project, Mercurial SCM Support build configuration and download either mercurial-server.zip or mercurial-src.zip file.

Follow these simple instructions to enable Mercurial support in your TeamCity installation after downloading the mercurial-server.zip:

• for TeamCity 3.1.x server, move the mercurial-server.zip to the WEB-INF/lib directory of the TeamCity server,
• for TeamCity 4.0 EAP builds, put the whole zip archive into the .BuildServer/plugins folder and restart the server.

The mercurial-src.zip contains the plugin sources available under the terms of Apache 2.0 license, and you can also obtain source code of the plugin from the mercurial repository where it actually resides.

We wait for your feedback and suggestions and wish you a happy building!

Technorati tags: TeamCity, JetBrains, Java, VCS, .NET, IntelliJ IDEA, continuous integration, build management, agile development, best practices, MS Visual Studio 2003, Eclipse, Mercurial, CMS

After, yes, we admit, a long break we unleash a new EAP build of TeamCity 4.0 which has a great number of new features, plus multiple performance improvements and bugfixes. Among the major ones:

• reordering of NUnit tests
• redesigned plugins packaging
• possibility to redefine certain build parameters on manual build run
• running personal builds on a specific build agent from within IntelliJ IDEA
• configurable charts on Projects page
• support for Diana (IntelliJ IDEA 8 EAP project file format)
• and much more…

Please download this build and familiarize with the release and upgrade notes.

Happy building and wait for your feedback!

Technorati tags: TeamCity, JetBrains, IntelliJ IDEA, Eclipse, EAP, roadmap, continuous integration, build management, database, MySQL, PostgreSQL, oracle, MS SQL 2005, agile development, MS Visual Studio 2005, MS Visual Studio 2008

If you want to investigate the problems of a particular build and find out, for example, the changes which caused the build failure, you can use TeamCity’s Difference Viewer. It allows to review the differences between two versions of a modified file and navigate between these differences.

You can access the Difference Viewer from almost any place in TeamCity’s UI where the changes lists appear, may it be Projects page, Build Configuration Home page, or Build Results > Changes tab and so on. After you click the modified file name, a new window opens:

In the window heading you can see the file modifications summary:

• file name alone with its status,
• changes author,
• comment for the changes list.

To move between changes, use the next and previous change buttons and red and green bars on the versions separator.

If you want to switch to the IDE and digg into the issue deeper, click the Open in the IDE button in the upper-right corner of the window. The file in question opens, and you will navigate to the exact change in your project file. Please note that you need to have a TeamCity IDE plugin installed for this.

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

Here, at JetBrains, we use TeamCity to build all our projects – commercial, open-source, and internal solutions. This is why we understand the value and importance of information that will be kept “inside” TeamCity server as well as the burden of setup, adoption, and maintenance of “yet another server” for your company.This is why we support four major industry-wide databases:

• MySQL (5.0.40+)
• PostreSQL (8+)
• Oracle (10+)
• Microsoft SQL 2005

to back end your TeamCity server, so you can reuse your existing IT infrastructure in the most efficient way.Â

To ease the evaluation process, TeamCity comes with a built-in pure Java database (HSQLDB) that works out of the box under any environment without any additional configuration. When you evaluate TeamCity to see whether it suits your needs and which benefits it brings, it collects information on the build results and preserves it in this simple built-in database. But because of its simplicity, the database does not scale well and is not targeted on a real production.

Once you decide to handle the software building process to TeamCity and use it for production purposes, you need to switch to one of the supported databases most suitable for your environment and infrastructure. Please note that after initial setup the external database does not require any kind of special maintenance – TeamCity server does everything automatically using the database you have selected, and you control performance, scalability, and safety.

The database switching process is rather simple and straightforward:

1. Stop TeamCity server.
2. Back up the TeamCity data directory.
3. Follow an extensive explanation of this procedure in the Setting up an External Database and Migrating to an External Database sections of our online reference.

We strive to make both adoption and production usage as easy as possible, and if you have any questions, comments or suggestions, please don’t hesitate to drop us a line – either here or at teamcity-feedback at jetbrains dot com.

Technorati tags: TeamCity, JetBrains, IntelliJ IDEA, Eclipse, EAP, roadmap, continuous integration, build management, database, MySQL, PostgreSQL, oracle, MS SQL 2005, agile development, MS Visual Studio 2005, MS Visual Studio 2008

After series of long discussions we have finally managed to extract a list of features based on your feedback and votes, and create a TeamCity 4.0 roadmap. Among the feature highlights of the following release:

• composite builds
• builds promotion
• statistics-related improvements
• .NET platform support enhancements
• teamwork facilitation

Let us note that the roadmap is still a subject of change, and we eagerly wait for your suggestions, votes, and feedback at our forum or issue tracker.

The preliminary release date is the fall of this year. Meanwhile, you can keep an eye on the development process and participate in our EAP program where you can always find the most recent builds and learn about changes and progress we have made.

As always we wish you happy building!
The JetBrains TeamCity Team

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

In addition to several time-saving features supporting quick testing and getting notifications as soon as the first problems appear, TeamCtiy now enables even faster feedback on tests results resulting in more rapid and efficient development. This new feature can become especially useful if your builds take rather long time (this case is true for our company as well) when the waste of time can become a critical factor of the project success.

When setting up the build runner of your build configuration with Ant and Ipr build runners and JUnit and TestNG frameworks you can now select to run:

• recently failed tests first (tests failed in previous finished or running builds and tests which fail from time to time)
• new and modified tests first (tests which were recently added or edited in your changelists and included in the running build)

Selecting these options you forces your build run these types of tests before any others.

You can select either one or both of these types of tests and use the feature if you run tests using your own custom build runner.

Now just a few words about how tests reordering mechanism works:
TeamCity provides tests that should be run first (test classes), after that when a JUnit task starts, it checks whether it includes these tests. If at least one test is included, TeamCity generates a new fileset containing included tests only and processes it before any other filesets. It also patches other filesets to exclude tests which were added to the automatically generated fileset. After that JUnit task starts and runs as usual.

We hope the feature (available in the latest EAP build) will save much time for you, and you will use it on a daily basis especially when starting personal builds.

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

In the forthcoming version of TeamCity, which we are working on right now, we want you to gain more control and a useful overview of the specific project. This is going to be a “space” for evaluating its different aspects.

Clicking some project name on the Projects page you now navigate to a page containing a list of all project’s build configurations and their statistics.

The Overview tab displays quite common build configuration-related information (similar to what you see on the Projects page). On the Statistics tab you can view several graphs depending on the build configurations specified for the project; these can, for example, be inspections, duplicates, coverage and number of code lines. You can change the view of the graphs by applying various filters and provide your own metrics soon.

We are polishing the feature right now, and will likely introduce some serious changes in it. We’ll tell about them in the nearest posts but right now we would like to get as many comments and suggestions as possible.

Download the EAP build and share your opinion with us at our tracker or online forum.

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