Jeff Handley - Headless Horseplay - MediaSmart Home Server Status Indicators

I am working on a Family Photos application that organizes digital pictures into a chronological structure. I had ~~created~~ thrown together an application like this years ago, but it was no longer going to cut it, especially with the new Windows Home Server in the mix. One key requirement for Family Photos is to very easily move pictures off of the SD card from the camera, queuing them up for organization, and allowing the SD card to be taken back and put back into the camera. Our old process involved the following:

Unlock the screen for Jeff's computer
Plug the SD card into the SD->USB adapter
Double-click an icon on the desktop (minimizing windows if needed)
Watch the console window and wait for it to print a message stating that the program has finished moving all files off the drive
Take the SD card out and be on your way

While a little clumsy, it had a high WAF. Kelly knew how to do it, and it allowed her to be on her way in minutes, with a clear indication as to when she could take the card out. Family Photos needs to offer the same benefits while ideally simplifying the process even further.

The HP MediaSmart Windows Home Server adds an interesting twist on this problem too: it's headless. No monitor, keyboard or mouse. That means there's no icon on the desktop, no mouse to click with anyway, and no console window to offer status indicators. There's no user input and no output. So how can we tell the server, "Hey, I just put in a drive that has photos. Take the photos off of there as quickly as possible and let me know when you're done so that I can take the drive back. Then, after I'm gone, organize all of the pictures for me. Thanks!" I haven't done any recreational coding since we moved, but this problem has been stirring in the back of my head for months. I'm finally working on it, and it feels great.

It boils down to the two requirements: the server needs to accept input, and it needs to give output. The rest of this article will focus on the output aspect, and we'll leave the input for another post. We need to think hard about ways the home server can provide status indicators as its output. Let's consider some options, ignoring the user input problem.

Require a remote desktop session into the server to perform the task so that a console window can show status, just like the old process
Send an email or IM when completed
Send a network message to the family laptop, triggering it to pop up a dialog

None of those is good. This is where I was stuck for a long time. But the other night, I thought of option 4, and it was the clear winner.

Find a way to programmatically flash the LEDs on the MediaSmart server

The MediaSmart server console provides a slider that adjusts the brightness of the LEDs for the drives. The idea was to crank the brightness all the way up while the files were being moved over, and then dim the lights way back down when finished. I'd tell Kelly, "When the lights basically turn off, you can take the card back out." So, how can the brightness be controlled programmatically? Let's ask Google.

Shiver me timbers! An Easter Egg!? That lets you perform light shows on your MediaSmart Server? Go read this post and watch the video real quick to see what I’m talking about.

…

Now, that's just cool! And boy does that offer up some new possibilities! It turns out that the MediaSmart servers support an array of light themes, along with the variable brightness. Instead of just changing the brightness, I can alter the light theme to give clues as to what the server is doing.

Specifically, when the process is copying files up from the USB stick, I'll have bright, red lights ascend over the USB drive. When that's finished and the server begins doing some crazy processing of the photos, I'll have the server put on a holiday light show. The dramatic change in theme will clearly indicate that the server is finished copying the files and it's off doing work--take the card out whenever you'd like.

It only took a minute to find that the LED settings are stored in the registry under HKLM. And it was pretty straight-forward to determine the values of the themes and the brightness. With this information in hand, the HomeServer.Notifications.Lights class is born.

using System;
using Microsoft.Win32;
  
namespace HomeServer.Notifications
{
  /// <summary>
  /// Manipulate the lights on an HP MediaSmart Windows Home Server
  /// </summary>
  public class Lights : IDisposable
    {
  // Registry LocalMachine key path where the values are stored (as DWORD values)
  private const string _key = @"SOFTWARE\Hewlett-Packard\HP MediaSmart Server\LEDs";
  
  // The registry key that we'll work against
  private RegistryKey _leds;
  
  // Whether or not the key is currently opened for writing
  private bool _isWriting;
  
  /// <summary>
  /// Gets whether the lights are available on the current system.
  /// </summary>
  /// <remarks>
  /// When unavailable, any attempt to read or write values will
  /// result in an InvalidOperationException.
  /// </remarks>
  public bool Available
        {
            get
            {
  // Try to open the registry key for reading
                OpenForReading();
  
  // If we found the key, then indicate that the lights are available
  return _leds != null;
            }
        }
  
  /// <summary>
  /// Gets or Sets the native value for the brightness
  /// </summary>
  private object BrightnessValue
        {
            get
            {
  return Read("Brightness");
            }
            set
            {
                Write("Brightness", value);
            }
        }
  
  /// <summary>
  /// Gets or Sets the native value for the theme
  /// </summary>
  private object ThemeValue
        {
            get
            {
  return Read("Theme");
            }
            set
            {
                Write("Theme", value);
            }
        }
  
