a little madness

A man needs a little madness, or else he never dares cut the rope and be free -Nikos Kazantzakis

Zutubi

Archive for the ‘Zutubi’ Category

Pulse 3.0 Alpha

With great pleasure I can announce the very first build of Pulse 3.0 is now available from our Alpha Program page! Although this build is very much incomplete and unstable, this is a huge milestone after months of work in both the back and front ends of Pulse.

As this is a larger release we’ve made the choice to release earlier in the cycle than we otherwise would, for a couple of reasons:

  • To show the massive progress that has already been achieved.
  • To solicit feedback about the all-new administration UI (in time to apply said feedback before feature freeze).

We know from previous feedback that the new UI will address some pain points, mainly around quickly navigating and understanding your configuration in a large setup. We’ve also taken advantage of modern browser features to fix clunky corners: e.g. proper history integration and drag-and-drop reordering (no more clickety-click!). With such major changes, though, we’re always keen to hear what you think — good or bad — so we can keep on the right track.

So please do find the time to download and play with an alpha build, then get in touch with us via support email. We’ll be iterating fast on this release stream now, so expect to see updates about regular builds with new UI features each time. Happy building!

Pulse Admin UI Updates

In my previous post, Pulse Roadmap Update, I mentioned that we are working on major changes to the Pulse administration UI. I also mentioned these changes were worthy of their own post, so here we are! After an initial evaluation and prototyping period, work on the new administration UI is now in full swing. We’ve still got months of work to go, but the direction has become clear enough for us to communicate.

As I mentioned previously, the main goals of this rewrite are discoverability and efficiency. We want it to be easier for you to find the configuration you’re after, and faster to make changes when required. We’re also dragging the admin UI from it’s humble lightly-scripted beginnings into the brave new world of HTML5 (we might even drop the quaint “AJAX-powered” terminology from our website 😉 ). For example: the new UI makes use of HTML history APIs to finally integrate with the back/forward navigation of the browser.

We’ll be making things more discoverable in two key ways:

  1. Providing an overview page for each project, which displays a summary of the main configuration in one place (key details from the SCM, recipes, requirements, properties, stages and dependencies). This will allow you to see what the project is about at a glance, without digging into the details.
  2. Making it easier to find where projects override values set in their template ancestors, as these are usually the key things you want to see and/or change. Currently overrides are marked but can only be found by browsing to their specific location in the configuration tree.

On the efficiency side, we also have multiple changes, some more visible than others:

  1. Navigating through the template hierarchy will be possible in a consistent way on every configuration page. You’ll be able to navigate to the same configuration in any other project (not just direct ancestors and descendants), where such configuration exists.
  2. The project and agent trees will be searchable, making it easy to jump straight to the instance you’re after.
  3. As mentioned above, proper browser history navigation is supported so you can easily jump back and forth.
  4. Under the covers a lot less data will be transferred between the Pulse master and browser, and the master will do a lot less work. The existing implementation has become heavyweight through multiple iterations and is being replaced with a lighter HTTP-friendly API with more work done on the client.

These are ambitious changes and as such we’ll be launching them in a new major version: Pulse 3.0! The implementation will also lay the groundwork for updates to other parts of the UI, as well as a new config API, although these will be held back for future releases. We prefer to ship sooner and tackle other areas incrementally rather than embark on a full rewrite. As always, while the next major version is in the works, Pulse 2.7 will be actively maintained including minor feature updates where practical.

Now, back to the UI work!

Pulse Roadmap Update

Long time users of our Pulse Continuous Integration Server would know that we don’t believe in posting long-term roadmaps. They just never reflect a changing reality! But we have always been happy to discuss features with customers, including keeping our issue tracker (creaky old version of Jira that it is) completely open for all to see and contribute. In that spirit I’d like to talk a little about where we’re heading with Pulse in the near term, the bit that can be predicted, in a format more digestible than disparate issues.

The next version of Pulse (as yet unnamed), will have updates focused on a few areas:

  1. Upgrades of underlying libraries including Equinox, Spring, Spring Security, Hibernate, Jetty, Quartz, EhCache and more. If you haven’t seen a lot of visible changes reported recently this is why: these upgrades have occupied the first part of this development cycle. These are truly the most boring of all changes, which we hope you won’t notice directly at all! What you will notice, though, is a payoff of this strong foundation over time.
  2. Major updates to the administration interface. The interface works well enough at the moment but could be improved in a couple of key areas: discoverability and efficiency. Key goals for these updates include:

    • Improving the visibility of the most commonly-used configuration via overview pages.
    • Making it easier to discover what is overridden (via templating) and where.
    • More efficient navigation, especially through the template hierarchy.
    • Modernisation to take advantage of HTML 5 (which the current interface predates).

    These changes are big enough to warrant a dedicated blog post at a future point.

  3. Improved visibility of the build environment. When builds fail in curious ways the culprit is often a small difference in the environment. Pulse currently publishes environment information via implicit env.txt artifacts, but these haven’t kept up to date with the variety of options Pulse now gives for specifying build properties.
  4. Improvements to the Windows experience. In 2.7 work was done to improve Windows service support, but more could be done to streamline the setup process in particular.

