Code Like Zell

Setting up Rails, MySQL, PHP, Apache, and Git on EC2

2011-02-19T00:00:00-08:00

This is a step by step tutorial on setting up an Amazon Linux EC2 instance with Rails, PHP, MySQL, Apache, and Git. You will have three EBS volumes mounted, one for each of the following:

MySQL data and logs
httpd virtual hosts and logs
Git repositories

You will bundle your instance into it’s own AMI, launch an instance from that AMI, and recreate the state of your first instance by moving EBS volumes.

Launching and Accessing Your First Instance

The first thing we need is a set of command line tools for accessing AWS. For this tutorial we will be using Tim Kay’s AWS. To install:

  $ cd /usr/bin
  $ sudo curl https://github.com/timkay/aws/raw/master/aws -o aws
  $ sudo chmod +x aws

Next, get your AWS access keys by going to your AWS Account page and clicking on Security Credentials. Under Access Credentials will be two keys: an Access Key and a Secret Access Key. Substitute your keys into the following:

  $ echo "<your-access-key>" >> ~/.awssecret
  $ echo "<your-secret-key>" >> ~/.awssecret
  $ chmod 600 ~/.awssecret

Now we can see what regions are available for our EC2 instance:

  $ aws describe-regions

Let’s tell aws what region to use. For pricing on the various regions, go here. I am using us-east-1:

  $ echo "--region=us-east-1" >> ~/.awsrc

And let’s see what zones are available within the region we selected:

  $ aws describe-availability-zones

Before we launch an instance, we need to setup a key pair and security group. The key pair will be used to access the instance for the first time, we will name the key pair ec2temp:

  $ aws add-keypair ec2temp > ~/.ssh/ec2temp.key
  $ chmod 400 ~/.ssh/ec2temp.key

The security group specifies what ports to open on the instance. We will open ports 22, 80, and 443; you can leave off 443 if you do not need HTTPS. Let’s name the security group Web1:

  $ aws add-group Web1 -d "Ports 22 (ssh), 80 (http), and 443 (https) are open"
  $ aws auth Web1 -P tcp -p 22 -s 0.0.0.0/0
  $ aws auth Web1 -P tcp -p 80 -s 0.0.0.0/0
  $ aws auth Web1 -P tcp -p 443 -s 0.0.0.0/0

We are now ready to launch an instance. We are going to start with an Amazon Linux S3-Backed 32-bit AMI, found here. The AMI ID is ami-d59d6bbc. Here I am launching a small instance in the us-east-1a zone with the ec2temp key pair and the Web1 security group:

  $ aws run ami-d59d6bbc -k ec2temp -g Web1 -z us-east-1a

Your instance will take a minute to finish launching. You can check the status of your instance with aws din (short for describe-instances):

  $ aws din | awk -F '[+|]' '{print $2,$4,$6}'

Repeat the command above until the instance state changes to running. At that point, copy the public DNS name of your instance. Now you can access your instance using ec2-user:

  $ echo "export EC2_HOST=<your-public-dns>" >> ~/.bash_profile
  $ source ~/.bash_profile
  $ ssh -i ~/.ssh/ec2temp.key ec2-user@$EC2_HOST

Setting up User Accounts

You are now logged in as ec2-user, which has sudo access by default. Now create your user accounts, in my case Lou and Todd will be using this server.

  $ sudo useradd lou
  $ sudo useradd todd

In another window, use ssh-keygen to create a keypair called id_rsa_ec2, then scp it to your instance and append it to your authorized_keys file:

  local$ ssh-keygen
  local$ cd ~/.ssh
  local$ scp -i ec2temp.key id_rsa_ec2.pub ec2-user@$EC2_HOST:~

Now, back on the instance:

  ec2-user$ sudo su lou 
       lou$ mkdir -m 700 ~/.ssh
       lou$ touch ~/.ssh/authorized_keys
       lou$ chmod 600 ~/.ssh/authorized_keys
       lou$ exit
  ec2-user$ cat ~/id_rsa_ec2.pub | sudo tee -a /home/lou/.ssh/authorized_keys

Locally, verify that you can ssh in using your new user account:

local$ ssh -i ~/.ssh/id_rsa_ec2 lou@$EC2_HOST
  lou$ exit

If you are getting denied, tail /var/log/secure for clues. Next, as ec2-user, let’s set some passwords:

  $ sudo passwd root
  $ sudo passwd lou
  $ sudo passwd todd

And set colorful prompts so we can tell who we are:

  $ echo 'export PS1="\e[1;31m[\u@\h \w]\\$ \e[m"' | sudo tee -a /root/.bashrc
  $ echo 'export PS1="\e[0;35m[\u@\h \w]\$ \e[m"' | sudo tee -a /home/lou/.bashrc
  $ echo 'export PS1="\e[0;32m[\u@\h \w]\$ \e[m"' | sudo tee -a /home/todd/.bashrc
  $ source ~/.bash_profile

Now let’s remove ec2-user. But first, we need to edit sudoers:

  $ sudo vim /etc/sudoers

  Change this line of the file:
    ec2-user ALL = NOPASSWD: ALL
  
  To this (in this case lou is the admin): 
    lou ALL=(ALL) ALL

And then remove the ec2-user:

  ec2-user$ exit
     local$ ssh -i ~/.ssh/id_rsa_ec2 lou@$EC2_HOST
       lou$ sudo userdel -r ec2-user

While we are tightening things up, let’s wipe out the authorized_key file for root:

  lou$ sudo su root -c '> ~/.ssh/authorized_keys'
  lou$ exit

Modifying Your SSH Config File

To make it easier to access your instance, add the following to your local ~/.ssh/config:

  Host=*compute-1.amazonaws.com
  User=<your-user-name>
  IdentityFile=~/.ssh/id_rsa_ec2

Now you can ssh into your instance with:

  $ ssh $EC2_HOST

Setting up Git

The git repositories will be on an EBS. On the filesystem, they will be at /home/git/repos. Let’s create a git user and add our other users to the git group. I am going to use root for the remaining commands; if you aren’t comfortable doing this, then prefix each command with sudo.

  $ sudo su
  # yum install -y git
  # useradd git
  # usermod -a -G git lou
  # usermod -a -G git todd

