Arun Gupta, Miles to go ...: Arun Gupta's Weblog

Friday September 18, 2009

Free Rails/GlassFish Webinar with live Q&A: Sep 23, 2009,10am PT

Content available at: http://blog.arungupta.me/2009/09/free-railsglassfish-webinar-with-live-qa-sep-23-200910am-pt/

Posted by Arun Gupta in General | Comments[0]

|

|

|

|

|
|

Wednesday August 12, 2009

TOTD #92: Session Failover for Rails applications running on GlassFish

The GlassFish High Availability allows to setup a cluster of GlassFish instances and achieve highly scalable architecture using in-memory session state replication. This cluster can be very easily created and tested using the "clusterjsp" sample bundled with GlassFish. Here are some clustering related entries published on this blog so far:

TOTD #84 shows how to setup Apache + mod_proxy balancer for Ruby-on-Rails load balancing
TOTD #81 shows how to use nginx to front end a cluster of GlassFish Gems
TOTD #69 explains how a GlassFish cluster can be front-ended using Sun Web Server and Load Balancer Plugin
TOTD #67 shows the same thing using Apache httpd + mod_jk

#67 & #69 uses a web application "clusterjsp" (bundled with GlassFish) that uses JSP to demonstrate in-memory session replication state replication. This blog creates a similar application "clusterrails" - this time using Ruby-on-Rails and deploy it on GlassFish v2.1.1. The idea is to demonstrate how Rails applications can leverage the in-memory session replication feature of GlassFish.

Rails applications can be easily deployed as a WAR file on GlassFish v2 as explained in TOTD #73. This blog will guide through the steps of creating the Controller and View to mimic "clusterjsp" and configuring the Rails application for session replication.

Create a template Rails application and create/migrate the database. Add a Controller/View as:

~/samples/jruby/session >~/tools/jruby/bin/jruby script/generate controller home index
JRuby limited openssl loaded. gem install jruby-openssl for full support.
http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL
      exists app/controllers/
      exists app/helpers/
      create app/views/home
      exists test/functional/
      create test/unit/helpers/
      create app/controllers/home_controller.rb
      create test/functional/home_controller_test.rb
      create app/helpers/home_helper.rb
      create test/unit/helpers/home_helper_test.rb
      create app/views/home/index.html.erb

Edit the controller in "app/controllers/home_controller.rb" and change the code to (explained below):

class HomeController < ApplicationController
include Java

def index
 @server_served = servlet_request.get_server_name
 @port = servlet_request.get_server_port
 @instance = java.lang.System.get_property "com.sun.aas.instanceName"
 @server_executed = java.net.InetAddress.get_local_host().get_host_name()
 @ip = java.net.InetAddress.get_local_host().get_host_address
 @session_id = servlet_request.session.get_id
 @session_created = servlet_request.session.get_creation_time
 @session_last_accessed = servlet_request.session.get_last_accessed_time
 @session_inactive = servlet_request.session.get_max_inactive_interval

 if (params[:name] != nil)
 servlet_request.session[params[:name]] = params[:value]
 end

 @session_values = ""
 value_names = servlet_request.session.get_attribute_names
 unless (value_names.has_more_elements)
 @session_values = " No parameter entered for this request"
 else
 @session_values << "<UL>"
 while (value_names.has_more_elements)
 param = value_names.next_element
 unless (param.starts_with?("__"))
 value = servlet_request.session.get_attribute(param)
 @session_values << "<LI>" + param + " = " + value + "</LI>"
 end
 end
 @session_values << "</UL>"
 end

end

def adddata
 servlet_request.session.set_attribute(params[:name], params[:value])
 render :action => "index"
end

def cleardata
 servlet_request.session.invalidate
 render :action => "index"
end
end

The "index" action initializes some instance variables using the "servlet_request" variable mapped from "javax.servlet.http.ServletRequest" class. The "servlet_request" provides access to different properties of the request received such as server name/port, host name/address and others. It also uses an application server specific property "com.sun.aas.instanceName" to fetch the name of particular instance serving the request. In this blog we'll create a cluster with 2 instances. The action then prints the servlet session attributes name/value pairs entered so far.

The "adddata" action takes the name/value pair entered on the page and stores them in the servlet request. The "cleardata" action clears any data that is storied in the session.

Edit the view in "app/views/home/index.html.erb" and change to (explained below):

<h1>Home#index</h1>
Find me in app/views/home/index.html.erb
HttpSession Information:
<UL>
<LI>Served From Server: <%= @server_served %></LI>
<LI>Server Port Number: <%= @port %></LI>
<LI>Executed From Server: <%= @server_executed %></LI>
<LI>Served From Server instance: <%= @instance %></LI>
<LI>Executed Server IP Address: <%= @ip %></LI>
<LI>Session ID: <%= @session_id %></LI>
<LI>Session Created: <%= @session_created %></LI>
<LI>Last Accessed: <%= @session_last_accessed %></LI>
<LI>Session will go inactive in <%= @session_inactive %> seconds</LI>
</UL>
 
<% form_tag "/session/home/index" do %>
<label for="name">Name of Session Attribute:</label>
<%= text_field_tag :name, params[:name] %> 

<label for="value">Value of Session Attribute:</label>
<%= text_field_tag :value, params[:value] %> 

 <%= submit_tag "Add Session Data" %>
<% end %>
<% form_tag "/session/home/cleardata" do %>
 <%= submit_tag "Clear Session Data" %>
<% end %>
<% form_tag "/session/home/index" do %>
 <%= submit_tag "Reload Page" %>
<% end %>
 
Data retrieved from the HttpSession: 
<%= @session_values %>

The view dumps the property value retrieved from the servlet context in the action. Then it consists of some forms to enter the session name/value pairs, clear the session and reload the page. The application is now ready, lets configure it for WAR packaging.

Generate a template "web.xml" and copy it to "config" directory as:

~/samples/jruby/session >~/tools/jruby/bin/jruby -S warble war:webxml
mkdir -p tmp/war/WEB-INF
~/samples/jruby/session >cp tmp/war/WEB-INF/web.xml config/

Edit "tmp/war/WEB-INF/web.xml" and change the first few lines from:

<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>

to

<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

This is required because the element to be added next is introduced in the Servlet 2.4 specification.

