Vivek Pandey's Blog

Quick update to GlassFish gem: GlassFish gem 0.3.1 Released

As it happens sometimes, right after GlassFish 0.3.0 release we found a critical regression that happened due to the fact that Rails grizzly adapter was re-written and this regression was introduced in that process.

It is fixed and updated GlassFish gem 0.3.1 is released on RubyForge. As always try it out and send your comments to forum or alias and report issues at the issue tracker.

Glassfish JRuby gem 0.3.0 released

I just released GlassFish gem 0.3.0. This is a bug fix release with few enhancements.

The issues fixed in this release are these and these

There is one enhancement that I would like to mention here is that the Rails logger is wired to GlassFish gem logger so when you run your Rails application using
jruby -S glassfish_rails yourappdir it will not only print GlassFish v3 gem logs but also Rails log.

Here is the log printed when a sample Rails application cookbook is deployed:


$jruby -S glassfish_rails cookbook/
Jun 23, 2008 7:02:47 PM com.sun.enterprise.glassfish.bootstrap.ASMain main
INFO: Launching GlassFish on HK2 platform
Jun 23, 2008 7:02:47 PM com.sun.enterprise.glassfish.bootstrap.ExtensibleClassLoader
INFO: Added file:/tools/jdk5/lib/tools.jar to shared classpath
Jun 23, 2008 7:02:47 PM com.sun.enterprise.v3.services.impl.GrizzlyProxy start
INFO: Listening on port 3000
Jun 23, 2008 7:02:47 PM com.sun.enterprise.v3.services.impl.GrizzlyEmbeddedHttpConfigurator configureSSL
WARNING: pewebcontainer.all_ssl_protocols_disabled
Jun 23, 2008 7:02:47 PM com.sun.enterprise.v3.services.impl.GrizzlyEmbeddedHttpConfigurator configureSSL
WARNING: pewebcontainer.all_ssl_ciphers_disabled
Jun 23, 2008 7:02:47 PM com.sun.enterprise.v3.services.impl.GrizzlyProxy start
INFO: Listening on port 3131
Jun 23, 2008 7:02:47 PM com.sun.enterprise.v3.services.impl.GrizzlyProxy start
INFO: Listening on port 3838
Jun 23, 2008 7:02:47 PM com.sun.enterprise.v3.admin.adapter.AdminConsoleAdapter setContextRoot
INFO: Admin Console Adapter: context root: /admin
Jun 23, 2008 7:02:48 PM com.sun.grizzly.jruby.RailsAdapter startRubyRuntimePool
INFO: Starting Rails instances
Jun 23, 2008 7:02:52 PM
SEVERE: JRuby limited openssl loaded. gem install jruby-openssl for full support.
http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL
Jun 23, 2008 7:02:53 PM com.sun.grizzly.jruby.RubyObjectPool$1 run
INFO: JRuby and Rails instance instantiation took : 4988ms
Jun 23, 2008 7:02:53 PM org.glassfish.scripting.rails.RailsDeployer load
INFO: Loading application cookbook at /
Jun 23, 2008 7:02:53 PM com.sun.enterprise.v3.server.AppServerStartup run
INFO: Glassfish v3 started in 5966 ms

Accessing the application http://localhost:3000/recipes shows me the following Rails log that you would be printed at log/development.log


Processing RecipesController#index (for 127.0.0.1 at 2008-06-23 19:02:57) [GET]

Jun 23, 2008 7:02:57 PM com.sun.grizzly.jruby.RailsAdapter$Logger log
INFO:   Session ID: BAh7BiIKZmxhc2hJQzonQWN0aW9uQ29udHJvbGxlcjo6Rmxhc2g6OkZsYXNo
SGFzaHsABjoKQHVzZWR7AA==--1fcc8bed80c5349246099b22244d1f5831fe8285

Jun 23, 2008 7:02:57 PM com.sun.grizzly.jruby.RailsAdapter$Logger log
INFO:   Parameters: {"controller"=>"recipes", "action"=>"index"}

Jun 23, 2008 7:02:57 PM com.sun.grizzly.jruby.RailsAdapter$Logger log
INFO: WARNING: You're using the Ruby-based MySQL library that ships with Rails. This library is not suited for production.
    Please install the C-based MySQL library instead (gem install mysql).

Jun 23, 2008 7:02:57 PM com.sun.grizzly.jruby.RailsAdapter$Logger log
INFO:   SQL (0.000000)   SET NAMES 'utf8'

Jun 23, 2008 7:02:57 PM com.sun.grizzly.jruby.RailsAdapter$Logger log
INFO:   SQL (0.001000)   SET SQL_AUTO_IS_NULL=0

Jun 23, 2008 7:02:57 PM com.sun.grizzly.jruby.RailsAdapter$Logger log
INFO:   Recipe Load (0.010000)   SELECT * FROM `recipes`

Jun 23, 2008 7:02:57 PM com.sun.grizzly.jruby.RailsAdapter$Logger log
INFO: Rendering template within layouts/application

Jun 23, 2008 7:02:57 PM com.sun.grizzly.jruby.RailsAdapter$Logger log
INFO: Rendering recipes/index

Jun 23, 2008 7:02:57 PM com.sun.grizzly.jruby.RailsAdapter$Logger log
INFO:   Recipe Columns (0.005000)   SHOW FIELDS FROM `recipes`

Jun 23, 2008 7:02:57 PM com.sun.grizzly.jruby.RailsAdapter$Logger log
INFO:   Category Columns (0.005000)   SHOW FIELDS FROM `categories`

Jun 23, 2008 7:02:57 PM com.sun.grizzly.jruby.RailsAdapter$Logger log
INFO:   Category Load (0.011000)   SELECT * FROM `categories` WHERE (`categories`.`id` = 2)

