Arun Gupta, Miles to go ...

Rails on GlassFish - "most performant of all", "simpler and just works", "blazing speed"

Here are some quotes about running Rails applications on GlassFish from user@jruby mailing list:

I find the glassfish gem to be the most performant of all -- and I don't need to war-up my app.

I also have some mongrel cluster stuff, but glassfish is simpler and just works.

Voila...blazing speed, can handle lots of traffic. Note that I am also cominging into apache from a dyndns name. So, whatever IP I have, I can go straight to execution on the glassfish gem and NO warring up! What could be easier deployment, or a faster execution?

It's running fantasticly and performing like nothing I've seen before :) Completely stable memory, no wirings or anything bad for 5 days now.. (with several ab/htperf stresstests).

It's always exciting to get good endorsements of our efforts in the GlassFish team :)

Other similar stories for using Rails/GlassFish in production are described at rubyonrails+stories.

Technorati: glassfish v3 gem rubyonrails stories jruby

Posted by Arun Gupta in web2.0  |  Comments[3]

TOTD #81: How to use nginx to load balance a cluster of GlassFish Gem ?

nginx (pronounced as "engine-ex") is an open-source and high-performance HTTP server. It provides the common features such as reverse proxying with caching, load balancing, modular architecture using filters (gzipping, chunked responses, etc), virtual servers, flexible configuration and much more.

1. Download, build, and install nginx using the simple script (borrowed from dzone):
   
   

   ~/tools > curl -L -O http://sysoev.ru/nginx/nginx-0.6.36.tar.gz ~/tools > tar -xzf nginx-0.6.36.tar.gz ~/tools > curl -L -O http://downloads.sourceforge.net/pcre/pcre-7.7.tar.gz ~/tools > tar -xzf pcre-7.7.tar.gz ~/tools/nginx-0.6.36 > ./configure --prefix=/usr/local/nginx --sbin-path=/usr/sbin --with-debug --with-http_ssl_module --with-pcre=../pcre-7.7 ~/tools/nginx-0.6.36 > make ~/tools/nginx-0.6.36 > sudo make install ~/tools/nginx-0.6.36 > which nginx /usr/sbin/nginx

   
   OK, nginx is now roaring and can be verified by visiting "http://localhost" as shown below:
   
   
   
2. Create a simple Rails scaffold as:
   
   

   ~/samples/jruby >~/tools/jruby/bin/jruby -S rails runner ~/samples/jruby/runner >~/tools/jruby/bin/jruby script/generate scaffold runlog miles:float minutes:integer ~/samples/jruby/runner >sed s/'adapter: sqlite3'/'adapter: jdbcsqlite3'/ <config/database.yml >config/database.yml.new ~/samples/jruby/runner >mv config/database.yml.new config/database.yml ~/samples/jruby/runner >~/tools/jruby/bin/jruby -S rake db:migrate

3. Run this application using GlassFish Gem on 3 separate ports as:
   
   

   ~/samples/jruby/runner >~/tools/jruby/bin/jruby -S glassfish Starting GlassFish server at: 192.168.1.145:3000 in development environment... Writing log messages to: /Users/arungupta/samples/jruby/runner/log/development.log. Press Ctrl+C to stop.

   
   The default port is 3000. Start the seond one by explicitly specifying the port using "-p" option ..
   
   

   ~/samples/jruby/runner >~/tools/jruby/bin/jruby -S glassfish -p 3001 Starting GlassFish server at: 192.168.1.145:3001 in development environment... Writing log messages to: /Users/arungupta/samples/jruby/runner/log/development.log. Press Ctrl+C to stop.

   
   and the last one on 3002 port ...
   
   

   ~/samples/jruby/runner >~/tools/jruby/bin/jruby -S glassfish -p 3002 Starting GlassFish server at: 192.168.1.145:3002 in development environment... Writing log messages to: /Users/arungupta/samples/jruby/runner/log/development.log. Press Ctrl+C to stop.

   
   On Solaris and Linux, you can run GlassFish as a daemon as well.
4. Nginx currently uses a simple round-robin algorithm. Other load balancers such as nginx-upstream-fair (fair proxy) and nginx-ey-balancer (maximum connections) are also available. The built-in algorithm will be used for this blog. Edit "/usr/local/nginx/conf/nginx.conf" to specify an upstream module which provides load balancing:
1. Create a cluster definition by adding an upstream module (configuration details) right before the "server" module:
   
   

   upstream glassfish {         server 127.0.0.1:3000;         server 127.0.0.1:3001;         server 127.0.0.1:3002;     }

   
   The cluster specifies a bunch of GlassFish Gem instances running at the backend. Each server can be weighted differently as explained here. The port numbers must exactly match as those specified at the start up. The modified "nginx.conf" looks like:
   
   
   
   The changes are highlighted on lines #35 through #39.
2. Configure load balancing by specifying this cluster using "proxy_pass" directive as shown below:
   
   

   proxy_pass http://glassfish;

   
   in the "location" module. The updated "nginx.conf" looks like:
   
   
   
   The change is highlighted on line #52.
   
5. Restart nginx by using the following commands:
   
   

   sudo kill -15 `cat /usr/local/nginx/logs/nginx.pid` sudo nginx

• nginx Website
• nginx Forum (very useful)
• nginx Wiki
• IRC #nginx

Posted by Arun Gupta in web2.0  |  Comments[8]

TOTD # 76: JRuby 1.2, Rails 2.3, GlassFish Gem 0.9.3, ActiveRecord JDBC Adapter 0.9.1 - can they work together ?

Oh, what a week for the JRuby, Rails, and GlassFish enthusiasts!

JRuby 1.2, Rails 2.3, GlassFish Gem 0.9.3, and ActiveRecord JDBC Adapater 0.9.1 - all released earlier this week. This is an opportune moment to run the integration tests to ensure the latest JRuby and GlassFish versions work nicely with each other.

First, lets see whats there to get exicted in each release.

JRuby 1.2 introduces a new versioning scheme by jumping from 1.1.6 -> 1.2. JRUBY-3649 is an important fix for the Windows users. Improved Ruby 1.9 support, 3-6x faster parsing, and preliminary android support are some other highlights. 1052 revisions and 256 bugfixes since 1.1.6 (89 days ago) means close to 12 revisions / day and 3 bugfixes/day!

Rails 2.3 has a bunch of highlights ranging from Rack integration, nested forms, attributes, and transactions, reconnecting lost MySQL connections, Application controller renamed (make sure to "rake rails:update:action_controller" to update from an older version), faster boot time in dev mode using lazy loading, and many others. The Release Notes provide all the detailed information.

The GlassFish Gem with features like running as daemon,  rake-style configuration of JVM options, ability to "sudo install" gem and run as normal user and multi-level logging are all gearing towards adding more production-quality features. My favorite here is running as daemon since that brings the Gem one step closer to the Rails community.

Lets get back to running our tests #1, #2, #3, #4, and #5 for these released versions.

First, lets unzip JRuby 1.2 and install Rails 2.3, GlassFish Gem 0.9.3, and other gems as:

1. Uncomment the following line from "config/initializers/session_initializers.rb":
   
   

   ActionController::Base.session_store = :active_record_store

2. Do "jruby -S warble config" to generate the template "config/warble.rb", edit it and add the following line:
   
   

   config.webxml.jruby.session_store = 'db'

3. In "config/environment.rb", add the following code:
   
   

   if defined?(JRUBY_VERSION)  # hack to fix jruby-rack's incompatibility with rails edge  module ActionController    module Session      class JavaServletStore        def initialize(app, options={}); end        def call(env); end      end    end  end end

   
   just above the line "Rails::Initializer.run do |config|".
   

Posted by Arun Gupta in web2.0  |  Comments[1]

TOTD # 74: JRuby and GlassFish Integration Test #5: JRuby 1.2.0 RC2 + Rails 2.x.x + GlassFish + Redmine

TOTD #70, #71, #72, #73 shows four integration tests that can ensure that the latest JRuby and GlassFish versions work nicely with each other.

#70 showed how to create a trivial Rails application and run it using GlassFish Gem. #71 showed how the same application can be deployed on GlassFish v3 Prelude. #72 showed how to deploy the same application on GlassFish v3. #73 showed how to deploy a Rails application as WAR file and use the JDBC connection pooling framework available in GlassFish.

The next set of tests ensure that some commonly used open source Rails applications can be easily run using this setup. The first one is Redmine - 0.8 is the stable release now. Redmine was first tried on GlassFish a few months ago. The steps have simplified since then :)

Lets begin integration test #5.

1. Download Redmine 0.8 ...
   
   

   /samples/jruby/redmine >svn co http://redmine.rubyforge.org/svn/branches/0.8-stable redmine-0.8 A    redmine-0.8/test A    redmine-0.8/test/unit A    redmine-0.8/test/unit/document_test.rb A    redmine-0.8/test/unit/token_test.rb . . . A    redmine-0.8/public/stylesheets/scm.css A    redmine-0.8/public/stylesheets/application.css A    redmine-0.8/public/favicon.ico  U   redmine-0.8 Checked out revision 2580.

2. Copy "config/database.yml.example" to "config/database.yml" and then generate/migrate the database:
   
   

   ~/samples/jruby/redmine/redmine-0.8 >../jruby-1.2.0RC2/bin/jruby -S rake db:create (in /Users/arungupta/samples/jruby/redmine/redmine-0.8) ~/samples/jruby/redmine/redmine-0.8 >../jruby-1.2.0RC2/bin/jruby -S rake db:migrate (in /Users/arungupta/samples/jruby/redmine/redmine-0.8) == 1 Setup: migrating ========================================================= -- create_table("attachments", {:force=>true})    -> 0.0880s -- create_table("auth_sources", {:force=>true})    -> 0.1430s . . . == 100 AddChangesetsUserId: migrating ========================================= -- add_column(:changesets, :user_id, :integer, {:default=>nil})    -> 0.0980s == 100 AddChangesetsUserId: migrated (0.0990s) ================================ == 101 PopulateChangesetsUserId: migrating ==================================== == 101 PopulateChangesetsUserId: migrated (0.0030s) ===========================

   
   
