Arun Gupta, Miles to go ...

TOTD #113: JavaFX front-end for GlassFish v3 Administration - Using REST interface

GlassFish v3 provides a REST interface to management and monitoring information as discussed in TOTD #96. As mentioned in that blog "the REST interface is a lower level API that enables toolkit developers and IT administrators to write their custom scripts/clients using language of their choice". This blog introduces a tool that uses the REST API to provide management and monitoring of GlassFish v3 and is written using JavaFX.

This tool is only a proof-of-concept that demonstrates that GlassFish v3 REST interface is functionally very rich and can indeed be used to write third-party administration tools. The tool uses a subset of the REST interface and exposes only a limited amount of management and monitoring capabilities otherwise exposed. After all this is a proof-of-concept :-)

A screencast of this tool in action along with a downloadable JNLP version will soon be available. For now, here is a snapshot of the main window of this tool:

The main screen allows you to enter a URL for the GlassFish administration. Then the GlassFish instance can be stopped/restarted from the main window using the buttons on top right. There is an animation at the bottom of the screen where the glassfish is swimming in the ocean and is directly related to the state of server running in the background. If the server is running, the animation works. If the server is not running then the animation stops as well.

The main screen has three main buttons:

• "List Applications" - list all the applications deployed on the running instance
• "Show Monitoring Levels" - show/Update all the monitoring levels
• "Server Stats" - show statistics of the running server

Clicking on "List Applications" shows the list of applications deployed on this particular instance. Here is how a snapshot looks like for an instance running on my localhost at port 4848:

As shown in the screen, it shows a radio-bulleted list of all the applications. Each bullet is also accompanied by an image indicating the type of application - Web or Rails for now. Select the application and click on "Monitor" button to monitor that particular application. The REST API exposes a vast amount of monitoring data but a subset of monitoring data is displayed for Web and Rails application for now. Here is a snapshot of the monitoring data published for a Web application:

As evident by the list of engines, this web application has EJBs bundled as well. It also shows total number of Servlets/JSPs loaded, number of requests made to this web application and some other monitoring data.

Here is a snapshot of the monitoring data published for a Rails application:

It shows number of JRuby runtimes configured for the application, number of requests sent to the application, number of responses with different HTTP access codes and some other data.

The monitoring levels of different containers can be easily updated by clicking on "Show Monitoring Levels" as shown below:

And finally some server statistics are shown by clicking on "Server Stats" as shown below:

It shows when the server was started, host/port information, version and finally how long the server has been running for. The dials are an animation that shows the server up time.

Here are other related JavaFX and GlassFish related blogs published earlier:

• TOTD #23: JavaFX Client invoking a Metro endpoint
• JavaFX 1.0 launched - access services hosted on embedded GlassFish

How are you going to use the REST interface exposed by GlassFish v3 in your environment ?

Are you using JavaFX with GlassFish together in any way ?

Leave a comment on this blog if you do!

Technorati: javafx glassfish v3 rest web jruby rubyonrails rest administration monitoring management

Posted by Arun Gupta in General  |  Comments[0]

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]

Screencast #26: Develop/Run/Debug Rails application using NetBeans IDE and GlassFish v3 Prelude

GlassFish v3 Prelude is now available. It allows Rails applications to be deployed natively using JRuby and without the need of any WAR packaging or Servlet container. An integrated NetBeans tooling provides a comprehensive development and deployment platform for all your Rails applications. And you can even purchase enterprise support as well!

This screencast shows how you can create a simple Rails application using NetBeans IDE, deploy it directly on GlassFish v3 and then debug it.


Typo, Redmine, Substruct, and Mephisto are some of the applications I've tried deploying on GlassFish. Have you tried deploying your Rails app on GlassFish ?

File Rails/GlassFish related bugs here using "jruby" sub-component and ask your questions on webtier@glassfish.dev.java.net.

All other GlassFish related screencasts are available here.

Technorati: glassfish v3 netbeans rubyonrails jruby screencast

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

Getting Started with Edge Rails (2.2) using JRuby and GlassFish

This blog shows how to get started with Edge Rails (2.2, almost there) using JRuby. The blog uses JRuby 1.1.5 and GlassFish v3 Prelude b28c to deploy a simple Rails app.