And make the git directory group read and writeable.

  # chmod -R g+rwX /home/git

Also, we want all files and directories created under /home/git to retain the git group:

  # chmod g+s /home/git

Let’s allocate an EBS to hold your repositories. Do this from your local machine, and be sure to create your volume in the same zone as your instance:

  local$ aws create-volume --size 5 --zone us-east-1a

A volume ID will be returned. We need that ID and the ID of your instance to attach the EBS. To get the instance ID:

  local$ aws din | cut -b -15

And then to attach:

  local$ aws attach-volume -i <instance-id> -d /dev/sdf <volume-id>

When I attach the EBS as /dev/sdf it shows up on my instance as /dev/xvdf, your mileage may vary. Also, as far as I can tell there is no way to tag the volume using aws. We are going to create three volumes by the time this tutorial is over, and we need to be able to distinguish between them. So, go to the EC2 Console, select Volumes, right click your volume, and tag it with the name “GIT”.

While you are in the Console, create two additional Volumes. Attach them as /dev/sdg and /dev/sdh; label them MySQL and Apache, respectively.

Back on the instance, format your volume for Git:

  # mkfs -t ext3 /dev/xvdf

And mount it:

  # echo "/dev/xvdf /mnt/vol1 ext3 noatime 0 0" >> /etc/fstab
  # mkdir /mnt/vol1
  # mount /mnt/vol1

Now we will bind the /mnt/vol1/repos directory to /home/git/repos:

  # echo "/mnt/vol1/repos /home/git/repos none bind" >> /etc/fstab
  # mkdir -m 770 /mnt/vol1/repos
  # su git -c 'mkdir -m 770 ~/repos'
  # mount /home/git/repos
  # chown git /home/git/repos
  # chgrp git /home/git/repos

Let’s make our first git repo:

  # su git
  git$ mkdir -m 770 ~/repos/testing.git
  git$ cd ~/repos/testing.git
  git$ git init --bare --shared=group
  git$ exit

From your local machine, verify that you can push to the new repo:

  local$ mkdir testing
  local$ cd testing
  local$ git init 
  local$ git remote add origin ssh://<user>@$EC2_HOST/home/git/repos/testing.git
  local$ echo "nothing here" > README
  local$ git add .
  local$ git commit -m "initial commit"
  local$ git push origin head

One final note regarding git: if you are moving repositories from an old location to your instance, clone them with the --bare option, e.g.

  $ git clone --bare ssh://user@an.old.host...

Setting up MySQL

First, install MySQL:

  # yum install -y mysql mysql-server
  # mysql_install_db
  # service mysqld start
  # mysql_secure_installation

Next, let’s put the data and log directories on an EBS. The majority of these steps are from Eric Hammond’s excellent tutorial.

We already allocated an EBS and attached it as /dev/xvdg in a previous step. Next, format and mount it:

  #  yum install -y xfsprogs
  #  grep -q xfs /proc/filesystems || modprobe xfs
  #  mkfs -t xfs /dev/xvdg
  #  echo "/dev/xvdg /mnt/vol2 xfs noatime 0 0" >> /etc/fstab
  #  mkdir /mnt/vol2
  #  mount /mnt/vol2

We have an EBS volume formatted with xfs at /mnt/vol2. We can now move
our MySQL data and log directories to the volume:

  # service mysqld stop

  # mkdir /mnt/vol2/lib
  # mv /var/lib/mysql /mnt/vol2/lib/

  # mkdir -p /mnt/vol2/log/mysql
  # mkdir /var/log/mysql /var/lib/mysql

  # cp /etc/my.cnf /etc/my.cnf.bak
  # sed -i 's|/var/log/|/var/log/mysql/|g' /etc/my.cnf

  # echo "/mnt/vol2/lib/mysql /var/lib/mysql none bind" >> /etc/fstab
  # mount /var/lib/mysql
  # echo "/mnt/vol2/log/mysql /var/log/mysql none bind" >> /etc/fstab
  # mount /var/log/mysql

  # chown -R mysql /var/lib/mysql /var/log/mysql
  # chgrp -R mysql /var/lib/mysql /var/log/mysql

Start up mysqld

  # service mysqld start

Setting up Apache

We are going to have our httpd logs and virtual hosts on a third EBS. The process is very similar to what we just went through with MySQL. Our virtual hosts will be at /var/www/vhosts, and the httpd logs at /var/log/httpd.

First install Apache:

  # yum install -y httpd

Our final EBS was attached to our instance as /dev/xvdh. Format and mount:

  # mkfs -t xfs /dev/xvdh
  # echo "/dev/xvdh /mnt/vol3 xfs noatime 0 0" >> /etc/fstab
  # mkdir /mnt/vol3
  # mount /mnt/vol3

Now let’s bind /var/www/vhosts to /mnt/vol3/vhosts and /var/log/httpd to /mnt/vol3/log/httpd:

  # mkdir /mnt/vol3/log
  # mv /var/log/httpd /mnt/vol3/log/

  # mkdir -p /mnt/vol3/www/vhosts
  # mkdir /var/www/vhosts /var/log/httpd

  # echo "/mnt/vol3/www/vhosts /var/www/vhosts none bind" >> /etc/fstab
  # echo "/mnt/vol3/log/httpd /var/log/httpd none bind" >> /etc/fstab

  # mount /var/www/vhosts
  # mount /var/log/httpd

  # service httpd start

You can convince yourself that the httpd log is on the EBS by tailing the access_log at /mnt/vol3/log/httpd/access_log and pointing your browser to the public DNS of your instance. You should see the Apache test page.

Testing PHP, Apache, and MySQL

First let’s get php and verify that Apache serves a simple php file:

  # yum install -y php
  # echo '<?php echo("hello from php"); ?>' >> /var/www/html/index.php
  # chgrp apache /var/www/html/index.php

Restart Apache:

  # service httpd restart

