Arun Gupta, Miles to go ...

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]

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]

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

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

1. Create a Rails application as:
   
   

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

   
   The generated "database.yml" looks like:
   
   

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

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

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

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

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

5. Create a simple scaffold as shown below:
   
   

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

   
   and run the migration as
   
   

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

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

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

7. Run the application on GlassFish v3 gem as:
   
   

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

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

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

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

TOTD# 36: Writing First Test for a Rails Application

I've created a Rails "Hello World" app numerous times. But I decided to write a simple using the testing framework provided by Rails. This blog explains my experience of writing such a test.

1. Create a "Hello World" app as:
   
   

   ~/samples/jruby/test >~/testbed/jruby-1.1.2/bin/jruby -S rails helloworld               create        create  app/controllers       create  app/helpers       create  app/models       create  app/views/layouts       create  config/environments       create  config/initializers . . .       create  log/production.log       create  log/development.log       create  log/test.log

   
   There is no "-d mysql" in the command because I don't expect this application to do any database access. The database access is disabled by following TOTD #26.
2. I tried generating a new controller using the command:
   
   

   ~/samples/jruby/test/helloworld >~/testbed/jruby-1.1.2/bin/jruby script/generate controller home index

   
   and got the error:
   
   

   JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL /Users/arungupta/testbed/jruby-1.1.2/lib/ruby/gems/1.8/gems/activesupport-2.1.0/lib/active_support/dependencies.rb:278:in `load_missing_constant': uninitialized constant ActiveRecord (NameError)         from /Users/arungupta/testbed/jruby-1.1.2/lib/ruby/gems/1.8/gems/activesupport-2.1.0/lib/active_support/dependencies.rb:467:in `const_missing'         from /Users/arungupta/testbed/jruby-1.1.2/lib/ruby/gems/1.8/gems/activesupport-2.1.0/lib/active_support/dependencies.rb:479:in `const_missing'         from /Users/arungupta/samples/jruby/test/helloworld/config/initializers/new_rails_defaults.rb:5:in `/Users/arungupta/samples/jruby/test/helloworld/config/initializers/new_rails_defaults.rb'         from /Users/arungupta/samples/jruby/test/helloworld/config/initializers/new_rails_defaults.rb:502:in `load'         from /Users/arungupta/testbed/jruby-1.1.2/lib/ruby/gems/1.8/gems/activesupport-2.1.0/lib/active_support/dependencies.rb:502:in `load'         from /Users/arungupta/testbed/jruby-1.1.2/lib/ruby/gems/1.8/gems/activesupport-2.1.0/lib/active_support/dependencies.rb:354:in `new_constants_in'         from /Users/arungupta/testbed/jruby-1.1.2/lib/ruby/gems/1.8/gems/activesupport-2.1.0/lib/active_support/dependencies.rb:502:in `load'         from /Users/arungupta/testbed/jruby-1.1.2/lib/ruby/gems/1.8/gems/rails-2.1.0/lib/initializer.rb:475:in `load_application_initializers'          ... 8 levels...         from /Users/arungupta/testbed/jruby-1.1.2/lib/ruby/gems/1.8/gems/rails-2.1.0/lib/commands/generate.rb:27:in `require'         from /Users/arungupta/testbed/jruby-1.1.2/lib/ruby/site_ruby/1.8/rubygems/custom_require.rb:27:in `require'         from script/generate:3

   
   So even though database access has been explicitly disabled, there are still references to ActiveRecord. So I had to explicitly disable them by changing the code in "config/initializers/new_rails_defaults.rb" as:
   
   

   if defined?(ActiveRecord) # Include Active Record class name as root for JSON serialized output. ActiveRecord::Base.include_root_in_json = true # Store the full class name (including module namespace) in STI type column. ActiveRecord::Base.store_full_sti_class = true end

   
   and then the controller is easily generated as:
   
   

   ~/samples/jruby/test/helloworld >~/testbed/jruby-1.1.2/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  app/controllers/home_controller.rb       create  test/functional/home_controller_test.rb       create  app/helpers/home_helper.rb       create  app/views/home/index.html.erb

3. Run your application using GlassFish v3 gem as:
   
   

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

