Rails Frontend, Plain Ruby Backend using ActiveRecord and Friends

This is a very quick recipe for using a backend process with a Rails frontend. I’ve been experimenting with Rails at work and needed a long running backend process to keep the information displayed in the frontend up to date and to do house-keeping tasks.

I wanted to share models and helper code between the back and frontends, so required the ability to use Active Record outside the typical Rails environment. It turns out this is simple to do. I couldn’t find an example on the web on how to set this up, so I decided to write one.

I assume a familiarity with both Ruby and Rails, and will go through the steps to create a simple application. The application consists of backend which posts messages into a MySql database along with a frontend to display the messages in the database.

This tutorial uses the newly released Rails 2.0, but the steps needed for 1.x are identical (I initially used 1.x). Some of the code is slightly different in 2.0, so you may need to adapt the code shown a little.

A word of caution: I haven’t looked here at coping with concurrent database accesses from the front- and back-ends. I’ve no idea how ActiveRecord handles database locking when explicit transactions are not used, so my approach may break down under load. It certainly works for how I am using it, however.

Let’s begin!

First create a new Rails site:

Creating the Frontend

As the fronted is drop-dead simple, a scaffold model/view/controller should be fine:

Create the database “backend_demo_development” in MySql (or whichever database you are using). I used CocoaMySql to do this.

The database migration needs to be updated to add a message field to the database. This code uses Rails 2.0 features to simplify setup. Open db/migrate/001_create_messages.rb and add the message field.



class CreateMessages < ActiveRecord::Migration
  def self.up
    create_table :messages do |t|
      	t.string :message, :null => false
      	t.timestamps
    end
  end

Next run the migration to create the database tables.

The scaffolds created by Rails 2 are not so functional as in 1, so edit `app/views/messages/index.html.erb`. Add the following line into the table row generating code:

Similarly, edit `app/views/messages/new.html.erb` to add a field for the message text into the form:

Now, the Rails site is complete, so run the server:

Open http://localhost:3000/messages in your browser and check there are no errors, and all you can see is an empty list. Use the "New Message" link to create a new message and make sure it appears in the /messages list.

Hit control-c in the console to kill the server. Now the backend needs to be written.

#### Creating the Backend

To keep things simple, the backend is going to be stored in backend_demo/backend. Create this folder.

Create backend/backend.rb and open it in your editor, entering the following code:

	
		- These are the requires for using active record and loading
		the settings from your rails configuration

require "rubygems"

require "active_record"

require "yaml"
	

		You also need to add requires for each model used in the backend

require "../app/models/message"

class BackendDemo

	def initialize
		# Create the database connection
		dbconfig = YAML::load(File.open('../config/database.yml'))
		ActiveRecord::Base.establish_connection(dbconfig["development"])

		# Create a new message and save it
		m = Message.new
		m.message = "Test from backend"
		m.save
	end

end

BackendDemo.new

Now run the backend script, which will connect to the database and add a new message.
There should be no output from the ruby program, if there is it is most likely an error message.
Finally, check the new message has appeared in your Rails frontend by loading the server back up and checking the messages page.
Open http://localhost:3000/messages and check the message “Test from backend” has appeared.
If you want to use ActiveSupport helpers, just add require "active_support".
And that’s about it.