3. Redmine is a Rails 2.1.x application so install Rails 2.1.x using JRuby 1.2 and run the application as:
   
   

   ~/samples/jruby/redmine/redmine-0.8 >../jruby-1.2.0RC2/bin/jruby -S glassfish Mar 13, 2009 11:14:59 AM com.sun.enterprise.glassfish.bootstrap.ASMainStatic findDerbyClient INFO: Cannot find javadb client jar file, jdbc driver not available Mar 13, 2009 11:14:59 AM APIClassLoaderService createAPIClassLoader INFO: APIClassLoader = java.net.URLClassLoader@59fb8de1 . . . Mar 13, 2009 11:15:10 AM com.sun.grizzly.pool.DynamicPool$1 run INFO: New instance created in 10,175 milliseconds Mar 13, 2009 11:15:10 AM com.sun.enterprise.v3.server.AppServerStartup run INFO: GlassFish v3  startup time : Static(356ms) startup services(11456ms) total(11812ms)

   
   Very simple and seamless!
   

Posted by Arun Gupta in web2.0  |  Comments[0]

TOTD # 72: JRuby and GlassFish Integration Test #3: JRuby 1.2.0 RC2 + Rails 2.2.x + GlassFish v3

TOTD #70 and #71 shows the first two integration tests that I typically run to ensure that the latest JRuby and GlassFish versions work nicely with each other.  #70 showed how to create a trivial Rails application and run it using GlassFish Gem. #71 showed how the same application can be deployed on GlassFish v3 Prelude.

The third test (explained in this blog) ensures that the same application can be easily deployed using GlassFish v3. GlassFish v3 will be available later this year with full support for Java EE 6.

JRuby 1.2.0 RC2 is now released. Test #1 passed, Test #2 gives the following error:

1. Download and unzip the latest GlassFish v3, b39 is the latest at time of this writing. Fire up GlassFish v3 as:
   
   

   ~/tools/glassfish/v3/b39/glassfishv3/glassfish >./bin/asadmin start-domain Name of the domain started: [domain1] and its location: [/Users/arungupta/tools/glassfish/v3/b39/glassfishv3/glassfish/domains/domain1]. Admin port for the domain: [4848].

2. Add JRUBY_HOME as "jvm-option" using the following command:
   
   

   ~/tools/glassfish/v3/b39/glassfishv3/glassfish >./bin/asadmin create-jvm-options -DJRUBY_HOME="/Users/arungupta/tools/jruby-1.2.0RC2" created 1 option(s) Command create-jvm-options executed successfully.

   
   This tells the GlassFish runtime to pick JRuby and related libraries from the directory specified in JRUBY_HOME.
   
3. Deploy the application as:
   
   

   ~/tools/jruby-1.2.0RC1/samples/rails >~/tools/glassfish/v3/b39/glassfishv3/bin/asadmin deploy runner Command deploy executed successfully.

4. Accessing "http://localhost:8080/runner/runners" gives the error:
   
   

   ActionController::RoutingError (No route matches "s" with {:method=>:get}):     /Users/arungupta/tools/jruby-1.2.0RC1/lib/ruby/gems/1.8/gems/actionpack-2.2.2/lib/action_controller/routing/recognition_optimisation.rb:66:in `recognize_path'     /Users/arungupta/tools/jruby-1.2.0RC1/lib/ruby/gems/1.8/gems/actionpack-2.2.2/lib/action_controller/routing/route_set.rb:386:in `recognize'     /Users/arungupta/tools/jruby-1.2.0RC1/lib/ruby/gems/1.8/gems/actionpack-2.2.2/lib/action_controller/dispatcher.rb:182:in `handle_request'     /Users/arungupta/tools/jruby-1.2.0RC1/lib/ruby/gems/1.8/gems/actionpack-2.2.2/lib/action_controller/dispatcher.rb:110:in `dispatch_unlocked'     /Users/arungupta/tools/jruby-1.2.0RC1/lib/ruby/gems/1.8/gems/actionpack-2.2.2/lib/action_controller/dispatcher.rb:123:in `dispatch'     /Users/arungupta/tools/jruby-1.2.0RC1/lib/ruby/gems/1.8/gems/actionpack-2.2.2/lib/action_controller/dispatcher.rb:122:in `dispatch'     /Users/arungupta/tools/jruby-1.2.0RC1/lib/ruby/gems/1.8/gems/actionpack-2.2.2/lib/action_controller/dispatcher.rb:132:in `dispatch_cgi'     /Users/arungupta/tools/jruby-1.2.0RC1/lib/ruby/gems/1.8/gems/actionpack-2.2.2/lib/action_controller/dispatcher.rb:39:in `dispatch'     file:/Users/arungupta/tools/glassfish/v3/b39/glassfishv3/glassfish/modules/grizzly-jruby.jar!/rack/adapter/rails.rb:82:in `serve_rails'     file:/Users/arungupta/tools/glassfish/v3/b39/glassfishv3/glassfish/modules/grizzly-jruby.jar!/rack/adapter/rails.rb:109:in `call'     file:/Users/arungupta/tools/glassfish/v3/b39/glassfishv3/glassfish/modules/grizzly-jruby.jar!/jruby/rack/rails.rb:81:in `call'     file:/Users/arungupta/tools/glassfish/v3/b39/glassfishv3/glassfish/modules/grizzly-jruby.jar!/rack/handler/grizzly.rb:55:in `call'     :1

   
   This resulted in filing issue #7266.
5. GlassFish v3 allows an application to be deployed/redeployed on a different context root by specifying "--contextroot" switch. Lets try to deploy the app using a different context root as shown below:
   
   

   ~/tools/jruby-1.2.0RC1/samples/rails >~/tools/glassfish/v3/b39/glassfishv3/bin/asadmin deploy --contextroot runlog --force=true runner Command deploy executed successfully.

   
   Even though the application is deployed successful, but now "http://localhost:8080/runlog/runners" and "http://localhost:8080/runner/runners" give a 404. This resulted in filing issue #7270 and issue# 7271. The context root strippping does not happen correctly if a Rails application is deployed. But the good news is that a fix is already in progress. A workaround is to create exactly the same application with a different name.
6. Recreate the application using a name different from the controller. Lets use the name "runlog" and redeploy the application as:
   
   

   ~/tools/jruby-1.2.0RC2/samples/rails >~/tools/glassfish/v3/b39/glassfishv3/bin/asadmin deploy runlog Command deploy executed successfully.

   
   After adding few entries the page at "http://localhost:8080/runlog/runners" looks like:
   
   

Posted by Arun Gupta in web2.0  |  Comments[5]

TOTD # 71: JRuby and GlassFish Integration Test #2: JRuby 1.2.0 RC1 + Rails 2.2.x + GlassFish v3 Prelude

TOTD #70 shows the first integration integration tests that I typically run to ensure that the latest JRuby and GlassFish versions work nicely with each other.  The second test (explained in this blog) ensures that the same application can be deployed using GlassFish v3 Prelude.

GlassFish v3 Prelude allows Rails applications to be deployed natively, i.e. without any packaging.

Lets begin integration test #2.

1. Download and unzip GlassFish v3 Prelude. Fire up GlassFish v3 Prelude as:
   
   

   ~/tools/glassfish/v3/glassfishv3-prelude/glassfish >./bin/asadmin start-domain Name of the domain started: [domain1] and its location: [/Users/arungupta/tools/glassfish/v3/glassfishv3-prelude/glassfish/domains/domain1]. Admin port for the domain: [4848].

2. Add JRUBY_HOME as "jvm-option" using the following command:
   
   

   ~/tools/glassfish/v3/glassfishv3-prelude/glassfish >./bin/asadmin create-jvm-options -DJRUBY_HOME="/Users/arungupta/tools/jruby-1.2.0RC1" created 1 option(s) Command create-jvm-options executed successfully.

   
   This tells the GlassFish runtime to pick JRuby and related libraries from the directory specified in JRUBY_HOME.
   
3. Deploy the application as:
   
   

   ~/tools/jruby-1.2.0RC1/samples/rails >~/tools/glassfish/v3/glassfishv3-prelude/bin/asadmin deploy runner Command deploy executed successfully.

   
   