  /// <summary>
  /// The current brightness value: 0-9
  /// </summary>
  public Int32 CurrentBrightness
        {
            get { return Convert.ToInt32(BrightnessValue); }
            set
            {
  if (value < 0 || value > 9)
                {
  throw new ArgumentOutOfRangeException("Brightness values must be 0-9");
                }
  
                BrightnessValue = value;
            }
        }
  
  /// <summary>
  /// The current Theme of the lights
  /// </summary>
  public Theme CurrentTheme
        {
            get { return (Theme)Convert.ToInt32(ThemeValue); }
            set { ThemeValue = (Int32)value; }
        }
  
  /// <summary>
  /// Open the registry key for reading
  /// </summary>
  /// <remarks>
  /// Store the open key in a member variable, and don't re-open
  /// the key if it's already open
  /// </remarks>
  private void OpenForReading()
        {
  if (_leds == null)
            {
                _leds = Registry.LocalMachine.OpenSubKey(_key, false);
            }
        }
  
  /// <summary>
  /// Read a native value from the registry key
  /// </summary>
  /// <remarks>
  /// Will ensure the lights are available and then open the key
  /// for reading in order to get the value
  /// </remarks>
  /// <param name="valueName"></param>
  /// <returns></returns>
  private object Read(string valueName)
        {
            EnsureAvailable();
            OpenForReading();
  
  return _leds.GetValue(valueName);
        }
  
  /// <summary>
  /// Write a native key value
  /// </summary>
  /// <remarks>
  /// Will ensure the lights are available and that the key
  /// is presently opened for writing.  If it was previously
  /// opened for reading, it will be closed and then re-opened
  /// for writing.
  /// </remarks>
  /// <param name="valueName"></param>
  /// <param name="value"></param>
  private void Write(string valueName, object value)
        {
  // Make sure the lights are available
            EnsureAvailable();
  
  // If we already had the key open for reading, close it
  if (_leds != null && !_isWriting)
            {
                _leds.Close();
                _leds = null;
            }
  
  // If we don't have the key open, open it for writing
  if (_leds == null)
            {
                _leds = Registry.LocalMachine.OpenSubKey(_key, true);
                _isWriting = true;
            }
  
  // Set the value and flush to disk
            _leds.SetValue(valueName, value);
            _leds.Flush();
        }
  
  /// <summary>
  /// Ensure the lights are available.  When unavailable, throw
  /// InvalidOperationException.
  /// </summary>
  private void EnsureAvailable()
        {
  if (!Available)
            {
  throw new InvalidOperationException("Lights not available.  Maybe this isn't a MediaSmart server.");
            }
        }
  
  /// <summary>
  /// Implement IDisposable, properly disposing of resources
  /// </summary>
  public void Dispose()
        {
  // Close the registry key if still open
  if (_leds != null)
            {
                _leds.Close();
                _leds = null;
            }
        }
  
  /// <summary>
  /// Offer some helper values for brightness, allowing for consistent usage
  /// </summary>
  /// <remarks>
  /// This is a static class with these readonly properties instead of an enum
  /// because an enum would have required constant casting.
  /// </remarks>
  public static class Brightness
        {
  public static readonly Int32 Off = 0;
  public static readonly Int32 Low = 1;
  public static readonly Int32 MediumLow = 3;
  public static readonly Int32 Medium = 4;
  public static readonly Int32 MediumHigh = 5;
  public static readonly Int32 High = 7;
  public static readonly Int32 Max = 9;
        }
  
  /// <summary>
  /// The list of themes supported by the server
  /// </summary>
  public enum Theme
        {
            Default = 0,
            HolidayLights = 1,
            DescendingChaserBlue = 2,
            AscendingChaserBlue = 3,
            DescendingChaserPurple = 4,
            AscendingChaserPurple = 5,
            DescendingChaserRed = 6,
            AscendingChaserRed = 7,
            PulsingColors = 8,
            PulsingBlue = 9,
            PulsingPurple = 10,
            PulsingRed = 11,
            PulsingSystemColors = 12,
            NightRiderBlue = 13,
            NightRiderPurple = 14,
            NightRiderRed = 15,
            MorseCodeCredits = 16
        }
    }
}

The usage is pretty straight-forward.

if (lights.Available)
{
    lights.CurrentTheme = HomeServer.Notifications.Lights.Theme.AscendingChaserRed;
    lights.CurrentBrightness = HomeServer.Notifications.Lights.Brightness.Max;
}

The pattern I'm finding myself using is recording the original brightness and theme at the beginning of a process, then manipulate the lights during the process, and restore the lights afterward. I will be adding a more task-based API to the class, to support methods such as:

lights.StoreSettings();
lights.Show(Theme.HolidayLights, Brightness.Max);
// Do work here
lights.RestoreSettings();

I foresee using this class for other Home Server processes I end up writing, so that the server can report its status, and I can glean it from the couch. It'll be a balancing act between informative and annoying. We'll have to see what the WAF factor is on this one!