Introduzione

Nei precedenti articoli ci siamo occupati di Ruby e Rails senza considerare alcun punto di contatto con il mondo Java. Ora con JRuby forniamo il "bridge" tra le due piattaforme.

JRuby

Cosa è JRuby? JRuby è un'implementazione del linguaggio Ruby in Java. Molto semplicemente questo implica che il codice scritto in Ruby per essere utilizzato con MRI (Matz' Ruby Implementation) può essere fruito in una piattaforma Java. Perchè questo? Innanzitutto perchè ci sono milioni di righe di codice Java nel mondo con le quali un'applicazione Ruby, ricorrendo a JRuby, può interagire. Questo mantenendo la semplicità e velocità di sviluppo del linguaggio Ruby. Risulta in tal modo possibile sfruttare le potenzialità di un'interfaccia grafica utilizzabile sotto qualsiasi OS o accedere alle Math library Java. Inoltre, attraverso BSF (Bean Scripting Framework) si può invocare uno script Jruby dalla nostra applicazione Java. Altro valido motivo (almeno finché non risulterà disponibile Ruby 2.0) è riconducibile al fatto che l'implementazione in C di Ruby usa "green threads", non consentendo quindi, a differenza di quanto avviene in Java (e quindi con Jruby), di ricorrere ai thread nativi del sistema operativo. Ora vediamo in che modo ottenere tutto questo.

Installiamo e configuriamo JRuby

Supponiamo di avere già installato sulla macchina un JRE 1.6 e di aver settato la variabile d'ambiente JAVAHOME (e di aver aggiunto al PATH la JAVAHOME/bin). Andiamo sul sito HYPERLINK "http://dist.codehaus.org/jruby/" http://dist.codehaus.org/jruby/ e facciamo il download della versione che ci interessa di JRuby. Nello specifico, abbiamo utilizzato 1.1. Esplodiamo il pacchetto e configuriamo la nostra JRUBYHOME aggiungendo al PATH JRUBYHOME/bin. A questo punto dovremmo senza difficoltà disporre di tutti i comandi jruby. Come test proviamo

jruby –version

e dovremmo ottenere qualcosa del tipo

ruby 1.8.6 (2008-03-18 rev 6255) [i386-jruby1.1]

Utilizziamo classi Java da Ruby

Scriviamo qualche semplice riga di codice che consente di invocare codice Java da Ruby. Creiamo un file testJava.rb con il seguente contenuto

require 'java'
include_class 'java.util.TreeSet'
myset = TreeSet.new
myset.add "Primo"
myset.add "Secondo"
myset.add "Terzo"
i=0
myset.each do |v|
	puts "value:#{i} #{v}"
	i=i+1
end

Lanciamo jruby testJava.rb e dovremmo veder in output qualcosa del tipo:

value:0 Primo
value:1 Secondo
value:2 Terzo

Questo sta a significare che possiamo da codice Ruby utilizzare (quasi) qualsiasi libreria disponibile in ambiente Java .

Dove vogliamo andare a parare

Quello che a noi interessa è effettuare il deployment su di un application server Java di un'applicazione basata sul framework RoR. Seguiamo passo passo tutte le operazioni necessarie a raggiungere il risultato che ci siamo preposti. L'ambiente in cui abbiamo effettuato l'operazione è il seguente:

  • JRE 1.6.0
  • Tomcat 6
  • JRuby 1.1
  • RubyOnRails 2.0.2
  • Supponiamo di utilizzare MySQL come DBMS

Queste le operazioni da effettuare. Prima di tutto installiamo le "gemme" necessarie:

  • mongrel, un web server (per lo sviluppo e per fare dei test intermedi)
  • activerecord-jdbcmysql-adapter, l'adapter per consentire ad ActiveRecord di parlare con MySQL
  • rails... e qui non diciamo altro

In un'unico passaggio installiamole tutte.

jruby -S gem install mongrel activerecord-jdbcmysql-adapter rails

Attendiamo che l'operazione vada a buon fine e passiamo all'attività successiva.

Creiamo un applicazione Rails che parla con MySQL via JRuby e Jdbc Adapter

jruby -S rails mokaapp -d mysql

Entriamo nella nostra cartella mokaapp ed editiamo config/database.yml Impostiamo i parametri corrispondenti alla nostra base dati specificando l' adapter JDBC invece del default generato.

