Jason Madigan

Holiday time - bulk declining Google Calendar events

2017-07-03T19:00:00.000Z

I’m getting married in a few weeks, so recently I wanted a way to decline about 3 weeks worth of Google Calendar events en-masse. Since I was using Google Apps for our organisation’s calendar, I found the easiest way to accomplish this was to bust out some Google Apps Scripting, which lets you script a number of Google Apps in your domain, including the [Calendar](https://developers.google.com/apps-script/reference/calendar/calendar-event.

See an example below on how to bulk decline Google Calendar events using Google Apps Scripting - you’ll just need a calendar name & a date range and run this via the script console:

function GCalHoliday() {
  var fromDate = new Date('July 17, 2017 00:00:00 +0100');
  var toDate = new Date('August 8, 2017 23:30:00 +0100');
  var calendarName = '<Your Calendar - e.g. joe@bloggs.com>';

  var calendar = CalendarApp.getCalendarsByName(calendarName)[0];
  var events = calendar.getEvents(fromDate, toDate, {});
  Logger.log('Events: ' + events.length);

  for (var i = 0; i < events.length; i++) {
    var ev = events[i];
    // try/catch for setting status - may get exceptions where events 
    // are on calendar, but user is not a "guest" of the event - these can be ignored
    try {
      // !!!
      // ev.setMyStatus(CalendarApp.GuestStatus.NO); // Uncomment to actually update status
      // !!!
    } catch (e) {
      Logger.log('Error updating event status ' + e);
    }
    Logger.log('Item ' + ev.getTitle() + ' found on ' + ev.getStartTime() + ' marked as declined');
  }
}

High Altitude Adventures - Part 3

2013-07-04T21:00:00.000Z

A few weeks ago, I was mostly ready to launch. We’d bought an N30 cylinder of Helium from Irish Party Supplies, containing 7.82m³ of Helium - enough for roughly two launches of a standard sized 1000g balloon. Previously, I’d thought hydrogen would be a better choice, but considering it was a first launch we decided to play it safe (after having a gas seller painstakingly explain the various ways in which Hydrogen tanks can explode).

I’d also figured out the legals - the IAA didn’t seem to be able to grant permission to anyone other that Met Eireann, so rather than labour the point I decided to launch from Northern Ireland instead. I’m still not entirely sure if launches here are legal or not, but the IAA, who regulate our skies didn’t seem to be in a position to grant permission. The CAA in the UK have a procedure for weather balloon launches. So long as you heed their guidelines (which are very sensible), you have an excellent chance of being given permission. There also didn’t appear to be any issue with me being an Irish resident.

Frequently checking the CUSF Landing Predictor, I finally happened upon a good weekend at the end of June. The winds were calm and a predicted landing that wasn’t in either the sea or a lake - all good! I contacted the CAA at short notice for permission to launch, and they were very helpful and prompt - I received permission documentation the following day.

My payload was complete - I’d bought a 42 inch Spherachute and a 1000g Hwoyee weather balloon from the good people at Random Aerospace. I’d also sourced a small polystyrene payload box. For recording 1080p video, I finally settled on the excellent Veho Muvi HD - the video captured turned out better than I’d ever imagined.

The launch was a great success, with most things working as planned. The vertical radiator of the antenna broke off while we quickly tied off the balloon after filling.

I thought this would mean we wouldn’t get any live telemetry during the flight. But as it turned out, because the balloon was high above the horizon with no obstacles in the way, the transmitter’s weak 10mW signal was received clearly throughout by us in the car with a little handheld receiver as we chased the balloon.

While chasing, however, it become obvious that the GPS on board was not receiving updates, presumably because it had no lock. Although live telemetry was transmitted throughout the flight, without GPS data it wasn’t particularly interesting - the altitude was stuck at 4km. I’m still not entirely sure what failed, but my guess is that the active GPS antenna I used wasn’t working. The antenna was placed at the top of the payload box, which was quite close to the underbelly of the balloon. We’d tied things off quickly, so there was only about 6m between the payload box, the parachute and finally the balloon. I’d stowed a backup GPS tracker on board with GSM (redundancy!) which I’d hoped would give us a landing location in cse the primary tracker was no longer functional. I was able to call the GSM modem in the payload until sometime after the GPS lost it’s lock (~4km up), which was higher than I thought.

Two and a half hours after launch, with the payload still transmitting the same 4km, I was able to call the payload once more - which meant it was descending and was close to landing. After about 30 minutes of frantic texting “where” over and over to the payload box, it finally responded with it’s actual location. After landing, the GPS had regained a lock. The backup tracker refused to give us it’s location throughout, presumably (I thought) because the payload box had tipped over. We raced towards the field where it had landed only to find that it had landed with some very curious cows. Eventually, after concocting a distraction, I managed to hop the gate and recover our payload - all in tact and still working.

Source

Source for the Arduino Mega, Siemens TC35 serial GSM modem, RTTY transmission via the NTX2 is available here

South East Maker Space Presentation

The good folks at the South East Maker space (@semakerspace) invited me to talk about this recently. Slides are available here.

High Altitude Adventures - Part 2

2013-04-24T21:20:00.000Z

Following on from my previous post, I’m going to go into a little more detail as to what we’re planning and what I’ve built so far - hopefully it will be of interest!

The payload (or safeload as I’m now calling it) is now complete. It consists of:

It took a while to piece together the kind of parts I needed. I originally thought I could use an old Arduino Diecimila that I had lying around, along with a nice EM406-A GPS module that I’d used before. Unfortunately, the Diecimila only had 16KB of flash (2KB taken by the bootloader), and it looked like I’d need at least 32KB.

I bought an Uno and initally everything was going well - I had the EM406-A hooked up and was processing NMEA with relative ease, thanks to the great TinyGPS library. The NTX2 arrived a little later - this is when the problems began.

Software Serial Ports

I planned to transmit telemetry throughout the flight with the NTX2. To do this, I was going to use RTTY (simple frequency shift keying) to encode telemetry and transmit. This worked fine in isolation, so I then hooked up the GPS again and tried to send some telemetry. There were weird errors in the RTTY transmission that I spent a few days tracking down late at night. The problem in the end turned out to be the SoftwareSerial port I was using.

Uno’s only come with one hardware UART, and it’s wired into the USB port via FTDI. It was available to use, but it’s fiddly and it’d mean swapping things around when it came to programming over USB (which I needed to do a lot of, since nothing worked!), so the EM-406A was hooked up via a software serial port. Arduino’s SoftwareSerial is interrupt driven so NMEA data coming in on the SoftwareSerial port would trigger an interupt - RTTY transmissions are timing sensitive, so these interrupts interfered with transmission and introduced errors.

Once I’d figured out was going wrong, disabling interrupts and having a “quiet period” for RTTY transmissions seemed to mostly fix things. Half way through uncovering the fix, however, I got frustrated and ordered an Arduino Mega (which has 4 hardware UARTs). When the Mega arrived, things got a lot simpler - lots of complicated timing logic could be removed.

RTTY

I’ll post more about this later, but here’s a short video of an RTTY transmission of some telemetry:

High Altitude Adventures

2013-04-02T21:00:00.000Z

A few weeks ago, I spied a video on YouTube via Reddit - some guys had gotten together and put some cameras high up into the atmosphere (100,000ft, ~30km). I looked at it and thought it seemed like a good use of time. I got talking to a friend of mine at work about the possibilites of launching something like this from Ireland. As it turned out, some people from launched successfully from Kerry a few years back.

My initial plan was to launch something simple: a helium filled 800g balloon with some kind of cheap Android phone taking snaps every now and then. After watching lots of YouTube footage, and lots scouring through resources such the UK High Altitude Society, our plans evolved. Dan was keen for a more elaborate payload (it involves a fixed wing glider, some servos and a death spiral - I’m sure he’ll tell you all about it). Eventually we settled on the idea of sending two payloads on one flight.

Initial Questions

One of the first things that I wanted answering was whether or not it was actually legal to launch a high altitude balloon in Irish airspace. ~~As it turns out, the IAA have a pretty comprehensive document on the subject here. I’ve yet to receive permission to launch from them, but I am hopeful.~~

Update: the IAA were very firm in giving a “No” to any such launch. Apparently they’ve only ever given permission for such launches to Met Éireann. Disappointing, but the CAA in the UK granted me permission to launch in Northern Ireland and were far more helpful.

Problems

In the first few days, with some whiteboarding during lunches and late night conversations, we came up against some issues.

Initially, Android devices looked like a good idea for simple flight computers. We had some ideas to develop some FeedHenry powered Apps to record and relay basic telemetry to a Node.js app - we’d use WebSockets to pipe data back in realtime. Knowing how flakey your average cellular data network is, I had my doubts this would work. A bigger problem, though, was that GSM was unlikely to work at anywhere near the altitudes we were interested in.
We largely started out with no idea of how much this was likely to cost. Our guestimates of maybe €200 each were blown in the first week of parts acquisition (for me at least).

Lifting Gas

Helium looked like the best lifting gas, since it was inert and it’s relatively cheap. Or it was - this isn’t the case anymore. Poking around, we found many places offering balloon helium for party balloons. This, as it turned out, wasn’t good enough for our purposes. Your average party balloon gas is only about 30% helium - the rest is usually air. We’d heard some estimates from others that 9cubic meters of industrial helium from BOC costs about €600 (including tank rental) - which is pretty extraordinary.

Jekyll

2013-03-02T21:00:00.000Z

Way back in November, 2008, I read an article by Tom Preston-Werner which detailed his approach to blogging and blogging software. For years I’ve been trying to use one terrible CMS or another. The idea of sitting down to write yet another CMS to tackle some of the issues I have with blogging software really didn’t appeal to me. Remembering his article, I started poking with Jekyll. I had a pretty good idea of what I wanted:

Simplicity
CLI-based editing
Posts in a plaintext format, with formatting in a really lightweight
markup language like
Textile
Static content generation - if you post something popular, chances
are you’re going to start flushing “dynamic” content out to disk as
static HTML. Why bother waiting to write posts out as static files?
No comments — as far as I’m concerned, the effort required to manage
spam and user comments simply isn’t worth it.

Irish Weather app live on the App Store

2009-12-16T21:00:00.000Z

I was bored three weekends ago and had an idea for a simple Irish weather app. Met Eireann have tons of great data available to the public, but finding the good stuff was a little fiddly. Anyway, after a weekend of work in Photoshop and Xcode, I had a pretty nice app. It was finally approved late last night. It’s free to download, so feel free to give it a spin.

Irish Weather 1.0

The day a Time Capsule died

2009-11-25T21:00:00.000Z

This is the first Apple product I’ve owned that’s died. The hard drive seems to be fine though. Plugged it into another machine and it works just fine. I guess all that heat killed the logicboard. I guess it had been warning me with a few months though - its DHCP server had become very flakey over the past few weeks.

Oh well, time to dust off my old dependable WRT54GL.

Node.js - Event driven, non-blocking web servers written in JavaScript

2009-11-23T21:00:00.000Z

Update - 2015-09-11 while porting posts: This Node.js thing turned out to be a pretty big deal

I’ve been fiddling with Ryan Dahl’s Node.js event driven I/O framework for the V8 JavaScript VM over the past couple of days. It’s probably the coolest piece of software I’ve come across in ages, and it really builds upon one of JavaScript’s core strengths: event driven programming. If you’ve been looking to brush up on your event driven programming, it’s seriously worth taking the time to play with. As part of his work on Node, Ryan has also released a seriously cool tiny HTTP parser in C (and used by Node). At 128 bytes per connection, it’s perfect for use in any embedded environment which could do with some HTTP love, like the Arduino.

Bluetooth/USB tethering & MMS for O2 Ireland with iPhone OS 3.0

2009-03-19T21:00:00.000Z

Update #2: These carrier settings will work with Beta 2 also. Also,
Safari likes to attach a .zip extension to the ipcc, so either rename
the downloaded file minus the extension or use Firefox/curl something
else to download the updated carrier settings.

Update: Updated the MMS proxy settings, the previous version was using
an old proxy. To update just re-download the carrier settings and apply
an update once more.

After a little dicking around prompted by some stuff I noticed on
twitter, I cobbled together this updated carrier bundle for O2 Ireland
to enable USB/Bluetooth tethering for iPhone OS 3.0. This also enables
the sending/recieving of MMS messages a new photo button will appear in
Messages.app to send pictures as MMS messages.

Grab it here.

To install, option (alt) click update in iTunes, and select this updated
IPCC.

If something terrible happens, you can grab a backup of the old one to
restore here.

Trip report - fowadublin

2009-03-09T21:00:00.000Z

I attended FOWA Dublin Friday last, and had a pretty good time. The
speakers were the main reason I attended, with DHH & Simon Willison
delivering particularly great talks. There were a couple of things that
bugged me about the event setup. Not to be a jerk or anything, but
there’s a few points I hope the
Carsonified guys take a look at and
fix in time for next year:

Poor WiFi - I know the guys have apologised about this already, but
it stuck in most people’s craw and I guess it bears repeating. With
400 odd people milling about with iPhones and Macs some decent WiFi
would’ve been nice.
Socialising is kind of hard when you’ve got absolutely no room to
move.
I don’t really care about toilets, but I heard there was only one
bathroom for guys and one for girls.
Lack of freebies. The tickets were pretty pricey (although I’d guess
individuals paying for their own tickets were in the minority).
Basically the only thing given away was a name-tag & holder. Free
coffee for breaks or something would’ve gone down nicely.

Using cookies to calculate a user's timezone

2009-01-17T21:00:00.000Z

A few days ago I discovered a
quick & easy way few to use cookies to help your Rails app get a user’s
timezone, without prompting. It’s pretty easy to implement:

First up: set a cookie, any cookie:

var date = new Date();
// returns offset from GMT in minutes
var offset = date.getTimezoneOffset();

// set a cookie however you see fit, I like to use jQuery.cookie
$.cookie('timezone', offset);

Then, in application.rb or wherever you like:

def browser_timezone
 return nil if cookies[:timezone].blank?
 `browser_timezone ||= begin
    min = cookies[:timezone].to_i
    TimeZone[(min + (-2 * min)).minutes]
  end
end

The cookie gives you minutes from GMT, but `ActiveSupport::TimeZone@
expects seconds from GMT.

Anyway, hopefully someone will find my pointing it out useful. It may
buckle under pressure (with daylight savings), but guessing and getting
it right 50% of the time is better than forcing user interaction.
Probably.

An iPhone app is born

2008-12-27T21:00:00.000Z

We finally saw our first iPhone app land on
the App Store a couple of days ago. iPhone app development is pretty
wonderful in comparison to some of the other crapheaps out there, but
it’s also pretty damn nice by itself too. It was a ton of fun to write,
and it was nice to do something like it for a local paper, The Munster
Express.

Check it out
here

Ruby Christmas

2008-12-21T21:00:00.000Z

Thanks “whoever you are” :http://pastie.org/344030.

                     "/|"\
                 "/wl)e";eval(\
                    "A | A"\
                   "A  |  A"\
                       \
                    "InHhL"\
                   ",Z,%w{-"\
                  ",Y&/LH,L*"\
                 "cCnd,Hh&/d,"\
                "YCB/Hh,Y&YHh,"\
               "L&xHh,L*v*nHh,*"\
              "&ghHh,n&nHh,H*nHh"\
             ",*q*v*nHh,Hw*qv*Hh}"\
            "Iq&n*L,Z,[,n&qK,n&qK,"\
           "@TwC,LH/&ng,gLBbL@K,@Th"\
          "/**,YC/k*d,Hh/*QdL@K,@FCB"\
         "/,cQqq&ng,=/CcL@K,@F&v*,RBb"\
        "y,g*mL!@K,@S&x,mQ/LhQqL,dBm=&"\
       "ng@K,@S*v*n,dBckL,Q-Hy=&ng@K,@E"\
      "&ghH,d&/L,Q-gqCbb&ng@K,@N&n*,/Qng"\
     "*L,LH*==&ng@K,@T*n,H/yL,Q-cQHch&ng@"\
    "K,@Eq*v*n,&CL,=&=&ng@K,@Tw*qv*,mCnk*y"\
   "L,=QHch&ng@,]IDAJJA2)J*Qch,dC,U&UI=/&nH"\
  ",@\nOn,Hh*,\#{nHhL[&]},dQy,CY,MQHzmQL,my,"\
 "H/B*,qCv*,gQv*,HC,m*:\n@I&JdCwnHCD2),dC,UjU"\
"I=/&nH,@,,,\#{q&n*L[j]}\n@I*ndI=/&nHDD&,ZZ,A)"\
                    "?,@,,"\
                    ",G@,:"\
                    ",@,,,"\
                    "Gnd,Q"\
                    "@)I=/"\
      "&nH,@,n*w,v*/L&Cn,CY,RBby!\n@I*nd"\
       "I".tr(' ID/VHLYGBqCA&|*UQJ=Z@K,',
         '+;(r/tsfAulo1i8e|a.p=", '))

JavaScript flexes its muscles

2008-09-04T21:00:00.000Z

It’s an exciting time for JavaScript developers. Over the past few
months, we’ve seen all sorts of cool things coming our way. We’ve seen
new fast, heavily optimised JavaScript virtual machines such as
WebKit’sSquirrelFish,
Mozilla’s TraceMonkey
and, most recently, Google’s V8. We’ve
seen all kinds of cool things done with these new VMs, perhaps the
coolest (to my mind) is running dynamic languages such as Ruby in the
browser - see
here.

We’ve also seen the effective death of the ECMAScript 4 proposal and
seen it reborn as ECMAScript Harmony. To top things off, we’ve also seen
some very interesting new JavaScript frameworks designed specifically
with complex client-side web applications such as
SproutCore and, just today, Cappccino &
Objective-J. The web development world is
evolving too quickly for the current model of standards adoption remain
sustainable, and it’s nice to see that developers like those behind
Cappuccino get it.

Reinventing the wheel, just to see what all the fuss is about.

2008-05-24T21:00:00.000Z

I’ve been amassing a small army of broken arduinos over the past two
months, but now I have something to show for it - the bones of a
working (but altogether bulky) GPS tracker. The code I used seems kind
of nasty to me, mostly because the bit-banging used for serial
communication to try to ensure no data is missed in transition. The
Arduino IDE is okay I guess (for a Java app), but if you like Ruby you
may want to check out RAD. Looks like RAD
only works with version 10 of the arduino SDK right now though.

In terms of kit hooked up, we’ve got an EM-406A (GPS
Module)
& an Arduino Mini along with a USB to serial
header. I need to buy a EEPROM for storage, or possibly some kind of
microSD reader. Borrowing some code from
here
we can parse NMEA to take a look at where you are with Google Maps.

#define bit4800Delay 200 //1 bit per 0.2 ms
#define halfBit4800Delay 100

byte rx = 8; //Connect to EM-406A's TX
byte tx = 9; //Connect to EM-406A's RX
char dataformat[7] = "$GPGGA"; //GGA
char messageline[80] = "";
int i = 0;
char latitude[10];
char longitude[11];

void setup() {
 pinMode(rx,INPUT);
 pinMode(tx,OUTPUT);
 digitalWrite(tx,HIGH); // Needs to be pulled high before the EM-406A
will return data
 digitalWrite(13,HIGH); // Debugging LED
 Serial.begin(9600); // Echo EM-406A output through serial
}

char SWread()
{
 byte val = 0;
 //Wait for start bit (0)
 while(digitalRead(rx)  HIGH); 

  if (digitalRead(rx)  LOW) {
 delayMicroseconds(halfBit4800Delay);

for (int offset = 0; offset < 8; offset**) {
 delayMicroseconds;
 val |= digitalRead << offset;
 }

 delayMicroseconds;

 // Bitbanging
 if
 return val-128;
 else
 return val;
 }
}

void char2string {
 i = 0;
 messageline[0] = SWread;
 if {
 i**;
 messageline[i] = SWread();

while(messageline[i] != 13 & i<80) {
 i++;
 messageline[i] = SWread();
 }

messageline[i+1] = '0';
 }
}

void loop() {
 char2string();
 if (strncmp(messageline, dataformat, 6) == 0 & i>4) {
   Serial.println(messageline);
 }
}

iRot - iPhone development is fun

2008-02-18T21:00:00.000Z

Over the weekend I decided to try my hand at a little iPhone
development. My Objective-C skill is non-existant, and my C skill is
incredibly rusty - but I pressed on. First up was installation of the
toolchain required to compile native applications. This one was tough,
very tough. After much swearing and shouting, I finally managed to get
it to install. The iPhone dev team’s official instructions were of help
right up until

1 2	sed 's/^FLAGS_FOR_TARGET=$/FLAGS_FOR_TARGET=${FLAGS_FOR_TARGET-}/g'

This is where things seemed to go horribly wrong for me and others.
After scouring google for solutions for what seemed like hours, I
finally happened up on
this
little golden nugget. With the toolchain finally installed I cracked
open my copy of Stephen Kochan’s Programming in
Objective-C
along with iPhone Open Application
Development

a book by NES.app’s developer which I really can’t recommend at the
moment.

I decided to write a useless little ROT13 app which you can grab by
adding http://www.jasonmadigan.com/repo.xml to your installer.app’s
repository list. I’ll release the source tomorrow after a quick cleanup.

An end to a frickin' retarded restore path

2008-02-12T21:00:00.000Z

Finally. Restoring an iPhone is no longer quite so painful. No more
jumping through hoops downgrading to 1.1.1 and slowly clawing your way
back up to 1.1.3 with all manner of retarded soft updates. Thanks to
Zibree’s
ZiPhone, you
no longer need to beg and plead with your iPhone to play along with you
for two hours to get your iPhone back in working order. Unlocking,
activating & jailbreaking any iPhone is now incredibly simple and fast.

Somebody really had to do this - when 1.1.4 lands (and it will soon),
restoring an iPhone would have previously meant no less than 4 jailbreak
hoops to jump through.

Software Unlock for OOTB 1.1.2 & 1.1.3 iPhones

2008-02-08T21:00:00.000Z

Mister George Hotz has come through for us once again, with a software
based
unlock
for out of the box 1.1.2 & 1.1.3 iPhones. Now would be a good time to
buy one. It uses a delightful IPSF based method but this one doesn’t
zero out your seczones. So should Apple lose their minds in the future
and include a bootloader update in a future software release you won’t
end up with a complete brick.

Hot on it’s heals was a brief update regarding retarded dev-team/elite
team babby drama. It seems Zibri got tired of the two dev teams’
shenanigans once more and decided to jump the gun and
release the
method used by an upcoming semi-hardware unlock (an exploit piggybacking
on a Turbo SIM, once run there’s no need for the Turbo SIM anymore), the
details of which have been known by the dev-team for several weeks now.

Interesting times. Of course this means I’m going to be bombarded with a
stream of requests for unlocking - all of which I’m going to politely
decline. The iPhone is great and all, but eventually you come to realise
that, with every new firmware release, the time it’ll take you to
restore should something terrible happen is going to increase
considerably. I don’t know about you guys, but as soon as an official
release is confirmed for here with 3G, I’m jumping ship. It’s just too
tiring.

1.1.3 - IPSF Keep's On Truckin'

2008-01-25T21:00:00.000Z

Like I thought, IphoneSimFree’s unlock continues to work with recent
iPhone updates. Taking the baseband out of lockdown requires a little
minicom pockery until we see a patched lockdownd - I’ll look into
patching it this weekend.

Lightweight, fast Rails stack - Thin & nginx

2008-01-24T21:00:00.000Z

Since purchasing a
slice
of heaven a few days ago, I’ve setup a very lightweight Rails stack
consisting of
Thin
& nginx for my
Rails needs. Since I went for a slice with just 256MB of RAM, memory
consumption becomes a pretty serious issue. nginx has been around for
quite a while now, and has recently started to become more and more
popular in Rails deployments due to the fact that’s incredibly
lightweight, very fast and stable - perfect not only for VPS jerks like
me, but for anyone who really doesn’t feel it’s necessary to run Apache
for static content/cluster proxying/load balancing. Thin is something I
came across very recently and I decided to try is as a replacement for
mongrel since I’d heard some great things about it, even if it is still
alpha. It’s performance in comparison to mongrel (even with a tacked on
event machine) looks very impressive on paper.

Setting up clustering with it is a snap, just spawn the processes and
pipe them into nginx. Here’s a startup script borrowed from
Stephen
Celis:

namespace :thin do
 namespace :cluster do desc 'Start thin cluster'
 task :start => :environment do
 `cd #{RAILS_ROOT}`
 port_range = RAILS_ENV == 'development' ? 3 : 8
 (ENV['SIZE'] ? ENV['SIZE'].to_i : 4).times do |i|
 Thread.new do
 port = ENV['PORT'] ? ENV['PORT'].to_i + i : ("#{port_range}%03d"  i)
          str  = "thin start -d -p#{port} -Ptmp/pids/thin-#{port}.pid"
          str += " -e#{RAILS_ENV}"
          puts str
          puts "Starting server on port #{port}..."
          `#{str}`
        end
      end
    end
    desc 'Stop all thin clusters'
    task :stop => :environment do
      `cd #{RAILS_ROOT}`
      Dir.new("#{RAILS_ROOT}/tmp/pids").each do |file|
        Thread.new do
          if file.starts_with?("thin-")
            str  = "thin stop -Ptmp/pids/#{file}"
            puts "Stopping server on port #{file[/\d+/]}..."
            `#{str}`
          end
        end
      end
    end
  end
end

Then spawn however many processes you want using something like:

1	rake thin:cluster:start RAILS_ENV=production SIZE=2 PORT=3000

To stop them, use:

1	rake thin:cluster:stop

With that all nicely setup, you can use an nginx config similar to mine to get things in order:

upstream dapperjerk {
  server 127.0.0.1:3000;
  server 127.0.0.1:3001;
  }

server {
  listen 80;
  server_name  www.dapperjerk.com;
  rewrite \^/(.\*) http://dapperjerk.com permanent;
}

server {
  listen   80;
  server_name dapperjerk.com;

  access_log /home/jason/public_html/blog/log/access.log;
  error_log /home/jason/public_html/blog/log/error.log;

  root   /home/jason/public_html/blog/public/;
  index  index.html;

  location / {
    proxy_set_header  X-Real-IP  $remote_addr;
    proxy_set_header  X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header Host $http_host;
    proxy\_redirect false;

    if (-f $request_filename/index.html) {
      rewrite (.*) $1/index.html break;
    }

    if (-f $request_filename.html) {
      rewrite (.*) $1.html break;
    }

    if (!-f $request_filename) {
      proxy_pass http://dapperjerk;
      break;
    }
  }

}

And that’s really all there is too it. I’m not a masochist so I’ve never
bothered to fully read Apache’s documentation, but I don’t think I’m
going out on a limb here by saying that it seems to be a lot easier to
manage nginx. I haven’t really put thin through its paces yet, but we’ll
see in the coming weeks as I cobble together a custom blog app to run
this place.