Add the following element:

<distributable/>

as the first element, right after "<web-app>". This element marks the web application to be distributable across multiple JVMs in a cluster.

Generate and configure "warble/config.rb" as described in TOTD #87. This configuration is an important step otherwise you'll encounter JRUBY-3789. Create a WAR file as:

~/samples/jruby/session >~/tools/jruby/bin/jruby -S warble
mkdir -p tmp/war/WEB-INF/gems/specifications
cp /Users/arungupta/tools/jruby-1.3.0/lib/ruby/gems/1.8/specifications/rails-2.3.2.gemspec tmp/war/WEB-INF/gems/specifications/rails-2.3.2.gemspec

. . .

mkdir -p tmp/war/WEB-INF
cp config/web.xml tmp/war/WEB-INF
jar cf session.war -C tmp/war .

Download latest GlassFish v2.1.1, install/configure GlassFish and create/configure/start a cluster using the script described here. Make sure to change the download location and filename in the script. This script creates a cluster "wines" with two instances - "cabernet" runing on the port 58080 and "merlot" running on the port 58081.
Deploy the application using the command:

~/samples/jruby/session >asadmin deploy --target wines --port 5048 --availabilityenabled=true session.war

Now, the screenshots from the two instances are shown and explained below. The two (or more) instances are front-ended by a load balancer so none of this is typically visible to the user but it helps to understand.
Here is a snapshot of this application deployed on "cabernet":

The instance name and the session id is highlighted in the red box. It also shows the time when the session was created in "Session Created" field.

And now the same application form "merlot":

Notice, the session id exactly matches the one from the "cabernet" instance. Similarly "Session Created" matches but "Last Accessed" does not because the same session session is accessed from a different instance.

Lets enter some session data in the "cabernet" instance and click on "Add Session Data" button as shown below:

The session attribute is "aaa" and value is "111". Also the "Last Accessed" time is updated. In the "merlot" page, click on the "Reload Page" button and the same session name/value pairs are retrieved as shown below:

Notice, the "Last Accessed" time is after the time showed in "cabernet" instance. The session information added in "cabernet" is automatically replicated to the "merlot" instance.

Now, lets add a new session name/value pair in "merlot" instance as shown below:

The "Last Accessed" is updated and the session name/value pair ("bbb"/"222") is shown in the page. Click on "Reload page" in "cabernet" instance as shown below:

This time the session information added to "merlot" is replicated to "cabernet".

So any session information added in "cabernet" is replicated to "merlot" and vice versa.

Now, lets stop "cabernet" instance as shown below:

and click on "Reload Page" in "merlot" instance to see the following:

Even though one instance from which the session data was added is stopped, the replicating instance continues to serve both the session values.

As explained earlier, these two instances are front-ended by a load-balancer typically running at port 80. So the user makes a request to port 80 and the correct session values are served even if one of the instance goes down and there by providing in-memory session replication.

Please leave suggestions on other TOTD that you'd like to see. A complete archive of all the tips is available here.

Technorati: totd glassfish clustering rubyonrails jruby highavailability loadbalancer

Posted by Arun Gupta in General | Comments[2]

|

|
|

Monday August 03, 2009

TOTD #88: How add pagination to Rails - will_paginate

This Tip Of The Day (TOTD) explains how to add pagination to your Rails application.

Create a simple Rails scaffold as:

~/samples/jruby >~/tools/jruby/bin/jruby -S rails paginate
~/samples/jruby/paginate >~/tools/jruby/bin/jruby script/generate scaffold book title:string author:string
~/samples/jruby/paginate >sed s/'adapter: sqlite3'/'adapter: jdbcsqlite3'/ <config/database.yml >config/database.yml.new
~/samples/jruby/paginate >mv config/database.yml.new config/database.yml
~/samples/jruby/paginate >~/tools/jruby/bin/jruby -S rake db:migrate

Edit "test/fixtures/books.yml" and specify the content as:

# Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html

one:
title: Ultramarathon Man Confessions of an All-Night Runner
author: Dean Karnazes

two:
title: My Life on the Run
author: Bart Yasso

three:
title: 50/50 Secrets I Learned Running 50 Marathons in 50 Days
author: Dean Karnazes

four:
title: Born to Run
author: Christopher Mcdougall

five:
title: Four Months to a Four-hour Marathon
author: Dave Kuehls

six:
title: Galloway's Book on Running
author: Jeff Galloway

seven:
title: Marathoning for Mortals
author: John Bingham and Jenny Hadfield

eight:
title: Marathon You Can Do It!
author: Jeff Galloway

nine:
title: Marathon The Ultimate Training Guide
author: Hal Higdon

ten:
title: Running for Mortals
author: John Bingham and Jenny Hadfield

and load the fixtures as:

~/samples/jruby/paginate >~/tools/jruby/bin/jruby -S rake db:fixtures:load
(in /Users/arungupta/samples/jruby/paginate)

Run the application as:

~/samples/jruby/paginate >~/tools/jruby/bin/jruby -S glassfish -l
Starting GlassFish server at: 129.145.132.8:3000 in development environment...
Writing log messages to: /Users/arungupta/samples/jruby/paginate/log/development.log.

. . .

Jul 29, 2009 2:06:44 PM com.sun.grizzly.scripting.pool.DynamicPool$1 run
INFO: New instance created in 7,488 milliseconds

The application is accessible at "http://localhost:3000/books" and looks like:

The page shows 10 rows, all in one page.

Lets add pagination to this simple sample.

Install will_paginate gem as:

/tools/jruby >./bin/jruby -S gem install will_paginate
JRuby limited openssl loaded. gem install jruby-openssl for full support.
http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL
Successfully installed will_paginate-2.2.2
1 gem installed
Installing ri documentation for will_paginate-2.2.2...
Installing RDoc documentation for will_paginate-2.2.2...

There are other methods of installation as well.

Edit "config/environment.rb" and add

require "will_paginate"

as the last line.
Edit the "index" action in "app/controllers/books_controller.rb" as:

@books = Book.paginate(:page => params[:page], :per_page => 5)
#@books = Book.all

":per_page" specifies the number of items to be displayed in each page.
In "app/views/books/index.html.erb", add:

<%= will_paginate @books %>

right after "</table>".

The output now looks like:

and clicking on "Next" shows:

The information is nicely split amongst 2 pages.

An important point to remember is that will_paginate only adds pagination to your Rails app. You are still required to display all the values.

But essentially replacing "@books = Book.all" with "@books = Book.paginate(:page => params[:page], :per_page => 5)" in the Controller and adding
"<%= will_paginate @books %>" did the trick for us.

Clean and simple!

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

Technorati: jruby rubyonrails glassfish pagination will_paginate

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

|

|
|

Friday July 31, 2009

TOTD #87: How to fix the error undefined method `new' for "Rack::Lock":String caused by Warbler/JRuby-Rack ?

If you are using Warbler to create a WAR file of your application and deploying on GlassFish or any other Servlet container, then you are likely seeing the following error during deployment:

[#|2009-07-30T15:29:50.788-0700|SEVERE|sun-appserver2.1|javax.enterprise.system.container.web|_ThreadID=17;
_ThreadName=httpWorkerThread-4848-0;_RequestID=1d7e8f18-1c9a-4924-bd0b-6a07eba425ba;|WebModule
[/session]unable to create shared application instance
org.jruby.rack.RackInitializationException: undefined method `new' for "Rack::Lock":String
        from /Users/arungupta/tools/glassfish/v2.1/glassfish/domains/domain1/applications/j2ee-modules/session/WEB-INF/gems/gems/actionpack-2.3.2/lib/
action_controller/middleware_stack.rb:116:in `inject'
        from /Users/arungupta/tools/glassfish/v2.1/glassfish/domains/domain1/applications/j2ee-modules/session/WEB-INF/gems/gems/actionpack-2.3.2/lib/
action_controller/middleware_stack.rb:116:in `build'
        from /Users/arungupta/tools/glassfish/v2.1/glassfish/domains/domain1/applications/j2ee-modules/session/WEB-INF/gems/gems/actionpack-2.3.2/lib/
action_controller/dispatcher.rb:82:in `initialize'

. . .

This is a known issue as reported at JRUBY-3789 and JRUBY_RACK-18.

As the bug report indicates, this is actually an issue with jruby-rack-0.9.4 and is fixed in jruby-rack-0.9.5. The 3-step workaround is described here and explained below for convenience:

Do "warble war:clean" to clean up the .war file and staging area. This basically removes previous version of jruby-rack.jar.
Download the latest jruby-rack-0.9.5 snapshot (complete list) and copy in the "lib" directory of your application.

If "config/warble.rb" does not exist then generate it using "jruby -S config warble". Edit "config/warble.rb" such that it looks like:

# Additional Java .jar files to include. Note that if .jar files are placed
# in lib (and not otherwise excluded) then they need not be mentioned here.
# JRuby and JRuby-Rack are pre-loaded in this list. Be sure to include your
# own versions if you directly set the value
# config.java_libs += FileList["lib/java/*.jar"]
config.java_libs.delete_if {|f| f =~ /jruby-rack/ }
config.java_libs += FileList["lib/jruby-rack*.jar"]

This will pack jruby-rack-0.9.5 snapshot instead of the one bundled with Warbler.

Now warbler 1.0.0 bundles "jruby-complete-1.3.0RC1.jar". Optionally, you can also download the latest jruby-complete (jruby-complete-1.3.1.jar as of this writing) and copy in the "lib" directory of your application. In that case, modify the above fragment to:

# Additional Java .jar files to include. Note that if .jar files are placed
# in lib (and not otherwise excluded) then they need not be mentioned here.
# JRuby and JRuby-Rack are pre-loaded in this list. Be sure to include your
# own versions if you directly set the value
# config.java_libs += FileList["lib/java/*.jar"]
config.java_libs.delete_if {|f| f =~ /jruby-rack/ || f =~ /jruby-complete/ }
config.java_libs += FileList["lib/jruby-complete*.jar"]
config.java_libs += FileList["lib/jruby-rack*.jar"]

This packs the "jruby-complete-1.3.1.jar" in your .war file.

And now follow your regular procedure of creating the .war file using "jruby -S warble" and happily deploy your Rails/Sintara/Merb applications on GlassFish.

There are several users who are already using Rails on GlassFish in production environment and they are listed at rubyonrails+glassfish+stories. Drop a comment on this blog if you are using it too :)

Technorati: jruby rack glassfish war servlet rubyonrails

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

|

|
|

Tuesday July 28, 2009

Track your running miles using JRuby, Ruby-on-Rails, GlassFish, NetBeans, MySQL, and YUI Charts

This blog introduces a new application that will provide basic tracking of your running distance and generate charts to monitor progress. There are numerous similar applications that are already available/hosted and this is a very basic application. What's different about this ?

The first version of this application is built using JRuby, Ruby-on-Rails, GlassFish Gem, MySQL, and NetBeans IDE. This combination of technologies is a high quality Rails stack that is used in production deploymnet at various places. Still nothing different ?

A similar version of this application will be built using a variety of Web frameworks such as Java EE, Grails, Wicket, Spring and Struts2 (in no particular order). The goal is to provide a similar application, slightly bigger than "Hello World," built using different frameworks and deploy on GlassFish. Each framework will then be evaluated based upon the criteria ranging from the basic principles of framework, ease-of-use in design/development/testing/debugging/production of this web app, database interaction, tools support, ability to add 3rd party libraries, browser compatibility and other points.

An important point to note is that this is not an exhaustive evaluation of different Web frameworks and the scope is limited only to this application.

A complete list of frameworks planned is available here. The criteria used to evaluate each framework is described here. Your feedback in terms of Web frameworks and evaluation criteria is highly appreciated. Please share your feedback on the users list.

Now the first version of application. The complete instructions to check out and run the Rails version of this application are available here.

Here are some charts generated using the application:

and

YUI is used for all the charting capabilities.

And here is a short video that explains how the application work:

If you are a runner, check out the application and use it for tracking your miles. A sample runlog is available in "test/fixtures/runlogs.yml" and races in "test/fixtures/races.yml".

If you know Rails, please provide feedback if the application is DRY and using the right set of helpers.

If you'd like the existing list of web frameworks to be pruned or include another one to the list, let us know.

Share you feedback at users@runner.kenai.com.

Technorati: jruby rubyonrails glassfish netbeans mysql yahoo yui chart running miles framework

