On Oct 10, 2008, at 10:52 AM, Jason Dillon wrote:
On Oct 10, 2008, at 4:27 AM, Joe Bohn wrote:
Grails framework - This is a self contained framework that
leverages groovy for scripting. It uses a rails like code by
convention approach to generate and host web applications. It is
licensed under Apache. It embeds Jetty for hosting the generated
web applications but can also export WAR files which can be then
deployed application servers like Geronimo. There is an article
that gives a nice description on how to utilize Grails to generate
a web app and deploy it into Geronimo (http://www.ibm.com/developerworks/opensource/library/os-ag-grails/
).
As far as integration with Geronimo goes, I'm not sure that there
is much to we can do. I guess we could document this in our wiki
or perhaps generate a plugin (or whatever the Grails term is) so
that the geronimo deployment plan can be generated rather than
created manually, but I'm not sure that is worth the effort. There
doesn't seem to be a good place for programmatic integration with
regard to the framework itself.
Um, there isn't a good place, because there isn't really any need
for anything. From the containers perspective its just another WAR
deployment.
One thing I was thinking about was to create a Grails plugin (which
contains the jars required to run a Grails web app). Thus avoiding
having to package all of the Grails dependencies in the WAR, itself.
Instead, they'd be declared as a dependency. Pushing wars with a bunch
of redundant jars, didn't strike me as very desirable. Grails might
need a bit of customization to build suitable WARS.
I would still be interested to see something, a sample even, running
under Grails inside of Geronimo. AFAICT Grails is a very powerful
framework for whipping up apps, so we could potentially use it...
say for the console :-P
A sample would certainly be helpful... Agreed about Grails, in
general. I was thinking it would be interesting to see if we could
make it simpler/more efficient to bridge between the two environments.
JRuby on Rails - My understanding is that this is basically a Ruby
implementation that runs on the Java VM (the JRuby portion) and
leverages the Rails framework. It is licensed under CPL/GPL/LGPL.
In many ways it is similar to Grails using an embedded web server
to facilitate a rapid application development environment ... this
time built upon the JRuby language interpreter. Here again, I
suspect we can provide some directions so that an exported war
could be deployed in Geronimo (or perhaps a plugin to generate
geronimo deployment plans) but there doesn't seem to be much in the
way of direct integration that we can provide.
There are other frameworks as well. Trails is one that I stumbled
on which is also in the same vein as Grails with a focus on
definition of the domain model and generating the rest of the app
dynamically.
From what I have seen, most dynamic languages which run in Java also
support some-sort of web/WAR integration. But don't really require
much else to work. So I think that simply providing samples is
sufficient.
I guess supporting the javax.script/JSR-223 stuff via Apache BSF 3.x
is a good idea, though really I've no idea how/if/why someone would
want to use it. Maybe someone wants to generate a web-page, or
maybe someone wants to get the return value of a script injected
into their GBean, or wants the script to be their GBean, or wants to
have a chunk of script executed when the server loads... who knows.
Personally, I thought Grails was the best fit, but that may be because
I've used Groovy more (which isn't saying a whole lot) and new a bit
more about it...
--kevan