And point your browser to the public DNS of your instance. You should see “hello from php”. Next, let’s test the php mysql connection. To do this, we will manually enter a single row using the mysql client, then fetch it with php:

  # yum install -y php-mysql
  # mysql -u root -p
  
  mysql> CREATE DATABASE phptest;
  mysql> GRANT ALL PRIVILEGES ON phptest.* TO foo@localhost IDENTIFIED BY 'nachos';
  mysql> USE phptest;
  mysql> CREATE TABLE posts(id int(11) NOT NULL AUTO_INCREMENT, title varchar(255),
                            PRIMARY KEY (id)) ENGINE=InnoDB;
  mysql> INSERT INTO posts (title) VALUES ('hello from mysql');
  mysql> exit;

Now, to retrieve that row, edit /var/www/html/index.php to look like this:

<?php 
  mysql_connect("localhost", "foo", "nachos");
  mysql_select_db("phptest"); 
  $result=mysql_query("SELECT * FROM posts LIMIT 1");
  mysql_close();
  echo(mysql_result($result,0,"title")); 
?>

Restart Apache, then refresh your browser and verify that it says “hello from mysql”. If it does not, tail the default apache error log for clues:

  # tail -f /var/log/httpd/error_log

Once your test works, do a little cleanup:

  # rm /var/www/html/index.php
  # mysql -u root -p
  mysql> drop user foo@localhost;
  mysql> drop database phptest;
  mysql> exit;

On to Ruby and Rubygems!

First we need some ruby packages and gcc-c++ for building native extensions:

  # yum install -y gcc-c++ ruby ruby-libs ruby-devel ruby-irb rubygems
  # gem --version

I prefer not to install rdoc and ri files when installing gems on a server (feel free to skip this):

  # echo "gem: --no-ri --no-rdoc" >> ~/.gemrc

Installing Passenger (mod_rails)

  # yum install -y curl-devel httpd-devel openssl-devel zlib-devel
  # gem install passenger 
  # passenger-install-apache2-module

Follow the instructions that are spit out by the passenger install (by editing /etc/httpd/conf/httpd.conf).

Testing Rails

Let’s test out a rails app. We will need the mysql gem:

  # yum install -y mysql-devel
  # gem install mysql

Next, install Rails (I still use 2.3.8):

  # gem install rails -v=2.3.8

Then, create a test app:

  # cd /var/www/vhosts
  # rails -d mysql news

And edit httpd.conf to add a virtual host:

<VirtualHost *:80>
    # ServerName codelikezell.com
    DocumentRoot /var/www/vhosts/news/public
    <Directory /var/www/vhosts/news/public>
      AllowOverride all 
      Options -MultiViews
    </Directory>
</VirtualHost>

Restart Apache and refresh your browser, you should see the Riding Rails page. Let’s get the database involved to test the Rails MySQL connection:

  # cd /var/www/vhosts/news
  # rm public/index.html
  # mysqladmin -u root -p create news_production
  # vim config/database.yml
  
  Edit the production username and password: 
    username: news
    password: nachos

Grant privileges to the db user:

  # mysql -u root -p
  mysql> grant all privileges on news_production.* to news@localhost identified by 'nachos';
  mysql> exit

And generate some scaffolding:

  # script/generate scaffold Post title:string
  # RAILS_ENV=production rake db:migrate
  # vim config/routes.rb

Edit routes.rb to look like this:

  ActionController::Routing::Routes.draw do |map|
    map.resources :posts
    map.root :controller => "posts"
  end

Restart Apache, reload your browser, and (hopefully) behold a functioning Rails site! Put a few entries into the app so when we launch a second instance we can test whether the data stays intact.

Get Ready to Bundle

Let’s bundle up what we have into a new AMI. We need an X.509 certificate from Amazon to create a bundle. Go to your AWS account page and select Security Credentials. Under Access Credentials there is a tab for X.509 Certificates, select it. Create a new certificate and download the Private Key and X.509 pair to your ~/.ec2 directory.

While you are on the Security Credentials page, make note of your AWS Account ID, Access Key, and Secret Key—you will need all of these.

Next, scp the key and cert files to your instance. From the EC2 User Guide: “It is important to upload the key and cert files into /mnt to prevent them from being bundled with the new AMI.” So, let’s do that:

  local$ cd ~/.ec2
  local$ scp pk-xyz.pem cert-xyz.pem lou@$EC2_HOST:~
  local$ ssh lou@$EC2_HOST
    lou$ sudo mv cert-xyz.pem /mnt
    lou$ sudo mv pk-xyz.pem /mnt

Stop mysqld and httpd, and unmount the EBS volumes:

  # service httpd stop
  # service mysqld stop
  
  # umount /var/www/vhosts
  # umount /var/log/httpd
  # umount /var/lib/mysql
  # umount /var/log/mysql
  # umount /home/git/repos
  # umount /mnt/vol*

Verify that your EBS volumes are all unmounted by running the mount command with no arguments.

From your local machine, detach the EBS volumes. We will attach these again on an instance created from a new AMI. Get the volume ids, detach them, and then verify they are detached:

  $ aws describe-volumes | cut -b -150
  $ aws detach-volume <vol1-id>
  $ aws detach-volume <vol2-id>
  $ aws detach-volume <vol3-id>
  $ aws describe-volumes | cut -b -150

Now we can bundle:

   lou$ sudo su
  root# ec2-bundle-vol -k /mnt/pk-xyz.pem -c /mnt/cert-xyz.pem -u <your-aws-id-WITHOUT-dashes>

Next, let’s upload the bundle to S3. The bucket and subfolder will be created automatically if they do not already exist. As an example, in the command below I would use -b zell-amis/web1-image to upload my bundle to the web1-image subfolder of the zell-amis bucket:

  # cd /tmp
  # ec2-upload-bundle -b <bucket>/<subfolder> -m image.manifest.xml -a <aws-access-key> -s <aws-secret-key>

Note: if you get an error such as “Error talking to S3: Server.AccessDenied(403): Access Denied”, it could be because the S3 bucket name you chose is already taken—S3 buckets have a global namespace.

Finally, register your image from your local machine:

  $ aws register-image <bucket>/<subfolder>/image.manifest.xml -n <name-your-image>