4. The application should now be accessible on "http://localhost:8080/runner/runners". But instead the logs (located in "domains/domain1/logs/server.log) shows the following exception:
   
   

   Caused by: java.lang.NumberFormatException: For input string: "0RC1"         at java.lang.NumberFormatException.forInputString(NumberFormatException.java:48)         at java.lang.Integer.parseInt(Integer.java:456)         at java.lang.Integer.parseInt(Integer.java:497)         at com.sun.grizzly.jruby.RailsAdapter$JRubyVersion.<init>(RailsAdapter.java:137)         at com.sun.grizzly.jruby.RailsAdapter$JRubyVersion.<init>(RailsAdapter.java:131)         at com.sun.grizzly.jruby.RailsAdapter.<init>(RailsAdapter.java:110)         at com.sun.grizzly.jruby.RubyRuntime.<init>(RubyRuntime.java:48)         ... 30 more

   
   This is filed as issue #7235 in GlassFish Issue Tracker.
5. Lets try with the JRuby trunk.
1. Check out JRuby trunk and build the workspace as shown below
   
   

   ~/workspaces >svn co http://svn.codehaus.org/jruby/trunk/jruby/ A    jruby/bench A    jruby/bench/bench_tak.rb A    jruby/bench/bench_struct.rb . . . A    jruby/.settings/org.eclipse.jdt.core.prefs A    jruby/.settings/org.eclipse.jdt.ui.prefs  U   jruby Checked out revision 9347. ~/workspaces >cd jruby/ ~/workspaces/jruby >ant Buildfile: build.xml init: jar: . . . _update_scm_revision_:       [jar] Building jar: /Users/arungupta/workspaces/jruby/lib/jruby.jar       [jar] Warning: selected jar files include a META-INF/INDEX.LIST which will be replaced by a newly generated one. BUILD SUCCESSFUL Total time: 1 minute 21 seconds

2. Install Rails
   
   

   ~/workspaces/jruby >./bin/jruby gem install rails JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL Successfully installed rake-0.8.4 Successfully installed activesupport-2.2.2 Successfully installed activerecord-2.2.2 Successfully installed actionpack-2.2.2 Successfully installed actionmailer-2.2.2 Successfully installed activeresource-2.2.2 Successfully installed rails-2.2.2 7 gems installed Installing ri documentation for rake-0.8.4... Installing ri documentation for activesupport-2.2.2... Installing ri documentation for activerecord-2.2.2... Installing ri documentation for actionpack-2.2.2... Installing ri documentation for actionmailer-2.2.2... Installing ri documentation for activeresource-2.2.2... Installing RDoc documentation for rake-0.8.4... Installing RDoc documentation for activesupport-2.2.2... Installing RDoc documentation for activerecord-2.2.2... Installing RDoc documentation for actionpack-2.2.2... Installing RDoc documentation for actionmailer-2.2.2... Installing RDoc documentation for activeresource-2.2.2...

6. Delete the previously added jvm-option as
   
   

   ~/tools/glassfish/v3/glassfishv3-prelude/glassfish >./bin/asadmin delete-jvm-options -DJRUBY_HOME="/Users/arungupta/tools/jruby-1.2.0RC1" deleted 1 option(s) Command delete-jvm-options executed successfully.

   
   and add a new jvm-option pointing to the the new JRUBY_HOME as
   
   

   ~/tools/glassfish/v3/glassfishv3-prelude/glassfish >./bin/asadmin create-jvm-options -DJRUBY_HOME="/Users/arungupta/workspaces/jruby" created 1 option(s) Command create-jvm-options executed successfully.

7. Deploy the application as:
   
   

   ~/tools/jruby-1.2.0RC1/samples/rails >~/tools/glassfish/v3/glassfishv3-prelude/bin/asadmin deploy --force=true runner Command deploy executed successfully.

   
   The "NumberFormatException" as seen above is shown again in this case.
   
   If the application is deployed correctly then "http://localhost:8080/runner/runners" will show the scaffold page. The final JRuby 1.2 release will not have any text letters in the version and so you'll be able to deploy a Rails application using JRuby 1.2 (final release) on GlassFish v3 Prelude.
   

Posted by Arun Gupta in web2.0  |  Comments[5]

TOTD # 70: JRuby and GlassFish Integration Test# 1: JRuby 1.2.0 RC1 + Rails 2.2.x + GlassFish Gem

JRuby 1.2.0 RC1 is out for a while!

I typically run a series of tests to ensure that any publicly released version of JRuby works nicely with GlassFish. The main goal of running these tests is to discover any blocking bugs before users do. This particular set of tests are being run little late as RC1 was released on Feb 24th. But I'll describe all the steps clearly in the next few blog entries so that you can try them out yourself.

JRuby team runs a whole slew of tests before releasing any bits. Similarly we run a bunch of tests before releasing GlassFish Gem. These tests, as mentioned earlier, are only to ensure that the latest release of JRuby works nicely with the latest bits of GlassFish.

The first basic test is to check if a simple Rails application can be run using the latest GlassFish Gem. The steps are described next.

First, lets create a database user and grant privileges required by our application:

1. Download and unzip JRuby 1.2.0 RC1.
2. Install Rails and GlassFish Gem as:
   
   

   ~/tools/jruby-1.2.0RC1 >./bin/jruby -S gem install rails glassfish JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL Successfully installed activesupport-2.2.2 Successfully installed activerecord-2.2.2 Successfully installed actionpack-2.2.2 Successfully installed actionmailer-2.2.2 Successfully installed activeresource-2.2.2 Successfully installed rails-2.2.2 Successfully installed rack-0.9.1 Successfully installed glassfish-0.9.2-universal-java 8 gems installed Installing ri documentation for activesupport-2.2.2... Installing ri documentation for activerecord-2.2.2... Installing ri documentation for actionpack-2.2.2... Installing ri documentation for actionmailer-2.2.2... Installing ri documentation for activeresource-2.2.2... Installing ri documentation for rack-0.9.1... Installing ri documentation for glassfish-0.9.2-universal-java... Installing RDoc documentation for activesupport-2.2.2... Installing RDoc documentation for activerecord-2.2.2... Installing RDoc documentation for actionpack-2.2.2... Installing RDoc documentation for actionmailer-2.2.2... Installing RDoc documentation for activeresource-2.2.2... Installing RDoc documentation for rack-0.9.1... Installing RDoc documentation for glassfish-0.9.2-universal-java...

3. Create a new app as:
   
   

   ~/tools/jruby-1.2.0RC1/samples/rails >../../bin/jruby -S rails runner -d mysql JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL       create        create  app/controllers       create  app/helpers       . . .       create  log/server.log       create  log/production.log       create  log/development.log       create  log/test.log

4. Install MySQL JDBC ActiveRecord adapter as:
   
   

   ~/tools/jruby-1.2.0RC1/samples/rails >../../bin/jruby -S gem install activerecord-jdbcmysql-adapter JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL Successfully installed activerecord-jdbc-adapter-0.9 Successfully installed jdbc-mysql-5.0.4 Successfully installed activerecord-jdbcmysql-adapter-0.9 3 gems installed Installing ri documentation for activerecord-jdbc-adapter-0.9... Installing ri documentation for jdbc-mysql-5.0.4... Installing ri documentation for activerecord-jdbcmysql-adapter-0.9... Installing RDoc documentation for activerecord-jdbc-adapter-0.9... Installing RDoc documentation for jdbc-mysql-5.0.4... Installing RDoc documentation for activerecord-jdbcmysql-adapter-0.9...

   
   More details on configuring this adapter here.
   
5. Create a simple scaffold:
   
   

   ~/tools/jruby-1.2.0RC1/samples/rails/runner >../../../bin/jruby script/generate scaffold runner distance:float time:integer JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL       exists  app/models/       exists  app/controllers/       . . .       create    test/fixtures/runners.yml       create    db/migrate       create    db/migrate/20090226171752_create_runners.rb

6. Edit "config/database.yml" to use the JDBC adapter and specify database username/password. Change:
   
   

   development:   adapter: mysql   encoding: utf8   database: runner_development   pool: 5   username: root   password:   socket: /tmp/mysql.sock

   
   to
   
   

   development:   adapter: jdbcmysql   encoding: utf8   database: runner_development   pool: 5   username: duke   password: glassfish   socket: /tmp/mysql.sock

   
   The change is highlighted in bold letters.
7. Create and migrate the database as:
   
   

   ~/tools/jruby-1.2.0RC1/samples/rails/runner >../../../bin/jruby -S rake db:create (in /Users/arungupta/tools/jruby-1.2.0RC1/samples/rails/runner) ~/tools/jruby-1.2.0RC1/samples/rails/runner >../../../bin/jruby -S rake db:migrate (in /Users/arungupta/tools/jruby-1.2.0RC1/samples/rails/runner) ==  CreateRunners: migrating ================================================== -- create_table(:runners)    -> 0.1330s    -> 0 rows ==  CreateRunners: migrated (0.1340s) =========================================

   
   The default RAILS_ENV is DEVELOPMENT so there is no need to specify any addtional arguments.
   
8. And then run the application as:
   
   

   ~/tools/jruby-1.2.0RC1/samples/rails/runner >../../../bin/jruby -S glassfish Feb 26, 2009 10:30:10 AM com.sun.enterprise.glassfish.bootstrap.ASMainStatic start INFO: Cache not present, will revert to less efficient algorithm Feb 26, 2009 10:30:10 AM com.sun.enterprise.glassfish.bootstrap.ASMainStatic findDerbyClient INFO: Cannot find javadb client jar file, jdbc driver not available Feb 26, 2009 10:30:10 AM APIClassLoaderService createAPIClassLoader INFO: APIClassLoader = java.net.URLClassLoader@14a66e3f no resource bundle found for version, using default GlassFish version Feb 26, 2009 10:30:11 AM AppServerStartup run INFO: [Thread[GlassFish Kernel Main Thread,5,main]] started Feb 26, 2009 10:30:11 AM com.sun.enterprise.v3.services.impl.GrizzlyProxy start INFO: Listening on port 3000 Feb 26, 2009 10:30:11 AM com.sun.enterprise.v3.admin.adapter.AdminEndpointDecider setGuiContextRoot INFO: Admin Console Adapter: context root: /_____admingui Feb 26, 2009 10:30:11 AM com.sun.enterprise.v3.admin.adapter.AdminConsoleAdapter setStateMsg INFO: The Admin Console Application is not yet installed. Feb 26, 2009 10:30:11 AM com.sun.enterprise.v3.admin.adapter.AdminEndpointDecider setGuiContextRoot INFO: Admin Console Adapter: context root: /_____admingui Feb 26, 2009 10:30:11 AM org.glassfish.scripting.rails.RailsDeployer load INFO: Loading application runner at / Feb 26, 2009 10:30:11 AM com.sun.grizzly.jruby.RailsAdapter <init> INFO: Jruby version is: 1.2.0RC1 Feb 26, 2009 10:30:11 AM com.sun.grizzly.jruby.rack.RackApplicationChooser detectRails INFO: Detected Rails application Feb 26, 2009 10:30:11 AM com.sun.grizzly.jruby.rack.RackApplicationChooser detectRails INFO: Rails not in thread-safe mode, starting in single-thread mode Feb 26, 2009 10:30:11 AM com.sun.grizzly.pool.DynamicPool logDynamicStatus INFO: Pool started without dynamic resizing enabled. Pool will not attempt to determine the upper and lower bounds that it should be using, and will stay at 1 Feb 26, 2009 10:30:16 AM   SEVERE: JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL Feb 26, 2009 10:30:18 AM   INFO: RAILS_ROOT /Users/arungupta/tools/jruby-1.2.0RC1/samples/rails/runner Feb 26, 2009 10:30:18 AM   INFO: PUBLIC_ROOT /Users/arungupta/tools/jruby-1.2.0RC1/samples/rails/runner/public Feb 26, 2009 10:30:19 AM com.sun.grizzly.pool.DynamicPool$1 run INFO: New instance created in 7,074 milliseconds Feb 26, 2009 10:30:19 AM com.sun.enterprise.v3.server.AppServerStartup run INFO: GlassFish v3  startup time : Static(525ms) startup services(7962ms) total(8487ms) Feb 26, 2009 10:30:19 AM com.sun.enterprise.glassfish.bootstrap.ASMainStatic start INFO: Started cache creation Feb 26, 2009 10:30:20 AM com.sun.enterprise.glassfish.bootstrap.ASMainStatic start INFO: Finished cache creation Feb 26, 2009 10:30:34 AM sun.reflect.NativeMethodAccessorImpl invoke0 INFO:

   
   After adding few entries, the output at "http://localhost:3000/runners" looks like:
   
   
   
   So we are able to create a trivial Rails application and run it using GlassFish Gem, that passes Test#1.

Posted by Arun Gupta in web2.0  |  Comments[10]

TOTD #55: How to build GlassFish v3 Gem ?

GlassFish Gem is a light-weight and robust deployment solution for Ruby-on-Rails and Merb applications. The gem can be easily installed as:

Posted by Arun Gupta in web2.0  |  Comments[2]

TOTD #53: Scaffold in Merb using JRuby/GlassFish

GlassFish Gem 0.9.0 can be used to run Rails and Merb applications. Support another Rack-based framework Sinatra is coming up in the near future. This blog shows how to create a scaffold in Merb and run it using the GlassFish gem.

1. Lets create a Merb application using ActiveRecord ORM as:
   
   

   ~/samples/jruby/merb >~/tools/jruby-1.1.5/bin/jruby -S merb-gen core --orm activerecord hello Generating with core generator:      [ADDED]  gems      [ADDED]  merb.thor      [ADDED]  .gitignore      [ADDED]  public/.htaccess      [ADDED]  doc/rdoc/generators/merb_generator.rb      [ADDED]  doc/rdoc/generators/template/merb/api_grease.js      [ADDED]  doc/rdoc/generators/template/merb/index.html.erb      [ADDED]  doc/rdoc/generators/template/merb/merb.css      [ADDED]  doc/rdoc/generators/template/merb/merb.rb      [ADDED]  doc/rdoc/generators/template/merb/merb_doc_styles.css      [ADDED]  doc/rdoc/generators/template/merb/prototype.js      [ADDED]  public/favicon.ico      [ADDED]  public/merb.fcgi      [ADDED]  public/robots.txt      [ADDED]  public/images/merb.jpg      [ADDED]  Rakefile      [ADDED]  app/controllers/application.rb      [ADDED]  app/controllers/exceptions.rb      [ADDED]  app/helpers/global_helpers.rb      [ADDED]  app/views/exceptions/not_acceptable.html.erb      [ADDED]  app/views/exceptions/not_found.html.erb      [ADDED]  autotest/discover.rb      [ADDED]  autotest/merb.rb      [ADDED]  autotest/merb_rspec.rb      [ADDED]  config/init.rb      [ADDED]  config/rack.rb      [ADDED]  config/router.rb      [ADDED]  config/environments/development.rb      [ADDED]  config/environments/production.rb      [ADDED]  config/environments/rake.rb      [ADDED]  config/environments/staging.rb      [ADDED]  config/environments/test.rb      [ADDED]  public/javascripts/application.js      [ADDED]  public/stylesheets/master.css      [ADDED]  spec      [ADDED]  app/views/layout/application.html.erb

2. Generate a Merb resource (model, controller and associated things):
   
   

   ~/samples/jruby/merb/hello >merb-gen resource Runner distance:float,minutes:integer Loading init file from /Users/arungupta/samples/jruby/merb/hello/config/init.rb Loading /Users/arungupta/samples/jruby/merb/hello/config/environments/development.rb Generating with resource generator: Loading init file from /Users/arungupta/samples/jruby/merb/hello/config/init.rb Loading /Users/arungupta/samples/jruby/merb/hello/config/environments/development.rb Loading init file from /Users/arungupta/samples/jruby/merb/hello/config/init.rb Loading /Users/arungupta/samples/jruby/merb/hello/config/environments/development.rb Loading init file from /Users/arungupta/samples/jruby/merb/hello/config/init.rb Loading /Users/arungupta/samples/jruby/merb/hello/config/environments/development.rb Loading init file from /Users/arungupta/samples/jruby/merb/hello/config/init.rb Loading /Users/arungupta/samples/jruby/merb/hello/config/environments/development.rb      [ADDED]  spec/models/runner_spec.rb      [ADDED]  app/models/runner.rb      [ADDED]  schema/migrations/001_runner_migration.rb      [ADDED]  spec/requests/runners_spec.rb      [ADDED]  app/controllers/runners.rb      [ADDED]  app/views/runners/index.html.erb      [ADDED]  app/views/runners/show.html.erb      [ADDED]  app/views/runners/edit.html.erb      [ADDED]  app/views/runners/new.html.erb      [ADDED]  app/helpers/runners_helper.rb resources :runners route added to config/router.rb

   
   As evident from the generated files Model, Controller, Helper and Views are generated. The Views are only template files with no code because this code end up getting changed anyway most of the times. Instead template Views can be written as explained in CRUD View Examples (more on this later).
   
3. Configure Database
1. Merb applications do not have a pre-generated "database.yml" so create one as:
   
   

   ~/samples/jruby/merb/hello >rake db:create (in /Users/arungupta/samples/jruby/merb/hello) JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL Loading init file from /Users/arungupta/samples/jruby/merb/hello/config/init.rb Loading /Users/arungupta/samples/jruby/merb/hello/config/environments/development.rb Loading init file from /Users/arungupta/samples/jruby/merb/hello/config/init.rb Loading /Users/arungupta/samples/jruby/merb/hello/config/environments/development.rb  ~ It took: 0  ~ Loading: Merb::BootLoader::MixinSession  ~ It took: 0  ~ Loading: Merb::BootLoader::BeforeAppLoads  ~ It took: 0  ~ Loading: Merb::Orms::ActiveRecord::Connect  ~ No database.yml file found in /Users/arungupta/samples/jruby/merb/hello/config.  ~ A sample file was created called database.yml.sample for you to copy and edit.

2. Copy "config/database.yml.sample" to "config/database.yml". Wonder why this step is explicitly required ?
3. Edit database configuration such that it looks like:
   
   

   :development: &defaults   :adapter: mysql   :database: hello_development   :username: root   :password:   :host: localhost   :socket: /tmp/mysql.sock   :encoding: utf8

   
   The changed lines are shown in bold.
   
4. Create the database as:
   
   

   ~/samples/jruby/merb/hello >rake db:create (in /Users/arungupta/samples/jruby/merb/hello) JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL Loading init file from /Users/arungupta/samples/jruby/merb/hello/config/init.rb Loading /Users/arungupta/samples/jruby/merb/hello/config/environments/development.rb Loading init file from /Users/arungupta/samples/jruby/merb/hello/config/init.rb Loading /Users/arungupta/samples/jruby/merb/hello/config/environments/development.rb  ~ It took: 0  ~ Loading: Merb::BootLoader::MixinSession  ~ It took: 0  ~ Loading: Merb::BootLoader::BeforeAppLoads  ~ It took: 0  ~ Loading: Merb::Orms::ActiveRecord::Connect  ~ Connecting to database...  ~ It took: 0  ~ Loading: Merb::BootLoader::LoadClasses  ~ It took: 0  ~ Loading: Merb::BootLoader::Router  ~ Compiling routes...  ~ It took: 0  ~ Loading: Merb::BootLoader::Templates  ~ It took: 0  ~ Loading: Merb::BootLoader::MimeTypes  ~ It took: 0  ~ Loading: Merb::BootLoader::Cookies  ~ It took: 0  ~ Loading: Merb::BootLoader::SetupSession  ~ It took: 1  ~ Loading: Merb::BootLoader::SetupStubClasses  ~ It took: 0  ~ Loading: Merb::BootLoader::AfterAppLoads  ~ It took: 0  ~ Loading: Merb::BootLoader::ChooseAdapter  ~ It took: 0  ~ Loading: Merb::BootLoader::RackUpApplication  ~ It took: 0  ~ Loading: Merb::BootLoader::ReloadClasses  ~ It took: 0 DEPRECATION WARNING: You're using the Ruby-based MySQL library that ships with Rails. This library will be REMOVED FROM RAILS 2.2. Please switch to the offical mysql gem: `gem install mysql`  See http://www.rubyonrails.org/deprecation for details. (called from mysql_connection at /Users/arungupta/tools/jruby-1.1.5/lib/ruby/gems/1.8/gems/activerecord-2.1.2/lib/active_record/connection_adapters/mysql_adapter.rb:81)  ~   SQL (0.000581)   SET NAMES 'utf8'  ~   SQL (0.000581)   SET SQL_AUTO_IS_NULL=0  ~   SQL (0.000894)   CREATE DATABASE `hello_development` DEFAULT CHARACTER SET `utf8` COLLATE `utf8_general_ci` MySQL hello_development database successfully created

5. Migrate the database as:
   
   

   ~/samples/jruby/merb/hello >rake db:migrate (in /Users/arungupta/samples/jruby/merb/hello) JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL Loading init file from /Users/arungupta/samples/jruby/merb/hello/config/init.rb Loading /Users/arungupta/samples/jruby/merb/hello/config/environments/development.rb Loading init file from /Users/arungupta/samples/jruby/merb/hello/config/init.rb Loading /Users/arungupta/samples/jruby/merb/hello/config/environments/development.rb  ~ It took: 0  ~ Loading: Merb::BootLoader::MixinSession  ~ It took: 0  ~ Loading: Merb::BootLoader::BeforeAppLoads  ~ It took: 0  ~ Loading: Merb::Orms::ActiveRecord::Connect  ~ Connecting to database...  ~ It took: 0  ~ Loading: Merb::BootLoader::LoadClasses  ~ It took: 1  ~ Loading: Merb::BootLoader::Router  ~ Compiling routes...  ~ It took: 0  ~ Loading: Merb::BootLoader::Templates  ~ It took: 0  ~ Loading: Merb::BootLoader::MimeTypes  ~ It took: 0  ~ Loading: Merb::BootLoader::Cookies  ~ It took: 0  ~ Loading: Merb::BootLoader::SetupSession  ~ It took: 0  ~ Loading: Merb::BootLoader::SetupStubClasses  ~ It took: 0  ~ Loading: Merb::BootLoader::AfterAppLoads  ~ It took: 0  ~ Loading: Merb::BootLoader::ChooseAdapter  ~ It took: 0  ~ Loading: Merb::BootLoader::RackUpApplication  ~ It took: 0  ~ Loading: Merb::BootLoader::ReloadClasses  ~ It took: 0 DEPRECATION WARNING: You're using the Ruby-based MySQL library that ships with Rails. This library will be REMOVED FROM RAILS 2.2. Please switch to the offical mysql gem: `gem install mysql`  See http://www.rubyonrails.org/deprecation for details. (called from mysql_connection at /Users/arungupta/tools/jruby-1.1.5/lib/ruby/gems/1.8/gems/activerecord-2.1.2/lib/active_record/connection_adapters/mysql_adapter.rb:81)  ~   SQL (0.000769)   SET NAMES 'utf8'  ~   SQL (0.000610)   SET SQL_AUTO_IS_NULL=0  ~   SQL (0.001609)   SHOW TABLES  ~   SQL (0.003952)   CREATE TABLE `schema_migrations` (`version` varchar(255) NOT NULL) ENGINE=InnoDB  ~   SQL (0.054355)   CREATE UNIQUE INDEX `unique_schema_migrations` ON `schema_migrations` (`version`)  ~   SQL (0.001691)   SHOW TABLES  ~   SQL (0.001643)   SELECT version FROM schema_migrations  ~ Migrating to RunnerMigration (1) == 1 RunnerMigration: migrating =============================================== -- create_table(:runners)  ~   SQL (0.005301)   CREATE TABLE `runners` (`id` int(11) DEFAULT NULL auto_increment PRIMARY KEY, `distance` float, `minutes` int(11), `created_at` datetime, `updated_at` datetime) ENGINE=InnoDB    -> 0.0107s == 1 RunnerMigration: migrated (0.0114s) ======================================  ~   SQL (0.014063)   INSERT INTO schema_migrations (version) VALUES ('1')  ~   SQL (0.003585)   SHOW TABLES  ~   SQL (0.001324)   SELECT version FROM schema_migrations  ~   SQL (0.001451)   SHOW TABLES  ~   SQL (0.017054)   SHOW FIELDS FROM `runners`  ~   SQL (0.018503)   describe `runners`  ~   SQL (0.009372)   SHOW KEYS FROM `runners`

4. Create the CRUD views
1. Add dependencies
1. Edit "config/init.rb" and add the following line:
   
   

   require 'config/dependencies.rb'

   
   as the first uncommented line.
2. Create "config/dependencies.rb" and add the following dependency (explained here):
   
   

   dependency "merb-assets", "1.0" dependency "merb-helpers", "1.0"

2. Add the resource routes by editing "config/router.rb" and adding:
   
   

   resources :runners

   
   insider "Merb::Router.prepare do" block.
3. Edit the "index" view in "app/views/runners/index.html.erb" as:
   
   

   <h1>Runner controller, index action</h1> <table>   <tr>     <th>Distance (in miles)</th>     <th>Time (in mins)</th>     <th colspan="3">Actions</th>   </tr> <% @runners.each do |runner| %>   <tr>     <td><%=h runner.distance %></td>     <td><%=h runner.minutes %></td>     <td><%= link_to 'Show', resource(runner) %></td>     <td><%= link_to 'Edit', resource(runner, :edit) %></td>     <td><%= delete_button(runner, "Delete #{runner.distance}") %></td>   </tr> <% end %> </table> <%= link_to 'New', resource(:runners, :new) %>

4. Edit the "new" in "app/views/runners/new.html.erb" view as:
   
   

   <h1>Runners controller, new action</h1> <%= form_for(@runner, :action => resource(:runners) ) do %>     <p>     <%= text_field :distance, :label => "Distance (in miles)" %>   </p>     <p>     <%= text_field :minutes, :label => "Time (in mins)"  %>   </p>     <p>     <%= submit "Create" %>   </p> <% end =%>   <%= link_to 'Back', resource(:runners) %>

5. Edit the "show" view in "app/views/runners/show.html.erb" as:
   
   

   <h1>Runners controller, show action</h1> <p>Distance (in miles): <%=h @runner.distance %></p> <p>Time (in mins): <%=h @runner.minutes %></p>   <%= link_to 'Back', resource(:runners) %>

6. Edit the "edit" in "app/views/runners/edit.html.erb" view as:
   
   

   <h1>Runners controller, edit action</h1> <%= form_for(@runner, :action => resource(@runner)) do %>     <p>     <%= text_field :distance, :label => "Distance (in miles)"  %>   </p>     <p>     <%= text_field :minutes, :label => "Time (in mins)"  %>   </p>     <p>     <%= submit "Update" %>   </p> <% end =%>   <%= link_to 'Show', resource(@runner) %> | <%= link_to 'Back', resource(:runners) %>

Posted by Arun Gupta in web2.0  |  Comments[5]

TOTD #52: Getting Started with Merb using GlassFish Gem

GlassFish Gem 0.9.0 was recently released. It can run any Rack-compatible framework such as Rails and Merb. Support for another Rack-based framework Sinatra will be released in the near future. The gem is even extensible and allows to plug any of your favorite Ruby framework using -apptype switch (more on this in a future blog). This blog shows how to install the gem and use it for running a Merb application.

1. Install Merb: Merb 1.0 has some native dependencies in DataMapper and so cannot be installed as is with JRuby. However since Merb is ORM-agnostic, ActiveRecord can be installed as ORM layer. "gem install merb" uses DataMapper as the default ORM so a Merb installation in JRuby (for now) is:
   
   

   ~/tools/jruby-1.1.5 >gem install merb-core merb-more merb_activerecord JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL Successfully installed extlib-0.9.8 Successfully installed abstract-1.0.0 Successfully installed erubis-2.6.2 Successfully installed json_pure-1.1.3 Successfully installed rack-0.4.0 Successfully installed mime-types-1.15 Successfully installed thor-0.9.8 Successfully installed merb-core-1.0 Successfully installed ZenTest-3.11.0 Successfully installed RubyInline-3.8.1 Successfully installed sexp_processor-3.0.0 Successfully installed ParseTree-3.0.2 Successfully installed ruby2ruby-1.2.1 Successfully installed merb-action-args-1.0 Successfully installed merb-assets-1.0 Successfully installed merb-slices-1.0 Successfully installed merb-auth-core-1.0 Successfully installed merb-auth-more-1.0 Successfully installed merb-auth-slice-password-1.0 Successfully installed merb-auth-1.0 Successfully installed merb-cache-1.0 Successfully installed merb-exceptions-1.0 Successfully installed highline-1.5.0 Successfully installed diff-lcs-1.1.2 Successfully installed templater-0.4.0 Successfully installed merb-gen-1.0 Successfully installed haml-2.0.4 Successfully installed merb-haml-1.0 Successfully installed merb-helpers-1.0 Successfully installed mailfactory-1.4.0 Successfully installed merb-mailer-1.0 Successfully installed merb-param-protection-1.0 Successfully installed addressable-1.0.4 Successfully installed data_objects-0.9.6 Successfully installed dm-core-0.9.6 Successfully installed dm-migrations-0.9.6 Successfully installed merb_datamapper-1.0 Successfully installed merb-more-1.0 Successfully installed merb_activerecord-0.9.13 39 gems installed Installing ri documentation for json_pure-1.1.3... Installing ri documentation for rack-0.4.0... Installing ri documentation for mime-types-1.15... . . . Installing RDoc documentation for dm-migrations-0.9.6... Installing RDoc documentation for merb_datamapper-1.0... Installing RDoc documentation for merb_activerecord-0.9.13...

   
   It would be nice if this can be further simplified to "gem install merb --orm activerecord" or something similar.
   
2. Create a Merb application:  A "jump start" Merb application created using "merb-gen app" uses ERB templating and DataMapper for ORM. But as mentioned earlier DataMapper does not work with JRuby (at least for now) so a Merb application needs to be created using "merb-gen core". This command creates a Merb application with Ruby-on-Rails like structure and allows to plugin templating engine and ORM frameworks.
   
   Lets create our first Merb application with no ORM and default templating engine as:
   
   

   ~/samples/jruby/merb >merb-gen core hello Generating with core generator:      [ADDED]  gems      [ADDED]  merb.thor      [ADDED]  .gitignore      [ADDED]  public/.htaccess      [ADDED]  doc/rdoc/generators/merb_generator.rb      [ADDED]  doc/rdoc/generators/template/merb/api_grease.js      [ADDED]  doc/rdoc/generators/template/merb/index.html.erb      [ADDED]  doc/rdoc/generators/template/merb/merb.css      [ADDED]  doc/rdoc/generators/template/merb/merb.rb      [ADDED]  doc/rdoc/generators/template/merb/merb_doc_styles.css      [ADDED]  doc/rdoc/generators/template/merb/prototype.js      [ADDED]  public/favicon.ico      [ADDED]  public/merb.fcgi      [ADDED]  public/robots.txt      [ADDED]  public/images/merb.jpg      [ADDED]  Rakefile      [ADDED]  app/controllers/application.rb      [ADDED]  app/controllers/exceptions.rb      [ADDED]  app/helpers/global_helpers.rb      [ADDED]  app/views/exceptions/not_acceptable.html.erb      [ADDED]  app/views/exceptions/not_found.html.erb      [ADDED]  autotest/discover.rb      [ADDED]  autotest/merb.rb      [ADDED]  autotest/merb_rspec.rb      [ADDED]  config/init.rb      [ADDED]  config/rack.rb      [ADDED]  config/router.rb      [ADDED]  config/environments/development.rb      [ADDED]  config/environments/production.rb      [ADDED]  config/environments/rake.rb      [ADDED]  config/environments/staging.rb      [ADDED]  config/environments/test.rb      [ADDED]  public/javascripts/application.js      [ADDED]  public/stylesheets/master.css      [ADDED]  spec      [ADDED]  app/views/layout/application.html.erb

   
   ActiveRecord can be used as pluggable ORM by using the command "merb-gen core --orm activerecord hello". A future blog will cover creating a Merb scaffold using ActiveRecord.
3. Create a new controller as:
   
   

   ~/samples/jruby/merb/hello >merb-gen controller Runners Loading init file from /Users/arungupta/samples/jruby/merb/jruby-1.1.5/samples/merb/hello/config/init.rb Loading /Users/arungupta/samples/jruby/merb/jruby-1.1.5/samples/merb/hello/config/environments/development.rb Generating with controller generator: Loading init file from /Users/arungupta/samples/jruby/merb/jruby-1.1.5/samples/merb/hello/config/init.rb Loading /Users/arungupta/samples/jruby/merb/jruby-1.1.5/samples/merb/hello/config/environments/development.rb      [ADDED]  app/controllers/runners.rb      [ADDED]  app/views/runners/index.html.erb      [ADDED]  spec/requests/runners_spec.rb      [ADDED]  app/helpers/runners_helper.rb

   
   Notice the convention of controller name is a plural word and starting with a capital letter.
4. Edit application
1. Edit "app/controllers/runners.rb" and change the "index" action such that it looks like:
   
   

   def index     @message = "Miles to go ..."     render   end

2. Edit "app/views/runners/index.html.erb" and add "<br><%= @message %>" as the last line.
5. Run application:  Running a Merb application using the Gem is pretty straight forward. If JRUBY_HOME/bin is in PATH, just type the command "glassfish" in the application directory and now you are running a Merb application using GlassFish. The application is accessible at "http://localhost:3000" and the output looks like:
   
   
   
   The controller is accessible at "http://localhost:3000/runners" and the output is:
   
   

Posted by Arun Gupta in web2.0  |  Comments[7]

JRuby 1.1.3 released - Getting Started with GlassFish

JRuby 1.1.3 was released last week - download here. The highlights are:

• 82 issues resolved since JRUby 1.1.2
• RubyGem 1.2 (phew, finally Gem installation is much faster again :)
• Bunch of Compatibility and Performance problems

1. Download and unzip the distribution.
2. Install Rails and GlassFish gem:
   
   

   ~/testbed/jruby-1.1.3 >./bin/jruby -S gem install rails glassfish --no-ri --no-rdoc JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL Successfully installed activesupport-2.1.0 Successfully installed activerecord-2.1.0 Successfully installed actionpack-2.1.0 Successfully installed actionmailer-2.1.0 Successfully installed activeresource-2.1.0 Successfully installed rails-2.1.0 Successfully installed glassfish-0.3.1-universal-java 7 gems installed

3. Create a new Rails app as:
   
   

   ~/testbed/jruby-1.1.3/samples/rails >../../bin/jruby -S rails helloworld -d mysql        create        create  app/controllers       create  app/helpers       create  app/models       create  app/views/layouts       create  config/environments       create  config/initializers       create  db       create  doc . . .       create  log/server.log       create  log/production.log       create  log/development.log       create  log/test.log

4. Run Rails application on GlassFish gem as:
   
   

   ~/testbed/jruby-1.1.3/samples/rails >../../bin/jruby -S glassfish_rails helloworld Jul 21, 2008 8:32:03 AM com.sun.enterprise.glassfish.bootstrap.ASMain main INFO: Launching GlassFish on HK2 platform Jul 21, 2008 8:32:03 AM com.sun.enterprise.glassfish.bootstrap.ASMainHK2 findDerbyClient INFO: Cannot find javadb client jar file, jdbc driver not available Jul 21, 2008 8:32:04 AM com.sun.enterprise.v3.services.impl.GrizzlyProxy start INFO: Listening on port 3000 Jul 21, 2008 8:32:04 AM com.sun.enterprise.v3.services.impl.GrizzlyEmbeddedHttpConfigurator configureSSL WARNING: pewebcontainer.all_ssl_protocols_disabled Jul 21, 2008 8:32:04 AM com.sun.enterprise.v3.services.impl.GrizzlyEmbeddedHttpConfigurator configureSSL WARNING: pewebcontainer.all_ssl_ciphers_disabled Jul 21, 2008 8:32:04 AM com.sun.enterprise.v3.services.impl.GrizzlyProxy start INFO: Listening on port 3131 Jul 21, 2008 8:32:04 AM com.sun.enterprise.v3.services.impl.GrizzlyProxy start INFO: Listening on port 3838 Jul 21, 2008 8:32:04 AM com.sun.enterprise.v3.admin.adapter.AdminConsoleAdapter setContextRoot INFO: Admin Console Adapter: context root: /admin Jul 21, 2008 8:32:05 AM com.sun.grizzly.jruby.RailsAdapter startRubyRuntimePool INFO: Starting Rails instances Jul 21, 2008 8:32:09 AM  SEVERE: JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL Jul 21, 2008 8:32:10 AM com.sun.grizzly.jruby.RubyObjectPool$1 run INFO: JRuby and Rails instance instantiation took : 5623ms Jul 21, 2008 8:32:10 AM org.glassfish.scripting.rails.RailsDeployer load INFO: Loading application helloworld at / Jul 21, 2008 8:32:10 AM com.sun.enterprise.v3.server.AppServerStartup run INFO: Glassfish v3 started in 7046 ms

5. Create a scaffold as:



~/testbed/jruby-1.1.3/samples/rails/helloworld >../../../bin/jruby script/generate scaffold runner distance:float minutes:integer JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL       exists  app/models/       exists  app/controllers/       exists  app/helpers/       create  app/views/runners       exists  app/views/layouts/       exists  test/functional/       exists  test/unit/       exists  public/stylesheets/       create  app/views/runners/index.html.erb       create  app/views/runners/show.html.erb       create  app/views/runners/new.html.erb       create  app/views/runners/edit.html.erb       create  app/views/layouts/runners.html.erb       create  public/stylesheets/scaffold.css       create  app/controllers/runners_controller.rb       create  test/functional/runners_controller_test.rb       create  app/helpers/runners_helper.rb        route  map.resources :runners   dependency  model       exists    app/models/       exists    test/unit/       exists    test/fixtures/       create    app/models/runner.rb       create    test/unit/runner_test.rb       create    test/fixtures/runners.yml       create    db/migrate       create    db/migrate/20080721153737_create_runners.rb

6. Start MySQL database, create and migrate the database:
   
   

   ~/testbed/jruby-1.1.3/samples/rails/helloworld >../../../bin/jruby -S rake db:create (in /Users/arungupta/testbed/jruby-1.1.3/samples/rails/helloworld) ~/testbed/jruby-1.1.3/samples/rails/helloworld >../../../bin/jruby -S rake db:migrate (in /Users/arungupta/testbed/jruby-1.1.3/samples/rails/helloworld) == 20080721154435 CreateRunners: migrating ==================================== -- create_table(:runners)    -> 0.0097s == 20080721154435 CreateRunners: migrated (0.0104s) ===========================

   
   Now "http://localhost:3000/runners" page is shown as:
   
   
   
   After adding couple of entries, the page looks like:
   
   
   
   Now, let's try to run the same application on GlassFish v3 stand-alone build.
   
   TOTD #33 explains how to build GlassFish v3 workspace. Alternatively nightly or promoted builds can be downloaded as well.
   
   
7. Start the v3 server as:
   
   

   ~/testbed/glassfish/v3/snapshot/glassfish >java -DJRUBY_HOME=/Users/arungupta/testbed/jruby-1.1.3 -jar modules/glassfish-10.0-SNAPSHOT.jar Jul 21, 2008 9:40:41 AM com.sun.enterprise.glassfish.bootstrap.ASMain main INFO: Launching GlassFish on Apache Felix OSGi platform Jul 21, 2008 9:40:41 AM com.sun.enterprise.glassfish.bootstrap.ASMainOSGi getSharedRepos INFO: /Users/arungupta/testbed/glassfish/v3/snapshot/glassfish/domains/domain1/lib does not exist Welcome to Felix. ================= . . . INFO: Started bundle org.glassfish.common.container-common [91] Jul 21, 2008 9:47:13 AM com.sun.enterprise.v3.admin.adapter.AdminConsoleAdapter setContextRoot INFO: Admin Console Adapter: context root: /admin Jul 21, 2008 9:47:13 AM OSGiModuleImpl loadClass INFO: Started bundle org.glassfish.deployment.deployment-common [71] Jul 21, 2008 9:47:13 AM com.sun.enterprise.v3.server.AppServerStartup run INFO: Glassfish v3 started in 1507 ms

8. Deploy the application as:
   
   

   ~/testbed/jruby-1.1.3/samples/rails >~/testbed/glassfish/v3/snapshot/glassfish/bin/asadmin deploy helloworld Command deploy executed successfully.

   
   and the GlassFish console shows the following output:
   
   

   Jul 21, 2008 9:47:49 AM OSGiModuleImpl loadClass INFO: Started bundle org.glassfish.web.war-util [65] Jul 21, 2008 9:47:49 AM OSGiModuleImpl loadClass INFO: Started bundle org.glassfish.persistence.jpa-connector [25] Jul 21, 2008 9:47:49 AM OSGiModuleImpl loadClass INFO: Started bundle org.glassfish.scripting.gf-jruby-connector [13] Jul 21, 2008 9:47:49 AM OSGiModuleImpl loadClass INFO: Started bundle org.glassfish.core.security [22] Jul 21, 2008 9:47:49 AM OSGiModuleImpl loadClass INFO: Started bundle org.glassfish.web.gf-web-connector [86] Jul 21, 2008 9:47:49 AM OSGiModuleImpl loadClass INFO: Started bundle org.glassfish.connectors.gf-connectors-connector [53] Jul 21, 2008 9:47:49 AM com.sun.grizzly.jruby.RailsAdapter startRubyRuntimePool INFO: Starting Rails instances Jul 21, 2008 9:48:01 AM  SEVERE: JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL Jul 21, 2008 9:48:02 AM com.sun.grizzly.jruby.RubyObjectPool$1 run INFO: JRuby and Rails instance instantiation took : 12852ms Jul 21, 2008 9:48:02 AM org.glassfish.scripting.rails.RailsDeployer load INFO: Loading application helloworld at /helloworld Jul 21, 2008 9:48:02 AM com.sun.enterprise.v3.deployment.DeployCommand execute INFO: Deployment of helloworld done is 13326 ms


The deployed application at "http://localhost:8080/helloworld/runners" looks like:

Posted by Arun Gupta in web2.0  |  Comments[9]

TOTD #37: SQLite3 with Ruby-on-Rails on GlassFish Gem

The default database for Rails 2.0.x application is SQLite3. This database is bundled with Mac OSX Leopard and so makes it really easy to get started with Ruby-on-Rails. But it requires couple of additional steps if you are using JRuby.

1. Create a Rails application as:
   
   

   ~/samples/jruby >~/testbed/jruby-1.1.2/bin/jruby -S rails runner       create        create  app/controllers       create  app/helpers       create  app/models       create  app/views/layouts . . .       create  log/server.log       create  log/production.log       create  log/development.log       create  log/test.log

   
   The generated "database.yml" looks like:
   
   

   # SQLite version 3.x #   gem install sqlite3-ruby (not necessary on OS X Leopard) development:   adapter: sqlite3   database: db/development.sqlite3   timeout: 5000 # Warning: The database defined as "test" will be erased and # re-generated from your development database when you run "rake". # Do not set this db to the same as development or production. test:   adapter: sqlite3   database: db/test.sqlite3   timeout: 5000 production:   adapter: sqlite3   database: db/production.sqlite3   timeout: 5000

2. SQLite3 adapter is installed for the native Ruby bundled with Leopard. But in order to use SQLite3 with JRuby, you need to install SQLite3 JDBC adapter as shown below:
   
   

   ~/samples/jruby/runner >~/testbed/jruby-1.1.2/bin/jruby -S gem install activerecord-jdbcsqlite3-adapter JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL Successfully installed activerecord-jdbc-adapter-0.8.2 Successfully installed jdbc-sqlite3-3.5.8 Successfully installed activerecord-jdbcsqlite3-adapter-0.8.2 3 gems installed Installing ri documentation for activerecord-jdbc-adapter-0.8.2... Installing ri documentation for jdbc-sqlite3-3.5.8... Installing ri documentation for activerecord-jdbcsqlite3-adapter-0.8.2... Installing RDoc documentation for activerecord-jdbc-adapter-0.8.2... Installing RDoc documentation for jdbc-sqlite3-3.5.8... Installing RDoc documentation for activerecord-jdbcsqlite3-adapter-0.8.2...

3. Create a new file as "db/development.sqlite3". It can be easily created using the "touch" command. See the beauty of SQLite that "db:create" is not required :)
4. Update the development section of "database.yml" such that it looks like:
   
   

   development:   adapter: jdbcsqlite3   database: db/development.sqlite3   timeout: 5000