Posted by Arun Gupta in Running | Comments[2]

|

|
|

Thursday July 02, 2009

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]

|

|
|

Tuesday June 16, 2009

TOTD #84: Using Apache + mod_proxy_balancer to load balance Ruby-on-Rails running on GlassFish

TOTD #81 explained how to install/configure nginx for load-balancing/front-ending a cluster of Rails application running on GlassFish Gem. Another popular approach in the Rails community is to use Apache HTTPD + mod_proxy_balancer. A user asked the exact details of this setup on the GlassFish Gem Forum. This Tip Of The Day (TOTD) will clearly explain the steps.

Create a simple Rails scaffold and run this application using GlassFish Gem on 3 separate ports as explained in TOTD #81.
Setup and configure HTTPD and mod_proxy_balancer

Setup and install Apache HTTPD as explained here. I believe mod_proxy_balancer and other related modules comes pre-bundled with HTTPD, at least that's what I observed with Mac OS X 10.5.7. Make sure that the "mod_proxy_balancer" module is enabled by verifying the following line is uncommented in "/etc/apache2/httpd.conf":

LoadModule proxy_balancer_module libexec/apache2/mod_proxy_balancer.so

Please note another similar file exists in "/etc/httpd/httpd.conf" but ignore that one.

Setup a mod_proxy_balancer cluster by adding the following fragment in "httpd.conf" as:

<Proxy balancer://glassfishgem>
BalancerMember http://localhost:3000
BalancerMember http://localhost:3001
BalancerMember http://localhost:3002
</Proxy>

The port numbers must exactly match with those used in the first step.

Specify the ProxyPass directives to map the cluster to a local path as:

ProxyPass / balancer://glassfishgem/
CustomLog /var/log/glassfishgem.log/apache_access_log combined

The "/" at the end of "balancer://glassfishgem" is very important to ensure that all the files are resolved correctly.
Optionally, the following directive can be added to view the access log:

CustomLog /var/log/glassfishgem.log/apache_access_log combined

Make sure to create the directory specified in "CustomLog" directive.

Now the application is accessible at "http://localhost/runlogs". If a new GlassFish instance is started then update the <Proxy> directive and restart your HTTPD as "sudo httpd -k restart". Dynamic update of BalancerMembers can be configured as explained here.

TOTD #81 started the Rails application in root context. You can alternatively start the application in a non-root context as:

~/tools/jruby/rails/runner >../../bin/jruby -S glassfish -e production -c myapp
Starting GlassFish server at: 10.0.177.178:3000 in production environment...
Writing log messages to: /Users/arungupta/tools/jruby-1.3.0/rails/runner/log/production.log.
Press Ctrl+C to stop.
. . .
~/tools/jruby/rails/runner >../../bin/jruby -S glassfish -e production -c myapp -p 3001
Starting GlassFish server at: 10.0.177.178:3001 in production environment...
Writing log messages to: /Users/arungupta/tools/jruby-1.3.0/rails/runner/log/production.log.
Press Ctrl+C to stop.
. . .
~/tools/jruby/rails/runner >../../bin/jruby -S glassfish -e production -c myapp -p 3002
Starting GlassFish server at: 10.0.177.178:3002 in production environment...
Writing log messages to: /Users/arungupta/tools/jruby-1.3.0/rails/runner/log/production.log.
Press Ctrl+C to stop.

and then the ProxyPass directive will change to:

ProxyPass /myapp/ balancer://glassfishgem/myapp/

The changes are highlighted in bold. And the application is now accessible at "http://localhost/myapp/runlogs".

After discussing on Apache HTTP Server forum, the BalancerMember host/port can be printd in the log file using a custom log format. So add the following log format to "/etc/apache2/httpd.conf":

LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-agent}i\" \"%{BALANCER_WORKER_NAME}e\"" custom

And change the format from the default "combined" to the newly defined "custom" format as:

CustomLog /var/log/glassfishgem.com/apache_access_log custom

Three subsequent invocations of "http://localhost/runlogs" then prints the following log entries:

::1 - - [17/Jun/2009:10:53:53 -0700] "GET /runlogs HTTP/1.1" 304 - "-" "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.5; en-US; rv:1.9.0.11) Gecko/2009060214 Firefox/3.0.11" "http://localhost:3002"
::1 - - [17/Jun/2009:10:54:04 -0700] "GET /runlogs HTTP/1.1" 200 621 "-" "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.5; en-US; rv:1.9.0.11) Gecko/2009060214 Firefox/3.0.11" "http://localhost:3000"
::1 - - [17/Jun/2009:10:54:05 -0700] "GET /runlogs HTTP/1.1" 304 - "-" "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.5; en-US; rv:1.9.0.11) Gecko/2009060214 Firefox/3.0.11" "http://localhost:3001"

As evident from the last fragment of each log line, the load is distributed amongst three GlassFish Gem instances. More details on load balancer algorithm are available here.

Feel free to drop a comment on this blog if you are using GlassFish in production for your Rails applications. Several stories are already available at rubyonrails+glassfish+stories.

Technorati: glassfish rubyonrails apache httpd mod_proxy_balancer loadbalancing clustering

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

|

|
|

Wednesday June 10, 2009

OPIN Systems - Financial Application using JRuby-on-Rails on GlassFish

OPIN Systems has chosen JRuby, Rails, and GlassFish for a customer-facing financial application. Why ? "Easy to setup Rails application and add more intense logic in JRuby calls"

Learn more about it in this video:

Thanks to Ben Leadholm for the quick story! Check out other GlassFish Production Stories.

Check out Ben's "Dude, Where's my pass ?" entry:

Read several other Rails/GlassFish success stories.

Technorati: conf javaone sanfrancisco glassfish rubyonrails stories

Posted by Arun Gupta in General | Comments[1]

|

|
|

Friday May 15, 2009

Ruby-on-Rails and Ramaze production deployments on GlassFish

Published three new JRuby/GlassFish production deployment stories in as many days:

Who ?	Recipe	Why GlassFish ?
	JRuby + Rails + GlassFish v2 + MySQL + Apache Web Server + memcached	The GlassFish processes have been among the most stable of our deployment. and (The) GlassFish team has been extremely helpful along the way with tuning and diagnosing performance issues.
	JRuby + Rails + GlassFish v2 + MySQL + Solaris Zones	GlassFish works and provides useful error messages.
	Recipe: JRuby + Ramaze + GlassFish v2 + MySQL/H2	What's essential for me is that I spend my time doing development, not sysadmin work, so I settle for a working solution. I've had no trouble for a few months now, and redeploy using simple scripts.

Other similar JRuby stories are available at jruby+stories. Other GlassFish stories are available here.

Technorati: jruby rubyonrails ramaze stories glassfish

Posted by Arun Gupta in General | Comments[0]

|

|
|

Tuesday May 05, 2009

Rails Conf 2009 Day 2 Trip Report

This is a follow up post from David's keynote.

Attended Women in Rails panel discussion. The panel, Sarah Mei, Lori Olson, and Desi McAdam (from L to R), had a very interesting discussion around the genuine problems and possible solutions of involving more women in Rails community.

Sarah is trying to involve more women in the San Francisco Ruby meetup. She plans to invite non-traditional audience like those who never programmed before, other language programmers, and similar. The details will be shared after performing the exercise for a year. Lori started Calgary Ruby Group. She do lot of self promotion so that younger women feel inspired. Desi is a co-founder of devChix with the purpose of "build a community of women developers". All the panelists were very vocal about being visible, having a blog and twitter presence is a good start.

Here are some random notes captured ...

Women drop out because of kids, try to get a job and then come back with a gap in the resume. It's difficult to get a new job at that time. Sarah is trying to reach out to that group who have that gap in their resume.

Visbility is important "She did that, I can do too!".

Data point: Women % in Rails community is much less than in other development community, e.g. Java or .NET world.
Another data point: % of women is more in larger companies, not in smaller companies. The reason is facilities like maternity leave, training (don't have evening hours to train themselves, can't sacrifice family time), etc.

Real stats from 2006: Women participation in open source community is 2-3%, 20-25% in "enterprise"

Appeal from the panelist "Guys, help us, tell .NET developer that Rails is not all guys, spread the word.".

Here are some Q&As captured:

Q. Should women be given free/discounted tickets to RailsConf ?
A. If women can't pay for it, then devChix can help them. RailsConf have helped before. It'll help if childcare is available.

Q. Why are we only looking at CS ? Why not other areas who have the development skills ?
A. Panel do reach out to multiple audience and seeks help from everybody in spreading the word. Women will be working on JavaScript and thinks she is designer. A guy will read 3 blog entries and thinks he is developer. There is a market salary differential between designer and developer. Women need to be more public about their programming status.

Q. Women won't present themselves as something they are not confident because they'll be called upon. How do you fix it ?
A. Everybody is learning. David's comment "I don't know everything in Rails" was commended. Girls need to know if it's important then they can figure it out. They are scared of messing the impression of their gender.

And of course there was a discussion on "Pr0ngate scandal":

Sarah: Matt is not a bad guy, he made a mistake that lot of people make in software development. If 1 out of 100 does not match the pattern of software developer, then that "1" may not be a software developer. The organizers of the conference did not do anything wrong. I voted for the talk and trust the judgement of the people. A negative feeling started developing but don't want to see that honestly. We learned something from it. As a relatively young community, this was bound to happen.

Lori: Not from the presentation itself but form the community reaction to this event. Blown out of proportion because of the same reasons when there is a conflict with developers in same company. You can't argue with somebody regarding how they feel. Can have a discussion, but argument is never going to be a win for anyone. That's where the community reaction devolved.

Desi: If Matt would've said "Oh Crap, I offended and wouldnt mean to offend you.", everything would've been fine. To David: "Next time, do us a favor and keep your mouth shut. It didn't help."

I was certainly expecting many more women to show up in the room but there were very few. Anyway, read Desi's blog entry about the panel. And I reached out to all three of them for helping in any manner :)

I presented on Develop with Pleasure, Deploy with Fun: GlassFish and NetBeans for a better Rails experience, slides here. The several concepts in the talk are explained in the following bullets:

Directory-based deployment in TOTD #71, Capistrano recipes
GlassFish Gem in TOTD #70, Capistrano recipes
Merb support in TOTD #53
Sinatra support in TOTD #80
Any Rack-based framework
nginx Deployment in TOTD #81
Apache deployment
WAR deployment in TOTD #73
NetBeans Develop/Deploy/Debug in screencast #26
JMX-based management
Project Kenai
JRuby/GlassFish Success Stories
Rails Bootcamp in San Francisco on May 19/20

The next talk of the day was JRuby: State of the Art

Why JRuby on VM ?

Best memory management
Dynamic optimizations
Reliable native threads: run threads across multiple cores
Vast number of libraries
Interop with Java, Scala, Rhino, Jython, ...
Ubiquitous

Performance

Fastest production-ready Ruby implementation
Definitely faster than 1.8.6
JRuby -> Bytecode -> Native code -> Optimizations

Future JVM Work

"invokedynamic": Build fast dynamic invocation in JVM, JRuby support by June, allow Hotspot to do all optimizations across Ruby calls
Multi-language VM "Da Vinci Machine", Optimized tail calls, continuations, fixnums, value types

Threading

Only production-ready impl with real threads
Ruby thread is a normal thread that can run on multiple cores

Simple Rails App

1 Controller/Mode/View, send 1000 reqs
80% less memory in 10 instance example, 96% for 20 instances

GlassFish

Gem, WAR-based
nginx, Apache: mod_proxy

Ruby 1.9 is 80-90% complete, IRB works, RubyGems works

FFI

Call C functions directly from Ruby
Portable unlike extensions

Who uses JRuby ?

Kenai
Gravitor
King Pong (JRuby wrapping MonkeyEngine)
Oslo's Gardermoen Airport to refuel planes
ThoughtWorks Mingle

No cross-platform SVN libraryfor Ruby
Bundling of installation
Security (ecnrypting source code)
Memory profile
Avoiding process proliferation

mix.oracle.com

5 developers, 6 weeks for all development, 2887 LOC

Trisano: Open source infectious disease reporting system

Ease of deployment
Every enterprise on the planet run Java
Extensive project roadmap

Check out interactive Q & A from the session in the following video fragment:

Click To Play