4. Chapter 9 in Rails Manual explains how to test controllers. Modify "test/functional/home_controller_test.rb" as:
   
   

   require 'home_controller' class HomeControllerTest < ActionController::TestCase   def test_index     get :index     assert_response :success   end end

5. Run the test as:
   
   

   ~/workspaces/glassfish-scripting/rails/v3/src/test/rails/helloworld >~/testbed/jruby-1.1.2/bin/jruby -S rake test (in /Users/arungupta/workspaces/glassfish-scripting/rails/v3/src/test/rails/helloworld) /Users/arungupta/testbed/jruby-1.1.2/bin/jruby -Ilib:test "/Users/arungupta/testbed/jruby-1.1.2/lib/ruby/gems/1.8/gems/rake-0.8.1/lib/rake/rake_test_loader.rb"   /Users/arungupta/testbed/jruby-1.1.2/bin/jruby -Ilib:test "/Users/arungupta/testbed/jruby-1.1.2/lib/ruby/gems/1.8/gems/rake-0.8.1/lib/rake/rake_test_loader.rb" "test/functional/home_controller_test.rb" JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL Loaded suite /Users/arungupta/testbed/jruby-1.1.2/lib/ruby/gems/1.8/gems/rake-0.8.1/lib/rake/rake_test_loader Started . Finished in 0.308 seconds. 1 tests, 1 assertions, 0 failures, 0 errors /Users/arungupta/testbed/jruby-1.1.2/bin/jruby -Ilib:test "/Users/arungupta/testbed/jruby-1.1.2/lib/ruby/gems/1.8/gems/rake-0.8.1/lib/rake/rake_test_loader.rb"

   
   

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

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

TOTD #35: Rails Database Connection on Solaris

Are you deploying your JRuby-on-Rails applications on Solaris (or any variety of Unix) and not able to connect to the database ?

I experienced it last week so thought of sharing the tip here. Luckily it's really simple.

Here is the default generated "config/database.yml"

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

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

TOTD #32: Rails Deployment on GlassFish v3 from NetBeans IDE

Rails powered by the GlassFish Application Server explains all the benefits of using GlassFish for developing and deploying your Rails applications. If you are using NetBeans 6.1 builds then you can deploy your Rails application directly on GlassFish v3 from within NetBeans IDE. No longer you need to have different development and deployment options.

This blog explains how to install a bleeding-edge GlassFish v3 plugin and use it to deploy your Rails app natively on GlassFish (no WAR or anything :). Let's get started! Note, this plugin is bleeding edge and will soon be released on the Beta Update Center.

1. Install "GlassFish v3 TP2" plugin in NetBeans 6.1
1. In NetBeans 6.1 IDE, go to "Tools", "Plugins" and click on "Settings". The following window is shown:
   
   
   
2. Click on "Add" and specify the URL of Bleeding Edge Update Center values as shown (copy from "http://deadlock.netbeans.org/hudson/job/javadoc-nbms/lastSuccessfulBuild/artifact/nbbuild/nbms/updates.xml.gz"):
   
   
   
   Click on "OK". The updated "Plugins" window looks like:
   
   
   
   
   Notice "Available Plugins" has changed from 58 to 140 as many more bleeding edge plugins are now available.
3. Click on "Available Plugins" and search for "GlassFish" in the top-right corner text box as shown below:
   
   
   
4. Select "GlassFish V3 JRuby Integration" and "GlassFish V3 JavaEE Integration" plugin and click on "Install" as shown below:
   
   
   
   Follow the instructions to install the plugin. The IDE needs to restart for successful plugin installation.
5. In the restarted IDE,  go to "Services" tab, right-click on "Servers" and select "Add Server...". Select "GlassFish v3 TP2" as shown below:
   
   
   
6. Select "Next >", accept the license agreement and click on "Download V3 Now..."
   
   
   
   Click on "Download V3 Now...". This downloads the latest GlassFish v3 TP2 build and installs in "/Users/arungupta/GlassFish_V3_TP2" directory. This is only an interim build, final TP2 build will be available soon! The following screen is shown once GlassFish v3 is installed:
   
   
   
   Click on "Finish". In 58 seconds, you downloaded and installed the entire GlassFish v3 app server, cool isn't it!