1. Download and unzip JRuby 1.1.5.
2. JRuby 1.1.5 comes with "rake 0.8.3". However if you are using JRuby 1.1.4, then you need to update "rake" version to 0.8.3 as:
   
   

   ~/tools/jruby-1.1.4 >bin/jruby -S gem update rake JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL Updating installed gems Updating rake Successfully installed rake-0.8.3 Gems updated: rake

3. Install Edge Rails as:
   
   

   ~/tools/jruby-1.1.5 >bin/jruby -S gem install rails -s http://gems.rubyonrails.org -v 2.2.0 JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL Successfully installed activesupport-2.2.0 Successfully installed activerecord-2.2.0 Successfully installed actionpack-2.2.0 Successfully installed actionmailer-2.2.0 Successfully installed activeresource-2.2.0 Successfully installed rails-2.2.0 6 gems installed Installing ri documentation for activesupport-2.2.0... Installing ri documentation for activerecord-2.2.0... Installing ri documentation for actionpack-2.2.0... Installing ri documentation for actionmailer-2.2.0... Installing ri documentation for activeresource-2.2.0... Installing RDoc documentation for activesupport-2.2.0... Installing RDoc documentation for activerecord-2.2.0... Installing RDoc documentation for actionpack-2.2.0... Installing RDoc documentation for actionmailer-2.2.0... Installing RDoc documentation for activeresource-2.2.0...

4. Create a new app as:
   
   

   ~/samples/jruby/edge >~/tools/jruby-1.1.5/bin/jruby -S rails helloworld -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

5. Edge Rails do not ship with any(?, atleast MySQL) pure-Ruby database drivers and throws the following error if a database related operation is performed:
   
   

   ~/samples/jruby/helloworld >~/tools/jruby-1.1.5/bin/jruby -S rake db:create (in /Users/arungupta/samples/jruby/helloworld) !!! The bundled mysql.rb driver has been removed from Rails 2.2. Please install the mysql gem and try again: gem install mysql. rake aborted! no such file to load -- mysql (See full trace by running task with --trace)

   
   I find it weird that a database-backed framework does not ship database drivers. Anyway, lets install MySQL JDBC ActiveRecord adapter as:
   
   

   ~/tools/jruby-1.1.5 >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.8.2 Successfully installed jdbc-mysql-5.0.4 Successfully installed activerecord-jdbcmysql-adapter-0.8.2 3 gems installed Installing ri documentation for activerecord-jdbc-adapter-0.8.2... Installing ri documentation for jdbc-mysql-5.0.4... Installing ri documentation for activerecord-jdbcmysql-adapter-0.8.2... Installing RDoc documentation for activerecord-jdbc-adapter-0.8.2... Installing RDoc documentation for jdbc-mysql-5.0.4... Installing RDoc documentation for activerecord-jdbcmysql-adapter-0.8.2...

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

   ~/samples/jruby/edge/helloworld >~/tools/jruby-1.1.5/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/       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/20081103190813_create_runners.rb ~/samples/jruby/edge/helloworld >~/tools/jruby-1.1.5/bin/jruby -S rake db:create (in /Users/arungupta/samples/jruby/edge/helloworld) ~/samples/jruby/edge/helloworld >~/tools/edge/jruby-1.1.5/bin/jruby -S rake db:migrate (in /Users/arungupta/samples/jruby/edge/helloworld) ==  CreateRunners: migrating ================================================== -- create_table(:runners)    -> 0.0068s    -> 0 rows ==  CreateRunners: migrated (0.0077s) =========================================

   
   Some words here.
7. Change "config/database.yml" to use the JDBC adapter. Change:
   
   

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

   
   to
   
   

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

   
   The change is highlighted in bold letters.
8. Download GlassFish v3 Prelude 28c, unzip and start it as:
   
   

   ~/tools/glassfish/v3/28c/glassfishv3-prelude/glassfish >java -Xmx512m -DJRUBY_HOME=/Users/arungupta/tools/jruby-1.1.5/ -jar modules/glassfish.jar

9. Finally deploy the application as:
   
   

   ~/samples/jruby/edge >~/tools/glassfish/v3/28c/glassfishv3-prelude/glassfish/bin/asadmin deploy helloworld Command deploy executed successfully.

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