Creating an instance of your new AMI

The last command should have returned an AMI id in the response. Let’s launch an instance of it:

  $ aws run <your-new-ami-id> -g Web1 -z us-east-1a

Now, just like last time, monitor the status of your launching instance:

  $ aws din | awk -F '[+|]' '{print $2,$3,$4,$6}'

Once it is running, note the public DNS name. Before we login let’s attach the three EBS volumes. We need their volume IDs:

  $ aws describe-volumes

Examine the tagSet column, then:

  $ aws attach-volume -i <instance-id> -d /dev/sdf <GIT-volume-id>
  $ aws attach-volume -i <instance-id> -d /dev/sdg <MySQL-volume-id>
  $ aws attach-volume -i <instance-id> -d /dev/sdh <Apache-volume-id>

Now ssh into the new instance as your admin user:

  $ ssh <public-DNS>

And go mount crazy:

  $ sudo mkdir /mnt/vol1 /mnt/vol2 /mnt/vol3
  
  $ sudo mount /mnt/vol1
  $ sudo mount /mnt/vol2
  $ sudo mount /mnt/vol3

  $ sudo mount /home/git/repos
  $ sudo mount /var/log/mysql
  $ sudo mount /var/lib/mysql
  $ sudo mount /var/log/httpd
  $ sudo mount /var/www/vhosts

Next, start mysqld and httpd and hold on to your privates:

  $ sudo service mysqld start
  $ sudo service httpd start

Browse to the public DNS of this instance and you should be staring at the Rails app with any entries you previously put into it.

A couple final things:

Starting httpd and mysqld at Boot

  $ sudo chkconfig --levels 235 mysqld on
  $ sudo chkconfig --levels 235 httpd on

Test it!

  $ sudo reboot

When your instance comes back, all the volumes should be mounted and mysqld and httpd should be running.

Cleanup

  $ sudo rm -rf /home/git/repos/testing.git
  $ sudo rm -rf /var/www/vhosts/news
  $ mysql -u root -p 
  mysql> drop user news@localhost;
  mysql> drop database news_production;
  mysql> exit;

Attaching an Elastic IP

Through the AWS Management console, allocate an Elastic IP address and attach it to your instance by right clicking on it. Now, locally, add the following to ~/.ssh/config:

  Host ec2
  Hostname=<your-elastic-ip-address>
  User=<your-user-name>
  IdentityFile=~/.ssh/id_rsa_ec2

Now you can ssh into your instance with:

  $ ssh ec2

Rails callback order

2009-07-20T00:00:00-07:00

Here is a snippet to print the name of the Rails callback when called, as well as the receiving class:

  # Tested on Rails 2.3.8, put me in the config/initializers directory
  module ActiveRecord
    module Callbacks
      private

      alias :callback_orig :callback
      def callback(method)
        $stdout.puts "#{self.class.name} #{method}"
        callback_orig(method)
      end
    end
  end

Now to test it out, let’s create a couple models:

  ~$ script/generate model Foo 
  ~$ script/generate model Bar foo_id:integer
  ~$ rake db:migrate

Set their associations:

  class Foo < ActiveRecord::Base
    has_many :bars
  end  

  class Bar < ActiveRecord::Base
    belongs_to :foo
  end

Then start script/console and instantiate and save them:

  f = Foo.new
  f.bars.build
  f.save

The result for this situation was:

  Foo before_validation
  Foo before_validation_on_create
  Bar before_validation
  Bar before_validation_on_create
  Bar after_validation
  Bar after_validation_on_create
  Foo after_validation
  Foo after_validation_on_create
  Foo before_save
  Foo before_create
  Foo after_create
  Bar before_validation
  Bar before_validation_on_create
  Bar after_validation
  Bar after_validation_on_create
  Bar before_save
  Bar before_create
  Bar after_create
  Bar after_save
  Foo after_save

I’m not sure why the Bar validation callbacks are called twice.

How to send email with Ruby and Gmail

2009-07-08T00:00:00-07:00

For sending emails from my gmail account, I wanted to an interface like this:

  gmail = GmailSender.new(:login => 'yourgmail@example.com', 
                          :password => 'yourpass')

  gmail.deliver(:to => 'friend@example.com', 
                :subject => 'hello friend',
                :body => 'omgyay')

Here is one implementation:

require 'net/smtp'
require 'rubygems'
require 'tlsmail'
  
Net::SMTP.enable_tls(OpenSSL::SSL::VERIFY_PEER)
  
class GmailSender
  SMTP_ADDR = 'smtp.gmail.com'
  
  def initialize(opts = {})
    unless opts[:login] && opts[:password]
      raise ArgumentError.new("provide a login and password")
    end
    @login    = opts[:login]
    @password = opts[:password]
    @domain   = @login[/@(.+)$/,1]
  end

  
  def deliver(opts = {})
    @recipients = opts[:to]
    @subject = opts[:subject]
    @body = opts[:body]
    smtp_args = [SMTP_ADDR, 25, @domain, @login, @password, :login]
    Net::SMTP.start(*smtp_args) do |smtp|
      status = smtp.send_message message, @login, @recipients 
      puts status
    end
  end

  private

  def message
<<-EOS
FROM: #{@login}
TO: #{@recipients.is_a?(Array) ? @recipients.join(', ') : @recipients}
SUBJECT: #{@subject}

#{@body}
EOS
  end
end

Turn this into a local gem and you are ready to write command line email hacks to your heart’s content.

Using javascript to pre-fill forms in development

2009-07-05T00:00:00-07:00

I often want to click through the many pages of my application without slowing down to fill in form data. To do this, I use javascript to pre-fill forms with a click. Say I have an order form that takes a first name, last name, and credit card type. Like this:

  <form>
    <input name="order[first_name]" type="text">
    <input name="order[last_name]" type="text">
    <select name="order[card_type]">
      <option value="visa">Visa</option>
      <option value="american_express">American Express</option>
    </select>
  ...
  </form>