2. Create a Rails app and deploy on GlassFish V3
1. In NetBeans IDE, in the "Projects" tab, right-click and select "New Project...". Select "Ruby" in "Categories" and "Ruby on Rails Applications" in "Projects" as shown:
   
   
   
   Click on "Next".
2. Now comes the cool part. Enter the application name and select the recently installed GlassFish v3 as shown:
   
   
   
   This is a brand new feature in the "GlassFish v3 TP2" plugin available only on "Bleeding Edge" Update Center. It'll soon replace the default GlassFish v3 plugin from the Beta Update Center.
   
   Click on "Finish" to take all other defaults.
3. On the newly created project, right-click and select "Run" as shown:
   
   
4. The default browser page "http://localhost:8080/" shows up. Change the URL to "http://localhost:8080/HelloRails" and the following page shows up:
   
   

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

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

TOTD #28: Getting Started with Rails 2.0 Scaffold

Rails 2.0 changes the way Scaffold works. This blog walks you through the steps to create a simple CRUD application using Scaffold in Rails 2.0.

1. Download & Install JRuby 1.1 RC2.
2. Install Rails using the following command:
   
   jruby -S gem install rails
3. Create a new Rails app using the following command:
   
   cd samples; mkdir rails; cd rails
jruby -S rails books -d mysql
4. Start MySQL server in a different shell using the following command:
   
   sudo /usr/local/mysql/bin/mysqld_safe --console
5. Creat the database using the following command:
   
   cd books
jruby -S rake db:create

   This creates the database defined by RAILS_ENV (Development is default). Here are some other new database-related commands:
   
   

   db:create:all	Create all the databases (_Development, _Test, _Production)
   db:drop	Drops your database
   db:reset	Drop and Re-create your database, including migrations

6. Generate a scaffold using the following command:
   
jruby script/generate scaffold book title:string author:string isbn:string description:text
   
   The output of the command looks like:
   
      exists  app/models/
      exists  app/controllers/
      exists  app/helpers/
      create  app/views/books
      exists  app/views/layouts/
      exists  test/functional/
      exists  test/unit/
      create  app/views/books/index.html.erb
      create  app/views/books/show.html.erb
      create  app/views/books/new.html.erb
      create  app/views/books/edit.html.erb
      create  app/views/layouts/books.html.erb
      create  public/stylesheets/scaffold.css
  dependency  model
      exists    app/models/
      exists    test/unit/
      exists    test/fixtures/
      create    app/models/book.rb
      create    test/unit/book_test.rb
      create    test/fixtures/books.yml
      create    db/migrate
      create    db/migrate/001_create_books.rb
      create  app/controllers/books_controller.rb
      create  test/functional/books_controller_test.rb
      create  app/helpers/books_helper.rb
      route  map.resources :books
   
   There is no need to create the model explicitly as was the case in previous version of Rails. This creates the "db/migrate/001_create_books.rb" migration which looks like:
   
   class CreateBooks < ActiveRecord::Migration
  def self.up
    create_table :books do |t|
      t.string :title
      t.string :author
      t.string :isbn
      t.text :description

      t.timestamps
    end
  end

  def self.down
    drop_table :books
  end
end
7. Create the database tables using the following command:
   
   jruby -S rake db:migrate
8. Deploy the application on WEBrick using the following command:
   
jruby script/server
   
   The application is now available at "http://localhost:3000/books" and looks like:
   
   
   
9. Click on "New book" to see a page as shown below (with values entered):
   
   
   Click on Create button. After 2 entries have been entered, it looks like as shown below:
   
   

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

TOTD #27: Configurable Multiple Ruby Platforms in NetBeans 6.1 M1

NetBeans 6.1 M1 is now available. Download here!

There are several features in M1. But the feature I liked the most is storing multiple Ruby/JRuby runtime configurations in the IDE. In NetBeans 6.0 only one Ruby platform could be configured and stored. So if you have to change to another Ruby environment then you have to edit the values in the IDE. 6.1 M1 allows to configure and store multiple Ruby/JRuby runtimes. Click on "Tools", "Ruby Platforms" and you are presented with the following window:

