One of the long-standing MVC practices has been ‘Shun Magic Strings.’  For example, rather than specifying Controller/Action names in an ActionLink by string, we’ve always used an Expression<Action<TController>> instead to define the Controller class and Action method “in code.”  If the action changes in the future, this gives you somewhat better abilities to discover the problem sooner vs. later. 

MvcFutures includes a version of this idea, taken to the next level:  you provide the expression with the arguments you want passed to the action included – you don’t provide a 2nd anonymous type defining the arguments.  This gets rid of the somewhat confusing “null” arguments inside the expression, and just looks better overall.  Plus, if the arguments to the action change, you’ll get better warning of that as well.

<asp:Content ID="Content2" ContentPlaceHolderID="MainContent" runat="server">    <h2>Magic Strings are Evil</h2>    <p>        <%= Html.ActionLink<HomeController>(c => c.FavoriteNumber(16), "A Number") %>        <%= Html.ActionLink<HomeController>(c => c.FavoriteNumber(32), "Another Number") %>        <%= Html.ActionLink<HomeController>(c => c.FavoriteNumber(42), "Yet Another Number") %>            </p></asp:Content>

I like this method MUCH better. 

The implementation that makes this happen is in Microsoft.Web.Mvc.Internal.ExpressionHelper.  Which even though it’s in an “Internal” namespace, is neither marked Internal, Sealed, or otherwise made unavailable (hallelujah).  So you can use this trick for all sorts of things.

There is also a System.Web.Mvc.ExpressionHelper in the official MVC assembly, which is used to implement the smart Html.TextBoxFor(m => m.Property) functionality.  This class is also NOT internal, not sealed, not obfuscated and hidden away.  We’ve used it to extend the Html.[control]For() abilities to some other control types.  Very useful stuff.  Plus its just interesting code to read.

One potentially big caveat:  I’m told that the Html.ActionLink<TController>() methods don’t work if you’re using Areas in your MVC application.  I haven’t tried this myself, we aren’t using Areas in any of our MVC 2 applications yet.  That might be why this functionality is hidden in MvcFutures and not out with the rest of the smart expression code.

Problem: The raw bytes of the PDF are returned from SSRS by using the class Microsoft.SqlServer.ReportingServices2005.Execution.ReportExecutionService, via the Render() method.  This code works just fine in Dev, Test, and Stage environments – but in Production, without fail, this Render() method hangs and will never return back to the service process.

The Fix:  This functionality is a small bit in a much larger application, and even the PDF generation is a smallish piece of some larger responsibilities for the service.  So first, I want to isolate the behavior, and then duplicate it. 

I wrote a test windows service consisting of one project, that does one thing: when a timer fires, a hardcoded request to the production Reporting Services is made to get a PDF bytestream.  This service does what is expected in Dev and Stage, but when I tried to install it on Production:

An exception occurred while trying to find the installers in the C:\webreader\webreader.svc.exe assembly.
System.Reflection.ReflectionTypeLoadException: Unable to load one or more of the requested types. Retrieve the LoaderExceptions property for more information.
Aborting installation for C:\webreader\webreader.svc.exe.

Can’t load a type?!  So I copy Microsoft.ReportViewer.Common.dll and Microsoft.ReportViewer.WebForms.dll into the program directory, and my test service installs and works perfectly.  Copying the same files into the production service’s directory also fixes the problem.

So, if your Reporting Services ASMX calls are hanging, try changing your references over to “Copy Local” and see what happens…

Why this is weird: If those DLLs were missing or corrupt, then why did the original App code load and run (and hang)?  I thought perhaps the wrong version was referenced in the GAC, but no there were NO Microsoft.ReportViewer.*.dll’s registered.  The service installer caught the missing types when the references were all in one assembly, but didn’t have any problems when the references were spread into a 2nd assembly. 

Just when I think “hey, maybe I’m getting a hang of this .NET stuff” a problem like this happens…

Minimum and Maximum Zoom