I could write a javascript file that I only include in my development environment that would look like this:

  fill('order[first_name]', "Lou");
  fill('order[last_name]', "Zell");
  select('order[card_type]', "American Express");

The javascript functions that enable me to do this:

  function find(name){
    n = document.forms.length
    for (var i=0; i < n; i++){
      k = document.forms[i].elements.length
      for(var j=0; j < k; j++){
        if(document.forms[i].elements[j].name == name){
          return(document.forms[i].elements[j])
        }
      }
    }
  }
    
  function fill(name, content){
    find(name).value = content;
  }
    
  function select(name, content){
    s = find(name)
    for (var i = 0; i < s.options.length; i++){
      if (s.options[i].innerHTML == content){
        s.selectedIndex = i;
        return;
      }
    }
  }

These functions don’t rely on any library, and they also shouldn’t be used in production because they are far from optimized. Yes, I am 100% sure there is a much more efficient way to write them, but they work just fine for what I need them to do.

You could even create different sets of data to fill a form with, and attach each fill function to a link’s click event. Something like:

<a id="fill_with_bob">fill with bob's info</a>
<a id="fill_with_jane">fill with jane's info</a>

And the javascript:

  $('#fill_with_bob').click(function(){
    fill('order[first_name]', "Bob");
    fill('order[last_name]', "Jones");
    select('order[card_type]', "American Express");
  });
    
  $('#fill_with_jane').click(function(){
    fill('order[first_name]', "Jane");
    fill('order[last_name]', "Jones");
    select('order[card_type]', "Visa");
  });

I used jquery for that last part.

Steer clear of Paypal

2009-06-23T00:00:00-07:00

If you are considering using Paypal’s Website Payments Pro service for $30 per month, I would think twice. I was warned that their customer service was atrocious, but it’s much worse. If you are currently using them, you already know that every phone number they provide to reach merchant services directly takes you through the same automated system as every other Paypal number. Here are the steps I recommend to get you through to someone that can help, without losing your mind:

1. Take a shot (and one additional shot for each time you are disconnected)
2. Call any of several “direct lines” to merchant services
3. Say “no” when the automated system picks up
4. Say “agent” three times in a row, you will be placed on hold
5. You will get an agent, but they will be in the wrong department. They will inevitably discover that they cannot help you, and will transfer you to the merchant support group (which is the one you wanted in the first place). So save yourself the pain and demand an immediate transfer to merchant support. You will be on hold again for a while.

Good luck!

ShirtsTasteGood.com, YouTube Inspired T-Shirts

2009-06-16T00:00:00-07:00

**March 2010 Update: Shirts Taste Good has been shutdown.

I am very proud to announce Shirts Taste Good, a collection of t-shirts inspired by our favorite YouTube videos. It’s a four man team consisting of Todd Hamilton on artwork and web design, Doug and George Cline on screen printing, and myself on web development. Doug and George ditched their custom screen printing business that they had been running for the last few years, and Todd and I both quit our contracting/freelancing gigs in the city to full time STG. The operation is run out of a barn that Doug and George converted to a print shop near their home in New Jersey. The video that inspired each shirt is embedded on the shirt’s home page, so even if you aren’t interested in buying a t-shirt, you can come hang out and watch some hilarious videos. There is also a suggestions page where we auto-embed any videos that you would like us to turn into shirts! The suggestions page is particularly useful during that 1-3pm slot when you pretend to be working. We hope you enjoy the site, and please feel free to post any suggestions, questions, or comments. Thanks!

The Hudson Raft Project

2009-06-04T00:00:00-07:00

Over the last four years a few friends of mine, led by Dallas Trombley, have attempted to sail from Albany to Manhattan on homemade boats. They now have a site up describing their trials and tribulations. Most of their content is in the form of Wordpress pages rather than posts, so be sure to check out the left nav. It’s a really entertaining read. Good luck this year Dallas, Rob, and Co.

Disable SSL during Rails development

2009-05-26T00:00:00-07:00

Assuming you are using ssl_requirement, to disable SSL in your development environment:

  class ApplicationController < ActionController::Base
    include SslRequirement
  
    protected
    def ssl_required?
      RAILS_ENV != 'development' && super
    end
  end

Deploying Wordpress with Rails on Passenger

2009-05-20T00:00:00-07:00

I just finished integrating a Wordpress blog into a soon-to-be released Rails app, and I would like to share the steps I took to get it deployed on Phusion Passenger. Getting the permalinks working correctly had me hung up for a bit, so I’ll show you how to get around that.

To get started we can drop the blog right into the public directory of our rails app:

  cd /yourapp/public
  wget http://wordpress.org/latest.tar.gz
  tar xzvf latest.tar.gz
  mv wordpress blog     <--- blog will be at http://yourapp/blog
  cd blog
  mv wp-config-sample.php wp-config.php

Now edit the wp-config.php file (instructions are in the file) and be sure to grant database privileges to the user you specify.

Next, you have to edit your apache config file to disable passenger for the blog directory:

  <VirtualHost ...>
      ServerName ...
      DocumentRoot ...
      <Location /blog>
         PassengerEnabled off
      </Location>
  </VirtualHost>

I found that snippet here.

Restart Apache and point your browser to http://yourapp/blog/index.php to setup the rest of your blog through Wordpress’s web interface. One thing you will probably edit is the default permalink structure (Found at settings > permalink). I prefer to set a custom structure of ‘/%postname%’. Regardless of the structure you use, wordpress will tell you to edit the .htaccess file in your blog directory. For the life of me I could not get a .htaccess file to be recognized, so as a workaround I copied the snippet that wordpress specified into my apache config as follows:

  <VirtualHost ...>
      ServerName ...
      DocumentRoot ...
      <Location /blog>
         PassengerEnabled off
         <IfModule mod_rewrite.c>
           RewriteEngine On
           RewriteBase /blog/
           RewriteCond %{REQUEST_FILENAME} !-f
           RewriteCond %{REQUEST_FILENAME} !-d
           RewriteRule . /blog/index.php [L]
         </IfModule>
      </Location>
  </VirtualHost>

Finally, restart Apache.

A more readable sort by

2009-04-03T00:00:00-07:00

