Or, How WebSockets on the server can make the world an awesome place

Currently listening to: Roger Shah Live – Mix Mission

One of my ongoing open-source projects is something called ‘vlove’ – short for ‘virtual love’ – the idea being that one can have a bunch of machines that host VMs and would like to control them from the same web-based user interface.  Nothing groundbreaking or crazy here – plenty of people have done this before: Proxmox VE (my personal choice), Eucalyptus, CloudStack, OpenNebula, OpenStack…  And those tend to be the free ones – there are the expensive enterprise solutions from companies like VMware, Citrix, and Microsoft.

Sadly, I find that most of these solutions have a problem – they’re pre-rolled, and force you to install a bunch of servers or services that they support, in a very specific way.  My servers are already up and running, and I don’t need most of the Infrastructure as a Service (IaaS) functionality they provide – I just want a website that I can browse to to see what is or isn’t running, and so some basic administrative stuff like provisioning a new virtual machine.  If I was running RedHat or CentOS, I could use an existing solution, but since I’m using Ubuntu, I’m basically out of luck.

And thus vlove was born – a web-centric management interface that hooks into any libvirt-based virtualization tool.  I got it up and running and had the basics running when I had a bit of a problem.  You see, I have multiple servers located in a bunch of datacentres around the world, and I didn’t want each one to have it’s own interface.  So, I broke my code up into a centralized webapp along with a bunch of agents that could be deployed to a variety of servers.  (I’m not addressing security or reliability – at some point I might build in automatic failover support, but I gotta start at the bottom!)

After I split my code up, I had to make a decision: how do I get all of my agents to talk to the server?  Now, if I was doing an internal-only setup (or VPN deployed), I’d cheat, and probably use JMS.  However, I didn’t want to rely on another piece of software (embedded JMS or not – still something to worry about) – as I’m deploying a webapp, I thought that I could leverage that.  With that in mind, I started considering using REST services with the agent polling the server periodically to say that it was alive, or to check to see if anything needed to be done.  However, I killed that idea pretty quickly – if the user wants to provision something, I don’t want them waiting in any way.

In a flash of inspiration, I decided that I’d try to use Atmosphere and WebSockets – I can piggyback over HTTP, so nothing crazy there, but I’d get bi-directional communication with each agent!  I did some research, and found that there is a library called “Async HTTP Client” that has native WebSocket support.  Win!  With both the server side and client side up and running, it was time to do some integration work.

Server Side

First, we need to get Atmosphere integrated on the server side.  For those of you using Maven, it’s quick and dirty to import the dependency – the rest of you can figure something out:

   1: <!-- Atmosphere -->

   2: <dependency>

   3:   <groupId>org.atmosphere</groupId>

   4:   <artifactId>atmosphere-runtime</artifactId>

   5:   <version>0.9.0.RC2</version>

   6: </dependency>

You’ll see that I’m using a release candidate instead of the 0.8.6 release – I can’t guarantee that it’ll work, but at the same time the functionality that is in use has been in place for a while now.