TOTD #44: JDBC Connection Pooling for Rails on GlassFish v3

TOTD #9 explained how to configure JDBC connection pooling for Rails application deployed on GlassFish v2. There are several benefits of using using the JDBC connection pools:

• No need to create a new database connection for each Rails instance.
• No need to specify your password in database.yml or create a hack to hide it.
• No garbage collection of connection after each use.

1. Lets create a simple scaffold
   
   

   ~/samples/jruby >~/tools/jruby-1.1.3/bin/jruby -S rails jndi_rails2 -d mysql ~/samples/jruby/jndi_rails2 >~/tools/jruby-1.1.3/bin/jruby script/generate scaffold runner miles:float minutes:integer ~/samples/jruby/jndi_rails2 >~/tools/jruby-1.1.3/bin/jruby -S rake db:create ~/samples/jruby/jndi_rails2 >~/tools/jruby-1.1.3/bin/jruby -S rake db:migrate

2. Install MySQL ActiveRecord JDBC adapter
   
   

   ~/samples/jruby/jndi_rails2 >~/tools/jruby-1.1.3/bin/jruby -S gem install activerecord-jdbcmysql-adapter

3. Copy MySQL Connector/J jar to JAVA_HOME/lib/ext
   
   

   ~/samples/jruby/jndi_rails2 >sudo cp ~/tools/mysql-connector-java-5.1.6/mysql-connector-java-5.1.6-bin.jar /System/Library/Frameworks/JavaVM.framework/Versions/1.6/Home/lib/ext

4. Start GlassFish v3 server as ...
   
   

   ~/tools/glassfish/v3/b23/glassfishv3-prelude/glassfish >java -Xmx512m -DJRUBY_HOME=/Users/arungupta/tools/jruby-1.1.3 -jar modules/glassfish-10.0-SNAPSHOT.jar

5. Setup JDBC connection pool
1. Create JDBC connection pool
   
   

   ~/samples/jruby/jndi_rails2 >~/tools/glassfish/v3/b23/glassfishv3-prelude/glassfish/bin/asadmin create-jdbc-connection-pool --datasourceclassname com.mysql.jdbc.jdbc2.optional.MysqlConnectionPoolDataSource --restype javax.sql.DataSource --property "User=duke:Password=duke:URL=jdbc\:mysql\://localhost/jndi_rails2_production" jdbc/jndi_rails2_pool

2. Create JDBC resource
   
   

   ~/samples/jruby/jndi_rails2 >~/tools/glassfish/v3/b23/glassfishv3-prelude/glassfish/bin/asadmin create-jdbc-resource --connectionpoolid jdbc/jndi_rails2_pool jdbc/jndi_rails2

3. Ping JDBC pool
   
   

   ~/samples/jruby >~/tools/glassfish/v3/b23/glassfishv3-prelude/glassfish/bin/asadmin ping-connection-pool jdbc/jndi_rails2_pool

6. Change the development database in config/database.yml to:
   
   

   development:   adapter: jdbc   jndi: jdbc/jndi_rails2   driver: com.mysql.jdbc.Driver

7. Run your app as
   
   

   ~/samples/jruby >~/tools/glassfish/v3/b22/glassfishv3-prelude/glassfish/bin/asadmin deploy jndi_rails2

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

Typo on GlassFish v3 - Ruby-on-Rails Blogging Engine

Typo is an open-source Blogging Engine written using Ruby-on-Rails framework. It provides a lean engine that makes blogging easy. It's main attribtues are ease of use, usability, beauty and excellent support of web standards.

