Setting up your Ubuntu Server for Merb 111

Posted by mikong on November 27, 2008

I prepared a documentation about this for a company and I thought I might as well post it here (modified a bit). I had to make sure the setup worked from scratch so I tested it using Sun’s VirtualBox.

Table of Contents

  1. Ubuntu Server
  2. Package Manager: apt-get
  3. Ruby
  4. RubyGems
  5. Apache 2
  6. MySQL
  7. Merb + DataMapper (+ SQLite 3?)
  8. Phusion Passenger
  9. Deploy the Merb App

1. Ubuntu Server

This setup was tested on the Ubuntu Server OS Hardy Heron, the latest version with LTS as of writing. Go to the Ubuntu website to download the installer of the Ubuntu version you want, preferably the latest with LTS.

The following instructions may work in other Debian-based OSes because it relies mainly on the apt-get package manager.

2. Package Manager: apt-get

Attribution: The content of this section, Package Manager: apt-get, is copied from Configure the Package Manager section of this Slicehost wiki page.

Ubuntu’s package management is done through apt-get. But it starts out handicapped. You need to edit a configuration file to add some additional sources.

sudo nano /etc/apt/sources.list

Uncomment these lines (remove the “# “; ignore if not commented out).

# deb http://archive.ubuntu.com/ubuntu/ hardy main restricted universe
# deb-src http://archive.ubuntu.com/ubuntu/ hardy main restricted universe
...
# deb http://security.ubuntu.com/ubuntu hardy-security main restricted universe
# deb-src http://security.ubuntu.com/ubuntu hardy-security main restricted universe

Now update the repository index and upgrade your built-in software:

sudo apt-get update && sudo apt-get upgrade

3. Ruby

To install Ruby, execute the following in the server’s command line:

sudo apt-get install ruby1.8-dev ruby1.8 ri1.8 rdoc1.8 irb1.8 libreadline-ruby1.8 libruby1.8 libopenssl-ruby
sudo ln -s /usr/bin/ruby1.8 /usr/local/bin/ruby
sudo ln -s /usr/bin/ri1.8 /usr/local/bin/ri
sudo ln -s /usr/bin/rdoc1.8 /usr/local/bin/rdoc
sudo ln -s /usr/bin/irb1.8 /usr/local/bin/irb

4. RubyGems

First, install the essential tools for compiling:

sudo apt-get install build-essential

Then, install RubyGems (latest is version 1.3.1 as of writing; update the script if necessary):

mkdir sources; cd sources
wget http://rubyforge.org/frs/download.php/45905/rubygems-1.3.1.tgz
tar zxvf rubygems-1.3.1.tgz
cd rubygems-1.3.1
sudo ruby setup.rb
cd ~
sudo ln -s /usr/bin/gem1.8 /usr/local/bin/gem
sudo gem update --system

5. Apache 2

To install Apache, simply execute the following in the server’s command line:

sudo apt-get install apache2

6. MySQL

To install MySQL:

sudo apt-get install mysql-server mysql-client

Note: During installation, specify the root password for the MySQL when it’s asked.

7. Merb + DataMapper (+ SQLite 3?)

Unfortunately, installing the latest version of Merb (1.0 as of writing) requires SQLite 3. So for the moment,

sudo apt-get install sqlite3 libsqlite3-dev

Then, to install Merb and make it work with MySQL:

sudo gem install merb
sudo apt-get install libmysqlclient15-dev
sudo gem install do_mysql

8. Phusion Passenger

To install Passenger, do the following (from Phusion Passenger’s install page):

  1. Open a terminal and type:
    sudo gem install passenger
  2. Type:
    sudo passenger-install-apache2-module

    And follow the instructions.

Re-run ‘passenger-install-apache2-module’ if you were asked to install other dependencies. For example, if you followed the instructions in this document, you will probably be asked to install development libraries of apache2, so:

sudo apt-get install apache2-prefork-dev
sudo passenger-install-apache2-module

After that, you will probably be asked to edit your Apache configuration file (see /etc/apache2/httpd.conf) to add the following (note that version numbers may vary):

LoadModule passenger_module /usr/lib/ruby/gems/1.8/gems/passenger-2.0.3/ext/apache2/mod_passenger.so
PassengerRoot /usr/lib/ruby/gems/1.8/gems/passenger-2.0.3
PassengerRuby /usr/bin/ruby1.8

Since a Merb app is a Rack-based Ruby application, check out section 4 (or “Deploying a Rack-based Ruby Application” section) of the Phusion Passenger User’s Guide. From section 4.2 (or “Deploying to a virtual host’s root” section),

Add a virtual host entry to your Apache configuration file. The virtual host’s document root must point to the application’s public folder. For example,

  <VirtualHost *:80>
    ServerName www.yourdomain.com
    DocumentRoot /var/www/apps/my_app/public
  </VirtualHost>

Your Merb app needs to satisfy a certain directory layout for Passenger to work. This is described in section 4 of the User’s guide. In the root directory of your application, you need a public folder (which a standard Merb app should already have), a tmp folder (simply create an empty one), and a config.ru file containing the configuration detailed in section 4.5.4 of the User’s guide.

The Phusion Passenger User’s Guide is quite a comprehensive documentation. If you encounter any problems, be sure to check its other sections like the one on Troubleshooting. For example, if you have static assets (such as stylesheets) in your application’s public folder, you are likely to encounter the problem described in section 6.3.4. The solution is also there.

9. Deploy the Merb App

Basically, to get your Merb App to running you only need to do the following:

  1. Make sure the gem dependencies are satisfied by either installing the gems in your server, or freezing them in your app.
  2. Make sure your app satisfies the requirements of Passenger (i.e. tmp and public folders and config.ru file, see Phusion Passenger section above).
  3. Place a copy of the application in an appropriate directory such as /var/www/apps/my_app. Wherever it is, make sure that it is consistent with the specified directory in the Apache configuration file (see Phusion Passenger section above).
  4. Prepare your database: create it, configure your database.yml, and migrate your tables and data.
  5. Start your Apache server.
    sudo apache2ctl start

    Note that with Passenger, restarting your app is done by creating a restart.txt file in the Merb app’s tmp folder.

That should get you started. If you want more, there’s a great talk about Deploying a Merb App by Lindsay and you can download it from the MerbCamp videos page. It talks about freezing Merb and other gems, web servers, restarting your app, monitoring, configuration management, exception handling, and some other tips.

Custom rake tasks in Merb: Data Backup and Import 78

Posted by mikong on November 03, 2008

There are a lot of data import solutions in Rails, most of which depend on ActiveRecord. Since Merb supports ActiveRecord too, you can use those solutions in your Merb app. But I’m using DataMapper in my Merb app, so I had to look for another way.

This article shows how to create a simple rake task in a Merb + DataMapper project. It then talks about the Data Backup and Import rake tasks db:dump_data and db:load_data. I’ve added some notes for those with a Rails background.

A simple rake task

When I generated my Merb app, the lib folder wasn’t generated. It looked something like this:

sample_app
  |--> app
  |--> autotest
  |--> config
  |--> doc
  |--> gems
  |--> merb
  |--> public
  |--> spec
  |--> Rakefile
  `--> tasks

The folder structure seems to suggest that you write your custom rake tasks under the tasks folder of your Merb app, but this is not the case. Read the Rakefile and you can see these 3 important details:

  • Add your custom tasks named file_name.rake in /lib/tasks.
  • The Merb environment is initialized to the MERB_ENV value, or ‘rake’ environment if MERB_ENV is not set.
  • To start the runner environment, in case you need access to your application’s classes, there is a task called :merb_env.

So the location is just like in Rails, i.e. in the lib/tasks folder. Try creating a custom.rake file in the lib/tasks folder and add the following:

  desc "Print all classes that include DataMapper::Resource."
  task :print_dm_resources => :merb_env do
    DataMapper::Resource.descendants.each do |resource|
      puts resource
    end
  end

The rake task above depends on the :merb_env task in order to access the application’s models. This is just like a rake task in Rails that depends on the :environment task. To run the task:

$ MERB_ENV=development rake print_dm_resources

Data Backup and Import

The following rake tasks are based off of the rake file provided in Tobias Lutke’s old blog post about migration between databases. I’ve translated it to work with Merb + DataMapper:

namespace :db do

  def interesting_tables
    DataMapper::Resource.descendants.reject! do |table|
      [Merb::DataMapperSessionStore].include?(table)
    end
  end

  desc "Dump data from the current environment's DB."
  task :dump_data => :merb_env do
    dir = Merb.root_path("config/data/#{Merb.env}")
    FileUtils.mkdir_p(dir)
    FileUtils.chdir(dir)

    interesting_tables.each do |table|
      puts "Dumping #{table}..."

      File.open("#{table}.yml", 'w+') { |f| YAML.dump(table.all.collect(&:attributes), f) }
    end
  end

  desc "Load data (from config/data/<environment>) into the current environment's DB."
  task :load_data => :merb_env do
    dir = Merb.root_path("config/data/#{Merb.env}")
    FileUtils.mkdir_p(dir)
    FileUtils.chdir(dir)

    adapter = DataMapper.repository(:default).adapter

    interesting_tables.each do |table|
      table.transaction do |txn|
        puts "Loading #{table} data..."
        YAML.load_file("#{table}.yml").each do |fixture|
          adapter.execute("INSERT INTO #{table.name.pluralize.snake_case} (#{fixture.keys.join(",")}) VALUES (#{fixture.values.collect {|value| adapter.send(:quote_column_value, value)}.join(",")})")
        end
      end
    end
  end
end

Add the above to your custom rake file. To dump the data from your development environment, run the following:

$ MERB_ENV=development rake db:dump_data

This will create the folder config/data/development if it doesn’t exist yet, and generate a ModelName.yml file for each of your models that included DataMapper::Resource. It is necessary to specify MERB_ENV, otherwise the environment will be initialized to the ‘rake’ environment and the folder config/data/rake will be created instead.

Then as you migrate your database to the latest version of your models, our database is cleared of its data (a side effect when using DataMapper’s automigrate):

$ rake db:automigrate

After migrating, we can just reload the data using our other rake task:

$ MERB_ENV=development rake db:load_data

If you were to use the sample process above, you might want to update the yaml files to handle the changes that happened with the migration. If there’s a new model, you can just create a new yaml file for it.

Here are some of the things you can do with the script:

  • change the path where the yaml files are stored
  • use a different file format for the data (quite a big change though)
  • edit interesting_tables method to exclude more models
  • clear tables before loading the data (this could be dangerous!)
  • create a task that depends on dump_data, automigrate, and load_data

I didn’t clear the tables before loading the data because I prefer that the rake task throw an error when I’m running it on a populated database.

There are probably better ways to approach this problem. In my case though, I just needed a quick solution to reload my data after running automigrate.