So, now that you have the dependency in place, you need to create the implementation; it’s pretty painless as all we have to do is extend WebSocketHandler and we’re off to the races.  For reference, here’s the incredibly basic vlove implementation:

   1: package vlove.web.websocket;

   2:  

   3: import org.atmosphere.cpr.AtmosphereResource;

   4: import org.atmosphere.cpr.Broadcaster;

   5: import org.atmosphere.cpr.BroadcasterFactory;

   6: import org.atmosphere.websocket.WebSocket;

   7: import org.atmosphere.websocket.WebSocketEventListenerAdapter;

   8: import org.atmosphere.websocket.WebSocketHandler;

   9: import org.slf4j.Logger;

  10: import org.slf4j.LoggerFactory;

  11:  

  12: public class VloveWebSocketProtocol extends WebSocketHandler {

  13:   static final Logger log = LoggerFactory.getLogger(VloveWebSocketProtocol.class);

  14:   AtmosphereResource r;

  15:  

  16:   @Override

  17:   public void onTextMessage(WebSocket webSocket, String message) {

  18:     log.debug("Received message: {}", message);

  19:     

  20:     AtmosphereResource r = webSocket.resource();

  21:     Broadcaster b = lookupBroadcaster(r.getRequest().getPathInfo());

  22:  

  23:     if (message != null && message.indexOf("message") != -1) {

  24:       b.broadcast(message.substring("message=".length()));

  25:     }

  26:   }

  27:  

  28:   @Override

  29:   public void onOpen(WebSocket webSocket) {

  30:     // Accept the handshake by suspending the response.

  31:     r = webSocket.resource();

  32:     // Create a Broadcaster based on the path

  33:     Broadcaster b = lookupBroadcaster(r.getRequest().getPathInfo());

  34:     r.setBroadcaster(b);

  35:     r.addEventListener(new WebSocketEventListenerAdapter());

  36:     r.suspend(-1);

  37:   }

  38:  

  39:   /**

  40:    * Retrieve the {@link Broadcaster} based on the request's path info.

  41:    *

  42:    * @param pathInfo

  43:    * @return the {@link Broadcaster} based on the request's path info.

  44:    */

  45:   private Broadcaster lookupBroadcaster(String pathInfo) {

  46:     String[] decodedPath = pathInfo.split("/");

  47:     Broadcaster b = BroadcasterFactory.getDefault().lookup(decodedPath[decodedPath.length - 1], true);

  48:     return b;

  49:   }

  50:   

  51:   /**

  52:    * Used to send a message to whatever is connected on the other side.

  53:    * 

  54:    * @param message The message to send.

  55:    */

  56:   public void broadcastMessage(String message) {

  57:     r.getBroadcaster().broadcast(message);

  58:   }

  59: }

The next step would be to tie the above class to an in-memory topic to have the app push messages straight through to the agent.  That part hasn’t been implemented because I *just* got this code to work, and was very excited about sharing it!