1. Typo can be installed as Gem or from Sources. Installing as gem gives the following error:
   
   

   JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL Building native extensions.  This could take a while... /Users/arungupta/tools/rails20/jruby-1.1.3/lib/ruby/1.8/mkmf.rb:7: JRuby does not support native extensions. Check wiki.jruby.org for alternatives. (NotImplementedError)         from /Users/arungupta/tools/rails20/jruby-1.1.3/lib/ruby/1.8/mkmf.rb:1:in `require'         from extconf.rb:1 ERROR:  Error installing typo:         ERROR: Failed to build gem native extension. /Users/arungupta/tools/rails20/jruby-1.1.3/bin/jruby extconf.rb install typo Gem files will remain installed in /Users/arungupta/tools/rails20/jruby-1.1.3/lib/ruby/gems/1.8/gems/mysql-2.7 for inspection. Results logged to /Users/arungupta/tools/rails20/jruby-1.1.3/lib/ruby/gems/1.8/gems/mysql-2.7/gem_make.out

   
   This is discussed here. In the meanwhile, download and unzip Typo 5.1.2 as:
   
   

   ~/samples/jruby >unzip ~/Downloads/typo-5.1.2.zip Archive:  /Users/arungupta/Downloads/typo-5.1.2.zip    creating: typo-5.1.2/    creating: typo-5.1.2/app/    creating: typo-5.1.2/app/apis/    . . .   inflating: typo-5.1.2/vendor/uuidtools/lib/uuidtools.rb    inflating: typo-5.1.2/vendor/uuidtools/rakefile    inflating: typo-5.1.2/vendor/uuidtools/README

2. Create the database:
   
   

   ~/samples/jruby >sudo mysqladmin create typo_dev

   
   Typo 5.1.x works with Rails 2.0.x only and so migrate as shown below:
   
   

   ~/samples/jruby/typo-5.1.2 >~/tools/rails20/jruby-1.1.3/bin/jruby -S rake db:migrate (in /Users/arungupta/samples/jruby/typo-5.1.2) == 1 InitialSchema: migrating ================================================= -- create_table(:users)    -> 0.0377s -- create_table(:articles)    -> 0.0189s -- add_index(:articles, :permalink)    -> 0.0094s -- create_table(:categories)    -> 0.0069s  . . . == 69 AddModulesToProfile: migrating ========================================== -- add_column(:profiles, :modules, :text)    -> 0.0072s == 69 AddModulesToProfile: migrated (0.0454s) ================================= == 70 AddUsersToNonAdmins: migrating ========================================== == 70 AddUsersToNonAdmins: migrated (0.0488s) =================================


Typo 5.2 (scheduled in 3 days) will work with Rails 2.1.

3. Download GlassFish (nightly, promoted or build-your-own) and install by unzipping. I tried the nightly of 8/24 as:
   
   

   ~/tools/glassfish/v3/8-24 >unzip ~/Downloads/glassfish-snapshot-v3-prelude-08_24_2008.zip Archive:  /Users/arungupta/Downloads/glassfish-snapshot-v3-prelude-08_24_2008.zip    creating: glassfish/    creating: glassfish/docs/    creating: glassfish/docs/css/    creating: glassfish/docs/graphics/ . . .   inflating: glassfish/lib/templates/login.conf    inflating: glassfish/lib/templates/profile.properties    inflating: glassfish/lib/templates/server.policy

4. Start GlassFish as:
   
   

   ~/tools/glassfish/v3/8-24/glassfish >java -DJRUBY_HOME=/Users/arungupta/tools/rails20/jruby-1.1.3 -jar modules/glassfish-10.0-SNAPSHOT.jar Aug 26, 2008 5:56:10 PM com.sun.enterprise.glassfish.bootstrap.ASMain main INFO: Launching GlassFish on Apache Felix OSGi platform Welcome to Felix. ================= Aug 26, 2008 5:56:11 PM HK2Main start INFO: contextRootDir = /Users/arungupta/tools/glassfish/v3/8-24/glassfish/modules Aug 26, 2008 5:56:11 PM OSGiFactoryImpl initialize . . . INFO: APIClassLoader = Class Loader for Bundle [GlassFish-Application-Common-Module [66] ] Aug 26, 2008 5:56:13 PM CommonClassLoaderManager Skipping creation of CommonClassLoader as there are no libraries available INFO: urls = [] Aug 26, 2008 5:56:13 PM com.sun.enterprise.v3.server.AppServerStartup run INFO: Glassfish v3 started in 2176 ms

5. And deploy Typo as:
   
   

   ~/samples/jruby >~/tools/glassfish/v3/8-24/glassfish/bin/asadmin deploy typo-5.1.2 Command deploy executed successfully.

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