5. Create a simple scaffold as shown below:
   
   

   ~/samples/jruby/runner >~/testbed/jruby-1.1.2/bin/jruby script/generate scaffold run distance:float minutes:integer JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL       exists  app/models/       exists  app/controllers/       exists  app/helpers/       create  app/views/runs       exists  app/views/layouts/       exists  test/functional/       exists  test/unit/       exists  public/stylesheets/       create  app/views/runs/index.html.erb       create  app/views/runs/show.html.erb       create  app/views/runs/new.html.erb       create  app/views/runs/edit.html.erb       create  app/views/layouts/runs.html.erb       create  public/stylesheets/scaffold.css       create  app/controllers/runs_controller.rb       create  test/functional/runs_controller_test.rb       create  app/helpers/runs_helper.rb        route  map.resources :runs   dependency  model       exists    app/models/       exists    test/unit/       exists    test/fixtures/       create    app/models/run.rb       create    test/unit/run_test.rb       create    test/fixtures/runs.yml       create    db/migrate       create    db/migrate/20080630211244_create_runs.rb

   
   and run the migration as
   
   

   ~/samples/jruby/runner >~/testbed/jruby-1.1.2/bin/jruby -S rake db:migrate (in /Users/arungupta/samples/jruby/runner) == 20080630205502 CreateRuns: migrating ======================================= -- create_table(:runs)    -> 0.0410s    -> 0 rows == 20080630205502 CreateRuns: migrated (0.0420s) ==============================