Later in the evening, Brian Helmkamp, Aman Gupta, Luis Navena, Pat Allan, Dan Kubb, and John Nunemaker were awarded Ruby Heroes Award!

And the keynote by Tim Ferris, lets not talk about it ;-) I edited pictures, authored my blog, caught up on email/RSS during the keynote. #railconf on IRC and twitter were way more fun! Check the live ratings.

"1" was the lowest rating that could be given anyway!

Watch the interview on why Sea Change Affinity picked JRuby/GlassFish.

Finally watch some of the snapshots captured today:

And then the evolving album:

Technorati: conf railsconf lasvegas jruby rubyonrails glassfish netbeans

Posted by Arun Gupta in General | Comments[0]

|

|
|

Sea Change Affinity - Why JRuby/GlassFish ?

At Rails Conf 2009, Jay McGaffigan from Sea Change talked about why they choose JRuby/GlassFish for their product Affinity. Here are some of the reasons he quoted:

Performance characterisitics (of GlassFish) have been excellent
Picked GlassFish based upon the recommendations from the people in industry
Dramatically more throughput on our GlassFish installation, 400 requests/sec instead of 100 requests/sec comapred to Tomcat

Watch the interview recorded earlier today:

Read other simiar stories at glassfish+rubyonrails+stories.

Technorati: jruby rubyonrails glassfish stories

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

|

|
|

Monday May 04, 2009

Rails Conf 2009 - Day 1 Trip Report

Rails Conf 2009 started this morning. The first day consists of morning and afternoon tutorials.

I attended Nick Sieger's JRuby on Rails tutorial, the slides are available. A survey in the room showed:

95% comfortable with Ruby/Rails
80% have used JRuby
10% use JRuby actively

Here are some of the key points highlighted in the tutorial:

Why JRuby ?

JRuby is "Less Bitter Java", after all Java is a great platform.
Concurrency (Native threading)
Reliability (well-behaved because of Hotspot compiler, no process monitoring, etc)
Encapsulation (take a Rails application, bundle it as a single deployable artifact that is fully contained)
Choice (Any Java application server, huge breadth of Java libraries, and can write thin Ruby wrappers around Java libraries)

Download JDK 5 minimum, JDK 6 preferred, MySQL 5.x, JRuby 1.2 (1.3.0 RC1 OK too), GlassFish v2.1 b60e

Common options

--server: Run with server VM, better performance
--headless: No UI
--properties: Show tweaks for compiler, JIT compiling, thread pooling etc
-J<java-opt>: Pass any Java properties
-J-Xmx1G: Increase memory to 1G

Drawbacks: No fork(), No native extensions (for example ParseTree, EventMachine, RMagic cannot be used), No tty for subprocesses, Startup time slow for short scripts

Advantages: Improved versions of some Ruby APIs (tempfile, mutex, thread, timeout), 1.8 and 1.9 in a single install (jruby --1.9), Wrap Java libraries and APIs in Ruby

The slides have much more details in terms of deployment options (WAR-based, GlassFish Gem), and many other interesting details Scroll to slide #68 to understand all the guts of kenai.com - a real life application running using JRuby, Rails, and GlassFish.

The afternoon tutorial for me was A Hat Full of Tricks with Sinatra. The tutorial was completely code driven with no slides, just love that format!

The tutorial started with a brief introduction to Rack. A basic Rack application can be "config.ru" or "app.rb", lets start with "config.ru" Hello World:

run lambda { |env|
[
    200,
    {
    'Content-Length' => '2',
    'Content-Type' => 'text/html',
    },
    ["hi"]
]
}

Run it as ...

~/samples/railsconf/sinatra/basic-rack >~/tools/jruby/bin/jruby -S rackup
[2009-05-04 13:40:18] INFO WEBrick 1.3.1
[2009-05-04 13:40:18] INFO ruby 1.8.6 (2009-03-16) [java]
[2009-05-04 13:40:18] INFO WEBrick::HTTPServer#start: pid=90964 port=9292
127.0.0.1 - - [04/May/2009 13:40:27] "GET / HTTP/1.1" 200 2 0.0160
127.0.0.1 - - [04/May/2009 13:40:27] "GET /favicon.ico HTTP/1.1" 200 2 0.0060
127.0.0.1 - - [04/May/2009 13:40:30] "GET /favicon.ico HTTP/1.1" 200 2 0.0100

"config.ru" is the default Rackup script, otherwise need to specify the name. And now "app.rb" ..

App = lambda { |env|
[
    200,
    {
    'Content-Length' => '2',
    'Content-Type' => 'text/html',
    },
    ["hi"]
]
}

And run it as ...

~/samples/railsconf/sinatra/basic-rack >~/tools/jruby/bin/jruby -S rackup app.rb
[2009-05-04 13:43:57] INFO WEBrick 1.3.1
[2009-05-04 13:43:57] INFO ruby 1.8.6 (2009-03-16) [java]
[2009-05-04 13:43:57] INFO WEBrick::HTTPServer#start: pid=90990 port=9292
127.0.0.1 - - [04/May/2009 13:44:09] "GET / HTTP/1.1" 200 2 0.0110

In both cases, the application is accessible at "http://localhost:9292".

Change the basic "config.ru" to convert into a class as ...

class BasicRack
     def call(env)
    body = "Hello from a class"
    [
        200,
        {
        'Content-Length' => body.size.to_s,
        'Content-Type' => 'text/html',
        },
        [body]
    ]
    end
end

run BasicRack.new

and run the same way as earlier.

Change body to "env.inspect" to see an output as:

Sinatra allows reloading of application but that "feature" will be removed soon. Instead install shotgun (which does not work with JRuby yet!). Anyway, install the gem:

~/samples/railsconf/sinatra/basic-rack >~/tools/jruby/bin/jruby -S gem install shotgun
JRuby limited openssl loaded. gem install jruby-openssl for full support.
http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL
Successfully installed configuration-0.0.5
Successfully installed launchy-0.3.3
Successfully installed shotgun-0.2
3 gems installed
Installing ri documentation for launchy-0.3.3...
Installing RDoc documentation for launchy-0.3.3...

And run as:

