Lighting up your build process

What we all want is a nice automated build process that runs on checkin and gives an indication when thingsgo awry. Well, it should indicate everything is fine too, obviously.

The system you want to look into is CruiseControl.Net. I hope to get into some of the nice things it can do. For now, suffice it to say it connects to a source control system, pulls changes, spawns a build and informs interested parties about what just happened.

One of the interested parties will very likely be CCTray, a tray icon application that shows a green or – as it sometimes happens – red light in your tray area of the desktop.

Sometimes that is enough, sometimes not. What I want is a clearly visible light, like a lavalamp or something that bubbles away in the corresponding color. If I’m crazy, I am not alone – Ken Nichols and Nigel Thorne offer two excellent examples of seemingly sane people that had the same idea.

Using the publisher pattern of Nigel’s is a really elegant idea. Unfortunately my build server sits in a server room with no windows, and way too far for an extension cord to my lava lamp. Thus, I resorted to Ken’s approach of hacking CCTray with the idea of connecting everything to my development box. Due to a variety of reasons that didn’t work out so well, so I employed an old lap top to listen to build events and control the lava lamp.

Controlling the lava lamp by software and hardware is explained in this post.

Hacking cctray

Thanks to Ken’s post I found a nice entry point to cctray.

  1. public MainFormController(ICCTrayMultiConfiguration configuration, ISynchronizeInvoke owner)
  2. {
  3. […]
  4.   new BuildTransitionSoundPlayer(aggregatedProjectMonitor, new AudioPlayer(), configuration.Audio);
  5.   new BuildTransitionLavaLamp(aggregatedProjectMonitor); // Add this line
  6.   if (configuration.X10 != null && configuration.X10.Enabled)
  7. […]
  8. }

The BuildTransitionLavaLamp class is defined as

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Text;
  4. using System.Windows.Forms;
  5. using ThoughtWorks.CruiseControl.CCTrayLib.Configuration;
  6. using ThoughtWorks.CruiseControl.CCTrayLib.Monitoring;
  7. using CardAPI;
  8. using System.IO;
  9.  
  10. namespace ThoughtWorks.CruiseControl.CCTrayLib.Presentation
  11. {
  12.   class BuildTransitionLavaLamp
  13.   {
  14.     private enum ShowResult
  15.     {
  16.       MessageBox,
  17.       Nothing
  18.     }
  19.     private List monitoredProjects = new List();
  20.     public BuildTransitionLavaLamp(IProjectMonitor monitor)
  21.     {
  22.       GetMonitoredProjects();
  23.  
  24.       /*
  25.       monitoredProjects.Add("lava_fail");
  26.       monitoredProjects.Add("lava_pass");
  27.        */
  28.       monitor.BuildOccurred += new MonitorBuildOccurredEventHandler(Monitor_BuildOccurred);
  29.       CreateCard(ShowResult.MessageBox);
  30.     }
  31.  
  32.     private void GetMonitoredProjects()
  33.     {
  34.       string fileName = Application.ExecutablePath + ".ini";
  35.       if (!File.Exists(fileName))
  36.         return;
  37.       StreamReader configFile = new StreamReader(fileName);
  38.       string line;
  39.       while ((line = configFile.ReadLine()) != null)
  40.       {
  41.         if (!string.IsNullOrEmpty(line) && !line.StartsWith("#"))
  42.         {
  43.           line = line.Trim();
  44.           monitoredProjects.Add(line);
  45.           //MessageBox.Show(">>" + line + "<<");
  46.         }
  47.       }
  48.     }
  49.  
  50.     private Card card;
  51.     private static int greenLamp = 8;
  52.     private static int redLamp = 7;
  53.  
  54.     private byte buildPassRelays = (byte)(1 << (greenLamp – 1));
  55.     private byte buildFailRelays = (byte)(1 << (redLamp – 1));
  56.  
  57.     private void Monitor_BuildOccurred(object sender, MonitorBuildOccurredEventArgs e)
  58.     {
  59.       string projectname = e.ProjectMonitor.Detail.ProjectName;
  60.       //MessageBox.Show(">>" + projectname + "<<");
  61.  
  62.       if (monitoredProjects.Contains(projectname))
  63.       {
  64.         //MessageBox.Show("Acting");
  65.         bool status = e.BuildTransition == BuildTransition.Fixed || e.BuildTransition == BuildTransition.StillSuccessful;
  66.  
  67.         if (card == null)
  68.           CreateCard(ShowResult.Nothing);
  69.  
  70.         if (card == null)
  71.           return;
  72.  
  73.         if (status)
  74.           card.SetRelays(buildPassRelays);
  75.         else
  76.           card.SetRelays(buildFailRelays);
  77.       }
  78.     }
  79.  
  80.     private void CreateCard(ShowResult showResult) {
  81.       try {
  82.         card = new Card();
  83.       }
  84.       catch (Exception e) {
  85.         if (showResult == ShowResult.MessageBox)
  86.           MessageBox.Show("Failed to create Card.\n" + e.Message);
  87.       }
  88.     }
  89.   }
  90. }

What this code does is simply to

  • Load some config from an ini-file
  • plug into the listening event of project transitions
  • Send commands to the card.

The config file is simply an ini-file with project names.

The sample projects lava_pass and lava_fail are defined as

  1.  
  2.                         cmd
  3.                         /c exit 1
  4.  
  5.                         cmd
  6.                         /c exit 0

Compile everything and move onto the machine hosting the relay card and you’re done.

–Jesper Högström

  • Share/Bookmark
October 8th, 2008 in .Net, development infrastructure

Comments (2)

Nigel ThorneOctober 9th, 2008 at 11:24 am

Love the solution Jesper.

I did a later version of my publisher idea that talked to lightserver that could be run anywhere and kept track of which builds were passing. It means you can use it for several builds.

The problem I have is that if a build fails and then the build machine goes off the light_server has no way of telling so it stays red.

I have heard about people using the new digital photo-frames as cheap monitors for displaying an image for fail and another for passing. I like that idea. :)

adminOctober 10th, 2008 at 3:24 pm

The solution with the relay card is kind of nice in that it keeps the state all the time. I turn off the lava lamps during night time, but leave the relay card running.

I guess it would also be possible to save state in a file, and restore that state when the listener goes on line.

Maybe you could strip down cctray and integrate it with the light_server? That way you will get signals when the build server comes back on line.

Leave a comment

Your comment