Suppose we want to sort a collection of accounts by their account balance. We could put them in ascending order like this:

  @accounts.sort {|x,y| x.balance <=> y.balance}

Or descending order like this:

  @accounts.sort {|x,y| y.balance <=> x.balance}

To me this isn’t very readable. How about this as an alternative:

  @accounts.sort_by_ascending(:balance)
  # or 
  @accounts.sort_by_descending(:balance)

The implementation is pretty simple, first create the methods:

  module ReadableSortBy
    def sort_by_ascending(method)
      sort {|x, y| x.send(method) <=> y.send(method)}
    end
    def sort_by_descending(method)
      sort {|x, y| y.send(method) <=> x.send(method)}
    end
  end

Then include them in Array:

  class Array
    include ReadableSortBy
  end

You could also make sort_by_ascending! and sort_by_descending! methods that modify the collection itself. Do this by replacing sort with sort! in both cases.

A cheap abstract class in Ruby

2009-03-29T00:00:00-07:00

When I create a class that I don’t want to be instantiated, I use the following pattern:

  class MakeMeAbstract
    def initialize
      raise "Don't instantiate me!" if abstract_class?
      puts "Instantiated!"
    end
    private
    def abstract_class?
      self.class == MakeMeAbstract
    end
  end

It can’t be instantiated:

  MakeMeAbstract.new rescue puts "I'm abstract"   # => "I'm abstract"

But it can be subclassed, and the subclass can be instantiated:

  class Child < MakeMeAbstract
  end
  Child.new   # => "Instantiated!"

This is a learning experience for me. When subclassing an abstract class I wonder if it would be better to use a mixin instead: I could overwrite mixed in methods just as easily as methods in a parent class. The structure changes from this:

  class Bar
    def status
      print "is full"
    end
  end
  class WetBar < Bar
    def status
      print "is wet, "
      super
    end
  end
  wet_bar = WetBar.new
  wet_bar.status    # => "is wet, is full"

To this:

  module Bar
    def status
      print "is full"
    end
  end
  class WetBar
    include Bar
    def status
      print "is wet, "
      super
    end
  end
  wet_bar = WetBar.new
  wet_bar.status    # => "is wet, is full"

Input is welcome in the comments.

Introducing Nickel

2009-03-27T00:00:00-07:00

Nickel is a client for Natural Inputs

  sudo gem install lzell-nickel

Then try it out:

  require 'rubygems'
  require 'nickel'
  n = Nickel.query "party this friday at 10pm"
  
  n.message # => party
  n.occurrences.first.start_date # => 20090403
  n.occurrences.first.start_time # => 22:00:00

Many more examples here.

How to Backup and Restore a MySQL Database

2009-03-25T00:00:00-07:00

To dump your database:

  mysqldump -u USER -p PASS my_db > my_db.sql

Then to restore:

  mysql -u USER -p PASS my_db < my_db.sql

Or, using gzip for compression, dump with:

  mysqldump -u USER -p PASS my_db | gzip > my_db.sql.gz

And restore with:

  gzip -cd my_db.sql.gz | mysql -u USER -p PASS my_db

Using inject for nicer output in IRB

2009-03-01T00:00:00-08:00

Sometimes you want to inspect an array in irb by iterating through it and printing out some key values, for example:

  events.each do |event|
    puts event.title
  end

But if the array is large, you will first have to scroll up through the returned array to get to your desired printout. We can prevent that by using inject instead:

  events.inject do |x, event|
    puts event.title
  end

Now nil will be returned instead of the events array, and your desired output is in view.

Using Gmail with Rails

2009-03-01T00:00:00-08:00

To send email from Rails using your Google Apps account, you will need TLS support:

  sudo gem install tlsmail

Next, edit environment.rb to look like this:

  Rails::Initializer.run do |config|
    config.gem "tlsmail"
    ...
  end
  Net::SMTP.enable_tls(OpenSSL::SSL::VERIFY_PEER)

Then add this to environments/development.rb:

  config.action_mailer.delivery_method = :smtp
  config.action_mailer.smtp_settings = {
    :address => "smtp.gmail.com",
    :port => "25",
    :domain => "your_domain.com",
    :user_name => "your_login@your_domain.com",
    :password => "your_password",
    :authentication => :login
  }

Test it out by sending an email to yourself, create the model mailer.rb:

  class Mailer < ActionMailer::Base
    def test
      from "your name <your_login@your_domain.com>"
      recipients ["your_login@your_domain.com"]
      subject "working?"
      body "sending from rails"
    end
  end

Finally, from script/console:

  Mailer.deliver_test

Preventing default event behavior with Javascript

2009-02-23T00:00:00-08:00

Let’s say we want to disable all the links on a page, using jQuery we just have to return false from the click handler:

  jQuery(function(){
    jQuery('body a').click(function(){
      return false;
    });
  });

Using Prototype, we pass the event instance to Event.stop():

  document.observe("dom:loaded", function(){
    $$('body a').each(function(a, num){
      $(a).observe('click', function(e){
        Event.stop(e);
      });
    });
  });

With everyday Javascript, we again return false from the click handler:

  window.onload = function(){
    elements = document.getElementsByTagName('a');
    for (var i = 0; i < elements.length; i++){
      elements[i].onclick = function(){
        return false;
      }
    }
  }

Ruby Bitwise Notes

2009-02-10T00:00:00-08:00

Start with an integer:

  x = 1

Shift by two bit positions:

  x <<= 2

OR with 1:

  x |= 1

AND with 14 (hex E):

  x &= 0xE
  # is the same as:
  x &= 14

Get binary representation:

  x.to_s(2)

Get hex representation:

  x.to_s(16)

XOR (exclusive OR) with 1

  x ^= 1

Vim single line move when :set wrap is on

2009-01-25T00:00:00-08:00