This part is easy – I added two properties, MinimumZoom and MaximumZoom, default them to double.MinValue and double.MaxValue, and some trivial code in DoZoom to keep the scale values in line:

   1: public PanAndZoomViewer() {

   2:   MaximumZoom = double.MaxValue;

   3:   MinimumZoom = double.MinValue;

   4: }

   5: public double MaximumZoom { get; set; }

   6: public double MinimumZoom { get; set; }

   7:  

   8: public void DoZoom(double deltaZoom, 

   9:                    Point mousePosition, 

  10:                    Point physicalPosition) {

  11:   // Keep Zoom within bounds declared by Minimum/MaximumZoom

  12:   double currentZoom = zoomTransform.ScaleX;

  13:   currentZoom *= deltaZoom;

  14:   if (currentZoom < MinimumZoom)

  15:     currentZoom = MinimumZoom;

  16:   else if (currentZoom > MaximumZoom)

  17:     currentZoom = MaximumZoom;

  18:   // do zoom animation stuff...

  19: }

Limiting Pan Transform

This required slightly more thought, and some graph paper.  Having a clue about how WPF deals with its coordinate systems would have been helpful too.  I have a Canvas as the Content of my PanAndZoomViewer.  No matter what panning & zooming happens, this Canvas will always have a fixed Height and Width.  The Origin in our setup is always going to be the upper left corner of the Canvas, and remember that in the coordinate system used by Windows, “up” and “left” from that point are negative values.  (The Y axis is the opposite of what you’d expect).  Here’s a lame Paint.NET picture to help you understand:

The Red View area is the part of the map canvas you’re zoomed into and viewing.  The blue area is the entire map.  I don’t want you to be able to move the Red rectangle beyond the boundaries of the Blue Rectangle, because instead of viewing the map you’d be viewing the dining room table, or the Red Rectangle would fall off the table onto the floor, or something.

Handling the Left and Top boundaries of the Blue Rectangle are easy enough, at any zoom level.  If you were to move the Red Rectangle to beyond either of those edges, then one or both of the values for (ToX, ToY) would be positive (past the Origin corner).  So we reset positive values back to zero and then animate to keep things nice and smooth.

Pan Right, Bottom

The other two edges are slightly less intuitive, at least to me.  Consider the Right edge of the Red Rectangle View: I don’t want this edge passing over the Blue Rectangle.  This puts a “maximum” value on the distance from the Left Edge of the Red Rectangle (at X = 0), and the Left Edge of the Blue Rectangle.  Except that this value would be negative being to the left of the origin, so it’s really a minimum.  (Trivial arithmetic, I know, and yet I still messed it up the first time.) 

So, the minimum allowed ToX value is content.Width – (content.Width * scale).  If you try to move the Red Rectangle farther away, we just snap it back to the edge.  Same thing with the minimum Y values.

The Result

The code to handle this looks something like this:

   1: private void control_MouseMove(object sender, MouseEventArgs e)

   2: {

   3:     if (!IsMouseCaptured)

   4:         return; // don't care.

   5:  

   6:     // if the mouse is captured then move the content by changing the translate transform.  

   7:     // use the Pan Animation to animate to the new location based on the delta between the 

   8:     // starting point of the mouse and the current point.

   9:     Point physicalPoint = e.GetPosition(this);

  10:  

  11:     // where you'd like to move the top left corner of the view to

  12:     double toX = physicalPoint.X - ScreenStartPoint.X + startOffset.X;

  13:     double toY = physicalPoint.Y - ScreenStartPoint.Y + startOffset.Y;

  14:     Console.WriteLine("You're attempting to move to " + toX + "," + toY);

  15:  

  16:     double scaleValue = zoomTransform.ScaleX;

  17:     var content = (FrameworkElement)Content;

  18:  

  19:     // minimum values we can shift the origin to - 

  20:     // maximum values is always 0 (we don't want the left side of the content

  21:     // ever being beyond the left part of the view

  22:     double minToX = content.Width - (content.Width * scaleValue);

  23:     double minToY = content.Height - (content.Height * scaleValue);

  24:  

  25:     // correct any invalid amounts:

  26:     if (toX > 0)

  27:         toX = 0;

  28:     else if (toX < minToX)

  29:         toX = minToX;

  30:  

  31:     if (toY > 0)

  32:         toY = 0;

  33:     else if (toY < minToY)

  34:         toY = minToY;

  35:  

  36:     translateTransform.BeginAnimation(TranslateTransform.XProperty, CreatePanAnimation(toX),

  37:                                       HandoffBehavior.Compose);

  38:     translateTransform.BeginAnimation(TranslateTransform.YProperty, CreatePanAnimation(toY),

  39:                                       HandoffBehavior.Compose);

  40: }