I've already added JRuby 1.0.3 as an additional platform. And then you can choose the Ruby/JRuby runtime when creating the Rails application as shown below:

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

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

TOTD #26: Overriding Database Defaults in Rails 2.0.2

A Rails 2.0.2 application configures SQLite3 database by default. This requires you to have SQLlite3 database running and also have the corresponding database adapter installed. Even this is part of the Leopard (Mac OS 10.5+) development kit but this needs extra configuration on non-Leopard machines.

One of the guiding principles of Rails is Convention-over-Configuration. So there are couple of ways you can override this default:

1. Generate the Rails app by specifying the database of your choice. So if you want to use MySQL as the default database, then generate the application as:
   
   jruby -S rails -d mysql myapp
   
   This is assuming you are using JRuby for generating your Rails application.
2. If you want to use Rails without a database, remove ActiveRecord framework by editing "config/environment.rb" and adding the line:
   
   config.frameworks -= [ :active_record ]
   
   Alternatively you can uncomment line 21 in "environment.rb" and remove other frameworks from inside the parentheses.

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

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

TOTD #24: Getting Started with Rails 2.0.x in JRuby 1.0.3 and JRuby 1.1RC1

This TOTD (Tip Of The Day) shows how to install Rails 2.0.x in JRuby 1.0.3 and JRuby 1.1 RC1. Then it describes how a simple Rails application can be created and deployed using WEBrick.

First, lets deal with installing Rails 2.0.x in JRuby 1.0.3 and JRuby 1.1 RC1.

Step 1: How to install Rails 2.0.x in JRuby 1.0.3 ?

• Download and Unzip JRuby 1.0.3. This creates "jruby-1.0.3" directory.
• Install Rails by giving the following command in the newly created directory:
  
  bin/jruby -S gem install rails --include-dependencies --no-ri --no-rdoc
Bulk updating Gem source index for: http://gems.rubyforge.org
Successfully installed rails-2.0.2
Successfully installed activesupport-2.0.2
Successfully installed activerecord-2.0.2
Successfully installed actionpack-2.0.2
Successfully installed actionmailer-2.0.2
Successfully installed activeresource-2.0.2

Step 2: How to install Rails 2.0.x in JRuby 1.1RC1?

• Download and Unzip JRuby 1.1 RC1. This creates "jruby-1.1RC1" directory.
• Install Rails by giving the following command in the newly created directory:
  
  bin/jruby -S gem install rails --no-ri --no-rdoc
Updating metadata for 632 gems from http://gems.rubyforge.org
................................................................................................................
................................................................................................................
................................................................................................................
................................................................................................................
................................................................................................................
........................................................................
complete
Successfully installed activesupport-2.0.2
Successfully installed activerecord-2.0.2
Successfully installed actionpack-2.0.2
Successfully installed actionmailer-2.0.2
Successfully installed activeresource-2.0.2
Successfully installed rails-2.0.2
6 gems installed

Step 3: How to create and deploy a trivial Rails app ?

1. Create the application
1. Create a Rails template app by giving the following command:
   
   jruby -S rails --database mysql hello
2. Create Controller and View by giving the following command:
   
   cd hello
jruby script/generate controller say hello
3. Edit Controller by giving the following command:
   
   vi app/controllers/say_controller.rb
   
   and updating the "hello" helper method to look like:
   
   def hello
    @hello_string = "Hello from Rail 2.0.2!!"
end
4. Edit View by giving the following command:
   
   vi app/views/say/hello.html.erb
   
   and adding the following line at the end:
   
   <%= @hello_string %>
2. Rails 2.0 default is to configure a database for the application. Following Convention-over-Configuration, either the defaults can be taken in which case you need to configure the database. Or override the convention by specifying "config.frameworks -= [ :active_record, :action_mailer ]" in "config/environment.rb". Follow the steps below if you prefer configuring the database:
1. Start MySQL server by giving the following command:
   
   sudo /usr/local/mysql/bin/mysqld_safe --user root
Starting mysqld daemon with databases from /usr/local/mysql/data
2. Create development database by giving the following command:
   
   jruby -S rake db:create