~/samples/railsconf/sinatra/basic-rack >~/tools/jruby/bin/jruby -J-Djruby.fork.enabled=true -S shotgun
[2009-05-04 13:55:46] INFO WEBrick 1.3.1
[2009-05-04 13:55:46] INFO ruby 1.8.6 (2009-03-16) [java]
== Shotgun starting Rack::Handler::WEBrick on localhost:9393
[2009-05-04 13:55:46] INFO WEBrick::HTTPServer#start: pid=91089 port=9393

Process separate bodies depending upon the info:

class BasicRack
     def call(env)
    body = if env["PATH_INFO"] == "/foo"
        "in foo"
    else
       "in other"
    end
    [
        200,
        {
        'Content-Length' => body.size.to_s,
        'Content-Type' => 'text/html',
        },
        [body]
    ]
    end
end

run BasicRack.new

Accessing "http://localhost:9292/foo" shows "in foo" and accessing "http://localhost:9393" shows "in other".

Target application is the last application specified by "run".

Rack supports middleware which are like filters, they can applied before/after a message is processed.

Rack will initialize middleware at load, so hold on to that application as shown:

class BasicRackApp
     def call(env)
    body = "hello from app"
    [
        200,
        {
        'Content-Length' => body.size.to_s,
        'Content-Type' => 'text/html',
        },
        [body]
    ]
    end
end

class MyMiddleware
    def initialize(app)
        @app = app
    end

    def call(env)
        @app.call(env)
    end
end

use MyMiddleware

run BasicRackApp.new

@app.call calls the next middleware in the chain.

Rack comes with couple of standard middleware, e.g.:

use Rack::CommonLogger

Example of an after filter:

    def call(env)
        status, headers, body = @app.call(env)
        body.map! { |part| part.upcase}
        [status, headers, body]
    end

Lots of other filters available.

With a basic Rack understanding, lets build a Sinatra app:

require 'sinatra'

is the simplest Sinatra application. Save it in a file "basic-sinatra.rb" and run it as:

~/samples/railsconf/sinatra/basic-sinatra >~/tools/jruby/bin/jruby -rubygems basic-sinatra.rb
== Sinatra/0.9.1.1 has taken the stage on 4567 for development with backup from WEBrick
[2009-05-04 14:40:14] INFO WEBrick 1.3.1
[2009-05-04 14:40:14] INFO ruby 1.8.6 (2009-03-16) [java]
[2009-05-04 14:40:14] INFO WEBrick::HTTPServer#start: pid=91396 port=4567

The application is now available at "http://localhost:4567". BTW, this app can easily be run using GlassFish Gem as explained in TOTD #79. Add a simple GET method and "not_found" handler as:

require 'rubygems'
require 'sinatra'

not_found do
'hi from other'
end

get '/foo' do
'hi from foo'
end

Every time a request comes in, it builds a request context, instance evals lambda and finds the one that hits.

Sinatra takes care of status and headers, the application needs to process the body.

Another one ...

require 'rubygems'
require 'sinatra'

get '/env' do
env.inspect
end

And it shows Rack environment hash at 'http://localhost:4567".

Another one ...

require 'rubygems'
require 'sinatra'

get '/' do
end

post '/' do
end

put '/' do
end

delete '/' do
end

This adds 4 HTTP methods with different routes.

No explicit render method, e.g.

require 'rubygems'
require 'sinatra'

get '/' do
content_type "application/json"
{ "foo" => "goo" }.to_json
end

No ".rhtml.erb" or ".json.erb", instead it's just ".erb". Add "views/index.erb" as:

<html>
<body>
Hello form Sinatra + ERB
</body>
</html>

And change GET method to:

require 'rubygems'
require 'sinatra'

get '/' do
erb :index
end

And the application now uses ERB templating.

Using HAML templates is simple, change to:

require 'rubygems'
require 'sinatra'
require 'haml'

get '/' do
haml :index
end

And add "views/index.haml" as:

%html
%body
%h1 Hello from HAML

And now the application is using HAML templates.

__END__ is the end of Ruby, can be anything after that and it'll not barf. Sinatra uses it for in file templates:

require 'rubygems'
require 'sinatra'
require 'haml'

get '/' do
erb :index
end

use_in_file_templates!

__END__

@@ index

<html>
<body>
Hello form Sinatra + ERB in file
</body>
</html>

Start with in-file templates, and then move out to separate directory ("views") once grows big. But no syntax highlighting etc.

Add your custom template as:

require 'rubygems'
require 'sinatra'
require 'haml'

get '/' do
erb :index
end

get '/foo' do
erb :foo
end

use_in_file_templates!

__END__

@@ index

<html>
<body>
Hello form Sinatra + ERB in file
</body>
</html>

@@ foo
<h1>FOO!</h1>

With this file "http://localhost:4567/" uses ERB template, and "http://localhost:4567/foo" uses "foo" template.

Sinatra defines on Main. The before filters work before every single request, executed in the same context as lambda. Can be used if every request needs to do some setup.

Helpers can be defined as:

require 'rubygems'
require 'sinatra'
require 'haml'

helpers do

end

without defining on Main. Or ...

require 'rubygems'
require 'sinatra'
require 'haml'

module helpers
    def self.dosomething(arg)
    end
end

get '/' do
    Helpers.dosomething
end

Don't define something on Main, it's a bad practice.

Extension is a nice package that can be shared for other Sinatra developers to use, like Rails plugins but does not have boilerplate, much easier to do.

Rest of tutorial was quite fast paced so the code samples could not be captured. But there is boatload of information available at sinatrarb.com.

Check out the pictures from Day 1:

The evening concluded with dinner at Burger Bar at Mandalay Bay along with Project Kenai team.

And check the evolving album at:

On to GlassFish talk tomorrow, and running with @railsConfRunner in the morning before that :)

Technorati: conf railsconf lasvegas jruby rubyonrails sinatra glassfish

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

|

|
|

Friday May 01, 2009

JRuby, Rails, and GlassFish Bootcamp - San Francisco, May 19/20, 2009

Would you like to power up your Rails applications using JRuby and GlassFish ? And learn that from the engineers who develop the technology.

If yes, then we have organized a bootcamp for you!

Day 1 (FREE) of this bootcamp provides an introduction to JRuby and GlassFish and how they serve as an excellent development and deployment environment for Rails applications. Starting with clean slate on your laptop, you'll be able to setup JRuby, Rails, GlassFish and learn about different options available for running your applications.