All The Source Code

To zoom in or out, use the mouse wheel while hovering over the map.  Zooming In should bring you into the point you are hovering over – “zoom in here.”  This is implemented via a ScaleTransform, plus an animation to keep things nice and smooth.  The ScaleTransform exposes two properties, CenterX and CenterY, to make this happen.  

And in fact, when you first zoom in to a section of the map, the zoom does exactly that.  The problem is – zoom back out, now move to a different section of the map and attempt to zoom in – the animation completely ignores the new CenterX and Y values and will always use the previous Center value.  This problem was also confirmed using the latest release of Silverlight 4.

If I remove the animation completely and just alter the ScaleTransform directly, the CenterXY code works fine.  However this was causing other problems…

The Pan and Zoom functionality seemed like it was much easier to get working in WPF however – and since I didn’t have a strict requirement to be using Silverlight… I will post a working Pan/Zoom Canvas example, largely based on code from this article on Joe Wood’s blog.

Three different sample sln’s showing the problem available over here:

The bad news:  I’m writing this on a Windows box and support for some things is sketchy or just non-existent.  Also, using Python vs. this C library puts a big distance between “what you think is happening” and “what is happening,” so debugging leaves you wondering if the problem is your code, Eclipse somehow messing things up, Python, the Python bindings, somewhere within openCV, or just broken or incomplete support for Windows.

So imagine my confusion when this simple program:

import cv
img = cv.LoadImage("img.tif")

Generates IOError: [Errno 2] No such file or directory: ‘img.tif’

I mean, what’s simpler than just loading a file from disk?! 

I found many people reporting this error, but no solutions other than “The file or directory doesn’t exist or isn’t readable…”

So, after checking (and rechecking) that the file does indeed exist, and then after using the full path to the file and getting the same error, I tried to find where the error was originating through all these layers.

I tried opening the image file using PIL and then converting the image over to OpenCV format, which did not generate an error, except that the resulting image wouldn’t quite survive the process – so I guess that doesn’t count as “working.”  Displaying the image using Windows Photo Viewer worked fine.  Out of desperation I grabbed a random image off of the Internet and tried to open it with OpenCV — and it worked.

Hmm, where did my original images come from?  I screen-grabbed them off of another application, and then to save time – rather than waiting for Gimp to open – I just used MSPAINT.EXE to … oh, damn.  “Short Cuts make for Long Journeys.”  The original file was corrupt, just enough so that openCV would be unable to load it, but not so much that other programs and libs couldn’t load “something.”

So, ignore the text of that error message and read it as “openCV, for some reason that it won’t describe, could not load your image.  Maybe the file is not there, or maybe you messed it up by being sloppy?” 

Re-capturing the image using Gimp and PNG fixed the problem.

Over time, the bandwidth problems were fixed, and as sometimes happens the WSUS server crumbled to dust.  For the most part nobody noticed – new servers and clients were not configured with the WSUS policy, downloading their hotfixes direct from Microsoft through plentiful bandwidth.  Unfortunately, older server and clients were left in the dark, sending cries out to a WSUS URL that will never respond…  oops

To Fix (and get your automatic updates to work again):

Delete the registry key at “HKLM\SOFTWARE\Policies\Microsoft\Windows\WindowsUpdate”.  For fun, restart the “Windows Update” service (not sure if this is necessary). 

I found this VBS file to be useful in figuring out if a server was still trying to use an old WSUS install, or if the problem was group-policy related. 

The tl;dr version

Azure involves a classic tradeoff: being able to scale very effectively and not having to make major capital investments, vs. having to pay more to your cloud computing environment for the convenience of it.  It’s suitable for some applications and businesses, but certainly not all.  To make the most of it, you should (or, must) architect your application around the whole cloud-notion to begin with.  How much, and how bad it’ll hurt, depends on platform and your application.