As always we will also be working on dozens of smaller improvements and suggestions from our user base, most of which fall under one of:

  • UI polish, especially in the reporting interface.
  • Increased flexibility of project and build configuration.
  • Updated support for modern versions of build tooling.

Customers are more than welcome to connect with us via our support email, support forum, or issue tracker to discuss these and other changes you’d like to see in Pulse!

Pulse Pricing Updates

To all Pulse customers, existing and potential, a bit of news: we’ve applied some long-overdue changes to pricing. Well, not changes so much as clarification! Since the initial release of Pulse we’ve always favoured an up-front pricing policy. We loathe hidden pricing designed to lure you into a lengthy, pushy sales process. So our sales front page has always included pricing information.

However, the pricing on the page didn’t show the full reality. We had three tiers of pricing for 1, 5 and 15 agents, then the option of license 10 packs on top. In practice customers often asked a few questions:

  1. Can we get a more specific number of agents, e.g. 10?
  2. Can Pulse handle large numbers of agents, well beyond 15?
  3. Do discounts apply as the number of agents continues to grow?

In all cases the answer has been yes. We aim for flexibility, and have allowed anyone that asked to purchase a smaller number of agents at a time. Pulse can certainly handle many more than 15 agents: some customers have hundreds in production and we’ve always offered discounts for high numbers.

Thus it is about time we reflected reality in our published prices. From now on there are no defined agent pack sizes: you start with a single agent license for US$900, then add as many additional agents as you need. Agents are priced on a sliding scale so they become progressively cheaper as your installation grows. You can see this clearly on our updated sales page.

What does this mean for existing customers? As a matter of policy: no existing customer will lose out. If you have a deal better than the new published pricing, that deal remains. This may mean you can get more agents free, or a discounted renewal price next time around. For reference: the original single agent license is now US$50 cheaper, and this will translate to a US$25 discount for our existing Pulse Standard License holders. The pricing for 5, 15 and 25 agents remains identical, so many customers will see no change. Larger licenses will be dealt with individually as they come up for renewal.

We think this new pricing better reflects our aim to be both up front and flexible. If you have any questions, please contact sales.

Pulse 2.7 Released

I’m dusting off the blog with a bang, announcing that Pulse 2.7 has gone gold! This release brings a broad range of new features and improvements, including:

  • New agent storage management options, including the ability to prevent builds when disk space is low.
  • Configuration system performance improvements.
  • Live logging performance improvements.
  • Xcode command updates, including a new clang output processor.
  • A new plugin for integration of XCTest reports.
  • More flexibility and feedback for manual triggering.
  • New service support, including integration with systemd and upstart.
  • Improved support for git 2.x, especially partial clones.
  • Support for Subversion 1.8.
  • Improved dependency revision handling across multiple SCMs.
  • More convenient actions for cancelling builds.
  • The ability to run post build hooks on agents.

As always we based these improvements on feedback from our customers, and we thank all those that took the time to let us know their priorities.

Pulse 2.7 packages can de downloaded from the downloads page. If you’re an existing customer with an active support contract then this is a free upgrade. If you’re new to Pulse, we also provide free licenses for evaluation, open source projects and small teams!

Open Source at Zutubi

At Zutubi we’ve reaped massive benefits over the years from open source. We’ve contributed back bits and pieces in that time — feedback and patches — but always felt we could do more. You may have noticed recent posts here about some of our projects, but we thought they deserved a bit more attention. So we’ve recently launch an new open source section on our website. This is a home for a few small projects of our own that we’ve opened up to the community. We hope you find them useful!

So far we’ve listed three projects:

  1. android junit report: a custom test runner for Android projects that produces XML test reports in a format similar to the Ant JUnit task.
  2. zutubi android ant: a collection of Ant tasks that supplement the standard Android build tooling.
  3. zutubi diff: a Java library for reading, inspecting and applying patch files in unified diff and other formats.

Over time we hope to publish more of our work in this way. You can keep an eye out for new projects on our website and/or follow our organisation on GitHub (or indeed my own GitHub account for Android-specific projects).

And as always: feedback is welcome, so fork away!

Android: Easier Source Linking in Eclipse

In my prior post Android: Attaching Sources to Libraries in Eclipse I noted that ADT version r20 added the ability to link sources to libraries in the Android Dependencies classpath container in Eclipse. Although this was a welcome addition, the method used to link sources is a bit cumbersome: you must create a .properties file alongside each library, and add a property that points to the source jar.

I felt this could be a lot simpler if you are willing to adopt a convention for the location of source jars. Once the convention is established, adding linked sources is as simple as placing the source jar in the expected location. This makes the process as seamless as the Android Dependency container is for adding libraries in the first place.