6. A Rails application is deployed on GlassFish from it's parent directory. Therefore the application needs to be updated so taht exact location of database is specified. Basically you need to edit "database.yml" and the updated "development" fragment looks like:
   
   

   development:   adapter: jdbcsqlite3   database: runner/db/development.sqlite3   timeout: 5000

7. Run the application on GlassFish v3 gem as:
   
   

   ~/samples/jruby >~/testbed/jruby-1.1.2/bin/jruby -S glassfish_rails runner Jun 30, 2008 1:52:08 PM com.sun.enterprise.glassfish.bootstrap.ASMain main INFO: Launching GlassFish on HK2 platform Jun 30, 2008 1:52:08 PM com.sun.enterprise.glassfish.bootstrap.ASMainHK2 findDerbyClient INFO: Cannot find javadb client jar file, jdbc driver not available Jun 30, 2008 1:52:09 PM com.sun.enterprise.v3.services.impl.GrizzlyProxy start INFO: Listening on port 3000 Jun 30, 2008 1:52:09 PM com.sun.enterprise.v3.services.impl.GrizzlyEmbeddedHttpConfigurator configureSSL WARNING: pewebcontainer.all_ssl_protocols_disabled Jun 30, 2008 1:52:09 PM com.sun.enterprise.v3.services.impl.GrizzlyEmbeddedHttpConfigurator configureSSL WARNING: pewebcontainer.all_ssl_ciphers_disabled Jun 30, 2008 1:52:09 PM com.sun.enterprise.v3.services.impl.GrizzlyProxy start INFO: Listening on port 3131 Jun 30, 2008 1:52:09 PM com.sun.enterprise.v3.services.impl.GrizzlyProxy start INFO: Listening on port 3838 Jun 30, 2008 1:52:09 PM com.sun.enterprise.v3.admin.adapter.AdminConsoleAdapter setContextRoot INFO: Admin Console Adapter: context root: /admin Jun 30, 2008 1:52:09 PM com.sun.grizzly.jruby.RailsAdapter startRubyRuntimePool INFO: Starting Rails instances Jun 30, 2008 1:52:16 PM   SEVERE: JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL Jun 30, 2008 1:52:17 PM com.sun.grizzly.jruby.RubyObjectPool$1 run INFO: JRuby and Rails instance instantiation took : 7998ms Jun 30, 2008 1:52:17 PM org.glassfish.scripting.rails.RailsDeployer load INFO: Loading application runner at / Jun 30, 2008 1:52:17 PM com.sun.enterprise.v3.server.AppServerStartup run INFO: Glassfish v3 started in 9430 ms