The Long Winded Version

Let’s say you’re a big online retailer, selling books online (as an example I just made up).    For 3 months of the year, your servers are completely slammed with orders – you need lots of bandwidth, lots of CPU, everything.  I’m talking about renting out a big data center for $BidMoney a month, hiring SysAdmins, NetAdmins, all of that.    The other 9 months of the year, its boring.  You could just have a server under your desk, and hire some high school kid to keep it running.

This is why Amazon’s EC2 was invented (and why Microsoft is competing with them with Azure).   Rather than buying racks of servers, hiring staff to keep it running, and so on – for stuff that you won’t need for most of the year, you deploy your application to Azure – when times are busy, you spool up additional servers easily.  When the rush is over, just throw those extra instances away.

Your startup get mentioned in the WSJ?  Add servers to deal with the traffic, so you don’t look stupid with “Server Unavailable” errors.  Any sort of business model that is built around ‘bursts’ makes a lot of sense for this.

The tradeoff:  Cost.  You pay for CPU time, storage space, transactions, bandwidth.  Each of these are really small numbers like “$0.15 / GB stored / month” and “$0.01 / 10k transactions” but they can add up quickly – a Death of a Thousand Cuts.  Plus, with EC2 and Azure, the CPU time is not “cpu time doing something useful,” it is “amount of hours the virtual server was running.”   So if your app spends most of its time doing nothing…

For a small app with little traffic, this could add up to $100s / month, instead of just paying $VeryLittle/month for really lousy shared hosting, or a little more for less-lousy virtual hosting.   And as I understand it, all of these services are “No Refunds” so if you get hit with a big wave of traffic, or forget to turn a server off when you were done with it, or whatever, … too bad, pay up! 

It’s not all bad though – Google App Engine is free for 500 MB of storage and 5 million page views, and when you’re ready for more you can set up a quota and daily budget so you don’t get any nasty surprises.  And while Azure is in CTP, its without charge (with a few modest quotas applied).  So, you can start writing your Facebook-killer app right now, and deal with the costs later

Application Design

With Google App Engine and Amazon EC2, and mostly with Microsoft Azure, you must design your applications with cloud operation up front.  It’s not exactly trivial to take an app written for a more traditional web server/database structure and deploy it to the cloud: you should be using the cloud’s data access APIs, not storing anything on the server itself, and have ways to get your data to and from the cloud (racking up transaction fees in the process).  And don’t forget that your data is out there in hostile territory – how are you going to keep it safe?  Plus your choice of cloud dictates what languages and platforms you can choose from.

I said “mostly” because with Azure you can pay a little extra to get access to “SQL Azure” if you need relational database storage.  Which I think is great, although you’d have to balance those costs against the effort of using a more transaction based storage model.

So there you go, a tiny bit of understanding packed into a dangerous form of leaping conclusions. 

I’m writing a very basic WebPart to get started with SharePoint – this web part will display a list of links to other applications that the user is authorized to use.  The source of this data (names, URLs, etc.) comes from an external-to-SharePoint system, accessed through another C# assembly.  Once the web part gets the data there is some more processing to be done – we need to do more than just blindly display a list of URLs.  Rather than get into details I’m just going to do some handwaving here and say that “if you have access to X, then {stuff happens}, or if you have access to Y then {other stuff happens}.”  You know, business logic, stuff that is good to test.

the first thing I need to do is get business logic out of the WebPart and into something that I can write without having to reset AppPools over and over, not to mention have some unit tests to verify I’m going in the right direction.  So, I created a standard application service class which has a dependency on the external authorization system, via constructor injection. 

public class AuthorizedAppsService : IAuthorizedAppsService
{
  private readonly ExternalAuthorizeService authService;

  public AuthorizedAppsService(
    ExternalAuthorizeService authService)
  {
    this.authService = authService;
  }

  public AuthorizedApplications GetAuthorizedApplications(
                                  string userName)
  {
    var allApps = authService.AuthorizedApplications(userName);
    // business logic stuff happens here
    return thoseResultsWeJustFiguredOut;
  }
}