Jun 23, 2008 7:02:57 PM com.sun.grizzly.jruby.RailsAdapter$Logger log
INFO: Completed in 0.18900 (5 reqs/sec) | Rendering: 0.13300 (70%) | DB: 0.03200 (16%) | 200 OK [http://localhost/recipes]

To install simply do jruby -S gem install glassfish, if you have previous installation first uninstall it using jruby -S gem uninstall glassfish and then install it.

Try it out and send your comments to forum or alias and report issues at the issue tracker.

Scala Lift Web Framework on GlassFish v3

During JavaOne I heard about Lift - a Scala web framework and wanted to try it. It claims to provide best of Rails(simple and fast development), Seaside(security), Django(access control by default) and uses Wicket for view templates. In few steps I had my first Lift web application running on GlassFish v3.

Lift applicatin development process is Maven based and uses Derby as the default database. These are the steps to build a simple Lift application and deploy it on Embedded GlassFish v3 during development or deploy it on GlassFish v3 server.

Create Application

Lift uses Maven Archetype plugin to build a template project.

    
mvn org.apache.maven.plugins:maven-archetype-plugin:1.0-alpha-7:create  \
-DarchetypeGroupId=net.liftweb                             \
-DarchetypeArtifactId=lift-archetype-basic                 \
-DarchetypeVersion=0.8                            \
-DremoteRepositories=http://scala-tools.org/repo-releases  \
-DgroupId=my.liftapp -DartifactId=liftapp

This created liftapp directory.

src/main/scala directory contains the Scala source code.
src/main/webapp directory contains the HTML, JavaScript, CSS, and WEB-INF code.
lift_example directory contains the derby database.

Now let's build it

    
cd liftapp
mvn install

This would create a WAR directory structure at target/liftapp-1.0-SNAPSHOT/ and also the WAR file target/liftapp-1.0-SNAPSHOT.war

Deploy on GlassFish v3

I could simply deploy the application on GlassFish v3 server by doing:

    
        asadmin deploy target/liftapp-1.0-SNAPSHOT

Click http://localhost:8080/liftapp-1.0-SNAPSHOT/ and you should see the Welcome screen. Also note that the access controls login, add user features are automatically generated similar to Django admin.

Code-Save-Refresh with GlassFish v3

The previous deployment on to GlassFish v3 works fine but I needed something that could help me do Code-Save-Refresh cycle without restarting the v3 server. Basically I wanted to use Embedded GlassFish v3 where I would simply invoke mvn glassfish:run and make changes and compile in another window and at the end refresh the browser to see the changes.

Since pom.xml generated by Lift Archetype does not have entry for maven-glassfish-plugin so I had to add this plugin entry:

    

        
            
                maven2.java.net
                Java.net Repository for Maven 2
                http://download.java.net/maven/2
            
        

        
            
                org.glassfish
                maven-glassfish-plugin
                1.0-alpha-4
                
                    target/liftapp-${project.version}

I also had to make one more change in src/main/webapp/WEB-INF/web.xml to workaround due to the fact that http://java.sun.com/j2ee/dtds/web-app_2_3.dtd has been renamed to http://java.sun.com/dtd/web-app_2_3.dtd and the aliasing is not happening properly with Embedded GlassFish v3

So the change was to edit src/main/webapp/WEB-INF/web.xml and replace http://java.sun.com/j2ee/dtds/web-app_2_3.dtd by http://java.sun.com/dtd/web-app_2_3.dtd. This step would not be required once it is fixed in embedded GlassFish v3.

That's it! Next I did was invoke mvn glassfish:run


    vivekmz@boson(620)> mvn glassfish:run
    [INFO] Scanning for projects...
    [INFO] Searching repository for plugin with prefix: 'glassfish'.
    [INFO] ------------------------------------------------------------------------
    [INFO] Building liftapp
    [INFO]    task-segment: [glassfish:run]
    [INFO] ------------------------------------------------------------------------
    [INFO] Preparing glassfish:run
    [INFO] [resources:resources]
    [INFO] Using default encoding to copy filtered resources.
    [INFO] [yuicompressor:compress {execution: default}]
    [INFO] nb warnings: 0, nb errors: 0
    Downloading: http://scala-tools.org/repo-releases/org/igniterealtime/smack/smack/3.0.4/smack-3.0.4.pom
    Downloading: http://repo1.maven.org/maven2/org/igniterealtime/smack/smack/3.0.4/smack-3.0.4.pom
    Downloading: http://scala-tools.org/repo-releases/org/igniterealtime/smack/smackx/3.0.4/smackx-3.0.4.pom
    Downloading: http://repo1.maven.org/maven2/org/igniterealtime/smack/smackx/3.0.4/smackx-3.0.4.pom
    [INFO] [compiler:compile]
    [INFO] Nothing to compile - all classes are up to date
    [INFO] [scala:compile {execution: default}]
    [INFO] Nothing to compile - all classes are up to date
    [INFO] [glassfish:run]
    May 16, 2008 2:52:31 PM com.sun.enterprise.v3.server.AppServerStartup run
    INFO: HK2 initialized in 236 ms
    May 16, 2008 2:52:31 PM com.sun.enterprise.v3.server.AppServerStartup run
    INFO: com.sun.enterprise.naming.impl.ServicesHookup@1e708b2 Init done in 241 ms
    May 16, 2008 2:52:31 PM com.sun.enterprise.v3.server.AppServerStartup run
    INFO: com.sun.enterprise.v3.server.Globals@1fbc355 Init done in 242 ms
    May 16, 2008 2:52:31 PM com.sun.enterprise.v3.server.AppServerStartup run
    INFO: com.sun.enterprise.v3.server.SystemTasks@1f2edd2 Init done in 246 ms
    May 16, 2008 2:52:31 PM com.sun.enterprise.v3.server.AppServerStartup run
    INFO: com.sun.enterprise.v3.services.impl.HouseKeeper@f221f6 Init done in 247 ms
    May 16, 2008 2:52:31 PM com.sun.enterprise.v3.server.AppServerStartup run
    INFO: com.sun.enterprise.v3.services.impl.CmdLineParamProcessor@189a773 Init done in 249 ms
    JMXMP connector server URL = service:jmx:jmxmp://localhost:8888
    May 16, 2008 2:52:31 PM com.sun.enterprise.v3.services.impl.GrizzlyProxy start
    INFO: Listening on port 8080
    May 16, 2008 2:52:31 PM com.sun.enterprise.v3.server.AppServerStartup run
    INFO: com.sun.enterprise.v3.services.impl.GrizzlyService@154ea79 startup done in 398 ms
    May 16, 2008 2:52:31 PM com.sun.enterprise.v3.services.impl.ApplicationLoaderService postConstruct
    INFO: loader service postConstruct started at 1210978351811
    May 16, 2008 2:52:31 PM com.sun.enterprise.v3.server.AppServerStartup run
    INFO: Application Loader startup done in 431 ms
    May 16, 2008 2:52:31 PM com.sun.enterprise.v3.server.AppServerStartup run
    INFO: Glassfish v3 started in 432 ms
    May 16, 2008 2:52:37 PM com.sun.enterprise.web.WebModuleContextConfig authenticatorConfig
    SEVERE: webModuleContextConfig.missingRealm
    Hit ENTER for redeploy

Click http://localhost:8080/liftapp/ would display

Then I tried to make some changes in the Scala code compile it and then refresh the browser to see if the changes appear there. So in another window, edit src/main/scala/my/liftapp/snippet/HelloWorld.scala

Replace

    
        def howdy = Welcome to liftapp at {new java.util.Date}

    
        def howdy = Welcome to liftapp deployed on GlassFish v3 at {new java.util.Date}

Save this file and run mvn install and hit Entner key in the windows where I ran embedded GlassFish v3.

That's

Now, I go back to the browser and refresh the window and it displays the changed text, but first see the GlassFish log where you hit Enter and see the log printed when refresh button was pressed in the browser

    
        Hit ENTER for redeploy
        May 16, 2008 2:57:30 PM com.sun.enterprise.web.WebModuleContextConfig authenticatorConfig
        SEVERE: webModuleContextConfig.missingRealm
        INFO - Service request (GET) /liftapp/ took 412 Milliseconds
        INFO - Service request (GET) /liftapp/classpath/blueprint/screen.css took 13 Milliseconds
        INFO - Service request (GET) /liftapp/classpath/blueprint/print.css took 2 Milliseconds
        INFO - Service request (GET) /liftapp/classpath/blueprint/plugins/fancy-type/fancy-type.css took 2 Milliseconds
        INFO - Service request (GET) /liftapp/classpath/jquery.js took 4 Milliseconds
        INFO - Service request (GET) /liftapp/classpath/json.js took 1 Milliseconds

To summarize, a Scala Lift application can be deployed on GlassFish v3 server as well as can be run in development mode with hot deployment by running embedded GlassFish mvn glassfish:run. Go ahead and try it out and let us know at the the forum or alias

GlassFish Gem 0.2.0 and JRuby 1.1.1 module for GlassFish v3 update center

New version of GlassFish gem 0.2.0 is out. See Arun's announcements. The major changes in this version are:

Version upgrade to GlassFish v3 TP2.
Fix to the size regression introduced in the previous release. It is back to about 3MB.

We also released JRuby 1.1.1 runtime bundle that includes Rails 2.0.2 along with other required gems, such as jdbc, jdbc-mysql.

To install JRuby 1.1.1 and Rails 2.0.2 runtime on Glassfish v3 TP2, do the following:

From inside GlassFish install directory: bin/updatetool
This will get all the required jars to run updatetool. After it gets all the dependencies, run
```
bin/updatetool
```

Select JRuby On GlassFish and click install. It will create jruby directory inside glassfish-tp2/glassfish/modules directory. Thats all you need. Now start deploying your Ruby/Rails applications on GlassFish v3 and you dont need to set JRUBY_HOME in config/asenv.bat or asenv.conf that you would do otherwise to tell GlassFish where to find JRuby runtime.

Scripting in GlassFish @ JavaOne 2008

JavaOne 2008 starts form tomorrow, actually today: there is Unconference in the afternoon. This is going to be my first 8th JavaOne in a row and a most busy one! Here are some of the scripting related talks and events:

BOF-5111 Scripting in GlassFish
TS-5416 JRuby: Why, What, How...Do It Now
TS-4806 JRuby on Rails: Web Development Evolved
TS-6039 Jython - Implementing Dynamic Language Features for the Java™ Platform Ecosystem
PAN-5435 The Script Bowl: A Rapid-Fire Comparison of Scripting Languages
TS-5764 Grails in Depth
TS-5793 Groovy and Grails: Changing the Landscape of Java™ Platform, Enterprise Edition (Java EE Platform) Patterns

There are also all week GlassFish events, do plan to attend these.

I hope to meet many of you. I will be speaking at BOF-5111: Scripting In GlassFish and also at CommunityOne sessions S295418 - Tools for GlassFish V3 (Java EE Platform and Scripting Environment) and Scripting environment.

We also have POD#135 Scripting On GlassFish Booth in the Pavillion. I plan to be around there on Wednesday afternoon so drop by to see what we are up to on supprting dynamic languages and frameworks on GlassFish.

JRuby Module 3.0 for for GlassFish v2 is out

JRuby Update Center module 3.0 for GlassFish v2 is out. It has been tested to work with GlassFish v2 UR2. The Update Center modules provide out of the box tested-on-GlassFish version of JRuby, Rails and other required gems. For the GlassFish users it is very convinient just install the JRuby module from the GlassFish update center and start writing the Rails applications.

Here are some details on this release of Update Centner Modules:

It is a major upgrade from the previous 2.1 version which came with JRuby 1.0.3 and Rails 1.2.6. The major upgrade comes in forms of JRuby version 1.1.1, Rails version 2.0.2 and Warbler. You can use Warbler to create a WAR of the Rails application on GlassFish v2. The UC module also provides ant scripts for shared mode, where JRuby and Goldspike jars are installed on Glassfish v2 and you don't have to package any of these jars and the gems with JRuby. This will result in to smaller Rails applications compared to the WAR files created by Warbler.

Rails 2.0.2 is not backward compatible with Rails 1.2.6 so samples form the previous JRuby UC module will not work on this new ver 3.0.

JRuby and installed gem versions

JRuby 1.1.1
gems


            actionmailer (2.0.2)
actionpack (2.0.2)
activerecord (2.0.2)
activerecord-jdbc-adapter (0.8)
activerecord-jdbcmysql-adapter (0.8)
activeresource (2.0.2)
activesupport (2.0.2)
jdbc-mysql (5.0.4)
rails (2.0.2)
rake (0.8.1)
rspec (1.1.3)
sources (0.0.1)
warbler (0.9.5)

Installing JRuby UC Module 3.0

To install, cd to your GlassFish installation, and run

./updatecenter/bin/updatetool

. This will bring the window below:

Select JRuby On GlassFish checkbox and click Install. After it finishes, it will create jruby director inside the GlassFish installation.

Run HelloWorldRailsApp sample

Start GlassFish v2 asadmin start-domain
Inside your GlassFish installation, cd jruby/samples/HelloWorldRailsApp
Create a WAR file HelloWorldRailsApp.war by running warbler JRuby -S warble
Now Deploy the war file asadmin deploy HelloWorldRailsApp.war
Access http://localhost:8080/HelloWorldRailsApp/say/hello in your browser.

Above Warbler was used to create a standalone WAR file. Warbler packages all the required JARs and gems in the the WAR file resulting in to large WAR size. You can as well use setup-shared-env target from jruby/build.xml from inside the GlassFish installation. This will copy JRuby and Goldspike jars in to glassfish/lib directory. After this instead of running Warlbe, simply run create-shared target inside the application this will create WEB-INF/web.xml inside your Rails application. At the end simply run asadmin deploy yourRailsApp. For details see GLASSFISH_README.txt inside the samples.

Continue sending your feedback to the GlassFish WebTier forum or to the mailing list. Report any bugs to the IssueTracker

Embedding GlassFish v3 with Grails

In my blog on running Grails application on GlassFish v3, I need to create a war of my application and then deploy that war. This was a serious bottleneck in my development process as I wanted to test it out this application on GlassFish v3.

I really wanted to run my Grails application with GlassFish v3 as embedded server in the same fashion as running grails run-app, that is without creating a war file and to speed up my development. By default Grails uses Jetty web server to run the applications. But I wanted to use V3, it is very modular, extensible and embeddable and and is going to allow me to get the JavaEE features that I may like to use at some point in time. One possible way was that GlassFish v3 is an OSGi container and if Grails has an OSGi container I could easily replace jetty with v3. So I mentioned this problem to Kohsuke and came to know that he is working on GlassFish v3 embed APIs. So I gave it a try and guess what? It was darn simple to write few lines of groovy script to get it embedded with Grails and run my application.

Here is the groovy script that starts GlassFish v3 server and deploys the grails application. Please note that the API is using scattered war in literal sense - there is no WAR file structure here.

    appName = new File("${grailsAppName}");
    webxml = new File(webXmlFile.absolutePath)
    resource = new File("${basedir}/web-app")
    ScatteredWar war = new ScatteredWar(
                "${grailsAppName}",
                resource,
                webxml,
                Collections.singleton(new File(appName, classesDir.getAbsolutePath()).toURI().toURL()))

    grailsServer = new GlassFish(serverPort)/a>
    grailsApp = grailsServer.deploy(war)

I called this script RunaAppGf.groovy and after adding V3 Embed API and other v3 dependent jars (web-all.jar) to the Grails classpath, copied it to $GRAILS_HOME/script directory. With this I was ready to run my grails app and so I did by invoking grails run-app-gf inside my grails application directory.


    vivekmz@boson(653)> grails run-app-gf

Welcome to Grails 1.0.1 - http://grails.org/
Licensed under Apache Standard License 2.0
Grails home is set to: /tools/grails

Base Directory: /myhome/vivekmz/dev/grails/hello
Environment set to development
Note: No plugin scripts found
Running script /tools/grails/scripts/RunAppGf.groovy
Starting GlassFish embedded server...Running Grails application..
Application name : hello
Web App Root :/myhome/vivekmz/dev/grails/hello/web-app
web.xml:/myhome/vivekmz/.grails/1.0.1/projects/hello/resources/web.xml
May 1, 2008 1:46:45 PM com.sun.enterprise.v3.server.AppServerStartup run
INFO: HK2 initialized in 380 ms
May 1, 2008 1:46:45 PM com.sun.enterprise.v3.server.AppServerStartup run
INFO: com.sun.enterprise.naming.impl.ServicesHookup@304648 Init done in 391 ms
May 1, 2008 1:46:45 PM com.sun.enterprise.v3.server.AppServerStartup run
INFO: com.sun.enterprise.v3.server.Globals@6c9f0f Init done in 393 ms
May 1, 2008 1:46:45 PM com.sun.enterprise.v3.server.AppServerStartup run
INFO: com.sun.enterprise.v3.server.SystemTasks@1cdc190 Init done in 400 ms
May 1, 2008 1:46:45 PM com.sun.enterprise.v3.server.AppServerStartup run
INFO: com.sun.enterprise.v3.services.impl.HouseKeeper@d9b071 Init done in 403 ms
May 1, 2008 1:46:45 PM com.sun.enterprise.v3.server.AppServerStartup run
INFO: com.sun.enterprise.v3.services.impl.CmdLineParamProcessor@19f9c7a Init done in 407 ms
JMXMP connector server URL = service:jmx:jmxmp://localhost:8888
May 1, 2008 1:46:45 PM com.sun.enterprise.v3.services.impl.GrizzlyProxy start
INFO: Listening on port 8080
May 1, 2008 1:46:45 PM com.sun.enterprise.v3.server.AppServerStartup run
INFO: com.sun.enterprise.v3.services.impl.GrizzlyService@3a4822 startup done in 718 ms
May 1, 2008 1:46:45 PM com.sun.enterprise.v3.services.impl.ApplicationLoaderService postConstruct
INFO: loader service postConstruct started at 1209678405813
May 1, 2008 1:46:45 PM com.sun.enterprise.v3.server.AppServerStartup run
INFO: Application Loader startup done in 764 ms
May 1, 2008 1:46:45 PM com.sun.enterprise.v3.server.AppServerStartup run
INFO: Glassfish v3 started in 765 ms
May 1, 2008 1:46:51 PM com.sun.enterprise.web.WebModuleContextConfig authenticatorConfig
SEVERE: webModuleContextConfig.missingRealm
[0] commons.DefaultGrailsApplication The class [UrlMappings] was not found when attempting to load Grails application. Skipping.
[3] commons.DefaultGrailsApplication The class [Config] was not found when attempting to load Grails application. Skipping.
[5] commons.DefaultGrailsApplication The class [BootStrap] was not found when attempting to load Grails application. Skipping.
[8] commons.DefaultGrailsApplication The class [DataSource] was not found when attempting to load Grails application. Skipping.
[10] commons.DefaultGrailsApplication The class [resources] was not found when attempting to load Grails application. Skipping.
[1426] spring.GrailsWebApplicationContext Refreshing org.codehaus.groovy.grails.commons.spring.GrailsWebApplicationContext@1e5052b: display name [org.codehaus.groovy.grails.commons.spring.GrailsWebApplicationContext@1e5052b]; startup date [Thu May 01 13:46:53 GMT-08:00 2008]; parent: org.springframework.web.context.support.XmlWebApplicationContext@13cb2c6
[1426] spring.GrailsWebApplicationContext Bean factory for application context [org.codehaus.groovy.grails.commons.spring.GrailsWebApplicationContext@1e5052b]: org.springframework.beans.factory.support.DefaultListableBeanFactory@192974
Server running. Browse to http://localhost:8080/hello

The next steps are really to provide the required V3 jars, V3 Embed Jars and this script as a bundle so that you can easily install over the Grails installation and enjoy modularity, extensibility and embeddability of GlassFish v3. I plan to talk about it more during JavaOne and Kohsuke and me are trying to see if we could have something ready in another day or so.

My first Jython web app on GlassFish v3

I have been thinking of playing with Jython and GlassFish for quite some time. I thought of taking the first shot at it. So after looking around a bit I found out that I can simply use PyServlet to delegate the HTTP requests to my Jython servlet which can do whatever with the Python script and write it back to the Servlet output stream. Let us see how I did it:

Setup

Install GlassFish v3.
Install Jython . The current version I got is Jython 2.2.1.

Create a Python Servlet

Create the servlet layout:

cd c:/dev
mkdir calendar
cd calendar
mkdir WEB-INF
mkdir WEB-INF/lib

Now, create Show.py, which is a Python Servlet and save it at c:/dev/calendar:

from javax.servlet.http import HttpServlet 
class Show (HttpServlet): 
    def doGet(self,request,response): 
        self.doPost (request,response) 
    def doPost(self,request,response): 
        toClient = response.getWriter() 
        response.setContentType ("text/html") 
        toClient.println ("Calendar
No 
Calendar")

Create web.xml to serve all the python files by PyServlet:



    
        PyServlet
        org.python.util.PyServlet
        1
    
    
        PyServlet
        *.py
    
    
        
            30

Copy jython.jar and python libraries to WEB-INF/lib. The Python libraries are located under Lib directory of Jython installation directory. You will also find jython.jar under the Jython installation directory.
```
cd c:/tools/jython
cp jython.jar c:/dev/calendar/WEB-INF/lib
cp -rf Lib c:/dev/calendar/WEB-INF/lib
```

Deploy the Python web application

Start GlassFish v3

[/c/dev]
$./glassfish/bin/asadmin deploy calendar
properties=(name=calendar)

Now access http://localhost:8080/calendar/Show.py, it should show this page:

This was simply a jython servlet but there was no Python specific libraries involved.

Invoke Python libraries

We will show Year 2008 calendar using python class calendar.

Let us modify Show.py.

import sys,calendar,time 
from javax.servlet.http import HttpServlet 
class Show (HttpServlet): 
    def doGet(self,request,response): 
        self.doPost (request,response) 
    def doPost(self,request,response): 
        toClient = response.getWriter() 
        response.setContentType ("text/html") 
        toClient.println 
("Calendar
%s" % 
calendar.calendar(time.localtime()[0]))

Notice that the main change made to Show.py is that we invoke calendar.calendar() and pass it the localtime. Also, there is an import of calendar and time.

Now, go back to your browser and refresh the page and you would see Year 2008 calendar:

This is it! However it involves Jython Servlet and some wiring and could be lot simpler. Frank plans to work on simplified and better integrated support for Jython on GlassFish. Stay tuned there is more to come...

Using JPA with Rails on GlassFish and MySQL

In my last post I mentioned that "...with Rails there are some known limitations, such as the ORM in Rails is not pluggable" by which I basically meant that you can't plug in another ORM and the Rails Model creation and db migration will not generate the correct code for another kind of ORM. The good news is that with little bit of coding you can reuse your entity classes. caroljmcdonald commented on my blog that Brian in his blog succssfully tried out JPA and Rails on WEBRick using JavaDB. So, in this blog I would go over what you would need to do to make JPA and Rails work on GlassFish v2.

Let's first try to understand how it is going to work: Rails by default uses ActiveRecords for Object Relational Mapping purposes or ORM. JPA is another ORM technique in JavaEE. Model class and database migration in Rails is what Entity class and persistence provider does for you in Java. Essentially In Java you just provide the Entity class and on the Rails side, you would provide the Model corresponding to the Entity class to do CRUD and that is pretty much it. The JPA provider does the rest.

This just means that to use Rails with JPA we simply do not use ActiveRecords - this means we don't create Model using Rails and we dont migrate the database. Just define your Entity class and code up the Rails Model without extending from ActiveRecord::Base.

Here is how I did it, which is basically few changes in Brian's sample and setting up GlassFish v2 with JRuby on Rails UC module.

Setup GlassFish v2 and NetBeans

Install NetBeans 6.1 Beata with Web and Java EE profile.
Follow these directions to install and setup JRuby on GlassFish v2.

Setup JRuby jars as shared libraries on Glassfish

cd $GLASSFISH_HOME/jruby
$ant -f install.xml setup-shared-env

Copy MySQL driver from your NetBeans installation:

cp "C:\Program Files\NetBeans 6.1 Beta\ide9\modules\ext\mysql-connector-java-5.1.5-bin.jar" c:/tools/glassfish/lib

or from here to $GLASSFISH_HOME/lib.

Start MySQL server and create test database if not already there
```
mysqladmin -u root create test;
```

Create Java Entity Beans with MySQL

First we create an entity class and a persistence unit.

Create a new Java Application named Post. There's no need for a Main Class.
Create a new Persistence Unit. Select jdbc:mysql://localhost:3306/test [root on Default Schema] as the database connection and the persistence unit name as PostPUclick Finish. This will generate src/META-INF/persistence.xml
Create a new Entity Class named Posts. Set the package name to entity.

Add fields and accessors for title and body. Your completed class should look as follows:

package entity;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

/**
 *
 * @author vivek
 */
@Entity
public class Posts implements Serializable {
    private static final long serialVersionUID = 1L;
    private Long id;
    private String title;
    private String body;

    public void setId(Long id) {
        this.id = id;
    }

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    public Long getId() {
        return id;
    }

    @Override
    public int hashCode() {
        int hash = 0;
        hash += (id != null ? id.hashCode() : 0);
        return hash;
    }

    @Override
    public boolean equals(Object object) {
        // TODO: Warning - this method won't work in the case the id fields are not set
        if (!(object instanceof Posts)) {
            return false;
        }
        Posts other = (Posts) object;
        if ((this.id == null && other.id != null) || (this.id != null && !this.id.equals(other.id))) {
            return false;
        }
        return true;
    }

    @Override
    public String toString() {
        return "entity.Post[id=" + id + "]";
    }
    
    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.body = body;
    }

}

Create Post.jar by clicking Build->Clean and Build Main Project or Shift+F11. This will create dist/Post.jar inside your project.
Copy Post.jar to $GLASSFISH_HOME/lib directory. $GLASSFISH_HOME is where you installed GlassFish.
```
    cp dist/Post.jar c:/tools/glassfish/lib
    
```

Create the Rails Application

Simply download the Rails application then do the following:


cd $GLASSFISH_HOME/jruby/samples
unzip jpa_blog.zip
cd jpa_blog

Brian's sample Rails application was created using Rails 1.2.3 and GlassFish v2 JRuby module includes Rails version 1.2.6. So edit config/environment.rb and replace RAILS_GEM_VERSION = '1.2.3' with RAILS_GEM_VERSION = '1.2.6'.

The last thing you want to do is prepare this rails application for deployment over GlassFish v2:

[/c/tools/glassfish/jruby/samples/jpa_blog]
$ant -f ../../install.xml create-shared
Buildfile: ..\..\install.xml

create-shared:
    [mkdir] Created dir: c:\tools\glassfish\jruby\samples\jpa_blog\WEB-INF
     [copy] Copying 1 file to c:\tools\glassfish\jruby\samples\jpa_blog\WEB-INF

BUILD SUCCESSFUL
Total time: 0 seconds

Simply deploy your rails application on to GlassFish (if you have not started Glassfish during GlassFish setup, you should do it now):

[/c/tools/glassfish/jruby/samples/jpa_blog]
$cd ..
[/c/tools/glassfish/jruby/samples]
$../../bin/asadmin.bat deploy jpa_blog
Command deploy executed successfully.

In the GlassFish server.log you should see:

[#|2008-03-20T17:46:32.250-0700|INFO|sun-appserver9.1|javax.enterprise.system.to
ols.deployment|_ThreadID=20;_ThreadName=Thread-28;|deployed with moduleid = jpa_
blog|#]

[#|2008-03-20T17:46:33.531-0700|INFO|sun-appserver9.1|javax.enterprise.system.co
ntainer.web|_ThreadID=21;_ThreadName=ObjectPoolManager;|PWC1412: WebModule[/jpa_
blog] ServletContext.log():JRuby init time: 94ms|#]

[#|2008-03-20T17:46:39.296-0700|INFO|sun-appserver9.1|javax.enterprise.system.co
ntainer.web|_ThreadID=21;_ThreadName=ObjectPoolManager;|PWC1412: WebModule[/jpa_
blog] ServletContext.log():Rails init time: 5750ms|#]

[#|2008-03-20T17:46:39.296-0700|INFO|sun-appserver9.1|javax.enterprise.system.co
ntainer.web|_ThreadID=21;_ThreadName=ObjectPoolManager;|PWC1412: WebModule[/jpa_
blog] ServletContext.log():Runtime 0 loaded|#]

[#|2008-03-20T17:46:39.296-0700|INFO|sun-appserver9.1|javax.enterprise.system.co
ntainer.web|_ThreadID=21;_ThreadName=ObjectPoolManager;|PWC1412: WebModule[/jpa_
blog] ServletContext.log():Requests can now be processed|#]

Now, accessing http://localhost:8080/jpa_blog/blog/ should show you:

Create a new Blog entry:

See the list of all the blogs:

I wanted to try it out on Glassfish gem but JPA is under development in GlassFish v3 and I get exception coming form inside GlassFish v3 where it can't find the PersistenceProvider:

javax.persistence.PersistenceException: No resource files named META-INF/services/javax.persistence.spi.PersistenceProvider were found. Please make sure that the persistence provider jar file is in your classpath.

Mitesh is working on JPA support in Glassfish v3, I would do a follow-up blog for GlassFish gem as soon as I see it working.

You can get the Rails and Entity code using the following link:

Continue using JRuby on GlassFish and keep sending us feedback on GlassFish forums, dev@glassfish or gem mailing list. For the latest information about the gem and JRuby Update Center module can be found at GlassFish JRuby wiki.

Report on JRuby On Glassfish@Silicon Valley JUG

I was at Silicon Valley JUG (Java User's Group) to talk about Ruby on Rails in GlassFish. See Arun's announcement on this talk. The slides used in this presentation can be found here.

The main theme of my presentation was on highlighting Rails development and deployment on GlassFish v2 and using GlassFish gem with live demos.

These are some of the questions asked during presentation and my answer to those

Q:This is cool that Rails applications can be deployed and run over GlassFish a JavaEE application server, but can the JavaEE features be invoked from inside a Rails application?

A:Yes we think it can be done, with JRuby you can call anything in Java. We know from one of the JRuby users that he is able to call in to EJB service form Rails. Having said that with Rails there are some known limitations, such as the ORM in Rails is not pluggable, so we can't plugin GlassFish JPA implementation in to Rails to take benefit of it. Merb allows such pluggable ORM. As a followup we would provide samples/blogs on Rails and JavaEE features.

Q:What is the performance comparison between JRuby vs Ruby?

Q:No formal performance study has been done. There are some blog posts that talk about it, such as this one by Nick, that shows with warm up JRuby/GlassFish as good as C-Ruby/Mogreal and there is another JRuby on GlassFish comparison to Ruby/Mogrel. We expect with GlassFish gem these numbers would look even better. In next few months the focus is going to be on performance and scalability, so stay tuned.

Q:Can you call in to Ruby from Java?

A:Yes, you can do it using JSR-223 APIs. JSR-223 scripting APIs are part of JDK6, with JDK 5 or earlier versions, you can get it from here.

Q:Does standalone JRuby programs can also get affect from PermGen issue?

A:It really depends on the application. For example, in a Rails application, because Rails being single threaded and so it results in to creating Rails for each of the concurrent requests and hence each Rails instance ends up consuming more of Permanent heap space.

There were more questions that I can't recall now. The talk was video recorded, I am not sure where and when it will be posted but when I get that link, I will add it to this blog.

Please use JRuby on GlassFish and send us feedback on GlassFish forums, dev@glassfish or gem mailing list. For the latest information about the gem and JRuby Update Center module can be found at GlassFish JRuby wiki.

Grails application now working on GlassFish v3

Recently Guillaume reported to me about his Grail app not deploying on GlassFish v3 Preview 2. The problem reported was that the Grail app was taking lots of time to deploy on GlassFish v3 Preview 2. Although such failures are not acceptable but considering GlassFish v3 is a complete new architecture, is still under development and feature incomplete and above all the preview releases do not go thru the normal test cycle so such bugs can appear.

This issue was discussed at the GlassFish mailing list, see the discussion here and the corresponding bug.

The good news is that Jerome quickly found out what the problem was and after the code went thru reviews, it was checked in and the fix went into yesterday's nightly build.

Here is how I created and deployed a Grails application on GlassFish v3:

Create a simple Grails app

Setup Grails This is the standard way you would setup the Grails environments:

    export PATH=$GRAILS_HOME/bin:$PATH
    export GRAILS_HOME=/tools/grails

Create a simple Grails app


       vivekmz@boson(555)> grails create-app MyFirstGrailsApp
    Welcome to Grails 1.0.1 - http://grails.org/
    Licensed under Apache Standard License 2.0
    Grails home is set to: /tools/grails
    Base Directory: /ws/sb
    Environment set to development
    Note: No plugin scripts found
    Running script /tools/grails/scripts/CreateApp.groovy
    [mkdir] Created dir: /ws/sb/MyFirstGrailsApp/src
    [mkdir] Created dir: /ws/sb/MyFirstGrailsApp/src/java
    [mkdir] Created dir: /ws/sb/MyFirstGrailsApp/src/groovy
    [mkdir] Created dir: /ws/sb/MyFirstGrailsApp/grails-app
    [mkdir] Created dir: /ws/sb/MyFirstGrailsApp/grails-app/controllers
    [mkdir] Created dir: /ws/sb/MyFirstGrailsApp/grails-app/services
    [mkdir] Created dir: /ws/sb/MyFirstGrailsApp/grails-app/domain
    [mkdir] Created dir: /ws/sb/MyFirstGrailsApp/grails-app/taglib
    [mkdir] Created dir: /ws/sb/MyFirstGrailsApp/grails-app/utils
    [mkdir] Created dir: /ws/sb/MyFirstGrailsApp/grails-app/views
    [mkdir] Created dir: /ws/sb/MyFirstGrailsApp/grails-app/views/layouts
    [mkdir] Created dir: /ws/sb/MyFirstGrailsApp/grails-app/i18n
    [mkdir] Created dir: /ws/sb/MyFirstGrailsApp/grails-app/conf
    [mkdir] Created dir: /ws/sb/MyFirstGrailsApp/test
    [mkdir] Created dir: /ws/sb/MyFirstGrailsApp/test/unit
    [mkdir] Created dir: /ws/sb/MyFirstGrailsApp/test/integration
    [mkdir] Created dir: /ws/sb/MyFirstGrailsApp/scripts
    [mkdir] Created dir: /ws/sb/MyFirstGrailsApp/web-app
    [mkdir] Created dir: /ws/sb/MyFirstGrailsApp/web-app/js
    [mkdir] Created dir: /ws/sb/MyFirstGrailsApp/web-app/css
    [mkdir] Created dir: /ws/sb/MyFirstGrailsApp/web-app/images
    [mkdir] Created dir: /ws/sb/MyFirstGrailsApp/web-app/META-INF
    [mkdir] Created dir: /ws/sb/MyFirstGrailsApp/lib
    [mkdir] Created dir: /ws/sb/MyFirstGrailsApp/grails-app/conf/spring
    [mkdir] Created dir: /ws/sb/MyFirstGrailsApp/grails-app/conf/hibernate
    [propertyfile] Creating new property file:
    /ws/sb/MyFirstGrailsApp/application.properties
    [copy] Copying 2 files to /ws/sb/MyFirstGrailsApp
    [copy] Copying 2 files to /ws/sb/MyFirstGrailsApp/web-app/WEB-INF
    [copy] Copying 5 files to /ws/sb/MyFirstGrailsApp/web-app/WEB-INF/tld
    [copy] Copying 87 files to /ws/sb/MyFirstGrailsApp/web-app
    [copy] Copying 17 files to /ws/sb/MyFirstGrailsApp/grails-app
    [copy] Copying 1 file to /ws/sb/MyFirstGrailsApp
    [copy] Copying 1 file to /ws/sb/MyFirstGrailsApp
    [copy] Copying 1 file to /ws/sb/MyFirstGrailsApp
    [propertyfile] Updating property file:
    /ws/sb/MyFirstGrailsApp/application.properties
    Created Grails Application at /ws/sb/MyFirstGrailsApp

Start GlassFish v3


    vivekmz@boson(735)> glassfish/bin/asadmin start-domain
    Mar 7, 2008 7:43:04 PM com.sun.enterprise.v3.server.AppServerStartup run
    INFO: HK2 initialized in 281 ms
    Mar 7, 2008 7:43:04 PM com.sun.enterprise.v3.server.AppServerStartup run
    INFO: com.sun.enterprise.naming.impl.ServicesHookup@51b48197 Init done in 307 ms
    Mar 7, 2008 7:43:04 PM com.sun.enterprise.v3.server.AppServerStartup run
    INFO: com.sun.enterprise.v3.services.impl.CmdLineParamProcessor@9c0ec97 Init done in 310 ms
    Mar 7, 2008 7:43:04 PM com.sun.enterprise.v3.server.AppServerStartup run
    INFO: com.sun.enterprise.v3.server.SystemTasks@1fd0fafc Init done in 382 ms
    Mar 7, 2008 7:43:04 PM com.sun.enterprise.v3.server.AppServerStartup run
    INFO: com.sun.enterprise.v3.services.impl.LogManagerService@388ee016 Init done in 411 ms
    Mar 7, 2008 7:43:04 PM com.sun.enterprise.v3.server.AppServerStartup run
    INFO: com.sun.enterprise.v3.services.impl.HouseKeeper@a210b5b Init done in 413 ms
    Mar 7, 2008 7:43:04 PM com.sun.enterprise.v3.services.impl.GrizzlyProxy start
    INFO: Listening on port 8080
    Mar 7, 2008 7:43:04 PM com.sun.enterprise.v3.services.impl.GrizzlyProxy start
    INFO: Listening on port 8181
    Mar 7, 2008 7:43:04 PM com.sun.enterprise.v3.services.impl.GrizzlyProxy start
    INFO: Listening on port 4848
    Mar 7, 2008 7:43:04 PM com.sun.enterprise.v3.server.AppServerStartup run
    INFO: com.sun.enterprise.v3.services.impl.GrizzlyService@506f9b8e startup done in 630 ms
    Mar 7, 2008 7:43:04 PM com.sun.enterprise.v3.server.AppServerStartup run
    INFO: com.sun.enterprise.security.SecurityServicesUtil@585976c2 startup done in 732 ms
    Mar 7, 2008 7:43:04 PM com.sun.enterprise.v3.server.AppServerStartup run
    INFO: Glassfish v3 started in 733 ms

You can see above it took 733ms to boot up!

Deploy the Grails App

Now that I have built MyFirstGrailsApp, it is time to deploy. So first I will create a war file:

    vivekmz@boson(558)> cd MyFirstGrailsApp/
    vivekmz@boson(559)> grails war

Now Let's deploy to GlassFish v3:

    vivekmz@boson(749)> ../glassfish/bin/asadmin deploy MyFirstGrailsApp-0.1.war
    SUCCESS : MyFirstGrailsApp-0.1 deployed successfully
    properties=(name=MyFirstGrailsApp-0.1)

The server log tells, it took about 9.7 seconds to deploy it:

Now when I accessing http://localhost:8080/MyFirstGrailsApp-0.1/ my Grails app appears in the Firefox:

GlassFish v3 has been going thru continuous improvements and the development team is busy making it rock solid while adding new features to it. Continue sending your feedbacks to users@glassfish.dev.java.net.

Python@Sun

This is further progress in solidifying Sun's Python story for dynamic language support in the JVM. Frank has been involved with Jython for quite some time and will be working on making Python language support in JVM. Ted will be represening Python in the open source world. Welcome Frank and Ted! See more on this story here.

This is just so exciting - JRuby, Jython, Da Vinci Machine, all of these are going to make it easier to not only have better support of dynamic languages in JVM but also in GlassFish!

I am looking forward to working with Frank and Ted for Python/Jyton support in GlassFish!

Ruby plugin for Hudson

Yes, I wrote my first Hudson plugin - a Ruby plugin as my weekend hobby project! You can use this plugin to write the build scripts using Ruby.

I must mention that Hudson has such an elegant architecture and the code is so well written. Kohsuke you Rock!

What's up with Scripting support on Glassfish?

Scripting is becoming ever popular among web application developers. Glassfish already supports Ruby on Rails with JRuby, Phobos brings in solid support for JavaScript on Glassfish and AJAX framework jMaki and all of these with excellent NetBeans tooling. There are other scripting languages such as PHP and Python, which are very popular among developers too. How nice would it be to deploy your PHP or Python based web applications on Glassfish? Well, we know that marrying Java and scripting languages has it's own challenges.

JSR-223 let you execute dynamic languages from inside Java. However the interpreters for such languages are written in Java and generate bytecodes and at runtime deal with all the dynamic types and method dispatching and what not. This is because JVM is designed to be used for statically typed language such as Java where you know the types at the compile time and to take care of types at the runtime the dynamic language interpreters use complex mechanism, which results in to uses of more memory, performance etc. JRuby overcomes these by doing JIT ahead of time, but then this poses limitation specially on the server side considering Rails which is single threaded.

The good news is that there are efforts in place in JVM to support Dynamic Languages, such as JSR -292 is going to add a new bytecode, invokedynamic, that supports efficient and flexible execution of method invocations in the absence of static type information. There is also a new project Da Vinci Machine that is going to bring in support for dynamic languages (or any other language) to JVM.

You might wonder why I am talking about all the scripting stuff! Well, I have taken up the role of Scripting Lead in Glassfish. I will ensure that Glassfish is home to many of the popular scripting languages out there and in fact will try to bring best of both worlds to Glassfish. JAX-WS will be lead by very capable Jitu.

I am working on wrapping up implementing some new features for upcoming Metro 1.2 or JAX-WS RI 2.1.4 and starting to take on Scripting Lead. Stay tuned, you will be hearing more form me in coming days...

Metro 1.0.1 and 1.1 Released

Metro team is pleased to announce the release of Metro 1.1 and Metro 1.0.1. Both these releases are fully tested with many thousands of SQE/Unit/Compatibility/Interop tests on Glassfish V2 UR1.

Metro 1.0.1 is a restricted bug fix release and is integrated with Glassfish V2 UR1.

Metro 1.0.1 includes WSIT 1.0.1 and JAX-WS RI 2.1.2.1.

Changelog for Metro 1.0.1

Metro 1.1 release includes WSIT 1.1 and JAX-WS RI 2.1.3. Metro 1.1 is a stand alone release but can be easily installed on Glassfish v2 UR1, see the instructions on how to here. Good news is that Metro 1.1.1 which is a bug fix and selected feature release of Metro 1.1, will be integrated in to upcoming Glassfish v2.1 (Sailfin). See Metro roadmap for details.

Here are some key features in Metro 1.1

Efficient Handler using Handler support. See Rama's blog
Large and Streaming attachment support
XML Schema validation support for SOAP message
Authentication support in wsimport
Additional header support
Early Access WS-Reliable Messaging 1.1 support
Early Access Kerberose Token support

Complete Change log for Metro 1.1

For the users who like JAX-WS RI stand alone bundle and Maven releases there is corresponding release of JAX-WS RI, JAX-WS RI 2.1.3 and JAX-WS RI 2.1.2.1. These version are also released in the JAX-WS Maven repository. See the detailed announcement here.

What is next? We are planning Metro 1.2 that will be released around March 2008 and also on Metro 1.1.1. Metro 1.1.1 will be integrated with upcoming Glassfish v2.1. See the details on Metro roadmap.

Continue sending your feedbacks to the forum and to the mailing list.