• Running Rails with ActiveRecord-JDBC
• SQLite3 man page provides complete set of commands for this database.
• GlassFish v3 Gem 0.3.1
• Rails powered by the GlassFish Application Server
• Getting Started with JRuby on GlassFish

Please leave suggestions on other TOTD (Tip Of The Day) that you'd like to see. A complete archive is available here.

Posted by Arun Gupta in web2.0  |  Comments[5]

Rails GlassFish Gem 0.3.1 now available

Vivek released 0.3.0 version of GlassFish Gem for Rails (a total of 11 issues fixed and resolved - RubyForge & GlassFish Issue Tracker) earlier. But that caused a regression on #4228. And so matching the agility expected by Rails developers, he quickly released 0.3.1. And a wee bit smaller too - 2.68MB for 0.3.1 instead of 2.69MB for 0.3.0.

If you have an existing version of the gem, then you just need to update it:

Posted by Arun Gupta in web2.0  |  Comments[6]

Rails 2.1 on GlassFish - it works!

Rails 2.1 was released earlier this month. GlassFish provides a complete development/deployment environment for Rails applications. Some of the main reasons for using GlassFish (instead of WEBrick or Mongrel) are:

• Identical Development and Deployment environment
• Multiple Applications can be deployed on one Container
• Multiple requests can be handled by a single application (with no extra configuration)
• Out-of-the-box Clustering, Load Balancing and High Availability
• Database connection pooling
• Co-hosting Rails and Java EE applications