Next, I created a StructureMap Registry class to scan my assemblies, as well as adding in the details of how to create this external authorize service, using the typical method:

public class MyRegistry : Registry
{
  public MyRegistry()
  {
    Scan(scanner => {
      scanner.TheCallingAssembly();
      scanner.AssemblyContainingType(typeof(MyRegistry));
      scanner.WithDefaultConventions();
      });

    ForRequestedType<ExternalAuthorizeService>()
      .AsSingletons()
      .TheDefault.Is.ConstructedBy(c => Provider.GetService());

    // other dependency configuration...
  }
  public static void InitializeForSharepoint()
  {
    ObjectFactory.Initialize(init => init.AddRegistry<MyRegistry>());
    ObjectFactory.AssertConfigurationIsValid();
  }
}

And then, what remains is to have SharePoint call my StructureMap initialization when my SharePoint application starts up.  In an MVC or WebForms app, I’d just add code to the appropriate place in Global.asax.cs, but in SharePointLand, this is looked down on.  Instead, the preferred mechanism seems to be to use an HttpModule and a FeatureReceiver to plug the Module into the app’s web.config.

public class MyStartupModule : IHttpModule
{
  public void Init(HttpApplication context)
  {
        ConfigureOtherStuff();
        MyRegistry.InitializeForSharepoint();
  }
  public void Dispose() { }
}

