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 finche’ 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 JAVA_HOME (e di aver aggiunto al PATH la JAVA_HOME/bin).
Andiamo sul sito 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 JRUBY_HOME aggiungendo al PATH JRUBY_HOME/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 sopra riportate.
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 http://localhost:3000 e andiamo a vedere “About your application’s environment”
Figura 1 – L’ambiente della nostra applicazione
Andiamo a richiamare 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 (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
http://jruby.codehaus.org/
[2] 120 seconds guide to JRuby on Rails, The Empty Way
http://blog.emptyway.com/2008/04/08/120-seconds-guide-to-jruby-on-rails/
[3] JRuby on Rails on Tomcat, JRuby Wiki
http://wiki.jruby.org/wiki/Jruby_on_Rails_on_Tomcat
[4] Warbler, JRuby Wiki
http://wiki.jruby.org/wiki/Warbler
[5] Goldspike, JRuby Wiki
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
http://www.ibm.com/developerworks/websphere/techjournal/0801_shillington/0801_shillington.html
[7] JRuby and the Java Platform, SDN
http://java.sun.com/developer/technicalArticles/scripting/jruby/
Laureato in Scienze Statistiche e particolarmente attento alle novità che lo circondano, dal 1998 lavora nel settore dell‘IT. Prevalentemente coinvolto in progetti legati a Java, da un paio d‘anni è interessato al mondo Open Source. Dopo aver accumulato una notevole esperienza presso vari clienti e con vari ruoli (da programmatore a coordinatore gruppo di sviluppo), attualmente lavora in Ancitel S.p.A.