1. Install Rails 2.1 in a JRuby 1.1.2 installation:
   
   

   ~/testbed/rails21/jruby-1.1.2 >bin/jruby -S gem install rails --no-ri --no-rdoc JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL Updating metadata for 253 gems from http://gems.rubyforge.org/ ............................................................................... ............................................................................... ............................................................................... ................ complete Bulk updating Gem source index for: http://gems.rubyforge.org/ Successfully installed activesupport-2.1.0 Successfully installed activerecord-2.1.0 Successfully installed actionpack-2.1.0 Successfully installed actionmailer-2.1.0 Successfully installed activeresource-2.1.0 Successfully installed rails-2.1.0 6 gems installed

2. Create a new Rails app as:
   
   

   ~/testbed/rails21/jruby-1.1.2/samples/rails >../../bin/jruby -S rails -d mysql runner       create         create  app/controllers       create  app/helpers       create  app/models       create  app/views/layouts       create  config/environments       create  config/initializers       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/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  config/initializers/inflections.rb       create  config/initializers/mime_types.rb       create  config/initializers/new_rails_defaults.rb       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/console       create  script/dbconsole       create  script/destroy       create  script/generate       create  script/performance/benchmarker       create  script/performance/profiler       create  script/performance/request       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/422.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

3. Start GlassFish as:
   
   

   ~/testbed/glassfish/v3/tp2/glassfishv3-tp2/glassfish >java -DJRUBY_HOME=/Users/arungupta/testbed/rails21/jruby-1.1.2 -jar modules/glassfish-10.0-tp-2-SNAPSHOT.jar Jun 17, 2008 6:14:21 PM com.sun.enterprise.glassfish.bootstrap.ASMain main INFO: Launching GlassFish on HK2 platform Jun 17, 2008 6:14:22 PM com.sun.enterprise.v3.services.impl.GrizzlyProxy start INFO: Listening on port 8080 Jun 17, 2008 6:14:22 PM com.sun.enterprise.v3.services.impl.GrizzlyProxy start INFO: Listening on port 8181 Jun 17, 2008 6:14:22 PM com.sun.enterprise.v3.services.impl.GrizzlyProxy start INFO: Listening on port 4848 Jun 17, 2008 6:14:22 PM com.sun.enterprise.v3.admin.adapter.AdminConsoleAdapter setContextRoot INFO: Admin Console Adapter: context root: /admin Jun 17, 2008 6:14:22 PM com.sun.enterprise.v3.server.AppServerStartup run INFO: Glassfish v3 started in 974 ms