The final step is to flip Atmosphere on, which requires a change to your web.xml as you have to add a servlet.  Again, here’s a snippet:

   1: <servlet>

   2:     <description>AtmosphereServlet</description>

   3:     <servlet-name>AtmosphereServlet</servlet-name>

   4:     <servlet-class>org.atmosphere.cpr.AtmosphereServlet</servlet-class>

   5:     <init-param>

   6:       <param-name>org.atmosphere.useWebSocket</param-name>

   7:       <param-value>true</param-value>

   8:     </init-param>

   9:     <init-param>

  10:       <param-name>org.atmosphere.websocket.WebSocketProtocol</param-name>

  11:       <param-value>vlove.web.websocket.VloveWebSocketProtocol</param-value>

  12:     </init-param>

  13:     <load-on-startup>0 </load-on-startup>

  14:     <async-supported>true</async-supported>

  15:   </servlet>

  16:   <servlet-mapping>

  17:     <servlet-name>AtmosphereServlet</servlet-name>

  18:     <url-pattern>/s/*</url-pattern>

  19:   </servlet-mapping>

At this point you should be able to deploy your webapp to a WebSocket compliant servlet container – I specifically tested this against Jetty 8.1.1.

Client Side

Again, I’m using Maven, so here’s the Async HTTP Client dependency:

   1: <!-- Async Client -->

   2: <dependency>

   3:   <groupId>com.ning</groupId>

   4:   <artifactId>async-http-client</artifactId>

   5:   <version>1.8.0-SNAPSHOT</version>

   6: </dependency>

Similar to Atmosphere, I’m using the latest code (1.8.0-SNAPSHOT), but the 1.7.1 release should be just as useful.  The reason I am using the unreleased/snapshot versions was due to me not knowing if my utter failures in getting things to work was related to versioning, or failure to understand what was going on.  It was the latter, but I never got around to reverting to stable releases.

The final step is to create some test code that uses the AHC to actually invoke the server:

   1: package vlove.websocket;

   2:  

   3: import org.junit.Test;

   4: import org.slf4j.Logger;

   5: import org.slf4j.LoggerFactory;

   6:  

   7: import com.ning.http.client.AsyncHttpClient;

   8: import com.ning.http.client.websocket.WebSocket;

   9: import com.ning.http.client.websocket.WebSocketTextListener;

  10: import com.ning.http.client.websocket.WebSocketUpgradeHandler;

  11:  

  12: public class TestWebSocket {

  13:   protected static final Logger log = LoggerFactory.getLogger(TestWebSocket.class);

  14:   

  15:   @Test

  16:   public void testWebSocketConnection() {

  17:     AsyncHttpClient c = new AsyncHttpClient();

  18:     try {

  19:       WebSocket ws = c.prepareGet("ws://localhost:80/vlove/s/1").execute(new WebSocketUpgradeHandler.Builder().addWebSocketListener(new WebSocketTextListener() {

  20:         @Override

  21:         public void onOpen(WebSocket websocket) {

  22:           log.debug("Socket opened.");

  23:         }

  24:  

  25:         @Override

  26:         public void onClose(WebSocket websocket) {

  27:           log.debug("Socket closed.");

  28:         }

  29:  

  30:         @Override

  31:         public void onError(Throwable t) {

  32:           log.error("Error.", t);

  33:         }

  34:  

  35:         @Override

  36:         public void onMessage(String message) {

  37:           log.debug("Message: {}", message);

  38:         }

  39:  

  40:         @Override

  41:         public void onFragment(String fragment, boolean last) {

  42:           // TODO Auto-generated method stub

  43:         }

  44:       }).build()).get();

  45:       

  46:       while (!ws.isOpen()) {

  47:         Thread.sleep(50);

  48:       }

  49:       

  50:       log.debug("Sending message.");

  51:       ws.sendTextMessage("Narf.");

  52:     } catch (Exception ex) {

  53:       log.error("Could not do websocket stuff.", ex);

  54:     }

  55:     try {

  56:       System.in.read();

  57:     } catch (Exception ex) {

  58:       // ignore

  59:     }

  60:   }

  61: }

If you run the JUnit test, you should see things connect to the server, send a message and otherwise hang out.  To end the test, hit any key.

Questions?  Comments?  You can hit me up on Twitter (@mlaccetti), comment here, or email me (michael@laccetti.com).

Or, How I Learned to Love the Language

Currently listening to: Gui Boratto – The Mix Collection (Disc 1) – Lusine – Double Vision

When it comes to software and languages, I classify myself as having an attention problem – every morning I fire up hacker news or techmeme and take a peek at the “cool things” happening in the tech world.  Most days there is a post about a new language, new framework, or algorithm for solving a problem in a new and novel way.  Each time I read one of these, I feel compelled to try it out, to see how awesome it is, thinking to myself “this will be the one that gets me to switch from Java!”

And yet, I’m still writing apps in Java.  In the last few years, I’ve tried most things out there.  Some, like Python, I rather liked, but didn’t really see any advantage to changing – one could argue that Python is better than Java, but it isn’t orders of magnitude.  I tried Ruby, saw the cruft that goes into an HTML page in Rails and ran screaming.  I tried Scala and Lift, and liked it, but came to the conclusion that there would be no financial services company using Scala any time soon – they have enough problems with basic Java.  C and C++ don’t target the markets I tend to work in, and while I do like C#, I’m just not a Microsoft guy; aside from using their OS on my workstation.  PHP and Perl get lumped in the “I don’t hate myself that much” department.  I gave Erlang a whirl and loved it, then looked to see who uses it, and felt like I was lost in a forest at night.

The most recent foray was into node.js and server-side JavaScript.  Now, as a web developer in the 90s and 00s, you learned to hate JS with a passion.  Buggy implementations, browser specific features, having to sniff for functionality…  It was a terrible time.  Luckily, smart people came up with libraries that abstracted that away – jQuery, Dojo, Moo, YUI – they all made it okay to be a JS developer.  In fact, it was a guilty pleasure to write little scripts that did cool things in a browser.  Using node seemed like a no-brainer – taking the simplicity and elegance from the browser to the server.

The first time I tried node, I gave up the same day.  Apparently the developers were using anything but Windows, which didn’t do much for me.  If I have to switch OS to use your platform, you’re not for me.  (Which is why I don’t do very much with xcode/Objective C.)  Microsoft came along and decided that node would be a great addition to Azure, so they got the cross-platform ball rolling.  I tried node again, and found that while the command line was functional, there wasn’t much in the way of tooling – IDE support was pretty limited.  So, more waiting.

Then, I ran into the Cloud9 IDE – a web-based IDE for working on node.js apps.  Wonderful stuff, except that you had to pay to get a private workspace.  I was lucky and found the Komodo 7 IDE on the day that the release candidate launched.  It had first class node support, and I could tolerate it as an IDE.  (But just tolerate – it didn’t rub me in any happy place.)  More searching, and I found WebStorm from JetBrains.  First class node support AND an IDE that didn’t look like a reject from 90s *nix days!

Finally, I had most of the cross platform functionality of node (minus some NPMs that require gcc and the like) and an IDE that made it easy.  My first thought was that I’d port findmusicfor.me over to node, as that was a relatively uncomplicated task.  In fact, to make it beyond easy, I decided that the backend service could stay in Java – I’d expose them via REST, and have node simply invoke the services.  I looked at my webapp and the various tutorials for node, and settled on using Express to build the app.  After a few false starts and screw-ups relating to routing and the like, I did more digging.  Turns out that I should also look into backbone and underscore, and maybe use client-side templating instead of server-side.  After I put my app framework together, I had to stop myself.  As I looked at the code, I saw that everything was exactly the same as what I had been doing in Java, but written in JavaScript.

Instead of Wicket, I was using Express.  Instead of JPA, I was using a node ORM.  I kept using jQuery, and the only difference with backbone was that the code was shared instead of having Wicket perform the mapping automatically.  In fact, I was confused, because things were actually looking less elegant in JS than they were in Java.  After all, Java has been used to build web applications for over a decade, and lots of time and effort has been put into providing clean and functional frameworks.  In fact, if you try, you can create a nice Java-based webapp that has no XML configuration.  You can build small horizontally scalable applications using either language.  The only difference?

I’m not entirely sure.

So, until I figure that out, I see no particular reason to switch away from Java.  As long as I keep exploring, I keep learning more, and I don’t assume that Java is “done” – I’ll still be here.  I agree that the language has quirks and having Oracle as the steward terrifies me, but I don’t think we can stick a fork in it.  So, I’ll keep building my apps and testing out new languages and frameworks, until one day I find something compelling enough to switch.

I’ve been a big proponent of Steam for a very long time – apparently I opened my account in November 2004.  That means that I’ve had an account for over seven years – in internet time, that’s an eternity!  For the most part, I’ve loved it, and had no problems with it.  While others had issues with server timeouts, disconnections, or other gremlins, I kept humming along.  Valve (the folks who own/run Steam) have been good with Steam, growing it at a good pace and adding solid features, all while ensuring that they have sufficient bandwidth available to allow me to download a 15GB game without any issues.

In the last six months, though, I’ve been having some very strange problems with Steam, specifically when trying to give them my money.  I’m a gamer, and given that I make a decent wage, I like to buy games to support the developers – the more money they get, the more likely I’ll get another solid game to play.  To that end, I have well over 300 games I’ve purchased on Steam.  A few months ago, I wanted to snag the new Batman game, as there was a good deal on it.  I logged in to Steam, visited the store page for Batman, added it to my cart, and tried to checkout.  That’s when I ran into a wonderful error message: “There seems to have been an error initializing or updating your transaction. Please wait a minute and try again or contact support for assistance.”

I waited, and tried again.  No love.  I made sure I didn’t have a negative account balance (improbable, since I buy stuff directly, instead of using credits, but hey, gotta be thorough.)  I unlinked the associated credit card, and tried PayPal.  Switched from PayPal to another credit card.  Nothing – I kept getting that wonderful error message – the vaguest and most useless error ever.  I fired up the steampowered.com website to see if it was related to the game.  Nope, same obnoxious error message.  I bounced over to the support site and promptly faded out – so many things to sift through.  At that point, I just wanted a well displayed 800 number to call and get things fixed, but no, everything has to be automated.

At that point, Valve lost me – I got frustrated and didn’t buy the game.  That’s $60 that somebody lost, all because of a silly error message, and a byzantine support system.  It burned me enough that I didn’t even bother firing up Steam again for a few months, though my current addiction to Battlefield 3 and/or Star Wars – The Old Republic might also have something to do with that.

Today, though, I decided that I’d play Choplifter HD, and fired up Steam.  I noticed that there was some DLC for it, so put them all in my cart, and clicked on the checkout button.  BAM!  That wonderful error message showed up, and with it, the red fog descended over my vision.  Somewhere, somebody is crying in the corner because they heard my tirade.  I tried the same steps as before – using the Steam client, using the web app, linking and unlinking payment messages, everything.  I searched the magical online realms for some hint, but for all the people who have had the error, nobody has actually come up with any useful way to fix it.  (To all of those people telling me to delete all the content from my Steam directory, how the hell does that fix a web app!?)

In a fit of pique, I went to the checkout page again, and started screwing with the location settings.  You see, while I live in Toronto, I’m currently in Boston, and have been travelling frequently for the last six months.  After I changed the country to the US (from Canada) and threw in MA as the state, it worked.

Let me repeat: changing the country fixed it.

So, it seems that Steam is actually doing some GeoIP stuff on the backend to make sure that the IP matches the country that you have selected.  That’s cool – I can see that they want to keep the fraudulent activities down.  But why in Jupiter’s name can’t they have a specific error message?  Is being purposefully vague and frustrating an actual business decision?  A development failure?  Either way, it has been a pain in my ass, and I would like to light the person who caused that to happen on fire.

On a happier note, I can theoretically buy games from Steam again.  I kind of don’t want to, though.  Maybe I’ll give Origin some money instead?  (Nah, their selection of games is kind of limited.)  And with Direct2Drive going away, my options have decreased yet more.  Sigh.

One of the weird things that I’ve come to realize is that people tend to have long email addresses.  Originally, back in the day, you might have been first@company.com – which was relatively easy to remember and tell people.  Of course, the whole internet thing started to catch on, so companies started assigning all of their employees email addresses.  This lead to the comical situation of 38 Michaels all having an e-mail address, which lead to – you guessed it – michael38@company.com.  This started to look unprofessional, so some corporate wonk decided that it should now be ‘first.last@company.com’.  Name collisions were less likely, but whenever you had to tell somebody your email address, you had to make sure you had some time on your hands.

Support Person (SP): “Okay sir, may I please have your email address?”
Random Guy (RG): “Sure.  It’s marcus.aurelius@romanshouseofawesome.com.”
SP: “Sorry sir, I missed that – it’s m..a..r..?”
RG: “Sure – it’s m..a..r..c..u..s..dot..”
SP: “M..a..r..a..”
RG:" “No, M..a..r..c – no ‘a’ after the c”
SP: “Oh, okay.  M..a..r..c..”
RG: “u..s..dot..a..u..”

It continues in this vein for a few minutes, with many back-pedals and random usage of words to describe letters.  “M..a for apple..r..c..u..s for susan…”  Eventually, the email address has hopefully been written down properly, and people can get on to actually trying to get help with whatever was the actual issue.  Of course, this isn’t always the case – I’m always amused when I get a paper record of a transaction or a welcome letter and my email address has been mangled beyond understanding.  It has to be those double Cs and double Ts – doesn’t help that the Italian pronunciation doesn’t really make sense to any non-Italian.

To combat this problem, I decided to procure a short domain and make myself a nice short email.  The io domains are pretty cool (woo geekery), so I procured one – lf.io.  Then, to make my life super easy, I decided that my email address would be m@lf.io – six whole characters.  Even if I had to revert to some crazy NATO-like reading, it’d be easy – “mike at lima foxtrot dot india oscar”.

It turns out that there was a problem with this whole premise.  You see, after at least a decade of having to do the whole long email dance, people can’t process a short email address.  It screws with their perception of reality, fragile thing that it is.  Recently, I had to fill out some form, and I was asked for my email address.  This was all done in person, so I got to see things up close and personal.  She filled out my name, address, birth date and the rest, then came to the email address part.  She looked up at me, pen ready.  “M,” I say.  She writes it down, clearly expecting much more.  “@,” I continue.  She paused and looked up at me, a question on her face, asking me if I had forgotten anything.  I just nodded and kept going – “lf dot io.”  She wrote it down and looked at it, then looked back up at me, looking confused and concerned, as if I had given her a fake email address.  “It’s okay – that’s my real email address,” I told her.  A few more seconds of confusion pass, until she decides it is okay.  With that, she burst out into a huge smile and excitedly tells me that I have the shorted email address ever, and how cool is that!

I wonder if I should have used one of my brutally long ones, instead.  I guess I have an experiment for the next time!

I just stumbled across this link (HCI 2020) while doing some research – curious to see if they’d update it to address things like Surface, Kinect, Tablets, LTE/WiMax and the like along with the ongoing intensified war between x86 and ARM. If they did update it, what would the difference(s) be?

This is such a small feature, and yet would be so invaluable – the ability to sort the Archive page by purchase date.  Currently, when I buy a book from the Amazon website, I have to remember the artist or title, then search the archive for it.  It’d be much nicer if I could hit up the archive page and simply sort by purchase date, and then select the item that I just bought.  I’m kind of baffled how this has been overlooked.

As part of my ongoing saga with having a cab decide to try to merge into my car, I’ve had to hand over my car to the body shop for roughly two weeks. In that time, my insurance has graciously (due to me paying, of course) provided me with a rental car. The rep offered me a Mitsubishi Lancer, which I was very excited by – I’ve always wanted to drive one, and this was my chance! But lo, my hopes were dashed, when a few moments later the rep told me that the Lancer was actually out. I was then presented with a few different options – a Nissan Sentra, the Ford Focus, and a Chevrolet Malibu.

Originally, I was leaning towards the Focus – it’s a decent little car, and in the right model, very peppy. This being a rental company, I figured it’d be the bare minimum – four wheels and, if I was lucky, a motor. (If I wasn’t, picture Fred Flinstone’s feet.) Based on that, I decided I’d try the Malibu – a large-ish, generic American car. I knew it’d have a big engine that did nothing but suck gas, and wouldn’t so much corner as wallow around a bend. However, I also knew that it’d have the interior space of a drawing room, and that I’d probably feel lost in the car.

Well, the first two predictions came true. The last, not so much! Turns out that the room in the car is taken up by the engine and trunk – the middle portion is probably 1/4 of the car! (No, not quite that bad, but still a pronounced smallness to it.) The front seat only moves back so far, and until the rep found the button to make the seat go down, I was pretty much part of the steering wheel. If I tried to take a corner, I’d be bruising my thighs with my ham hands. While the steering wheel does telescope and move up, it doesn’t come out very far, and sure doesn’t go up very much. The designers also thought that they should take the steering wheel from a bus – that thing is MASSIVE.

To top it all off, I’ve gotten so used to having a gas pedal that requires pressure that the vapid feedback I get from the accelerator drives me bonkers, and gave me a cramp from having to keep things “just so.”

TL;DR (you’d better have gotten this far) – it wallows, it wheezes, and it has the interior room for a family of mutant dwarf pigs. Steer clear!

Addendum
Things I’ve noticed in the last day while driving this behemoth:
1) Every time you hit a pothole, a crack in the pavement, or some other protrusion marring the perfectly flat surface of the road that the Malibu expects, the steering wheel bucks like an enraged steer trying to break loose. This causes some serious consternation.
2) On the flip side, the steering wheel has a good 10-15 degrees of play before it notices that you’re attempting to turn. Seriously – I feel like a bus driver.
3) A bus is a good comparison, especially when it comes to turning radii. I’d need an empty six lane highway to get this thing to do a 360. Parking in Toronto requires a nine point turn.
4) The person (or committee) that decided that the turn signal had to have the loudest, most horrible clacking noise should be summarily executed. I spend a lot of my time waiting to turn trying to decide what weight sledgehammer I want to introduce to the dashboard.

Hopefully I have found the full extent of the nightmare that is this car. Any more surprises would be very unwelcome. Can’t wait to have my car back!

My UPS nightmare is over, and the servers have arrived.  My living room table now has some 1U servers in it, and my closet has the 2U servers.  With the hardware taken care of, now it comes down to the fun part – software.  Do I use OpenStack, OpenNebula, or Eucalyptus?  Help!

I want to setup a little cloud at a local colo – while I won’t have the same amount of bandwidth as I do using dedicated servers down in the US, I’ll have better hardware, and I won’t have to pay outrageous sums of money for crappy hardware.  To this end, I went to eBay and snagged a few 1U servers; coupled with the existing hardware I have, I can have a pretty decent little setup.  Everything went smoothly – I paid for the servers and the seller set the shipment up using UPS.  I got my tracking number, and then the fun began.

You see, I am enthusiastic about tracking my package – overzealous, even.  I memorize that stupid UPS tracking URL and visit every two seconds, hoping that something will have changed.  When it does change, I get happier, as it means my package will be getting closer to me.  On Friday evening, I was super excited, because the package had arrived at the local depot, which meant that the package would be on a truck on Monday (today) morning.

First thing this morning, back to the website, and there it is – “Out for Delivery” as of 7:07am!  Of course, I then realize the downside – I’m basically going to be sitting around in a panic all day long, hearing phantom doorbells, rushing to the terrace to look over the railing to see if the delivery person was there.  Bathroom break?  Push!  Food?  Inhale it!  No food in the house?  What’s the closest (healthy) place?  The end result is that I have the longest, slowest day ever – where is my package!?

Finally, at around 6:15, I couldn’t take it anymore and started walking around the block in an attempt to burn off some nervous energy.  As I’m doing this, I see the UPS van pull up!  I’m all excited, and get ready to wander over, when I see the driver grab a (small) package and head over to drop it off.  I tell myself to relax, and go hang out in front of my place, so I will stop scaring the neighbourhood kids.  I hear the van start up, and start cruising around the crescent – I tell myself that he’s trying to find my unit.

Note to everybody: the block of townhouses I live in is beyond poorly marked – the signs are at the sides, not the front, and they are put so high up that you cannot see them from a vehicle.  When I first came to see the unit, I wandered around lost for roughly 20 minutes before I finally found it.  If anybody had moved in, I would have asked them, but the development was a ghost town.

Back to the UPS van – he’s driving around the crescent, passes my block.  Keeps going.  Accelerates.  Gets back to the “main” road, and stops.  I hear him get out – I’ve got ears that would rival those of an owl, when it comes to deliveries!  A few minutes pass, and I don’t see him walking around, looking for the unit.  Then, horror of horrors, the engine fires, and the van zooms off.  I don’t have a package, and I’ve wasted nearly twelve hours in a panicky state.

I venture online and check to see if the tracking information has updated.  Why, yes, it has!  “First Attempt Made” – “The driver was unable to collect funds on the 1st delivery attempt.”  I go from panicking that I’d miss the driver to wanting to immolate him with my mind!  I was right here!  I was sitting right out from of my damn house when you were here!  You went to the unit on Foundry, didn’t you!  If I walked over to that unit, I’m pretty sure there is a notice on their door, or that he had spoken to them asking for the $200 in “duties and fees” that my $900 package had slapped on it and the person at the door choked.  (Can’t wait to argue about the fees, too!)

With my anger tap wide open and spewing venom, I call UPS’ 800 number.  I breathe and tell myself to be calm, that the agent who calls isn’t the person who screwed up, and doesn’t need to put up with an irate person.  Calmly, I explain that there seems to have been some mix up, and could they send the driver back?  “I’m pretty sure that they went to the right unit, but on the wrong road!”  The agent proves to be less than useful, and says that she can send a message to the centre and that they’ll arrange for delivery tomorrow.

Seriously?  I get to do this whole thing again tomorrow?  I’m not sure my heart can take it.  Or if the driver will have both arms.

Okay, so I’m not moving just yet, but I did want to replace the table that collects the contents of my pockets. Here we have the before and after shots – kitty not included.

Update!

Here’s the replacement mostly put together: