Jamie van Dyke

Contrary to the Rumors

2012-05-22T19:39:15+01:00

I’m still alive! I’ve been contracting for a Healthcare company in Nashville. I’ve been doing a multitude of jobs, the timeline went something a little like this:

A month of web development
Infrastructure development (cost reduction, increased redundancy, instance automation)
Infrastructure Manager
Captain of the Imaginarium (Research and Development)

The last one is clearly the strangest title I chose, but it reflected what I do. Here’s some examples of what I get tasked:

“Give us geographical redundancy at a low cost”
“Find a solution for Cynthia, see if you can automate that”
“We need to send and receive faxes, both from a web app and from the desktop”

I research each one, find possible solutions and then prototype them. The final choice is given to the Director.

What else have I been doing?

My main role has been as a DevOps, working with Amazon mostly. Their tools are fantastically designed to help reduce costs while increasing redundancy. I reduced the hosting costs by a third at PharmMD, increasing redundancy at the same time. I took an Advanced PostgreSQL course which helped understand how to architect the entire infrastructure.

Amazon Cloud Formation, coupled with all the AWS tools is great for architecting a redundant, scalable framework. I’ve also played with VMWare’s CloudFoundry to reduce the lock-in you get with a vendor like that.

I’m currently looking around to see who else might need my services, I’m available globally as I work from home. I’m happy flying out for on-location work too, and can be hugely beneficial for initial planning and working closely with others.

If you’re interested, get in touch through my contact details on the ‘about me’ page. I’m not immediately available, but I might be the one you need to plan the next stage of your infrastructure. I look forward to hearing from you.

Installing Bluepill

2010-12-02T14:14:01+00:00

We use Chef for automating our server infrastructure, but I’ll show you the manual way of installing Bluepill (either locally or remotely) so you can play with it.

$ gem install bluepill

That wasn’t hard, was it? Dependencies will be resolved, and installed too. Now we’ve got it installed, let’s take a little look at the commands we can give it.

Check the status of all applications and processes

$ sudo bluepill status

Start all applications and stop all applications, or a single group.

$ sudo bluepill start
$ sudo bluepill stop
$ sudo bluepill start resque

Quit Bluepill.

$ sudo bluepill quit

You configure Bluepill with a configuration file. Here’s one we use to start multiple resque queues. It’s a work in progress but does what we want for now. I won’t explain the config file because there’s plenty of blogs (and of course the Bluepill README) that go into detail here.

queues = {}
queues["comms"] = 1
queues["rules"] = 2
queues["patients"] = 4
queues["import"] = 1

@app_name   = "pharmmd"
@owner_name = "rails"
@rails_env  = "production"
@rake_command = "bundle exec rake "

Bluepill.application("#{@app_name}_resque", :log_file => "/var/log/bluepill.log") do |app|
  app.uid = app.gid = @owner_name

  queues.each do |queue, count|
    count.times.each do |idx|
      app.process("resque_worker_#{queue}_#{idx}") do |process|
        process.group = 'resque'
        process.pid_file = "/var/run/resque/#{@app_name}/worker_#{queue}_#{idx}.pid"
        process.working_dir = "/data/#{@app_name}/current"
        process.start_command = @rake_command +
          "RACK_ENV=#{@rails_env} RAILS_ENV=#{@rails_env} " +
          "QUEUE=#{queue} " +
          "resque:work"
        process.stop_command = <<-EOF
        kill -QUIT {{PID}}
        sleep_count=0
        while [ -e /proc/{{PID}} ]; do
          sleep 1
          let "sleep_count+=1"
          if [ $sleep_count -eq 60 ]; then
            kill -TERM {{PID}}
          fi
          if [ $sleep_count -ge 70 ]; then
            kill -KILL {{PID}}
          fi
        done
        EOF
        process.start_grace_time = 5.seconds
        process.stop_grace_time = 75.seconds
        process.restart_grace_time = 80.seconds
        process.daemonize = true

        process.checks :mem_usage, :below => 150.megabytes, :every => 1.minute, :times => 3
      end
    end
  end
end

What I wanted to add was a notification system that let me know when things had gone horribly wrong. Specifically I wanted Campfire notifications, as that’s where all the cool techies at PharmMD hang out.

For notifications, Bluepill allows us to write simple ‘Triggers’. These triggers can be added to a process in the config file, like zoh:

process.checks :some_trigger, :every => 1.minute

So let’s add a Campfire notifier. First things first, I’ll be using the tinder gem to talk to Campfire, have a look at their README for details on how it works (or the excellent tinder homepage). Install tinder.

$ gem install tinder

At the top of the Bluepill config file (anywhere above the application block) add the following:

require 'rubygems'
require 'uri'
require 'tinder'

class Campfire < Bluepill::Trigger
  PARAMS = [:times, :within, :retry_in, :rails_env]

  attr_accessor *PARAMS

  def initialize(process, options = {})
    options.reverse_merge!(:times => 5, :within => 1, :retry_in => 5)

    options.each_pair do |name, val|
      instance_variable_set("@#{name}", val) if PARAMS.include?(name)
    end

    super
  end
  def notify(transition)
    @logger.info "I so just got triggered with a transition!"
    begin
      if transition.to == "down" && transition.from == "up"
        @logger.info "BluePill: #{@rails_env} worker(#{process.name}) went from #{transition.from_name} to #{transition.to_name}. Restarting them."
        campfire = Tinder::Campfire.new 'pharmmd', :token => 'TOKEN'
        room     = campfire.find_room_by_name('General')
        room.speak "BluePill: #{@rails_env} worker(#{process.name}) died. Restarting it."
      end
    rescue => x
      @logger.info "Totally failed with: #{x.message}"
    end
  end
end

In the initialize method I set up some parameters that I can pass in, as well as provide myself with some defaults to fall back on.

PARAMS = [:times, :within, :retry_in, :rails_env]
attr_accessor *PARAMS

I create instance variables for each option for access later on, and call super to allow the Bluepill::Trigger class to do its own initialisation.

options.each_pair do |name, val|
  instance_variable_set("@#{name}", val) if PARAMS.include?(name)
end

Next up I create one of the required methods that Bluepill will call periodically and sprinkle in a little logging (@logger is provided by Bluepill::Trigger).

@logger.info "I so just got triggered with a transition!"

Next up we wrap our Campfire notification in a rescue block, because we don’t want ay silly exceptions like a lack of net access from bombing Bluepill out. There are a few transitions we can use, the important one for me is when a process dies (even though Bluepill will restart it), I want to know when that happens so I can find out why and stop it.

if transition.to == "down" && transition.from == "up"

Tinder makes campfire access so simple. Connect to campfire, select a room, and then ‘speak’ into it.

 campfire = Tinder::Campfire.new 'pharmmd', :token => 'TOKEN'
 room     = campfire.find_room_by_name('General')
 room.speak "BluePill: #{@rails_env} worker(#{process.name}) died. Restarting it."

That’s it for the trigger. Now all we need to do is tell the process that it should fire that trigger. Add the following to the process block just beneath where we checked for memory usage.

process.checks :campfire, :rails_env => @rails_env

That’s it. Now when you load the config file in, Campfire will get notifications if the process needs restarting.

Simple Campfire notifications using Tinder and Bluepill? Done.

Getting gource installed using home brew

2010-11-18T22:26:02+00:00

Gource is an OpenGL capable visualisation tool for difference SCM’s, it’s easy to install and looks pretty damn cool. If you have Homebrew installed it’s simply:

$ brew install gource

Which happily goes off and grabs all the dependencies like pkg-config, libpng and others. Once it’s done, change into your projects directory (I’m assuming you use git) and then run gource.

$ cd /projects/myproject
$ gource

Then watch the asteroids takes on space invaders style 3D visualisation of your developers doing their thaaang. If you want to make it cooler, then how about a little perl script to grab gravatars for each of your developers and make it more personal? On the gource google code project wiki there’s a script for just that, grab it off this page and save it as grab_avatars.pl and run it on your commandline.

$ perl grab_avatars.pl

It’ll grab all of the gravatars for each developer and then save them in a .git/avatars folder, now we just need to tell gource to use that and we’re laffin’.

$ gource --user-image-dir .git/avatar/

For an example of what it looks like, here’s a snippet of our project with some developers PEW PEWing at the code:

Engine Yard AppCloud Experiences

2010-07-20T20:39:15+00:00

In Summary

As most of you probably know, I used to work at Engine Yard. The developers there are super intelligent and super knowledgeable and I loved working with them. Their vision for the AppCloud is a great idea in practise. To be able to scale your app as traffic increases and decreases, to replace broken server instances at the click of a button, this is the dream. Now the bad news. It’s unstable, woefully under-tested and not production ready.

In Detail

The client I was working with was working with medium sized clusters of instances, of varying sizes but usually along the lines of the following:

1 App server (64 bit CPU, 8 ECU’s, 15GB RAM, 1.7TB Persistent Storage)
1 DB Server (64 bit CPU, 13 ECU’s, 34GB RAM, 850GB Persistent Storage)
1 Mongo Instance (64 bit CPU, 20 ECU’s, 7GB RAM, 1.7TB Persistent Storage)
1 Util Instance Server (64 bit CPU, 13 ECU’s, 34GB RAM, 850GB Persistent Storage)

There are about 6-7 of these clusters, costing well into the 10’s of thousands a month. Don’t worry about the setup because I didn’t design it, the previous contractors did. We’re in the middle of a re-design now, e.g. we should 2 application servers for redundancy. We should be able to do this on the fly but this requires some manual DevOps to take place, specifically we need custom chef recipes to handle things that have been done manually, and this hasn’t been done yet.

Now in theory the AppCloud dashboard should also be able to clone an entire environment so you can run test deploys and more on it. In my experience those clones worked 1 day out of 7, the other times I was met with cryptic messages like “There was an unexpected error while provisioning your instance.”. Not terribly useful. Some of them worked sometimes, others failed. It turns out that for us the unexpected errors were one or all of the following at different times spread over a few weeks:

Reaching the Amazon EC2 EBS Device storage limit (20TB)
Reaching the Amazon EC2 API limit (due to having a few people using the dashboard at the same time)
One of many unknown dashboard errors
The data from a utility instance mounted on the application instance (!)

Let’s look at a few of these in detail.

Reaching the Amazon EC2 EBS Device storage limit (20TB)

That’s a huge amount of data, I know! How did the client come to get so much data, well they used EBS snapshots as backups. That’s crazy considering they range from 256GB to 512GB, and they need to keep them all! Snapshots are done daily automatically, but usually someone will fire off a snapshot at some other time during the day. Meaning every day the amount of data that is held in snapshots increases by about 2TB, instead of being pushed up to S3 (another TODO that needs sorting). So the Amazon EC2 limit was hit, which is not Engine Yard’s fault but they should have some API warnings in the dashboard so we know what’s happening. Otherwise errors like the next one pop up too.

Reaching the Amazon EC2 API limit

Too many queries at one time will get you temporarily banned from EC2 API queries and commands. That makes sense, but not when we don’t know how much of the query limit we’ve used. If you don’t grasp the horrors of not knowing, let’s just say if you bring the production cluster down for some quick maintenance (resizing EBS devices for example, which requires a terminate and rebuild) and you hit your limit before it comes back up….bad news, your cluster isn’t going to rebuild. On top of that, while it’s failing to rebuild you’ll probably terminate the cluster in the dashboard and try again which just prolongs the problem.

It turns out this problem was due to the dashboard making too many queries (polling Amazon for data regularly), note the past tense, the Engine Yard developers promise me that this error has gone away now.

One of many unknown dashboard errors

On many occasions I would see a 500 error page when trying to use their dashboard, and when I asked their support guys what was up the answer was usually “We need to roll back a new version of the dashboard we just pushed”. Seriously, this happened on a multitude of times. You lose your confidence after number 3 I can tell you.

There needs to be more testing done for different scenarios if it’s going to break so regularly. From their point of view I guess they will say it’s because of the Amazon backend and the cryptic API responses they get sometimes. Sure, but I don’t care about that. If you choose to use Amazon EC2 as your backend for a cloud service, you better be damn sure you know exactly what’s what before using it!

The data from a utility instance mounted on the application instance (!)

Oh, this one was just brilliant. 1 week the problem was that if you wanted to boot a cluster from old snapshots, the utility instances couldn’t actually re-attach old snapshots, it had to be done manually. That one sort of scared me a little because I was in the middle of production deploy testing when I was informed of it.

After they fixed the above issue in the dashboard, they introduced a brand new one. I cloned an environment and when it came online the utility instance had no data, which threw me. Until I looked on the application instance and found what should have been mounted to the utility instance. How exactly does this go wrong so badly?!

However…

I’m obliged to say again, the developers and support people over at Engine Yard are fantastic, but clearly this product has a long way to go before it can be used for large applications of any sort. If you are working with a smaller application it makes sense to use them, but as your application grows, hope to the Gods that they’ve matured it slightly.

The moral of the story here is simple and something you all know already. If you can’t rely on something 100% then don’t use it in production. This is a hard lesson that my client has learnt and suffered greatly from. The client is (of course) trying out other services from different providers to move off the AppCloud platform. More on that in the future.

If you’re looking for help with Application deployment, please do get in touch and I’ll see what I can do for you.

Get in touch with me

2010-04-15T15:24:29+01:00

The easiest way to get in touch with me, is to email me through my business email address, which is jamie@fearoffish.com

You want to know about me?

Current Status

For the past 2 years I’ve been contracting for a Healthcare company (PharmMD) as the Infrastructure Manager. I’ve reduced hosting costs to a third of the cost from when I arrived, as well as increasing redundancy over the board. I used Amazon Web Services as well as Opscode’s Chef to reduce those costs and automate the build of over 100 server instances.

Key Skills

So now you know about me, here’s some key parts of the past 7 years that you might find useful when judging if I’m the man you need for a job.

Since the beginning of 2005 I’ve been using Ruby and Rails on a daily basis
Skilled in hosting and deployment
Ruby on Rails Teacher for Skillsmatter both solo and alongside David Black
Rails Contributor with documentation and patches
Engine Yard App Support Manager, EU (Built up the EU team)
CTO at Venturian Media, planned and re-wrote Boxedup using MongoDB

Hunt me down on the internet

LinkedIn (Recommended by 22 people)
Working with Rails (Recommended by 53 people)
GitHub
Twitter
Rails Mentors
Ruby Programming Challenge
Google

Interviews

Ruby Learning

Conference Talks

External Articles

The Rubyist

I get personal

I’m Jamie van Dyke. I was born in the North of England in a little town called Steeton. My Father was Dutch (he passed away) and my Mother is British. I’m in my early thirties and my hair is balding slightly at the back, which is a little depressing. I only have two children as far as I’m aware, they are Lex (my son, who is 4) and Liesel (my Daughter, who is 12). I’m engaged to Kelly Baker who is clearly a little dizzy because she wants to marry me!

And now for the Ugly Truth. I’m a grumpy man with a twist of humour, I’ll make you laugh but I’m one hell of a cynic! I strive for perfection in most of the things I do and I’m continuously disappointed with other’s attitude toward those around them. I don’t think I’m the best Father in the world, nor am I the best partner or worker, but I work as hard as I can to be them. What I would say though is that I’m a lot like Marmite, you either love me or hate me and there’s very rarely a middle ground. I’m extremely helpful, but suffer from an inability to say “no” to those that need my help, so sometimes I spread myself too thin with too many things to do. I apologise for that.

Making your /etc/hostnames life easier

2010-02-08T19:26:02+01:00

I was just reading running rails local development with nginx, postgres, and passenger with homebrew on Sam Soffes site, and found it very useful for a quick copy and paste of his configs.

One thing that I found strange though is that he is using /etc/hosts to make local hostnames for web development. If you haven’t found out about the ghost gem yet:

➜  /  gem install ghost --no-ri --no-rdoc 
Successfully installed ghost-0.2.4
1 gem installed
➜  /  ghost add blah.local
  [Adding] blah.local -> 127.0.0.1
➜  /  ghost list
Listing 1 host(s):
                 blah.local -> 127.0.0.1

No need to piss about with your /etc/hosts file anymore, this is as simple as it gets.

uninitialized constant Rails::Railtie

2010-02-08T18:13:57+01:00

If you’re like me and you skip reading a gem’s README when you install the latest, you’ll be seriously sorry when you don’t for inherited_resources because it is Rails 3 only. The same can be said for responders. You’ll get a big fat punch in the face with this error:

uninitialized constant Rails::Railtie

But fear not, just reverting to the following version will get you back on track:

"inherited_resources", :version => "1.0.0"
"responders", :version => "0.4.0"

Now, on your bike. Get back to work!

Web Development with Source Code Management Basics

2009-08-30T20:39:41+01:00

Pre-Amble

I remember when I first started development. Even more fun was doing the same but over a remote ftp connection through Transmit, or just directly on the server. I got used to pretty GUI’s doing things for me and visually feedback for whether I’d got it right. Oh, how things have changed. My work flow was:

Make changes to my code
Flip to my browser and refresh
See what I’ve done has changed
Go back to my code and make more changes
Go back to my browser and refresh
See I broke stuff
Go back and try fix it
etc.

I want to take you through how a basic version of what I do now, and the benefits of what I do. I have confidence in my changes and a general feeling of happiness that I’d like to pass on to you. Whether or not I work in a team, I use distributed version managed code to do so. Any changes I make locally are pushed to a remote computer, why? What if my hard drive failed or I’m working on another machine for the day, you never know. Either way, I have access to my code, including all the changes I’ve made.

Why was my initial plan inefficient? Well, it was brittle and to test everything meant looking at all the pages sequentially. Making changes in one place might affect another and I had to double check it manually. Also, the changes I made weren’t reversible. I worked around that by saving multiple copies of my files or folders, keeping old version of sites hanging around so I could always revert back if I wanted. This just doesn’t scale.

What’s the alternative? Source Code Management. There are many systems around and I’ve certainly used a myriad of them, but I’ve settled on git which makes me warm and fuzzy inside. Git was developed initially by Linus Torvalds to manage the complicated process of building a Linux kernel in a distributed manner (multiple people, multiple places editing one set of files). Quick list of benefits we’re interested in:

Revert changes without saving different versions manually
Develop multiple version of your site concurrently
Log changes you’ve made without a separately managed log file

Enough talk, let’s just run through what I do. I use Ruby on Rails and Sinatra for web development, but this will work with most languages too, if not all.

Getting Setup

Create a new project in your tool of choice, I’ll create one called ‘scm_project’ with Ruby on Rails:

$ rails scm_project
create  
create  app/controllers
...
create  log/test.log

This is just a plain old Ruby on Rails project, but it could be anything for you, even just a folder with some php files. We need to initialise the folder with our source code manager ‘git’.

$ cd scm_project
scm_project $ git init
Initialized empty Git repository in /a/demos/scm_project/.git/

So git has set up our folder as a version managed folder. We can now, for example, ask git for the status of this folder:

$ git status
# On branch master
#
# Initial commit
#
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
#
#	README
#	Rakefile
#	app/
#	config/
#	doc/
#	log/
#	public/
#	script/
#	test/
nothing added to commit but untracked files present (use "git add" to track)</pre>

Don’t worry, this is nothing scary. It’s just telling me that this folder has some unmanaged (‘untracked’) files. Source code managers need to told which files they’re managing. In this case we just need to tell git what to add and what to ignore. Some things shouldn’t be added, for example a database credentials file. If you have multiple people on a project and you all have your own local database server, then there’s no guarantee that the access details are the same, so by leaving it out (telling git to ignore it) it will never be added and everyone can have their own version without it affecting others.

Let’s set up our file ignore list. Create a file in the root of that folder called .gitignore and put in contents like this:

log/*.log
tmp/
.DS_Store
doc/api
doc/app
doc/plugins
db/*.sqlite3
config/database.yml

This is my base .gitignore file, you can add to this later as you go. The idea is that anything you don’t want version managed, you add to this file.

Next up, we need to tell the version management to add all files.

scm_project $ 
scm_project $ git add .
scm_project $ git status
# On branch master
#
# Initial commit
#
# Changes to be committed:
#   (use "git rm --cached <file>..." to unstage)
#
#	new file:   .gitignore
#	new file:   README
...
#	new file:   test/performance/browsing_test.rb
#	new file:   test/test_helper.rb
#

So by running git add . we’re telling git to add everything within this directory. . means ‘this directory’ in linux talk. That’s easy enough. Adding files to git means you’re telling it what you want to store in the system, but you need to ‘commit’ them too. Committing the changes that you’ve racked up tells the version system to store them.

The pattern is generally to rack up related changes, and then commit them with a message that logs those changes. In the future you can look at those logs and see what changes were made, even over multiple files, because of the way you add them.

The changes I’ve added here are simply adding a bare project, so I’m going to commit them now with a relevant message.

scm_project $ git commit -m 'initial bare rails project'
[master (root-commit) a085392] initial bare rails project
 41 files changed, 8438 insertions(+), 0 deletions(-)
 create mode 100644 .gitignore
 create mode 100644 README
 ...
 create mode 100644 test/performance/browsing_test.rb
 create mode 100644 test/test_helper.rb

After running the command, notice that git has told me how many insertions and deletions it’s accomplished. These are line counts. Where are we now? We’ve added the files we want the version management system to track, we can add more later, and we’ve committed the first set of changes to those files. Let’s hope through a few more changes and see what happens.

Making Changes

I’m going to change my application’s README file.

scm_project $ echo 'My New README' > README
scm_project $ git status
# On branch master
# Changed but not updated:
#   (use "git add <file>..." to update what will be committed)
#   (use "git checkout -- <file>..." to discard changes in working directory)
#
#	modified:   README
#
no changes added to commit (use "git add" and/or "git commit -a")

Our status shows me that I’ve got changes in the README but I’ve not added them to a commit. So this highlights an important fact, adding files to git doesn’t mean ‘add the file’ it means ‘add the changes’. Let’s prove this fact by adding our changed README.

scm_project $ git add README
scm_project $ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#	modified:   README
#
scm_project $ git commit -m 'showing what modifying files that are tracked does'
[master b9b57e5] showing what modifying files that are tracked does
 1 files changed, 1 insertions(+), 243 deletions(-)
 rewrite README (100%)

Our status changed from ‘Changed but not updated’ to ‘Changes to be committed’. Changes can be over multiple files and be added in groups, what’s important is that when you commit those changes they must be relevant to each other. Notice also that git has counted the new lines I’ve added as well as the ones I deleted. 1 files changed, 1 insertions(+), 243 deletions(-).

The pattern I generally follow is:

Make changes for a feature or bugfix
Ensure my tests are passing
Add the changes for that commit
Commit them as a group describing what I changed overall

Some people like to describe it on a per file basis, but for me it comes down to a feature or bugfix. ’why did I change it’, not ’what did I change’. This is an important fact to note because the version manager is already logging ‘what’ changed, so all that remains is ‘why’.

Looking at Changes

What is it logging? Let’s take a look:

scm_project $ git log
2009-08-30 21:15:10 fearoffish ttys001
commit b9b57e53fa0bdcd29b14fb0ded6ab4355ef3cb92
Author: Jamie van Dyke <fearoffish@fearofpro.local>
Date:   Fri Aug 28 23:03:31 2009 +0100

    showing what modifying files that are tracked does

commit a08539202e8bf908106e1736dabf588c3b367151
Author: Jamie van Dyke <fearoffish@fearofpro.local>
Date:   Fri Aug 28 21:58:47 2009 +0100

    initial bare rails project

What we see is who committed changes, when, and what they logged as the message. You also get a reference id to the commit, which is a 40 character SHA-1 value of the commit contents. When you reference a commit in the future you use this id, like others I mostly just use 6 characters as that’s more than likely the amount of characters you need to uniquely identify it. The beauty of the @git log@ is that if you keep good logs of the changes you’ve made and you group your commits correctly, then you can revert blocks of changes as required.

Reverting Changes

Let’s revert the last commit and see how easy it is to go back to previous version of your app.

scm_project $ git revert b9b57e
2009-08-30 21:20:59 fearoffish ttys001
Finished one revert.
[master 47d2c28] Revert "showing what modifying files that are tracked does"
 1 files changed, 243 insertions(+), 1 deletions(-)
 rewrite README (100%)
scm_project $ git log
2009-08-30 21:33:04 fearoffish ttys001
commit 47d2c28a1c90ed95a32c5e76fa6e669b89ca5f09
Author: Jamie van Dyke <fearoffish@fearofpro.local>
Date:   Sun Aug 30 21:33:03 2009 +0100

    Revert "showing what modifying files that are tracked does"

    This reverts commit b9b57e53fa0bdcd29b14fb0ded6ab4355ef3cb92.

commit b9b57e53fa0bdcd29b14fb0ded6ab4355ef3cb92
Author: Jamie van Dyke <fearoffish@fearofpro.local>
Date:   Fri Aug 28 23:03:31 2009 +0100

    showing what modifying files that are tracked does

commit a08539202e8bf908106e1736dabf588c3b367151
Author: Jamie van Dyke <fearoffish@fearofpro.local>
Date:   Fri Aug 28 21:58:47 2009 +0100

    initial bare rails project

When you run the git revert command, you give it the SHA-1 reference – or six characters, like I did – and git will remove any changes you made for that commit. Cool, huh? So you are keeping multiple versions of your application without keeping multiple files.

Okay, that’s enough for this episode. I’ll be creating more episodes on subjects like local and remote repositories, hosting your Rails applications and more, soon.

Giving Twitter some WoW

2009-05-03T19:25:44+01:00

It’s been a while since I posted anything, and I intend to fix that with smaller posts that describe things I’m doing. So let’s start off this new regime with a little post about a tiny script I wrote the other day for my WoW guild. We are now using a twitter account to post scheduled raids and other announcements, and I knocked together a little script that parses our guilds (Enigma on Hellfire) guildomatic site for raids we’ve rostered for later that day, and it posts them to twitter.

I needed to parse some html and for that I use the venerable HPricot gem, and to communicate with Twitter I use the Twitter gem. Here’s the code:

require 'rubygems'
require 'twitter'
require 'hpricot'  
require 'open-uri'  
require 'parsedate'

TWITTER_USERNAME = 'replaceme'
TWITTER_PASSWORD = 'replaceme'
# http://enigma-hellfire.guildomatic.com/ is ours
GUILD_SITE = 'replaceme'

def get_raids(doc)  
  message = "[RAID REMINDER] "
  curr_date = Time.new
  raids_today = false
  (doc/"tr.today").each do |post|
    raids_today = true
    (post/"td.clickable/a").each do |name|
      unless name.inner_html.include?( 'Roster' ) or name.inner_html.include?( 'roster' )
        message << name.inner_html 
        (post/"td.inviteAtTime").each do |start_time|
          message << " (" << start_time.inner_html << ") | "
        end
      end
    end
  end
  raids_today ? message[0..-3] : nil
end  

doc = Hpricot(open(GUILD_SITE))  

httpauth = Twitter::HTTPAuth.new(TWITTER_USERNAME, TWITTER_PASSWORD)
base = Twitter::Base.new(httpauth)
message = get_raids(doc)

if message
  base.update(message)
else
  base.update("[RAID REMINDER] There are no raids today, take a break, slacker!")
end

Guildomatic has the raids for today posted in a table cell with a class of ‘today’, which made this much easier. You get the idea from the code.

I’m also cheered up immensely on what 10 minutes of key bashing can output. I run this on my server (hosted by Linode) in a cron job at 12pm every day.

My PDF Ruby on Rails Beginner Handout

2008-12-09T22:32:48+00:00

A while ago I gave away my Ruby on Rails handout for beginners. It was a PDF that contained the real basics for getting started or at least understanding the fundamentals of what Ruby on Rails is all about. However, my blog changed, the article url moved and ultimately it disappeared.

Well here it is again, there are plenty of books like this out there, but hopefully there’s something in it that will help you start.

For now, here’s the Ruby on Rails Beginner Handout again.