Skip to main content

First JRuby on Rails App in GlassFish V3

Posted by arungupta on August 13, 2007 at 9:28 AM PDT

In a

previous screencast
, I showed how a Rails application can be deployed as WAR
file on GlassFish V2. In

GlassFish V3
, the Grizzly connector
by-passes the need to bundle a Rails application as WAR. Instead it directly
invokes JRuby interpreter and deploys a Rails application without any

This blog entry describes the exact steps to deploy your first JRuby
application in

GlassFish V3 Technology Preview builds

  1. Download, Install and Configure JRuby
    1. If you already have downloaded JRuby1.0,
      then skip this step. Otherwise download and install JRuby1.0 in
      a directory, say 'c:\jruby-bin-1.0' (lets say JRUBY_HOME).
    2. Add "JRUBY_HOME/bin" in your environment PATH.
    3. If you have already configured Rails in your JRuby installation, then
      skip this step. Otherwise install Rails by giving the command:

      jruby -S gem install rails -y --no-rdoc

      "-S" switch
      instructs JRuby to run the command in it's "bin" directory. The output of the command looks like:

      C:\glassfish\lib\jruby>gem install rails -y --no-rdoc
      Bulk updating Gem source index for:
      installed rails-1.2.3
      Successfully installed activesupport-1.4.2
      Successfully installed activerecord-1.15.3
      Successfully installed actionpack-1.13.3
      Successfully installed actionmailer-1.3.3
      Successfully installed actionwebservice-1.2.3
      Installing ri documentation for activesupport-1.4.2...
      Installing ri documentation for activerecord-1.15.3...
      Installing ri documentation for actionpack-1.13.3...
      While generating documentation for actionpack-1.13.3
      ... MESSAGE: java.lang.ArrayIndexOutOfBoundsException: null
      ... RDOC args: --ri --op C://glassfish/lib/jruby/lib/ruby/gems/1.8/doc/actionpack-1.13.3/ri --quiet lib
      (continuing with the rest of the installation)
      Installing ri documentation for actionmailer-1.3.3...
      Installing ri documentation for actionwebservice-1.2.3...
  2. Download, Install and Configure GlassFish V3
    1. Download
      GlassFish V3 Technology Preview 1, Build 2.
    2. Install by giving the command:
      java -jar glassfish-installer-v3-preview1-b2.jarThis will create a new directory by the name "glassfish" in your
      current directory.
    3. Add "GLASSFISH_HOME/bin" in your environment PATH.
    4. Edit "config/asenv.bat" and add "set JRUBY_HOME=C:\jruby-bin-1.0"
      as the last line. Make sure to change the directory location to match your
  3. Create a Rails application
    1. Create a standard Rails application by giving the command:

      jruby -S rails helloThis creates a new directory
      "hello" in your current directory.
      The output of the command looks like:

      create app/controllers
      create app/helpers
      create app/models
      create app/views/layouts
      create config/environments
      create components
      create db
      create doc
      create lib
      create lib/tasks
      create log
      create public/images
      create public/javascripts
      create public/stylesheets
      create script/performance
      create script/process
      create test/fixtures
      create test/functional
      create test/integration
      create test/mocks/development
      create test/mocks/test
      create test/unit
      create vendor
      create vendor/plugins
      create tmp/sessions
      create tmp/sockets
      create tmp/cache
      create tmp/pids
      create Rakefile
      create README
      create app/controllers/application.rb
      create app/helpers/application_helper.rb
      create test/test_helper.rb
      create config/database.yml
      create config/routes.rb
      create public/.htaccess
      create config/boot.rb
      create config/environment.rb
      create config/environments/production.rb
      create config/environments/development.rb
      create config/environments/test.rb
      create script/about
      create script/breakpointer
      create script/console
      create script/destroy
      create script/generate
      create script/performance/benchmarker
      create script/performance/profiler
      create script/process/reaper
      create script/process/spawner
      create script/process/inspector
      create script/runner
      create script/server
      create script/plugin
      create public/dispatch.rb
      create public/dispatch.cgi
      create public/dispatch.fcgi
      create public/404.html
      create public/500.html
      create public/index.html
      create public/favicon.ico
      create public/robots.txt
      create public/images/rails.png
      create public/javascripts/prototype.js
      create public/javascripts/effects.js
      create public/javascripts/dragdrop.js
      create public/javascripts/controls.js
      create public/javascripts/application.js
      create doc/README_FOR_APP
      create log/server.log
      create log/production.log
      create log/development.log
      create log/test.log
    2. Add a controller to the application by changing to the directory "hello" and
      giving the command:

      jruby script/generate controller say helloThe output of the command looks like:

      exists app/controllers/
      exists app/helpers/
      create app/views/say
      exists test/functional/
      create app/controllers/say_controller.rb
      create test/functional/say_controller_test.rb
      create app/helpers/say_helper.rb
      create app/views/say/hello.rhtml
    3. In hello\app\views\say directory, edit "hello.rhtml" such that it looks like:

      <p>Find me in app/views/say/hello.rhtml</p>
      <%= @hello_string %>
    4. In hello\app\controllers directory, edit "say_controller.rb"
      such that it looks like:

      class SayController < ApplicationController
        def hello
          @hello_string = "Hello from Controller!"
  4. Run the application in GlassFish V3
    1. In GLASSFISH_HOME, start V3 container by giving the command:
      java -jar lib\glassfish-10.0-SNAPSHOT.jarThe output of the command looks like:

      [#|2007-08-10T15:00:52.551-0700|INFO|GlassFish10.0|javax.enterprise.system.core|_ThreadID=10;_ThreadName=Thread-2;|Listening on port 8080|#]

      [#|2007-08-10T15:00:52.736-0700|INFO|GlassFish10.0|javax.enterprise.system.core|_ThreadID=10;_ThreadName=Thread-2;|Supported containers : phobos,web,jruby,php|#]

      [#|2007-08-10T15:00:52.753-0700|INFO|GlassFish10.0|javax.enterprise.system.core|_ThreadID=10;_ThreadName=Thread-2;|Glassfish v3 started in 802 ms|#]
    2. In the parent directory of "hello", deploy the application by giving the
      following command:

      asadmin deploy --path hello
    3. The output of the command looks like:

      C:\workarea\samples\gfv3>java -jar C:\testbed\v3-p1-v2\glassfish\bin\\..\lib\admin-cli-10.0-SNAPSHOT.jar 
      deploy --path hello
      SUCCESS : Application hello deployed successfully
      The GlassFish console shows the following entry:

      [#|2007-08-10T15:01:53.833-0700|INFO|GlassFish10.0|GRIZZLY|_ThreadID=11;_ThreadName=httpWorkerThread-8080-0;|New Servicing page from: C:\workarea\samples\gfv3\hello\public|#]

      C:/testbed/v3-p1-v2/glassfish/lib/jruby/lib/ruby/gems/1.8/gems/actionmailer-1.3.3/lib/action_mailer.rb:49 warning: already initialized constant MAX_LINE_LEN
      [#|2007-08-10T15:02:15.740-0700|INFO|GlassFish10.0||_ThreadID=11;_ThreadName=httpWorkerThread-8080-0;|hello jruby application loaded in 22083 ms|#]
    4. The application can now be accessed at
      "http://localhost:8080/hello/say/hello". The GlassFish console shows the
      following entry:


      Processing SayController#hello (for at 2007-08-10 15:03:22) [GET]

      [#|2007-08-10T15:03:22.225-0700|INFO|GlassFish10.0|GRIZZLY|_ThreadID=12;_ThreadName=httpWorkerThread-8080-1;| Session ID: a78627d02071347f6fb5f0268fa47f18


      [#|2007-08-10T15:03:22.227-0700|INFO|GlassFish10.0|GRIZZLY|_ThreadID=12;_ThreadName=httpWorkerThread-8080-1;| Parameters: {"action"=>"hello", "controller"=>"say"}


      [#|2007-08-10T15:03:22.253-0700|INFO|GlassFish10.0|GRIZZLY|_ThreadID=12;_ThreadName=httpWorkerThread-8080-1;|Rendering say/hello

      [#|2007-08-10T15:03:22.295-0700|INFO|GlassFish10.0|GRIZZLY|_ThreadID=12;_ThreadName=httpWorkerThread-8080-1;|Completed in 0.06500 (15 reqs/sec) | Rendering: 0.0 6300 (96%) | 200 OK [http://localhost/hello/say/hello]

      The main point to notice here is that the Rails application request is
      served directly by the Grizzly connector.

This concludes all the steps required to run a simple JRuby on Rails
application on GlassFish. If you want to run the same application using the WEBrick
container, then follow the additional steps given below:

  1. In the directory "hello", start WEBrick by giving the command:

    jruby script/server

    The output of the command looks like:

    => Booting WEBrick...
    => Rails application started on
    Ctrl-C to shutdown server; call with --help for options
    [2007-08-10 14:14:26] INFO WEBrick 1.3.1
    [2007-08-10 14:14:26] INFO ruby 1.8.5 (2007-06-07) [java]
    [2007-08-10 14:14:26] INFO WEBrick::HTTPServer#start: pid=6336176 port=3000
  2. Open "http://localhost:3000/say/hello" in a browser window and it shows the

    Hello from Controller!

    The WEBrick console shows the following output: - - [10/Aug/2007:14:15:25 PDT] "GET /say/hello HTTP/1.1" 200 89
    - -> /say/hello - - [10/Aug/2007:14:15:27 PDT] "GET /favicon.ico HTTP/1.1" 200 0
    - -> /favicon.ico

In the process, I found
Ruby on Rails Cheatsheet
very handy for a quick summary of commands.

The NetBeans IDE provides a comprehensive
support for Ruby code
, Rails
for RHTML files
code templates,
unit test execution,
shortcuts, and
much more.

Technorati: jruby


Related Topics >>