First of all I wanted to put my Rails application into a Maven like directory structure so I created /src/main/rails and put the app in there,  then I knocked up a pretty standard POM for a WAR file.  Next up I wanted to Warble the project so I first up I installed the gem.

pdodds:(svn)trunk[trunk:4184]/src/main/rails$ sudo gem install warbler
Bulk updating Gem source index for: http://gems.rubyforge.org
Successfully installed warbler-0.9.11
1 gem installed
Installing ri documentation for warbler-0.9.11...
Installing RDoc documentation for warbler-0.9.11...
pdodds:(svn)trunk[trunk:4184]/src/main/rails$

Then I pluginize the Warble so that it will be available in my project using warble pluginize.

Next up I wanted to get my Maven pom sorted out – the quickest way I could find to get Warble integrated was through the jruby-rake-plugin. Adding the following plugin to my pom.xml ensures that the gems that I need are installed by the jruby plugin and then warble can be called in the compile phase.

<plugin>
	<groupId>org.jruby.plugins</groupId>
	<artifactId>jruby-rake-plugin</artifactId>
	<version>1.1.4</version>
	<executions>
		<execution>
			<id>install-gems</id>
			<phase>process-resources</phase>
				<goals>
					<goal>install-gems</goal>
				</goals>
				<configuration>
					<gems>warbler,rails</gems>
				</configuration>
		</execution>
		<execution>
				<id>build-war</id>
				<phase>compile</phase>
				<goals>
					<goal>rake</goal>
				</goals>
				<configuration>
					<launchDirectory>${basedir}/src/main/rails
					</launchDirectory>
			    	        <args>war:clean war</args>
				</configuration>
	           </execution>
	</executions>
</plugin>

In the first instance of the execution of the jruby plugin we pull down and install the gems that we are going to use, in the second we actually call the Warble goals in the project to create the WAR file.

In order to quickly integrate this process with the standard WAR building in Maven we need to configure the Maven WAR plugin, you could also change the Warble output but in the end I found this way worked when I wanted to use the Jetty plugin.

<plugin>
	<groupId>org.apache.maven.plugins</groupId>
	<artifactId>maven-war-plugin</artifactId>
	<configuration>
		<webappDirectory>${basedir}/src/main/rails/tmp</webappDirectory>
        </configuration>
</plugin>

While this is pretty brief hopefully it helps others get going and I’m very open to alternate or better ways to achieve the same goal.

In order to get things started I simply set-up the new Amazon EC2 gem.

# ONE TIME ONLY
# Execute this on each machine where you install gems to add github as a gem source
gem sources -a http://gems.github.com/

# ONE TIME ONLY
# Only if you had a previous version of the gem installed from RubyForge before we moved to GitHub
# Say 'Y' to remove all previous versions and all binaries when prompted.
sudo gem uninstall amazon-ec2

# Finally install the gem
sudo gem install grempe-amazon-ec2

Once installed we need to add a couple of environment variables  to our .bash_profile, this is useful to have around if you want to use the EC2 CLI anyway. Here’s what I put in my .bash_profile (on Leopard):

export RUBYOPT="rubygems"

# For amazon-ec2 and amazon s3 ruby gems
export AMAZON_ACCESS_KEY_ID="YOUR_ACCESS_KEY_ID"
export AMAZON_SECRET_ACCESS_KEY="YOUR_SECRET_ACCESS_KEY_ID"

Before going too far we will need to create a key pair that we can use, this is easy enough – lets start up the ec2sh and create a new keypair. We store this in a local file.

>> File.open("pdodds-keypair","w") { |file| file.write(@ec2.create_keypair(:key_name=>"pdodds-keypair").keyMaterial); file.close }
>> File.chmod 0700,"pdodds-keypair"

First up I thought I would take a look around the images that are available so that I can pick up something that I could use, since I’m bedding slowly into the Ruby world I thought I would use ec2sh and get back some information on what is available.

>> @ec2.describe_images(:owner=>'amazon').imagesSet.item.each { |image| puts "#{image.imageId} #{image.imageLocation}" } == true

Beside the scruffy ==true on the end basically this prints out the ID’s and locations of the Amazon owned images. For those new to EC2 these are the images of operating systems that we can use to boot our instance. EC2 machines currently only support persistent filesystems for those lucky enough to get on the beta (anyone going to invite me?). These means that when you boot up a machine the image is all you have, and when you power down anything you have written to disk is lost. In a while we’ll touch upon bundles – this is a way to allow you to build AMIs (Amazon Machine Image) and store them away.

The output of our command should give us a nice list, we can do a little to filter down the results (since their is a fair few to choose from).

>> @ec2.describe_images(:owner=>'amazon').imagesSet.item.each { |image| puts "#{image.imageId} #{image.imageLocation}" if image.imageLocation =~ /rails/} == true

This gave me a few to choose from

