I’ve just released a new version of the jetty-rails gem. Now, you can also run Merb applications inside JRuby and Jetty!
jruby -S gem install jetty-rails cd mymerbapp jruby -S jetty_merb
Unfortunately, it’s blocking my console (ctrl + c doesn’t terminate it). Has anyone suggestions on this?
I’ve also updated the basic documentation, as you can see here.
The Merb support was actually done in JRuby Rack. It was quite simple to support it. Many thanks to Nick Sieger, Dudley Flanders e cia!
This is the first time I’m writing about it, but jetty-rails is already 0.3!
Most people doing JRuby on Rails development are using JMongrels1 for development and some real Java Application Server in production.
The common flow is:
$ 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 ** Starting Mongrel listening at 0.0.0.0:3000 ** Starting Rails with development environment...
code, code, test, code, code, test, … (shouldn’t it be red-green-refactor?)
$ jruby -S warble $ cp myapp.war $TOMCAT_HOME/webapps $ $TOMCAT_HOME/bin/startup.sh
Sure you can automate those things with ant, rake, sake or anything else. Some people are still using the goldspike-plugin, but be warned: I suspect it won’t get much more attention.
The great Warbler from Nick Sieger is becoming the de facto standard for JRuby on Rails packaging. The Warbler’s recent move from goldspike to JRuby-Rack adapter reveals two interesting points:
Although Warbler works really well, it introduces complexity in the development cycle. You can no more save code and immediately test it in your browser:
It breaks one of the most important rails development characteristics: instant feedback. During development, it’s very important to see changes without have to wait for server/context restarting.
JMongrel and Glassfish Gem are good candidates for JRuby on Rails development with instant feedback, but you can’t use Java (Servlet specification) specific features, such as web.xml; they aren’t complete Servlet Containers. Some things have an alternative in pure-rails as Servlet Filters and Servlet Listeners, but many haven’t. Servlet Context might be a good way to share things between rails runtimes. I know railers should “share nothing”, but -hey- sometimes it’s so good to share!
You can take the Servlet Application Context as your in-memory cache store (fragment and page caching), eliminating the need for filesystem or database overhead and even memcached, in many cases.
I had also a specific reason to share the same HttpSession between Rails and “pure Java” applications. Single sign-on wasn’t an option, so I needed to run both applications in the same context. I’m going to tell more about it soon.
Anyone can fall in cases, like mine, when you just can’t use jmongrel or glassfish_rails. Now, we fortunately have jetty-rails to rescue!
It’s a (one more) gem to run rails applications, based on the nice JRuby-Rack adapter, which I recommend you to take a look. Jetty is a very powerful Servlet Container, known for being pioneer at being embedded and at using NIO Connectors.
The gem creates a Jetty Server with two Handlers. The first is for static content and the last to serve dynamic requests using JRuby-Rack. These handlers are applied in order and request processing stops when one responds. That way, no rails code is runned to serve static content, improving response times. Take a look at the rdocs for more details.
Jetty is also very quick to start. I’ve measured (in a complete inaccurate way) some start times just for ugly2 comparison:
$ jruby -v ruby 1.8.6 (2008-03-28 rev 6360) [i386-jruby1.1] $ time jruby script/server => Booting Mongrel (use 'script/server webrick' to force WEBrick) => Rails application starting on http://0.0.0.0:3000 ... ** INT signal received. Exiting real 0m13.947s user 0m11.327s sys 0m0.892s
$ ruby -v ruby 1.8.6 (2007-09-24 patchlevel 111) [universal-darwin9.0] $ time ./script/server => Booting Mongrel (use 'script/server webrick' to force WEBrick) => Rails application starting on http://0.0.0.0:3000 ... ** INT signal received. Exiting real 0m6.273s user 0m1.893s sys 0m0.611s
With the same JRuby 1.1 (and without Charles recent speedup patch for jruby startup):
$ time jruby -S jetty_rails 2008-05-04 10:50:00.846::INFO: Logging to STDERR via org.mortbay.log.StdErrLog 2008-05-04 10:50:01.013::INFO: jetty-6.1.9 ... 2008-05-04 10:50:02.987::INFO: Started SelectChannelConnector@0.0.0.0:8080 real 0m7.035s user 0m4.387s sys 0m0.296s
As you can see, jetty_rails is very close to mongrel running in MRI, but please, don’t take those numbers so seriously.
Jetty Rails should be ready to run any rails application (tell me otherwise!) with no dependencies on extra jars. All gems used by the application must be installed in your JRuby. I’ve made some simple benchmarks with JMeter and only one thread, firing 500 consecutive requests to a simple rails blog application. All requests pointed to ‘/posts’ controller, and there was only one Post is the MySQL database.
The machine used to run all tests is a Intel Core2 Duo E4500 @ 2.20GHz, 2.0GB RAM, running Ubuntu 7.10, Ruby (MRI) 1.8.6 and JRuby 1.1.1. MRI tests were done using plain ruby activerecord-mysql-adapter and JRuby tests were done using activerecord-jdbcmysql-adapter.
Mongrel: 30.7 req/s
JMongrel: 19.1 req/s
Glassfish Gem: 17.5 req/s
dropping JVM warm time: 23.8 req/s
Jetty Rails: 18.2 req/s
dropping JVM warm time: 26.6 req/s
This is obviously a simple measure, just to feel how jetty-rails is going. But I’m very happy with the results. If we ignore the time that JVM takes to warm and JIT compile things, jetty-rails comes close to Mongrel! Impressive. I knew Jetty was always very fast, but I really didn’t expect those results.
There is much more to do. Things from the roadmap I wanted to see working soon include:
The source code lives in GitHub. Feel free to fork, contribute, send patches and suggestions!
It was a great time last weekend, spending part of my holiday at RejectConf SP’07 in Brazil, “our first relevant conference”, as said by Fabio Akita.
The lectures were really great and the coffee-break (thanks Caelum) really came on the right time. During his RSpec talk, Danilo Sato created a web application to rate the presentations. As you can see there, the coffee-break shined. It was a pleasure to meet new people from our community and to see old friends.
I talked about the most fantastic project nowadays and fortunately people seemed very interested about it. Get the slides.
One week before (10 Nov 2007), I was at Conexao Java 2007 and gave a mini-course (~6 hours) about JSF, Ajax and Richfaces. Great time too, thanks to all attendees!
You can get the slides and code here. More info at the Caelum Blog (pt-BR).
Ruby has changed its logo:
It’s licensed under the Creative Commons Attribution-ShareAlike license and created by Tom Schaub for the Ruby Logo Contest.
IMO, the older logo is far better:
Sexy, simple and cleaner. What do you think?
Recently, I built an internal DSL using Scheme to describe Deterministic Finite State Automata. It was quite easy to do through Scheme Macros, whose are really powerful (and hard to understand). The article “S. Krishnamurti. Automata via Macros. Journal of Functional Programming, Volume 16 , Issue 3 (May 2006)” is a great reference if you want to go deeply.
A macro to describe automata in Scheme would be as:
(define-syntax automaton
(syntax-rules (:)
[(_ init-state
(state : response ...)
...)
(let-syntax
([process-state
(syntax-rules (accept ->)
[(_ accept)
(lambda (stream )
(cond
[(empty? stream ) true]
[else false]))]
[(_ (label -> target ) (... ...))
(lambda (stream)
(cond
[(empty? stream ) false]
[else
(case (first stream )
[(label ) (target (rest stream ))]
(... ...)
[else false])]))])])
(letrec ([state
(process-state response ...)]
...)
init-state ))]))
Imagine it’s needed to recognize chars sequences like c[ad]*r. Such macro, would allow you to describe a recognizer automaton for these char sequences:
(define cdar-sequence?
(automaton init
[init : (c -> more)]
[more : (a -> more)
(d -> more)
(r -> end)]
[end : accept]))
Now you can test any char sequence:
(cdar-sequence? '(c a d a d r)) ; => #t (cdar-sequence? '(c a r a d r)) ; => #f
Well, I have to do it now in Ruby. Has anyone built some Ruby internal DSL to describe automata? I really wanted to describe them such as:
automaton "recognizer" do
initial_state :state1 do
transition 'c', state2
transition 'd', state3
end
state :state2 do
transition 'c', state3
end
final_state :state3
end
I haven’t found anything and probably will make something. What do you think?
Unfortunately, we still have few events related to Ruby on Rails here in Brazil. Fabio Akita started the movement to change it.
We are organizing an event here in Ṣo Paulo РBrazil (link pt-BR), similar to RejectConfs. It will happen on November 17, 2007.
If you are close to São Paulo this day, do not miss it.
Update: rubyonrailsworkshops.com is now listing our event and Geoffrey Grosenbach talked about it in his last Ruby on Rails podcast. Great.
It’s been amazing days for tech guys like me. Due to the incredible job from the JRuby team (take a look here, here and here), JRuby is closer than ever to run Rails apps faster than MRI!
Congrats guys. I will for sure keep watching.
Some more great news came from JetBrains: “The Magnificent Seven is Released”. IntelliJ IDEA 7 (aka Selena) official release is available!
Fabio Kung 