And then the FeatureReceiver to alter the app’s Web.Config looks something like this (note I borrowed most of this code from another sample SharePoint project:

//
// this is borrowing heavily from http://www.codeplex.com/SPAXO
// 
public class StartupFeatureReceiver : SPFeatureReceiver
{
  public override void FeatureActivated(
        SPFeatureReceiverProperties properties)
  {
    var webApp = properties.Feature.Parent as SPWebApplication;
    AddWebConfigEntry(webApp);
    UpdateApp(webApp);
  }

  public override void FeatureDeactivating(
        SPFeatureReceiverProperties properties)
  {
    var webApp = properties.Feature.Parent as SPWebApplication;
    RemoveWebConfigEntry(webApp);
    UpdateApp(webApp);
  }

  private static void AddWebConfigEntry(SPWebApplication webApp)
  {
    SPWebConfigModification mod = GetModification();
    var existingModifications =
             new List<SPWebConfigModification>(
                      webApp.WebConfigModifications);
    if (existingModifications.FindIndex(
                    value =>
                        value.Name == mod.Name &&
                        value.Value == mod.Value &&
                        value.Owner == mod.Owner) == -1)
    {
      // If the modifcation does not already exist 
      // add the entry to the config
      webApp.WebConfigModifications.Add(mod);
    }
  }

  private static void RemoveWebConfigEntry(
            SPWebApplication webApp)
  {
    SPWebConfigModification mod = GetModification();
    webApp.WebConfigModifications.Remove(mod);
  }

  private static SPWebConfigModification GetModification()
  {
    string asmName = typeof(StartupModule).AssemblyQualifiedName;
    string typeName = typeof(StartupModule).FullName;

    return new SPWebConfigModification
      {
        Path = "configuration/system.web/httpModules",
        Name = String.Format(CultureInfo.InvariantCulture,
                "add[@name='{0}'][@type='{1}']",
                typeName, asmName),
        Sequence = 0,
        Owner = asmName,
        Type = SPWebConfigModification.
                    SPWebConfigModificationType.EnsureChildNode,
        Value = String.Format(CultureInfo.InvariantCulture,
                  "<add name='{0}' type='{1}' />",
                  typeName, asmName)
      };
  }

  private static void UpdateApp(SPWebApplication webApp)
  {
    // Update the Web App and apply the changes 
    // to all servers in the farm
    webApp.Update();
    webApp.Farm.Services
        .GetValue<SPWebService>()
        .ApplyWebConfigModifications();
  }
}

First there was Windows Server 2003.  And then in 2005, Microsoft released something of a super-service-pack with new functionality, patches, and other stuff.  It was much more than a regular service pack, full of optional components that shipped on a 2nd CD.  So, it was name “Windows Server 2003 R2.”  But underneath, it’s still Windows Server 2003 at the core.

You might think that Windows Server 2008 R2 follows the same naming convention.  But you’d be wrong.

Windows Server 2008 R2 is not “Windows Server 2008 + More Good Stuff,” it’s actually much more like “Windows 7 – Server Edition.”  The core is a different (though of course related) operating system. 

Why did Microsoft do this?  I’m sure they have good reasons… investment in the Windows 2008 ‘brand,’ major/minor naming schedules, and so on. 

I’m sure that Windows 2008 R2 is a wonderful operating system.  Windows 7 seems pretty nice, after all.  But, don’t be fooled by the name and think that upgrading from Windows 2008 to Windows 2008 R2 is no big deal, its a full blown OS upgrade. 

I hope you read that in Leonard Nimoy’s voice, from his work on Civilization IV.  “Our scientists have unlocked the secrets of Bacon!  Now we can cook bacon!”

So after attempting to cook bacon in carbon dioxide, the next logical step was to repeat the experiment in a vacuum.  Would the absence of an atmosphere (more or less) alter the taste of bacon?  If this worked, this could be another alternative to having robots cook bacon unattended without the risk of fire.

Fortunately Dave Gapen over at The Reuseum happened to have a working vacuum chamber, and was willing to let us experiment with it as long as we cleaned up the mess afterwards. 

The plan was simple: insert Foreman grill into chamber.  Remove air via a hand pump.  Cook bacon.  Eat bacon.

First thing: the chamber has holes for connecting pumps and other handy scientific devices, one of which we need to run the grill power cord through.  And then manage to seal up the remains of the whole.  And to do that, the power cord needs to come off the grill, be threaded through mentioned hole, and then seal the hole up with copious amounts of silicone caulk.

With the box wired for sound, and some time to kill waiting for our sealant to hold, it was time to cook the Control Bacon.  One comment with the previous attempt was that the grill was colder cooking the CO2 bacon than the control bacon, which could explain the lack of crispiness.  So this time, we allowed the grill to heat up for 2 minutes sans-bacon, and then cooked the control bacon first.

The control bacon cooked for 15 minutes.  It was good, as one expects from control bacon.   Hail, Bacon!

Control bacon eaten, now it’s time to set up our vacuum.  Uncooked bacon was placed on the grill, the chamber cover was placed and sealed, and I started using the hand pump to get as much air out of the chamber as possible.

Here’s the part where things start to go wrong: cranking the hand pump is hard work, and I didn’t have access to (and sure wasn’t going to buy) a compressor or electric pump or something that would have been more efficient.  I was able to get the gauge up to 200 mmHg and maintain it there, but getting more of a vacuum than that was a lot of work.  And since it didn’t seem like this setup was going to get much better than that, I flipped the switch to apply power to the grill.  Commence bacon!

After 5 minutes, I could begin smelling the bacon cooking through the hand pump – along with a smell sort of like industrial grease.  Not very pleasant.  Would the bacon flavor be tainted?

I had to pump continuously to maintain pressure, at one point I was able to get the gauge up to 300 mmHg, but then the silicone seal developed an audible leak. 

15 minutes elapse – vacuum bacon removed.  It appeared to have suffered no side effects from its exposure to low pressure.  The taste and other qualities of the bacon was as you’d expect from any other sort of bacon.  Bacon is stronger than it’s environment.

Results

The gauge is measuring the pressure difference between the outside and the inside.  STP is defined as 760 mmHg at room temperature.  If we assume that the outside is STP (and we haven’t been very rigorous with numbers up to this point, so why start now?) then that’d mean that the pressure inside was 760 – 200 mmHg = 560 mmHg, or 0.74 atmospheres.  Not the sort of vacuum I was hoping for…

The preheating and cooking order seems to have controlled for temperature, so that’s one less problem.  If I were to repeat this experiment, I’d let the seals set overnight (at least) so we could get less pressure in there.  Also, this really calls for a more powerful pump than what we had – unfortunately that just wasn’t going to happen with the time and money available. 

But, it was an excellent excuse to eat more bacon, visit the Reuseum, and DO SCIENCE!