development:
  adapter: jdbcmysql
  encoding: utf8
  database: mokaapp
  username: moka
  password: moka

Chiaramente dobbiamo avere disponibile una base dati con le caratteristiche soprariportate. Creiamo la base dati

jruby -S rake db:create:all

quindi creiamo la nostra scaffold per la tabella testmoka

jruby script/generate scaffold testmoka title:string body:text

quindi eseguiamo le operazioni sul database

jruby -S rake db:migrate

A questo punto facciamo partire Mongrel

jruby script/server

Abbiamo la nostra applicazione Rails disponibile, ma questa volta stiamo girando su di un Runtime Environment Java. Via browser invochiamo HYPERLINK "http://localhost:3000/" http://localhost:3000 e andiamo a vedere "About your application's environment"

Figura 1 - L'ambiente della nostra applicazione
Figura 1 - L'ambiente della nostra applicazione

Andiamo a richiamare HYPERLINK "http://localhost:3000/testmokas" http://localhost:3000/testmokas e iniziamo a fruire della scaffold application RoR. A questo punto però avremmo piacere (o meglio dei vantaggi) nel rendere disponibile l'applicazione su di una piattaforma "tipica", diciamo Apache Tomcat. Vediamo come procedere. Lo strumento più immediato che ci consente di effettuare l'operazione di creazione del .war con tutto il necessario si chiama Warbler.

Installiamo la gemma

jruby -S gem install -y rails warbler

Il comando per effettuare questa operazione, lanciato sempre dalla root dell'applicazione, è

jruby -S warble war

Prima di far questo creiamo il nostro file di configurazione config/warble.rb mediante

jruby -S warble config

Il default dovrebbe andare... magari mettendo

config.webxml.rails_env = 'development'

per puntare alla base dati di sviluppo. Il file è ampiamente documentato quindi non ci dovrebbero essere ostacoli particolari nella modifica della configurazione. Dobbiamo fare attenzione al fatto che, utilizzando Rails 2.0, è presente nell'application.rb un meccanismo di security... che al momento evitiamo.

protect_from_forgery # :secret

In questa fase eludiamo il problema e commentiamo l'istruzione prima di effettuare la creazione del nostro mokaapp.war. A questo punto dovremmo poterne effettuare il deployment sotto un qualsiasi Application Server Java. Così facendo ci apriamo alla possibilità di rendere disponibile la facilità di sviluppo del mondo Rails e della programmazione Ruby alla solidità di un'ambiente Java-based.

Conclusioni

Abbiamo messo le basi per consentire di utilizzare Ruby e soprattutto Ruby on Rails con una JRE attraverso JRuby. Il progetto (HYPERLINK "http://jruby.codehaus.org/" http://jruby.codehaus.org/) sembra evolversi piuttosto rapidamente ed il supporto di strumenti quali NetBeans o Eclipse completerà di fatto l'operazione di "bridging" tra i due mondi.

Riferimenti

  • [1] JRuby Home

HYPERLINK "http://www.pragmaticprogrammer.com/" http://jruby.codehaus.org/

  • [2] 120 seconds guide to JRuby on Rails, The Empty Way

HYPERLINK "http://www.pragmaticprogrammer.com/" http://blog.emptyway.com/2008/04/08/120-seconds-guide-to-jruby-on-rails/

  • [3] JRuby on Rails on Tomcat, JRuby Wiki

HYPERLINK "http://wiki.jruby.org/wiki/JrubyonRailsonTomcat" http://wiki.jruby.org/wiki/JrubyonRailsonTomcat

  • [4] Warbler, JRuby Wiki

HYPERLINK "http://wiki.jruby.org/wiki/Warbler" http://wiki.jruby.org/wiki/Warbler

  • [5] Goldspike, JRuby Wiki

HYPERLINK "http://mongrel.rubyforge.org/" http://wiki.jruby.org/wiki/Goldspike

  • [6] Riding the Rails with WebSphere: Part 1: Combine Ruby on Rails with WebSphere Application Server and get rapid development with security, scalability, and reliability

HYPERLINK "http://www.fastcgi.com/" http://www.ibm.com/developerworks/websphere/techjournal/0801shillington/0801shillington.html

  • [7] JRuby and the Java Platform, SDN

HYPERLINK "http://java.sun.com/developer/technicalArticles/scripting/jruby/" http://java.sun.com/developer/technicalArticles/scripting/jruby/