Day 2 (need $$$) takes a deep dive on each topic and convert you into a power user instantaneously. The topics range from Virtual Machine tuning for JRuby and GlassFish, Warbler tricks, Java EE integration, Deployment strategies, Monitoring applications to Running other Rack-based frameworks. Lunch and beverages will be served on Day 2.

On both days, you get an opportunity to practice everything on your laptop by following the experts along.

Complete details on venue, time, agenda, etc are available at railscamp.eventbrite.com.

Register now before the seats fill out. And get ready to be drenched!

Technorati: conf jruby rubyonrails glassfish netbeans bootcamp sanfrancisco

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

|

|
|

Thursday April 30, 2009

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.

nginx is known for it's high performance and low resource consumption. It's a fairly popular front-end HTTP server in the Rails community along with Apache, Lighttpd, and others. This TOTD (Tip Of The Day) will show how to install/configure nginx for load-balancing/front-ending a cluster of Rails application running on GlassFish Gem.

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:

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

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.

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:

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.
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.

Restart nginx by using the following commands:

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

Now "http://localhost" shows the default Rails page as shown below:

"http://localhost/runlogs" now serves the page from the deployed Rails application.

Now lets configure logging so that the upstream server IP address and port are printed in the log files. In "nginx.conf", uncomment "log_format" directive and add "$upstream_addr" variable as shown:

log_format main '$remote_addr - [$upstream_addr] $remote_user [$time_local] $request '
                      '"$status" $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log logs/access.log main;

Also change the log format to "main" by uncommenting "access_log logs/access.log main;" line as shown above (default format is "combined"). Accessing "http://localhost/runlogs" shows the following lines in "logs/access.log":

127.0.0.1 - [127.0.0.1:3000] - [29/Apr/2009:15:27:57 -0700] GET /runlogs/ HTTP/1.1 "200" 3689 "-" "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_5_6; en-us) AppleWebKit/525.27.1 (KHTML, like Gecko) Version/3.2.1 Safari/525.27.1" "-"
127.0.0.1 - [127.0.0.1:3001] - [29/Apr/2009:15:27:57 -0700] GET /favicon.ico HTTP/1.1 "200" 0 "http://localhost/runlogs/" "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_5_6; en-us) AppleWebKit/525.27.1 (KHTML, like Gecko) Version/3.2.1 Safari/525.27.1" "-"
127.0.0.1 - [127.0.0.1:3002] - [29/Apr/2009:15:27:57 -0700] GET /stylesheets/scaffold.css?1240977992 HTTP/1.1 "200" 889 "http://localhost/runlogs/" "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_5_6; en-us) AppleWebKit/525.27.1 (KHTML, like Gecko) Version/3.2.1 Safari/525.27.1" "-"

The browser makes multiple requests (3 in this case) to load resources on a page and they are nicely load-balanced on the cluster. If an instance running on port 3002 is killed, then the access log show the entries like:

127.0.0.1 - [127.0.0.1:3000] - [29/Apr/2009:15:28:53 -0700] GET /runlogs/ HTTP/1.1 "200" 3689 "-" "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_5_6; en-us) AppleWebKit/525.27.1 (KHTML, like Gecko) Version/3.2.1 Safari/525.27.1" "-"
127.0.0.1 - [127.0.0.1:3002, 127.0.0.1:3000] - [29/Apr/2009:15:28:53 -0700] GET /favicon.ico HTTP/1.1 "200" 0 "http://localhost/runlogs/" "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_5_6; en-us) AppleWebKit/525.27.1 (KHTML, like Gecko) Version/3.2.1 Safari/525.27.1" "-"
127.0.0.1 - [127.0.0.1:3001] - [29/Apr/2009:15:28:53 -0700] GET /stylesheets/scaffold.css?1240977992 HTTP/1.1 "200" 889 "http://localhost/runlogs/" "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_5_6; en-us) AppleWebKit/525.27.1 (KHTML, like Gecko) Version/3.2.1 Safari/525.27.1" "-"

The second log line shows that server running on port 3002 did not respond and so it automatically fall back to 3000, this is nice!

But this is inefficient because a back-end trip is made even for serving a static file ("/favicon.ico" and "/stylesheets/scaffold.css?1240977992"). This can be easily solved by enabling Rails page caching as described here and here.

More options about logging are described in NginxHttpLogModule and upstream module variables are defined in NginxHttpUpstreamModule.

Here are some nginx resources:

Are you using nginx to front-end your GlassFish cluster ?

Apache + JRuby + Rails + GlassFish = Easy Deployment! shows similar steps if you want to front-end your Rails application running using JRuby/GlassFish with Apache.

Hear all about it in Develop with Pleasure, Deploy with Fun: GlassFish and NetBeans for a Better Rails Experience session at Rails Conf next week.

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

Technorati: rubyonrails glassfish v3 gem jruby nginx loadbalancing clustering

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

|

|
|

Monday April 27, 2009

GlassFish, NetBeans, and Project Kenai at Rails Conf 2009

Did you know that ...

GlassFish Gem is already used in production
GlassFish Gem can be used to run Rails, Merb, Sinatra, and any other Rack-based framework
Capistrano recipes are available for starting/stopping/bouncing the server
With GlassFish, standard Java monitoring techniques like JMX can be used for monitoring Rails apps
NetBeans provide a complete development environment for Rails applications

There are many other similar nuggets that I'll be covering in my Rails Conf 2009 session. Details are given below:

Develop with pleasure, Deploy with Fun: GlassFish and NetBeans for a better Rails experience
Tuesday, May 5th, 2009, 1:50pm
Pavilion 1

Register Today and avail a 15% discount using the code: RC09FOS.

I plan to attend these sessions, lets see how many I can make :-) And of course, you'll see me in the Exhibit Hall.

And you'll get to meet Project Kenai team, they form the foundation for Sun's connected developer experience. Read about their participation here and meet them to learn about NetBeans and Kenai integration.

And if you are interested in running with fellow attendees, follow @railsConfRunner.

And it's Vegas baby!

JRuby and GlassFish is already used in production. Do you have a success story to share ? I'll be happy to promote at RailsConf.

Technorati: conf glassfish netbeans rubyonrails kenai railsconf lasvegas jruby

Posted by Arun Gupta in General | Comments[5]

|

|
|