Archive for the ‘FYI’ Category

Welcome our new Company Blog!

Tuesday, August 21st, 2012

Dear Friends,

As you know, we’re a company of software products. 14 are already known to the wider audience, and more are to come sooner or later.

But a company isn’t just what we develop. It’s also who we are, what we’re passionate about, what inspires us, and what we believe in. We decided to share these essential parts of our world called JetBrains with you – in the JetBrains Company Blog. In fact, it’s been in the works for quite some time and is finally coming to life.
Check in often to get to know us better – the people, the events, the hobbies, the beliefs, the anecdotes and the pure facts – everything behind the tools that we make for you.

Don’t miss our Interview with JetBrains’ John Lindquist, already published on the blog.

Stay tuned for more news and keep developing with pleasure!

Your TeamCity Team

 

TeamCIty 6.5.5 bugfix update

Thursday, October 27th, 2011

New bug-fix update is available – TeamCity 6.5.5. Several performance problems were addressed in this build, as well as quite old issue with symbolic links (TW-7938) and some other bugs: see the complete list of fixed issues.

Download the build and share your feedback with us.

Happy building!

TeamCity Service Messages Library for .NET

Monday, October 24th, 2011

TeamCity uses Service Messages to provide an easy API to allow for build scripts integration, i.e. the build providing status reports, artifacts publishing, test reporting, etc. A Service Message has the following format:

##teamcity[hello message='teamcity' version='6.5.x' comment='awesome']

Service Messages introduce a communication protocol for data exchanges  between processes using streams, sockets, HTTP or pipes.

I’ve created a wrapper to allow for easier interaction with TeamCity Service Messages, providing it as a package available on NuGet.

Usage

PM> Install-Package TeamCity.ServiceMessages

The library contains two main classes. One for reading and one for writing service messages.

Reading service messages

Reading service messages can be done using a TextReader or string with minimal memory requirements:

  using JetBrains.TeamCity.ServiceMessages.Read;
  ...
  var parser = new ServiceMessageParser();
  using(TextReader reader = ... ) {
     foreach(var message in parser.ParseServiceMessages(reader)) {
        /// process IServiceMessage object
     }
  }
  ...

Parse method gives us an IEnumerable of IServiceMessage:

  public interface IServiceMessage
  {
    [NotNull]
    string Name { get; }
    [CanBeNull]
    string DefaultValue { get; }
    IEnumerable<string> Keys { get; }
    [CanBeNull]
    string GetValue([NotNull] string key);
  }

The Name is the name of service message, i.e. ‘name’ in ##teamcity[name'aaa'].
The DefaultValue contains simple value, i.e. ‘value’ for ##teamcity[name 'value'] or null for service message with attributes, i.e. ##teamcity[name tea='hot' ice='cold']. To access service message attributes use Keys property and GetValue method.

Writing service messages

To create a service message you may use anonymous type for service message attributes:

using JetBrains.TeamCity.ServiceMessages.Write;
....
string serializedMessage
  = new ServiceMessageFormatter().FormatMessage(
        "rulez",
        new {
          Version = "3.2.2",
          Mode = "zoom"
        }));
/// returns:  ##teamcity[rulez Version='3.2.2' Mode='zoom']
...

The previous is the simplest way for creating service messages, although you may use a strongly typed approach:

using JetBrains.TeamCity.ServiceMessages.Write;
....
string serializedMessage
  = new ServiceMessageFormatter().FormatMessage(
        "rulez",
        new ServiceMessageProperty("Apple", "239"),
        new ServiceMessageProperty("Pie", "42")
  ));
...

Summary

The source code for the project is available on GitHub and the build is at TeamCity.CodeBetter.Com and with TeamCity support for NuGet, it automatically publishes the library as NuGet package on NuGet.org. For a full description of the format and usages of Service Messages see the Build Script Integration with TeamCity article.

NuGet plugin

Wednesday, July 20th, 2011

Today I’d like to share with you a plugin for TeamCity 6.5 that provides support for NuGet, the open source developer focused package management system for the .NET platform. What does the plugin bring?

NuGet Packages Installer

The plugin adds dedicated build runner that allows you to:

  • Install NuGet packages without having to check them in to the version control, which comes in handy especially when using a DVCS, like Mercurial or Git. The problem and a workaround is also covered in David Ebbo post.
  • Automatically update package dependencies to the most recent ones (optionally).

Note, that for installing and updating packages we use NuGet.exe install and NuGet.exe update commands respectively.

NuGet Packages Tab

Once you start using NuGet Packages Installer in your build, you most likely will need to know the exact versions of packages used in the build, and that’s very easy to do – they are listed in the build results at the corresponding tab:

NuGet Dependencies Trigger

Do you want TeamCity to run a build if a build packages are updated? Easy as a pie – just add NuGet Dependencies Trigger to your build configuration. It will start a build if there is a NuGet packages update detected in NuGet repository:

Feel free to try the plugin – download the latest build (the plugin is called dotNetPackagesSupport) and follow the installation instructions in the plugin docs.  Do not hesitate also to update/report sources at https://github.com/jonnyzzz/dotNetPackagesSupport.