3. Test the App
1. Start WEBrick, using JRuby 1.0.3, by giving the following command:
   
   jruby script/server
=> Booting WEBrick...
=> Rails application started on http://0.0.0.0:3000
=> Ctrl-C to shutdown server; call with --help for options
[2008-02-05 23:35:02] INFO  WEBrick 1.3.1
[2008-02-05 23:35:02] INFO  ruby 1.8.5 (2007-12-15) [java]
[2008-02-05 23:35:02] INFO  WEBrick::HTTPServer#start: pid=13446204 port=3000

   The application is now accessible at http://localhost:3000/say/hello. Accessing the application shows the following output in console:
   
   127.0.0.1 - - [05/Feb/2008:23:35:31 PST] "GET /say/hello HTTP/1.1" 200 89
- -> /say/hello
127.0.0.1 - - [05/Feb/2008:23:35:32 PST] "GET /say/hello HTTP/1.1" 200 89
- -> /say/hello
127.0.0.1 - - [05/Feb/2008:23:35:32 PST] "GET /say/hello HTTP/1.1" 200 89
- -> /say/hello
   
2. Start WEBrick using JRuby 1.1RC1, then the following output is shown:
   
   => Booting WEBrick...
=> Rails application started on http://0.0.0.0:3000
=> Ctrl-C to shutdown server; call with --help for options
[2008-02-05 23:37:43] INFO  WEBrick 1.3.1
[2008-02-05 23:37:43] INFO  ruby 1.8.6 (2008-01-07) [java]
[2008-02-05 23:37:43] INFO  WEBrick::HTTPServer#start: pid=2533 port=3000

   Note, that even though the application was created using JRuby 1.0.3, it can be easily invoked using JRuby 1.1RC1 because they are using the same Rails version. Accessing the application in this case shows the following output:
   
127.0.0.1 - - [05/Feb/2008:23:37:51 PST] "GET /say/hello HTTP/1.1" 200 89
- -> /say/hello

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

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

TOTD #18: How to Build The GlassFish v3 Gem for JRuby ?

Jerome posted the instructions to build GlassFish v3 Gem for JRuby - very simple and easy. A binary version of Gem is available here.

1. Software pre-requisite
   1. Subversion client (for example Tigris)
   2. Maven 2.0.x
   3. JRuby 1.0.x (I used JRuby 1.0.2 and lets say installed in JRUBY_HOME).  Make sure JRUBY_HOME/bin is in your path.
2. Build the Gem

   1. As explained in Jerome's entry, you can check out complete GlassFish v3 workspace or just the Gem code. Here is how you'll check out only the Gem code on a Windows machine using Tigris Subversion client:
      
      
      
      And after the check out is complete, you'll see:
      
      

   2. Build the gem by giving the command:
      
      mvn install
      
      And success is achieved by seeing the following in the console:
      
      [INFO] (in C:/workspaces/glassfish/gem/target/dependency/glassfish)
[WARNING] mkdir -p pkg
[INFO] Successfully built RubyGem
[INFO] Name: GlassFish
[WARNING] mv GlassFish-10.0.0-java.gem pkg/GlassFish-10.0.0-java.gem
[INFO] Version: 10.0.0
[INFO] File: GlassFish-10.0.0-java.gem
[INFO] [install:install]
[INFO] Installing C:\workspaces\glassfish\gem\target\gem-10.0-SNAPSHOT.jar to C:\Users\Arun Gupta\.m2\repository\org\glassfish\distributions\gem\10.0-SNAPSHOT\gem-10.0-SNAPSHOT.jar
[INFO] [install:install-file {execution: install-gem}]
[INFO] Installing C:\workspaces\glassfish\gem\target\dependency\glassfish\pkg\GlassFish-10.0.0-java.gem to C:\Users\Arun Gupta\.m2\repository\org\glassfish\distributions\GlassFish-Gem\10.0-SNAPSHOT\GlassFish-Gem-10.0-SNAPSHOT.gem
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 2 minutes 2 seconds
[INFO] Finished at: Fri Nov 16 17:56:12 PST 2007
[INFO] Final Memory: 11M/20M
[INFO] ------------------------------------------------------------------------