So I’ve made this possible via a new libproperties task in my zutubi-android-ant project. This task inspects the jars in your libs/ directory, looks for corresponding source jars by naming convention, and adds appropriate .properties files when sources are found. If you’re willing to accept the default convention, where source a source jar for library libs/foo.jar is placed at libs/src/foo-source.jar, then this simple Ant target can be used to generate the required .properties files for you:

<target name="link-sources">
    <zaa:libproperties/>
</target>

Of course you’ll need to import the zutubi-android-ant tasks into your build file first. If you want to ensure sources are present for all libraries, set the attribute failOnMissingSrc to true and your build will fail if any source jar is missing. You can even establish your own conventions, using a regular expression to match the libraries and a replacement string to generate paths to source jars:

<target name="link-sources">
    <-- libs/alib-1.3.jar maps to libs/src/alib-src-1.3.jar -->
    <zaa:libproperties failOnMissingSrc="true"
                         jarPattern="(.+)-([0-9.]+)\.jar"
                         srcReplacement="src/$1-src-$2.jar"/>
</target>

Head over to the new zutubi-android-ant home page for more details, including quick-start instructions to get the tasks installed in your build in minutes.

Pulse Continuous Integration Server 2.5 Released!

After a smooth beta period, we’re excited to announce the release of Pulse 2.5! Massive credit for the new feature and improvement ideas in this release go to the Pulse community, whose feedback was invaluable. Here’s the brief list of what’s new:

  • Browse and dashboard view filtering (by project health).
  • A new MSTest post-processor plugin.
  • Increased visibility of build (and other) comments.
  • Comments on agents, to communicate with other users.
  • Properties on agents, for simpler parameterisation.
  • The ability to reference properties in SCM configuration.
  • The ability to configure SCMs using resources.
  • A resource repository on the Pulse master.
  • A new option to attach build logs to notification emails.
  • Upstream change reporting (changes via dependencies).
  • Downstream build notifications (again via dependencies).
  • Simpler delivery of directory trees via dependencies.
  • Pre-stage hooks, which run just before the stage is dispatched to the agent.
  • Stage terminate hooks, allowing you to run custom cleanup.
  • SCM inclusion filters, complementing existing exclusion filters.
  • Inverse resource requirements (i.e. requiring the absence of a resource).
  • Smart label renaming.
  • A distinct warnings status for UI and API consistency.
  • A separate permission for the ability to clean up build directories.
  • Support for git submodules.
  • Support for Subversion 1.7 in personal builds.
  • Support for Perforce streams.

For more details, see the new in 2.5 page on our website. Or, why not just download Pulse and try it free today?

Pulse Continuous Integration Server 2.5 Beta!

I’m happy to report that the Pulse 2.5 release stream has been upgraded to beta! This marks completion of the 2.5 feature set. Since the alpha release, we’ve powered through more features and improvements; examples include:

  • A new warning status, making it easier to work with builds with warnings.
  • The ability to reference properties in SCM configuration.
  • Another new stage hook points on stage termination.
  • Upstream change reporting to show how dependencies influenced a build.
  • Dependency notifications to show how your changes affected downstream builds.
  • Artifact archives, allowing easy delivery of directory trees between projects.
  • Flexible bootstrapping allows control over how your builds are prepared.
  • Subversion 1.7 working copy format support.
  • Git submodule support.

Our plan now is to focus on performance and stability for the next few builds before pushing 2.5 as the stable release. In the mean time you can find out more, and even try beta builds, by visiting our beta program page. Happy building!

Pulse Continuous Integration Server 2.5 Alpha!

Cobwebs may be creeping over the blog, but not over Pulse: we’ve just published the first Pulse 2.5 alpha build! The Pulse 2.5 series is focused (even more so than usual) on customer feedback. We’ve got plenty of great ideas from the Pulse community, and we’re folding in some of the best ones in this release series. Updates so far include:

  • Browse and dashboard view filtering (by project health).
  • A new MSTest post-processor plugin.
  • Increased visibility of build (and other) comments.
  • Comments on agents, to communicate with other users.
  • Properties on agents, for simpler parameterisation.
  • The ability to configure SCMs using resources.
  • A resource repository on the Pulse master.
  • A new option to attach build logs to notification emails.
  • Pre-stage hooks, which run just before the stage is dispatched to the agent.
  • SCM inclusion filters, complementing existing exclusion filters.
  • Inverse resource requirements (i.e. requiring the absence of a resource).
  • Smart label renaming.
  • A separate permission for the ability to clean up build directories.
  • Support for Perforce streams.

There’s plenty more to come in subsequent alpha builds, too. In fact, we’ve started the groundwork for some other larger changes already in 2.5.0.

To grab yourself a fresh-from-the-oven 2.5 alpha build, or just to find out more, head over to our alpha program page.