At the ALM Conference, Richard interviewed me for a podcast on the Ultimate ALM Environment circa 2010 as well as a little on build and deployment automation. Check out the podcast on Talking Shop!
Category: Ruby / Rails Page 3 of 7
Fed up with XML based builds that are hard to maintain, refactor and extend? Rather than trying to fix this with more xml and community tasks, or re-invent the wheel, let’s use Rake. Rake is a mature build system developed by the ruby community which can be applied equally well in the .NET world.
To help you get started quickly, I’ve put together nRake. nRake provides a template C# .NET solution with a nice directory structure (src, tools, lib, etc), a Rake build, NUnit tests, templated app and web configs for different environments (eg, dev, uat, prod, etc) and Continuous Integration server sample config files. It comes with everything you need – no additional libraries or downloads required, and all the plumbing work has been done for you.
How to use
- Git clone or Download nRake as a Zip
- Rename PlaceHolder app and tests to reflect your project
- Run rake in the root of the project. This will clean, compile, template config files and run unit tests.
- Start developing your app! How easy was that 🙂
Note: nRake currently uses Ruby 1.9 since IronRuby start up time was prohibitively slow. Hopefully IronRuby will get faster, and then nRake can make use of it. Also nRake uses the Albacore Gem for .NET build tasks. Documentation on Albacore tasks here.
Also check out the IronRuby update!
When offering higher levels of uptime on a web site backed by MySQL, a good approach is to set up a MySQL master-slave configuration for failover between servers. This generally works quite well, but once in a while, there is a problem or error that causes the replication to cease. The slave then ceases to process updates and gets out of sync with the master.
The script below is a quick and easy approach to monitoring the status of replication on the slave. If the slave thread or IO ceases, the slave gets more than 120 seconds behind the master, or there is an error, the script will email all the slave status information to an email address you specify to alert you that you need to log in and sort things out. I run the script from cron so that I get notified fairly soon if a problem arises.
RAILS_ENV = 'production' ALERT_EMAIL_ADDRESS = '[email protected]' require 'open3' require 'socket' require "#{File.dirname(__FILE__)}/../../config/environment.rb" r = ActiveRecord::Base.connection.execute("show slave status").fetch_hash unless r["Slave_IO_Running"] == "Yes" && r["Slave_SQL_Running"] == "Yes" && r["Last_Errno"] == "0" && r["Seconds_Behind_Master"].to_i < 120 status = "*** STATUS ***\\n" + r.to_a.collect { |i| "#{i[0]}: #{i[1]}\\n" }.join subject = "MySQL Slave Replication Down on #{Socket.gethostname}" Open3.popen3("mail -s \"#{subject}\" #{ALERT_EMAIL_ADDRESS}") do |stdin, stdout, stderr| stdin.write(status) end end
Note: This script relies on being part of a rails app to get a database connection. It would be fairly easy to modify it to include db credentials and open the connection.
Once a business web application reaches a certain size, the need often arises to generate PDFs from HTML/CSS.
Up until recently, the story around this for a MRI Rails application was not good. You could either use tools like Prawn, which require a description of the layout in a specific DSL, or pay for a tool like Prince XML which can convert from HTML, but which costs quite a bit. Those using JRuby were in a stronger position as they could use the Java PDF library called Flying Saucer.
The good news is that PDF generation for MRI Ruby is now easy and free, thanks to webkit, the open source webkit wrapper called wkhtmltopdf and mileszs’s wickedpdf plugin. I was really excited to come across this plugin and started to use it right away. However, it had a couple of issues:
- Temp file handling caused errors when two PDFs were being generated within the same second (eg, 2 requests at almost the same time)
- Problems generating PDF were not reported
Galdomedia forked the code and updated it to use standard Ruby temp files. This was great for ruby 1.7, but not good for Ruby 1.6 which does not allow you to set the extension on temp files (wkhtmltopdf relies on having a .html extension).
As my production servers run Ruby 1.6, I needed a different approach. My fork uses streams rather than temporary files, and adds some basic error handling and basic integration tests.
To install in a rails app:
script/plugin install git://github.com/jcrisp/wicked_pdf.git
Ruby for Rails by David Black is a fun read that takes concentration but repays it with little epiphanies that explain syntax and language features that you had previously taken for granted.
The book aims to “help Rails developers achieve Ruby mastery”. The coverage of Ruby features is not complete and there are some concepts missed that I would have liked to have read more about (eg, how do instance variables work under the hood?). There are also a number of introductory chapters on Ruby and Rails and some chapters devoted to a sample Rails project (R4RMusic) which I flicked through but didn’t add much value for me (they are also a little dated). By far, the most interesting parts of the book for me were on the Ruby type system, ‘self’ in various situations and how method look up works with modules and inheritance.
An area of Ruby that I had not previously explored was adding singleton methods to instances (like what you can do in Javascript). Eg,
o = Object.new def o.say_hi p "hi" end >> o.say_hi "hi"
or alternatively
o = Object.new
class << o
def say_hi
p "hi"
end
end
Now, the interesting thing is that this is the basis for the whole class system in Ruby!
Classes are just a special type of object, and when you add class methods, you are really adding singleton instance methods to the class object for the type.
Ie, when you do something like:
class Cars
def self.find_all
...
end
You are actually creating a new object, of type Class which has a singleton method called 'find_all'. 'self' in the code above is the Class object, so def self.xxx is adding a singleton method to it.
This also explains the alternative syntax for adding class methods:
class Cars
class << self
def find_all
...
end
end
The same thing could be done by saying:
Cars = Class.new
Cars.instance_eval { def find_all; ... end; }
In Ruby, the type and class system is not very different from the normal objects you work with every day. I find this really quite cute and internally consistent.
The way the method search path works in ruby was also nicely explained in the book. Basically, finding a method starts at the top of the list below and stops as soon as a method with a matching name is found (ie, that responds to the message sent to the object):
- Singleton methods on the object
- Methods defined by the object's class
- Methods defined by modules mixed in to the class
- Methods defined by parent class
- Methods defined by modules mixed into parent class
- Repeat checking parents until get to Object
- Methods defined on Object
- Methods defined on Kernel (module mixed into Object)
This also explains why you can always call methods like 'p' from anywhere. They are coming from Kernel which is mixed in at the top of the inheritance tree for your object. Another case of internal consistency - there's no 'special' mechanism for these seeming globals.
Overall, I enjoyed the book and would recommend anyone having a read who has worked with Ruby and Rails but would like to dig a bit deeper.
Sorry the the confusion, anyone who has been checking out the the Mephisto Contact Form Plugin from the old SVN repository. The latest version with an update for Rails 2.3 is at:
A little while back, a few colleagues and I were spiking a proxy concept based on extending an existing web server. We wanted to check out an instance variable (eg, @very_secret) in a framework object which did not have an accessor. In the past, we’d used send (eg, secretive_object.send :hello_private) to get at privates, but send is only for methods. We were just digging around doing some debugging, so we opened the relevant class and added a public accessor for the instance variable to see what was happening. However, we thought there must be a more elegant way to do access instance variables outside the class, and one has just come to mind (at last!):
secretive_object.instance_eval { @very_secret }
instance_eval lets us run the code block in the context of secretive_object. Ie, self == secretive_object, so we can get at all the hidden stuff.
It’s a rather different approach to other languages like C# and Java where accessing private variables and private methods are part of a reflection/introspection API.
Deploying Rails Applications: A Step-by-Step Guide by Ezra Zygmuntowicz, Bruce Tate and Clinton Begin is a good read, if a little dated. It was published in May 2008, and you can see that things have moved on a little in the Rails world since then. None the less, quite a lot of the information is still relevant and useful.
The book covers some basic Rails and version control concerns at the start, then rapidly launches into chapters devoted to Rails hosting options available from shared hosts to virtual and dedicated servers. The advice given is good and is in line with my experiences. Unix configuration is given in depth which would be very handy if you had not set up a server before. Next is a good discussion of Capistrano and automating deployments. The examples all use subversion. However, these days I expect the majority of Rails source code is pulled with Git. There is also a chapter on managing mongrels and setting up monitoring solutions. This is still relevant if you want to use mongrels, however these days Passenger is probably the best choice, and it does not have such complex management and configuration requirements. The scaling out chapter is useful and pulls together handy information including details on MySql replication/clustering. There’s a chapter on deploying on Windows and also some suggestions around performance and profiling.
I haven’t come across another book that brings together a structured collection of useful information to help you move from running rails locally to having a cluster of scalable production servers and the automated deployment process required to support it. Despite being too old to cover Git and Passenger, I’d still recommend having a read of this book if you’re at the stage of planning to launch a Rails site or looking to scale your VPS up to a cluster.
So yes, everyone has heard that Mac OS X and TextMate is the epitome of Rails development, and that it is so awesome that it brings tears of joy to developers eyes, &c. However, for those of us who either don’t have a Mac, or get to work on client provided hardware (often running Windows), there are a few options available.
Developing on Windows XP, with InstantRails is workable. It is easy to get everything you need and have your apps up and running quickly. However, performance is, well, quite frankly, terrible for anything you do on the command line. Mainly, this bites when running tests, doing migrations, generating files etc. Performance running Mongrel is good enough for development.
What about Cygwin? Subjectively, I found it provided similar speed to Windows Ruby/Rails.
So this brings us to virtualisation. Recently, I’ve been testing out VirtualBox running Ubuntu on top of Windows XP. This has had surprisingly good results. On the same machine, the virtual Ubuntu running Rails tasks has about 4 times (!!!) faster performance, even though it has less memory and system resources!
Here are some stats to give you and idea of the advantage.
Machine is a 2.4ghz quad core, 4gig of memory running Windows XP. Using VirtualBox 2.1.4 for virtualized Ubuntu Intrepid 64 bit, with 1.5gig of memory allocated. Figures are in seconds and approximate (taken with a wrist watch).
| generate scaffold | db:migrate with no changes | run tests for medium sized rails app | |
|---|---|---|---|
| Windows XP & Instant Rails | 7 | 7 | 25 |
| VirtualBox Ubuntu on same Windows XP | 1.5 | 1.5 | 6 |
Some of these commands / tests rely on hitting a MySQL database. However, I’m interested in overall development speed for both platforms, not in Ruby speed in particular, so I think it is fair game to include these in the results.
So if you want to do Rails Dev on Windows, I highly recommend trying a virtual machine running Linux!
In a fit of TextMate jealousy, several months ago, I scoured the web for a way to get find-file functionality info my favourite Ruby/Rails editor, vim. I was very happy to find that Jamis Buck had developed an aweseome plugin do to this. It is a little fiddly to install, but worth the trouble. Here’s some simplified steps to get you going.
- Install Jamis’s ruby gem
sudo gem install jamis-fuzzy_file_finder --source=http://gems.github.com
- Download this fuzzyfinder script and pop it in your ‘~/.vim/plugin’ directory. Note that the most recent versions of this script are incompatible with Jamis’s plugin.
- Grab the latest version of ‘fuzzyfinder_textmate.vim’ from http://github.com/jamis/fuzzyfinder_textmate/tree/master and pop it in your ‘~/.vim/plugin’ directory
Then, if you want to have a similar sort of light-weight Rails ‘IDE’ I enjoy coding with, see my config files below:
.vimrc
source $VIMRUNTIME/vimrc_example.vim behave xterm set nu set tabstop=2 set shiftwidth=2 set softtabstop=2 set ai set expandtab set smarttab let g:rubycomplete_rails = 1 map f :FuzzyFinderTextMate<CR> map n :tabnew<CR> map c :tabclose<CR> map m :tabnext<CR> let g:fuzzy_ignore = "*.svn" let g:fuzzy_ignore = "*.swp" let g:fuzzy_ignore = "*.jpg" let g:fuzzy_ignore = "*.gif" let g:fuzzy_ignore = "*~" set nobackup
.gvimrc
source ~/.vimrc set selectmode=mouse set columns=100 set lines=50
In this set up, there are no chords etc. Instead, when not in edit mode, ‘n’ will open a new tab. ‘f’ will let you find a new file to open in the current tab. ‘c’ will close the current tab and ‘m’ will move between tabs. So in a normal workflow, you might decide to swap the file in the current tab for a new one (simply press ‘f’), or if you need another file open, hit ‘n’ for new tab, and then ‘f’ to load the relevant file. My text description doesn’t do it justice, but I find this works very well to get you to the file you want quickly, and let you have the files you’re interested in open all at the same time.
One last note, remember to start vim/gVim in the root of your rails directory.
Happy Vimming 🙂
UPDATE
These files are now available from my github dotfiles repository, including the gem inside of the vim/gems_required directory.