The Gem is available in target\dependency\glassfish\pkg directory.
3. Install the Gem
   1. Change to the directory where the Gem is available
      
      cd target\dependency\glassfish\pkg
   2. Install the Gem as:
      
      C:\testbed\ruby\jruby-1.0.2\bin\jruby -S gem install GlassFish-10.0.0-java.gem
Successfully installed GlassFish, version 10.0.0

And use it!

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

Technorati: totd v3 jruby ruby rubyonrails glassfish gem jrubyonglassfish

Posted by Arun Gupta in Finance  |  Comments[2]

TOTD #14: How to generate JRuby-on-Rails Controller on Windows (#9893)

The current Rails Gem (version 1.2.5) gives an error when creating a Controller in a JRuby-on-Rails application on Windows. It gives the following error during controller creation as shown below:

C:/testbed/ruby/jruby-1.0.1/lib/ruby/1.8/pathname.rb:420:in `realpath_rec': No such file or directory -C:/testbed/ruby/jruby-1.0.1/samples/rails/hello/C: (Errno::ENOENT)
    from C:/testbed/ruby/jruby-1.0.1/lib/ruby/1.8/pathname.rb:453:in `realpath'
    from C:/testbed/ruby/jruby-1.0.1/lib/ruby/gems/1.8/gems/rails-1.2.4/lib/initializer.rb:543:in `set_root_path!'
    from C:/testbed/ruby/jruby-1.0.1/lib/ruby/gems/1.8/gems/rails-1.2.4/lib/initializer.rb:509:in `initialize'
    from ./script/../config/boot.rb:35:in `new'
    from ./script/../config/boot.rb:35:in `run'
    from ./script/../config/boot.rb:35
    from :1:in `require'
    from :1

and Rails 1.2.4 gives exactly the same error. This is Ticket #9893. This actually happens because of JRUBY-1401.

The workaround is to use Rails 1.2.3. If you have already installed the latest Rails plugin, then you can uninstall it using the command:

C:\testbed\ruby\jruby-1.0.1\bin>gem uninstall rails
Successfully uninstalled rails version 1.2.5
Remove executables and scripts for
'rails' in addition to the gem? [Yn] y
Removing rails

And then install Rails 1.2.3 as:

gem install rails --include-dependencies --version 1.2.3 --no-ri --no-rdoc
Successfully installed rails-1.2.3
Successfully installed activesupport-1.4.2
Successfully installed activerecord-1.15.3
Successfully installed actionpack-1.13.3
Successfully installed actionmailer-1.3.3
Successfully installed actionwebservice-1.2.3

Now create a new application as shown below:

jruby -S rails hello

And then create a controller as:

jruby script\generate controller say hello
exists app/controllers/
exists app/helpers/
create app/views/say
exists test/functional/
create app/controllers/say_controller.rb
create test/functional/say_controller_test.rb
create app/helpers/say_helper.rb
create app/views/say/hello.rhtml

Hope you find it useful and this bug is fixed in the next version of Rails.

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

Technorati: totd rubyonrails jruby windows

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

TOTD #13: Setup Mongrel for JRuby-on-Rails applications on Windows

In a previous entry, I posted instructions on how to setup Mongrel cluster for JRuby-on-Rails applications on Unix-based systems. The instructions specified there do not work on Windows-based systems because of the following reasons:

• JRuby 1.0.1 + (default) Rails Gem (version 1.2.4) does not work on Windows because of JRUBY-1401. An older Rails version (such as 1.2.3) can always be used as described below.
• JRuby 1.0.1 + (default) Mongrel 1.0.1 does not work on Windows because of JRUBY-1410, JRUBY-1411.

So if you want JRuby-on-Rails applications to deploy on Mongrel on Windows, then the workaround is to checkout the JRuby trunk and use Rails 1.2.3. This blog explains the instructions on how to do that. The Mongrel cluster cannot be configured on JRuby yet though.

As a side note, repeated invocation of "jruby" command will encounter JRUBY-1350. The workaround is to exit out of the current command prompt and execute the commands in a new one.

1. Check out the workspace and build it using the following commands:
   
   mkdir jruby-trunk
cd jruby-trunk
svn co http://svn.codehaus.org/jruby/trunk/jruby
ant
   
   Add jruby-trunk/bin to your PATH.
2. Install the required RubyGems
   1. Install Rails Gem version 1.2.3 using the command:
      
      C:\workspaces\jruby-trunk\bin>jruby -J-Xmx384m -S gem install rails --version 1.2.3 --include-dependencies --no-ri --no-rdoc
Bulk updating Gem source index for: http://gems.rubyforge.org
Successfully installed rails-1.2.3
Successfully installed rake-0.7.3
Successfully installed activesupport-1.4.2
Successfully installed activerecord-1.15.3
Successfully installed actionpack-1.13.3
Successfully installed actionmailer-1.3.3
Successfully installed actionwebservice-1.2.3
   2. Before installing Mongrel, install the pre-requisite gems as shown below (see discussion here):
      
      C:\workspaces\jruby-trunk\bin>jruby -S gem install gem_plugin --no-ri --no-rdoc
Successfully installed gem_plugin-0.2.2
      
      and another one:
      
      C:\workspaces\jruby-trunk\bin>jruby -S gem install cgi_multipart_eof_fix --no-ri --no-rdoc
Successfully installed cgi_multipart_eof_fix-2.3
   3. Mongrel cannot be installed as a gem on JRuby yet. So download Mongrel gem and install it as shown below:
      
      C:\workspaces\jruby-trunk\bin>jruby -S gem install mongrel-1.0.1-jruby.gem --no-ri --no-rdoc
Successfully installed mongrel, version 1.0.1

Make sure to invoke the command from the directory where the gem is downloaded.

   4. mongrel_cluster does not work with JRuby and mongrel_jcluster does not work on Windows. So Mongrel clusters cannot be configured on a Windows machine.

3. Create a new directory jruby-trunk\samples\rails and create a new Rails application as shown below:
   
   C:\workspaces\jruby-trunk\samples\rails>..\..\bin\jruby -S rails hello
create
create app/controllers
create app/helpers
create app/models
...
create log/production.log
create log/development.log
create log/test.log
4. Change to the newly created directory and start Mongrel as shown below:
   
   C:\workspaces\jruby-trunk\samples\rails\hello>..\..\..\bin\jruby script\server
=> Booting Mongrel (use 'script/server webrick' to force WEBrick)
=> Rails application starting on http://0.0.0.0:3000
=> Call with -d to detach
=> Ctrl-C to shutdown server
** Ruby version is not up-to-date; loading cgi_multipart_eof_fix
** Starting Mongrel listening at 0.0.0.0:3000
** Starting Rails with development environment...
** Rails loaded.
** Loading any Rails specific GemPlugins
** Signals ready. TERM => stop. USR2 => restart. INT => stop (no restart).
** Rails signals registered. HUP => reload (without restart). It might not work well.
** Mongrel available at 0.0.0.0:3000
** Use CTRL-C to stop.
   
   The application is now available at http://localhost:3000 and shows the default "Welcome Aboard You're riding the Rails!" page. Hit Ctrl-C to stop Mongrel as shown below:
   
   ** INT signal received.
Exiting
C:/workspaces/jruby-trunk/lib/ruby/gems/1.8/gems/activesupport-1.4.2/lib/active_support/dependencies.rb:452:in `const_missing': Mongrel::StopServer (Mongrel::StopServer)
        from C:/workspaces/jruby-trunk/lib/ruby/gems/1.8/gems/mongrel-1.0.1-jruby/lib/mongrel.rb:723:in `run'
        from C:/workspaces/jruby-trunk/lib/ruby/gems/1.8/gems/mongrel-1.0.1-jruby/lib/mongrel/configurator.rb:271:in `initialize'
Terminate batch job (Y/N)? y

An alternative to this behemoth configuration and lack of Mongrel cluster on Windows is to create a Web ARchive (WAR) of your JRuby-on-Rails application and deploy on GlassFish. A complete screencast of how this can be achieved using NetBeans IDE is shown here. A comprehensive list of JRuby on GlassFish documentation is available here.

Technorati: totd rubyonrails jruby ruby mongrel windows jrubyonglassfish glassfish netbeans

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