ami-0cf61365 ec2-on-rails-0.9.2/ec2-on-rails.manifest.xml
ami-540aef3d ec2onrails/ec2onrails-v0_9_7-x86_64.manifest.xml
ami-5c0aef35 ec2onrails/ec2onrails-v0_9_7-i386.manifest.xml
ami-6bcd2802 rails1-51193934437/rails1-51193934437.img.manifest.xml
ami-86c025ef ec2onrails/ec2onrails-v0_9_5-i386.manifest.xml
ami-99c025f0 ec2onrails/ec2onrails-v0_9_5-x86_64.manifest.xml
ami-99f712f0 ec2-on-rails-0.9.1/ec2-on-rails.manifest.xml
ami-a38b6eca amis.winelibrary.com/rails_svn.manifest.xml
ami-a3f91cca ec2onrails/ec2onrails-v0_9_3.manifest.xml
ami-a93adfc0 webficient/ec2_images/fc8-rails2-nginx-mysql/image.manifest.xml
ami-e620c58f ec2onrails/ec2onrails-v0_9_6-i386.manifest.xml
ami-ecc12485 ec2onrails/ec2onrails-v0_9_4-i386.manifest.xml
ami-efc12486 ec2onrails/ec2onrails-v0_9_4-x86_64.manifest.xml
ami-f920c590 ec2onrails/ec2onrails-v0_9_6-x86_64.manifest.xml

So lets get down to business – time to provision one of those servers for our use, I have to admit this was the bit that I always thought was cool, we can just use a simple command from ec2sh to create an instance of a server. Back to ec2sh.

>> @ec2.run_instances :image_id=>"ami-a93adfc0", :key_name=>"pdodds-keypair"

This will dump out a bunch of XML, basically the response from the web service. You could probably have done something to pretty up the response, however for now we can look up our instances to see if it is running

>> @ec2.describe_instances.reservationSet.item.each{ |reservation| puts "Reservation: #{reservation.reservationId}"; reservation.instancesSet.item.each {|item| puts "Instance: #{item.instanceId} #{item.instanceType} #{item.launchTime} #{item.dnsName}" }} == true

This will output the happy information, as long as the server has had a few minutes to provision and start.

i-9e5a97f7 m1.small 2008-05-03T09:19:12.000Z ec2-75-101-212-159.compute-1.amazonaws.com

Next we need to authorize the access to the server

>> @ec2.authorize_security_group_ingress :group_name=>"default",:from_port=>22,:ip_protocol=>"tcp", :to_port=>22, :cidr_ip=>"0.0.0.0/24"

Finally now from terminal we can SSH into the server, note that we do need to include the key that we created.

ssh -i pdodds-keypair root@ec2-75-101-212-159.compute-1.amazonaws.com

There we go – we have an instance of that Unix box, up and running, we can play around with the instance and when it’s time to say goodbye its a simple as going back to our ec2sh session and running:

>> @ec2.terminate_instances :instance_id=>"i-9e5a97f7"

I’ll follow up this blog post with how you can modify and then store images, later however I hope this shows how you can use the Ruby EC2 API to play around and create servers :) happy provisioning in the cloud….

Some of the nice components I’ve seen included the ability to sum calculated values from arrays where the method is accessing the ActiveRecord fields on the same object.

def sum_invoices
 invoices.to_a.sum(&:invoice_total)
end

Also I have been working with HAML after being introduced to it by one of the team and while it does take me back a little to all those Java templating languages and I now see how useful it is in pushing people toward using CSS.

Other nice little features I have been picking up on include using ruby in fixtures which includes being able to create large number amounts of test data.  As I get more into it the rewarding part the pace of my development appears to be picking up :)

Now at Exist I have been given the chance to look across more technologies again and so it is back to Ruby.   A lot has changed with a huge number of advances in Behaviour Driven Development with Rails 2.0 coming out.  I have to admit there is a lot to pick up again,  and I’m taking time to catch up with it all again.  Though as I start to enter the Ruby world it is nice to see a lot of really nice tools out there to make the work of creating rich solutions easier and easier.  Lately for me it has been working with newgem and rspec,  to start to allow some definition around a component layer for a pet project.

Also I got a chance to hang out with the growing Ruby on Rails scene in Manila which was fun – if you are out here for a while its worth catching up with them.   I’m sure in the next few months I’ll be seeing more and more of Ruby and Rails, and probably a bit of Merb and ActiveResource too.

There are many times when I need to put together an idea really quickly and lately I have been trying to use Ruby on Rails more,  in the past couple of months I’ve been trying to make that more of a thing.

Lately I needed to mock up a few screens for basic data entry and I decided to put something together using rails.  It was an easy start with a few migrations (Rails 2.0 style) to get a schema in place – then I considered a UI.  Originally I thought about scaffold, but I was never a big fan of generating lots of code that I would probably leave lying around.  I wanted something that would give me a shell of functionality (in this case to allow some basic CRUD operations) but not litter the application with code that I would probably want to remove later.  Enter ActiveScaffold.

It only took a couple of hours to get a  a five controllers in place to allow me to manage most of the data,  was it bullet-proof ? err.. no – but then again it was functional and step in the right direction.  Take a look at the demos,  they are worth a look, and when you get a chance have a look throwing it in to see what it can do :)