Enjoy!

Build Agent API Changes

Monday, October 4th, 2010

After our posts about TeamCity’s new multiple build steps (previously called “multiple build runners“) feature and further changes in .NET build runners, I believe that plugin developers might have some questions to be clarified.

So today, I’m going to shed some light on the major agent-side API changes that we’ve made to support multiple build steps. I hope this post will help you to painlessly improve your build runner plugins.

AgentRunningBuild interface no longer represents parameters for a build runner. We’ve introduced new interface BuildRunnerContext that provides parameters for build runner. Starting with TeamCity 6.0 AgentRunningBuild will only describe a build.

Note that there is no getter for BuildRunnerContext in AgentRunningBuild. AgentLifeCycleListener interface now provides BuildRunnerContext in build step related methods.
We’ve added runnerFinished event and updated almost all build-related events signatures to contain AgentRunningBuild and BuildRunnerContext instances. So, in most cases one will not need to cache those instances in a plugin code.

So if you ask yourself, what to do to improve your build runner, the answer is simple. If your build runner is implemented by extending CommandLineBuildService, you need to extend BuildServiceAdapter abstract class. This class contains all getters for all parameters you may need in build runner implementation.

Of course, this post doesn’t cover all the details, but only gives general tips. So don’t hesitate to ask questions, I’ll be glad to answer.

JetBrains E-Shop, Community Blackout Recovery Schedule

Tuesday, July 13th, 2010

Hello all,

This is a post for those of you who’s currently trying (and failing) to buy something from JetBrains, or to submit a bug into our issue tracker, or contribute to one of our community resources.

Today the extreme heat in Europe finally took a toll on us in the form of blackout that temporarily took down a part of our online assets.

While the majority of resources at jetbrains.com is available, our e-shop section is down (which is why you aren’t currently able to order any of our products), as are our bug tracker, wiki, and forums.

We’re regularly getting updates on the recovery progress, and the current (quite rough) recovery time estimate is today evening, 19:00 CET.

We apologize for the inconvenience, and we’re really hoping for a quick recovery.

Update! Seems like it’s all over, and on schedule! Power supply is resumed, meaning that YouTrack, Confluence, and JetBrains e-shops are now back online, and our support service is working well!

TeamCity Twitter Notifier

Thursday, June 24th, 2010

TeamCity provides several ways of getting notified about your builds’ status, like e-mail notifications, Jabber/XMPP instant messages and more. All the notifiers allow flexible customization to fit your needs.

However, there are other ways to keep track of your projects. For example, Scott Cowan has created TeamCity Twitter Notifier plugin. The installation is easy, and providing that Twitter allows to create private accounts, you can keep project notifications both restrictive and accessible. So if you like to twit, give it a try!

Twitter Notification

By the way, check the list of the plugins for TeamCity – you may find something interesting for you, or try to create your own.

Sincerely,
The JetBrains TeamCity Team

TeamCity 5.1 EAP (build 13215)

Thursday, March 25th, 2010

Yet another TeamCity 5.1 EAP build is now available. Here is the list of features and improvements included in it:

  • Customizable list of build configurations on the Overview and My Changes pages.
  • Improved Diff view.
  • HTML email notifications.
  • Ability to run personal builds with custom build parameters from IntelliJ IDEA.
  • Artifact dependencies improvements.
  • TFS 2010 support in Visual Studio addin.
  • and more.

See the complete release notes and try the build.
Do not forget to back up your data before upgrade.

Feedback is welcomed!
The JetBrains TeamCity Team

TeamCity 5.0.3

Tuesday, March 16th, 2010

The fresh update for TeamCity, which comes with a number of bug-fixes in it, is now available.

Check the release notes for the complete list of included changes and download the build.

As usual, we recommend backing up your TeamCity data before upgrading to a new version.
Stay tuned and try TeamCity 5.1 EAP.

Feedback is always welcomed!
Sincerely,
JetBrains TeamCity team.

Opening TeamCity 5.1 EAP

Thursday, February 25th, 2010

We are glad to announce, that we’ve just opened an Early Access Program for TeamCity 5.1.

Here’s the short list of only some of the improvements and features that today’s EAP brings:

  • Customizable email notifications — now you can use FreeMarker templates to create your custom notification messages.
  • Several UI improvements, such as collapsible projects on overview page and the most voted one — the ability to specify time zone, which is handy for geographically dispersed teams.
  • New Current problems tab is added for a project, that shows which tests are currently failing in this project and which configurations are red.
  • Support for .NET 4.0, and not yet released Visual Studio 2010 and TFS 2010.
  • Improved support for .NET test frameworks.
  • Code coverage support for Maven runner.
  • Ability to produce zip and tar.gz artifacts from a bunch of files.
  • IDE integration plugins improved.
  • read more…


View the detailed release notes, download the build and stay tuned — TeamCity 5.1 won’t take long to appear.

By tradition, we remind you to back up your data before upgrade.

Looking forward to your feedback!

Sincerely,
JetBrains TeamCity team.