If you are editing a long paragraph with word wrap on, you may find that ‘j’ and ‘k’ jump farther than you would expect. This is because ‘j’ is moving to the next real line instead of the next wrapped line. To make vim behave more intuitively—for me, at least—put this in your vim config file (~/.vimrc in my case):

  function! ScreenMovement(movement)
     if &wrap
        return "g" . a:movement
     else
        return a:movement
     endif
  endfunction
  onoremap   j ScreenMovement("j")
  onoremap   k ScreenMovement("k")
  onoremap   0 ScreenMovement("0")
  onoremap   ^ ScreenMovement("^")
  onoremap   $ ScreenMovement("$")
  nnoremap   j ScreenMovement("j")
  nnoremap   k ScreenMovement("k")
  nnoremap   0 ScreenMovement("0")
  nnoremap   ^ ScreenMovement("^")
  nnoremap   $ ScreenMovement("$")

Thanks to rick_h in #vim

Rails 2 migrations without the timestamp

2009-01-25T00:00:00-08:00

For Rails 1 style migrations, set this in environment.rb:

  config.active_record.timestamped_migrations = false

Note this will not work before Rails 2.2. Thanks to mikeg1a in #rubyonrails.

Edit through FTP with TextMate and Cyberduck

2008-06-29T00:00:00-07:00

I do a bit of freelance php work where I need to edit files through FTP. Textmate does not support this very well out of the box, and at first it seemed like I would have to open and edit each file in its own window. But by combining this tip by subtlegradient with this tip by ciaranwal.sh we can use tabbed editing, project drawer, and cmd+t to switch files. The steps:

1. In Cyberduck’s preferences make sure external editor is set to TextMate. Also, it helps if “Double click opens file in external editor” is set to true.

2. Open up a file from your FTP project that is close to the top level directory of your project, you’ll see why in a minute.

3. In the TextMate window that popped up, hit ctrl+shift+o (Bundles > Shell Script > Open Terminal). The terminal will open at the temporary location where the file you are editing is.

4. cd .. back to the top level directory of your project and enter: mate .

Now any subsequent files you open using Cyberduck will be added as tabs in the current TextMate project.

GoLark Mobile

2008-02-12T00:00:00-08:00

**2009 Update: GoLark has been shutdown.

The GoLark iPhone Application was released this week, making GoLark one step closer to providing us with local events, anywhere, at any time.

Currently, two of GoLark’s lists are supported on the iPhone: Top Larks and Top Recurring Larks. Date and time filtering–although slightly stripped down–is also provided. The app is purposely minimal in design, providing a clear and simple interface to the best local events.

Check it out at iphone.golark.com

Create a sick game with Processing

2007-11-04T00:00:00-07:00

I did a little experimenting with Processing, a language written for artists, graphics designers, and anyone interested in learning something new. I was very impressed with how easy it was to get started. The download comes with tons of simple example projects, and the API reference is easy to understand. I had hopes of Processing opening a whole, previously undiscovered, artistic side of my brain — it didn’t. But I did make a killer “blow up the falling spheres with my triangle’s laser” game. Check it out:

Wow, that screen shot makes it look even more lame than it really is (hard to do).

I know, I know, you want the code so you can try this game out for yourself. Here it is, paste into Processing and hit play:

  PFont fontA;
  int sphereDiameter = 10;
  boolean shoot = false;
  
  int randx()
  {
    return int(random(600));
  }
  
  int[] sphereXCoords = { randx(), randx(), randx(), randx(), randx() };
  int[] sphereYCoords = { 0, 0, 0, 0, 0 };
  
  void setup()
  {
    size(600,620);
  }
  
  void draw()
  {
    background(0);
    fill(color(0,255,0));
    stroke(color(0,255,0));
    triangle(mouseX-8, 580, mouseX+8, 580, mouseX, 565);
    fill(color(255,0,0));
    stroke(color(255,0,0));
  
    if(shoot==true)
    {
      sphereKiller(mouseX);
      shoot = false;
    }
  
    sphereDropper();
    gameEnder();  
  }
  
  void mousePressed()
  {
    shoot = true;
  }
  
  void sphereDropper()
  {  
    stroke(255);
    fill(255);
    for (int i=0; i<5; i++)
    {
      ellipse(sphereXCoords[i], sphereYCoords[i]++,
              sphereDiameter, sphereDiameter);
    }
  }
  
  void sphereKiller(int shotX)
  {
    boolean hit = false;
    for (int i = 0; i < 5; i++)
    {
      if((shotX >= (sphereXCoords[i]-sphereDiameter/2)) && 
         (shotX <= (sphereXCoords[i]+sphereDiameter/2)))
      {
        hit = true;
        line(mouseX, 565, mouseX, sphereYCoords[i]);
        ellipse(sphereXCoords[i], sphereYCoords[i],
                sphereDiameter+25, sphereDiameter+25);
        sphereXCoords[i] = randx();
        sphereYCoords[i] = 0;
      }    
    }
  
    if(hit == false)
    {
      line(mouseX, 565, mouseX, 0);
    }  
  
  }
  
  void gameEnder()
  {
    for (int i=0; i< 5; i++)
    {
      if(sphereYCoords[i]==600)
      {
        fill(color(255,0,0));
        noLoop();
      }
    }
  }

How to modify the GNU linker's default search path

2007-10-30T00:00:00-07:00

I installed GNU’s Scientific Library and Ruby’s wrapper for GSL on Ubuntu and OS X without any problems. Next up: CentOS. The install appeared to complete successfully, but a require ‘gsl’ from irb showed otherwise:

  LoadError: libgsl.so.0: cannot open shared object file: 
  No such file or directory

I located libgsl.so.0 in /usr/local/lib; so the problem is with the linker finding a shared library. The way I fixed this during the memcached install was to add the --rpath linker flag during the build. But I don’t wan’t to keep running into this in the future, so I decided to add /usr/local/lib to ld’s default search path, here’s how:

Open /etc/ld.so.conf in your editor and make sure there is a single line that reads:

  include ld.so.conf.d/*.conf

Then, from your shell prompt:

  echo "/usr/local/lib" >> /etc/ld.so.conf.d/loc_lib.conf
  /sbin/ldconfig

That should do it.

If you would like to learn more on the subject, this is the best documentation I have found on Shared Library Search Paths.

Benchmarking Ruby Time and Date instantiation

2007-10-19T00:00:00-07:00

A comparison of various ways to represent dates and times in ruby. I am creating October 10, 2007 in every case, here are the tests:

  n=10000
  Benchmark.bm(10) do |test|
    test.report("Date.strptime: ") do
      n.times {Date.strptime("20071001","%Y%m%d")}
    end 
    test.report("Date.parse: ") do
      n.times {Date.parse("20071001")}
    end 
    test.report("Time.now: ") do
      n.times {Time.now}
    end 
    test.report("Date.new: ") do
      n.times {Date.new(2007, 10, 1)}
    end 
    test.report("DateTime.civil: ") do
      n.times {DateTime.civil(2007, 10, 1)}
    end 
    test.report("DateTime.parse: ") do
      n.times {DateTime.parse("20071001")}
    end 
    test.report("DateTime.strptime: ") do
      n.times {DateTime.strptime("20071001","%Y%m%d")}
    end 
    test.report("Time.local: ") do
      n.times {Time.local(2007, "oct", 1)}
    end 
    test.report("Time.parse: ") do
      n.times {Time.parse("20071001")}
    end 
    test.report("Time.quick_parse: ") do
      n.times {Time.quick_parse("20071001")}
    end 
  end

Time.quick_parse is a method that I defined, it’s going to be the fastest way to parse a string in the form “YYYYMMDD”:

  class Time
    class << self
      # Usage:  Time.quick_parse("YYYYMMDD")
      def quick_parse(date_str)
        local(date_str[0..3], 
              RFC2822_MONTH_NAME[date_str[4..5].to_i - 1],
              date_str[6..7])
      end
    end
  end

The results:

                      user        system      total        real
  Date.strptime:      2.890000    0.040000    2.930000    (  2.982972)
  Date.parse:         3.630000    0.050000    3.680000    (  3.755735)
  Time.now:           0.010000    0.000000    0.010000    (  0.008608)
  Date.new:           0.590000    0.010000    0.600000    (  0.597446)
  DateTime.civil:     1.640000    0.010000    1.650000    (  1.675539)
  DateTime.parse:     4.970000    0.050000    5.020000    (  5.066107)
  DateTime.strptime:  4.250000    0.050000    4.300000    (  4.342663)
  Time.local:         0.120000    0.000000    0.120000    (  0.123242)
  Time.parse:         1.720000    0.010000    1.730000    (  1.750917)
  Time.quick_parse:   0.150000    0.000000    0.150000    (  0.157280)

The version of Ruby that I’m using:

  ruby -v 
  ruby 1.8.6 (2008-03-03 patchlevel 114) [universal-darwin9.0]

How to install memcached on CentOS

2007-10-11T00:00:00-07:00

This is a step by step guide to installing memcached from source on CentOS. To install using yum instead, run yum install memcached. The version of CentOS that I am using is CentOS release 5.2 (Final); to find what version you are using:

  cat /etc/redhat-release

First, install the dependency libevent:

  cd /usr/local/src
  curl -O http://monkey.org/~provos/libevent-1.4.14b-stable.tar.gz
  tar xzvf libevent-1.4.14b-stable.tar.gz 
  cd libevent-1.4.14b-stable
  ./configure --prefix=/usr/local
  make && make install

Next, install memcached:

  cd /usr/local/src
  curl -O http://memcached.googlecode.com/files/memcached-1.4.5.tar.gz
  tar xzvf memcached-1.4.5.tar.gz
  cd memcached-1.4.5
  LDFLAGS='-Wl,--rpath /usr/local/lib' ./configure --prefix=/usr/local
  make && make install

Verify that memcached starts:

  memcached -u root -d

If there were no errors, make sure it is running:

  ps aux | grep memcached

And finally, to stop memcached:

  pkill memcached

These instructions prevent the following errors:

  memcached: error while loading shared libraries: libevent-1.4.so.2: 
  cannot open shared object file: No such file or directory
  configure: error: libevent is required
  If it's already installed, specify its path using --with-libevent=/dir/

Detecting the enter key with javascript

2007-10-05T00:00:00-07:00

Let’s inspect a key-press event to determine if the enter key was pressed. The event instance has a property called keyCode, which indicates the enter key when set to 13. Let’s start with a text input:

  <input type="text" id="foo">

We can write an event handler to alert the contents of this field when enter is pressed:

  document.getElementById('foo').onkeypress = function(e){
    if (!e) e = window.event;   // resolve event instance
    if (e.keyCode == '13'){
      alert(this.value);
      return false;
    }
  }

IE will append the event instance to the window instead of passing it as a parameter to the handler, so the first line of our handler ensures that e is set to the event instance, regardless of browser. Next we see if keyCode is equal to ‘13’, which indicates the enter key. If enter was pressed we alert the contents of the text box and return false. We return false in case our input is within a form and we want to prevent the event’s default behavior (i.e. submitting the form).

Let’s try it out, type something in the field below and hit enter:

I would also like to mention that there is no need to resolve the event instance if we use jquery or prototype. Here is how we would accomplish the same thing with jquery:

  $('#foo').keypress(function(e){
    if (e.keyCode == '13'){
      alert(this.value);
      return false;
    }
  });

And finally, with prototype:

  $('foo').observe('keypress', function(e){
    if (e.keyCode == '13'){
      alert(this.value);
      Event.stop(e);
    }
  });

How to use Ruby variables in regular expressions

2007-09-27T00:00:00-07:00

If you do not know the pattern that you are trying to match ahead of time (e.g. it is some form of user input), you can construct a regex from a string:

  str = "this string has ruby in it"
  re = "ruby"
  str =~ /#{Regexp.escape(re)}/    # => 16

You can also combine components to create a new pattern:

  a = 'ruby'
  b = 'on rails'
  str = "this string has ruby on rails in it"
  str.match(/#{a} #{b}/)    # => true

If you are looking for a way to create patterns from combinations of common elements, and the elements are not derived from input, it is just as easy to combine Regexp objects:

  a = /ruby/
  b = /on rails/
  str = "this string has ruby on rails in it"
  str.match(/#{a} #{b}/)  # => true