4. Deploy the newly created application as:
   
   

   ~/testbed/rails21/jruby-1.1.2/samples/rails >~/testbed/glassfish/v3/tp2/glassfishv3-tp2/glassfish/bin/asadmin deploy runner Command deploy executed successfully.

   
   and the GlassFish console shows:
   
   

   Jun 17, 2008 6:14:41 PM com.sun.enterprise.rails.RailsDeployer registerAdapter INFO: Loading application runner at /runner Jun 17, 2008 6:14:41 PM   INFO: Starting Rails instances Jun 17, 2008 6:14:49 PM   SEVERE: JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL Jun 17, 2008 6:14:51 PM com.sun.grizzly.jruby.RubyObjectPool$1 run INFO: Rails instance instantiation took : 9066ms Jun 17, 2008 6:14:51 PM com.sun.enterprise.v3.deployment.DeployCommand execute INFO: Deployment of runner done is 9168 ms

   
   The default page at "http://localhost:8080/runner" shows
   
   
   
5. Generate a Scaffold as described in TOTD #28
   
   

   ~/testbed/rails21/jruby-1.1.2/samples/rails/runner >../../../bin/jruby -S rake db:create (in /Users/arungupta/testbed/rails21/jruby-1.1.2/samples/rails/runner) ~/testbed/rails21/jruby-1.1.2/samples/rails/runner >../../../bin/jruby script/generate scaffold distance miles:float run_at:datetime JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL       exists  app/models/       exists  app/controllers/       exists  app/helpers/       create  app/views/distances       exists  app/views/layouts/       exists  test/functional/       exists  test/unit/       exists  public/stylesheets/       create  app/views/distances/index.html.erb       create  app/views/distances/show.html.erb       create  app/views/distances/new.html.erb       create  app/views/distances/edit.html.erb       create  app/views/layouts/distances.html.erb       create  public/stylesheets/scaffold.css       create  app/controllers/distances_controller.rb       create  test/functional/distances_controller_test.rb       create  app/helpers/distances_helper.rb        route  map.resources :distances   dependency  model       exists    app/models/       exists    test/unit/       exists    test/fixtures/       create    app/models/distance.rb       create    test/unit/distance_test.rb       create    test/fixtures/distances.yml       create    db/migrate       create    db/migrate/20080618012326_create_distances.rb ~/testbed/rails21/jruby-1.1.2/samples/rails/runner >../../../bin/jruby -S rake db:migrate (in /Users/arungupta/testbed/rails21/jruby-1.1.2/samples/rails/runner) == 20080618012326 CreateDistances: migrating ================================== -- create_table(:distances)    -> 0.0080s == 20080618012326 CreateDistances: migrated (0.0090s) =========================

6. Edit line 44 of "config/environment.rb" to change the default timezone from "UTC" to "Pacific Time (US & Canada)". The updated line looks like:
   
   

   config.time_zone = 'Pacific Time (US & Canada)'

7. Creating a new scaffold entry shows the following screen:
   
   
   
   Notice how default timezone is selected using Rails 2.1 Time Zone Support. After creating couple of entries (as described in TOTD #28), the page at "http://localhost:8080/runner/distances" looks like:
   
   
   
   Notice how "-0700" is shown which is the offset for US Pacific Time during daylight savings.
   

1. Install GlassFish v3 Gem as:
   
   

   ~/testbed/rails21/jruby-1.1.2 >bin/jruby -S gem install glassfish JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL Updating metadata for 13 gems from http://gems.rubyforge.org/ ............. complete Successfully installed glassfish-0.2.0-universal-java 1 gem installed

2. Deploy the previously created Rails application as:
   
   

   ~/testbed/rails21/jruby-1.1.2/samples/rails >../../bin/jruby -S glassfish_rails runner Jun 17, 2008 6:39:37 PM com.sun.enterprise.glassfish.bootstrap.ASMain main INFO: Launching GlassFish on HK2 platform Jun 17, 2008 6:39:37 PM com.sun.enterprise.glassfish.bootstrap.ASMainHK2 findDerbyClient INFO: Cannot find javadb client jar file, jdbc driver not available Jun 17, 2008 6:39:38 PM com.sun.enterprise.v3.services.impl.GrizzlyProxy start INFO: Listening on port 3000 Jun 17, 2008 6:39:38 PM com.sun.enterprise.v3.services.impl.GrizzlyEmbeddedHttpConfigurator configureSSL WARNING: pewebcontainer.all_ssl_protocols_disabled Jun 17, 2008 6:39:38 PM com.sun.enterprise.v3.services.impl.GrizzlyEmbeddedHttpConfigurator configureSSL WARNING: pewebcontainer.all_ssl_ciphers_disabled Jun 17, 2008 6:39:38 PM com.sun.enterprise.v3.services.impl.GrizzlyProxy start INFO: Listening on port 3131 Jun 17, 2008 6:39:38 PM com.sun.enterprise.v3.services.impl.GrizzlyProxy start INFO: Listening on port 3838 Jun 17, 2008 6:39:39 PM com.sun.enterprise.v3.admin.adapter.AdminConsoleAdapter setContextRoot INFO: Admin Console Adapter: context root: /admin Jun 17, 2008 6:39:39 PM com.sun.enterprise.rails.RailsDeployer registerAdapter INFO: Loading application runner at / Jun 17, 2008 6:39:39 PM  INFO: Starting Rails instances Jun 17, 2008 6:39:44 PM  SEVERE: JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL Jun 17, 2008 6:39:45 PM com.sun.grizzly.jruby.RubyObjectPool$1 run INFO: Rails instance instantiation took : 6710ms Jun 17, 2008 6:39:45 PM com.sun.enterprise.v3.server.AppServerStartup run INFO: Glassfish v3 started in 8053 ms

   
   The page at "http://localhost:3000/runner" looks like:
   
   
   

Posted by Arun Gupta in web2.0  |  Comments[6]

JRuby 1.1.2 released - Getting Started with v3 Gem

JRuby 1.1.2 was released yesterday - download here!

The highlights are:

• Startup time drastically reduced
• YAML symbol parsing >100x faster
• Performance, threading, and stack depth improvements for method calls
• Fixed several nested backref problems
• Fixed bad data race (JRUBY-2483)
• Gazillions of bigdecimal issues fixed
• 95 issues resolved since JRuby 1.1.1
  

Posted by Arun Gupta in web2.0  |  Comments[4]