Creating a Rails 4.1 app using JRuby

Notes around creating a Rails 4.1.8 application on JRuby 1.7.16.1.

Creating application

Using RVM to manage my rubies.

rvm use jruby-1.7.16.1
gem install rails
rails new .

Configuring Rails app for PostgreSQL and JDBC

Add the following to the Gemfile.

gem 'activerecord-jdbcpostgresql-adapter'

Also add the following towards the top of the Gemfile.

ruby '1.9.3', :engine => 'jruby', :engine_version => '1.7.16.1'

My Gemfile as it currently stands:

source 'https://rubygems.org'

ruby '1.9.3', :engine => 'jruby', :engine_version => '1.7.16.1'

gem 'rails', '4.1.8'
gem 'activerecord-jdbcpostgresql-adapter'
gem 'sass-rails', '~> 4.0.3'
gem 'uglifier', '>= 1.3.0'
gem 'coffee-rails', '~> 4.0.0'
gem 'therubyrhino'
gem 'jquery-rails'
gem 'turbolinks'
gem 'jbuilder', '~> 2.0'
gem 'sdoc', '~> 0.4.0', group: :doc
gem 'puma'

Configuring database.yml

Set up your databases environments, similar to what I have here:

default: &default
  adapter: jdbcpostgresql
  encoding: unicode

development:
  <<: *default
  host: localhost
  database: foobar_development
  username: postgres
  password: postgres

test:
  <<: *default
  host: localhost
  database: foobar_test
  username: postgres
  password: postgres

production:
  <<: *default
  host: localhost
  database: foobar_production
  username: postgres
  password: postgres

Getting websocket-rails up and running on Heroku

I wanted to document my endeavors to get websocket-rails up and running on Heroku. In my case, I'll be adding Redis to the mix, as I'm trigger server-side events from a worker process that is running delayed_job tasks. Thus, in a multi-process environment, Redis has to be used to communicate from the worker process to the Rails process (which actually maintains the web socket infrastructure). My experiences with setting this all up were actually quite pleasant and things just worked without many issues. The documentation for websocket-rails could benefit from elaborating some non-development environment scenarios, but that's a very minor gripe.

---

Step 1: Get the solution running in development

Pretty straight-forward. You have to get everything working in your development environment. Nothing earth shattering here, but if you plan on triggering server-side events to your JavaScript clients from something like delayed_job, you will need to use Redis. I'm using OS X Mavericks here, so I install tools through Homebrew. Here's how I got Redis up and running in my environment:

1. Install via Homebrew: brew install redis
2. Start up Redis from the command line: redis-server /usr/local/etc/redis.conf

If you need to monitor Redis, use the redis-cli: redis-cli monitor Now that we have Redis up and running, get websocket-rails integrated into your application. I won't belabor how to do that--the documentation does a good job of detailing how. I use a channel to communicate from the client-side and the server-side. Another thing to note is that for anything I do on the client that I want an event for coming from the server, I use a correlation ID from the client-side that I can keep track of on the client-side, so when an event from the server-side is received, I can determine whether I'm interested in it because it contains the original correlation ID. Read more here about the correlation ID design pattern.

---

Step 2: Get the solution running on Heroku

Now that everything works in development, I needed to get the solution out to Heroku.

1. If you previously installed SSL, you will have to disable it before enabling websockets support. Remove the certificates: heroku certs:remove, then remove SSL support through the Dashboard.
2. Enable websockets support: heroku labs:enable websockets
3. Add a Redis provider Heroku addon to the app if you haven't done that already. Note the Redis connection information.
4. Update the websocket_rails.rb initializer with the Redis connection information. I had to add some conditional logic to determine which environment I was deployed in. Also import here is that host and port won't typically be enough to connect to a Redis add-on. You'll definitely need a password and probably a username. Those can be passed through the redis options in this initializer. Currently my websocket_rails initializer has some code in it like this:

   
       if ENV["RAILS_ENV"] == 'production'
           config.redis_options = {
               username: 'rediscloud',
               password: 'UHDDBHD&*#$DFkkdfha',
               host: 'pub-redis-88885.us-east-1-3.3.ec2.redisdomecity.com',
               port: '15204'
           }
       else
           config.redis_options = {
               host: 'localhost',
               port: '6379'
           }
       end
   
   

   This will invariably change so I can differentiate between staging and production, but you get the point.

Doing all this I was able to get the websocket-rails stuff to work and have not had any issues with it, even with dynes spinning up and down.

Debugging Before and After hooks in Cucumber

Had a heck of time trying to figure out why all my Cucumber steps were completing successfully, but my Cucumber scenario would fail. Seems that I had an issue with the web app that I was testing which would hit a REST endpoint asynchronously during the Cucumber scenario, causing an error. Cucumber seems to eat this normally, but running with the command line option of --format pretty dumps the backtrace of the exception. Blogging about this so I don't forget about it. Reference: https://groups.google.com/forum/#!topic/cukes/WTJDVWGQkTM

Effective use of the Rails has_and_belongs_to_many association

Just a note to myself and others using the Rails has_and_belongs_to_many association:

• The naming of the association table is by alphabetical convention. For example, a many-to-many relationship between Assemblies and Parts models would result in an association table named assemblies_parts. The migration will look like:

  class CreateAssembliesPartsAssociationTable < ActiveRecord::Migration
  
      def self.up
          create_table :assemblies_parts, :id => false do |t|
              t.integer :assembly_id, :null => false
              t.integer :part_id, :null => false
          end
  
          add_foreign_key(:assemblies_parts, :assemblies)
          add_foreign_key(:assemblies_parts, :parts)
      end
  
      def self.down
          drop_table :assemblies_parts
      end
  
  end
  		

  Note that I am using the foreigner gem to implement foreign keys in my migrations.
• Use this association type when you want a direct many-to-many mapping of models without any intervening association model.
• The model mapping looks like the following:

  class Assembly < ActiveRecord::Base
  
      has_and_belongs_to_many :parts
  end
  

  and

  class Part < ActiveRecord::Base
  
      has_and_belongs_to_many :assemblies
  end
  

I just got caught by the alphabetically ordering of the association table name. Thought I would write something up about it.

Pinning Rails 3.2 to a specific time zone

I've been wrestling with some issues of dates and times in Rails. Being that I'm still pretty new to Rails, I been soaking up knowledge about this platform and today was no different. ActiveRecord, by default, converts timestamps and dates to UTC and interacts with them that way. UTC is also the format that the values will be stored in the database. If this is not what you want, you can pin your Rails system to a specific time zone by setting the following two configuration options in config/application.rb:

    config.time_zone = 'Central Time (US & Canada)'
    config.active_record.default_timezone = :local

Hope this helps others that discover that the default behavior of UTC is not what is desired. Official documentation on these configuration items can be found at http://guides.rubyonrails.org/configuring.html#rails-general-configuration and http://guides.rubyonrails.org/configuring.html#configuring-active-record.

PeepCode has new Rails 3 videos up

If you're interested in getting up and running with Rails 3, I recommend PeepCode's videos.

https://peepcode.com/pages/rails-3-screencasts