Cassandra Ruby Gem Issues on Mac OS X 10.9.5

I was trying to resolve some issues with building the cassandra gem on Mac OS X 10.9.5. The solution was a multipart solution. You first need to build thrift first which has a known issue, and then build cassandra. This technical tip is very simple. I didn't want to lose it, and I am sure that there are other people out there who will need it.
Note: Please make sure you have updated all the gems in your repository before executing these commands. This will build both required gems.

JRuby and Rails 3

Rails 3.0 has been released. I know a number of you are excited about all of the possibilities. Along with the release of Rails is a new point release of JRuby.  So the big question is how do you use them together.

The default Rails environment uses SQLite as the database. Let me show you how to get started.

Riding on JRuby on Rails

1. Start by downloading JRuby, and install it.
2. Once it is installed you will want to install jruby-openssl.
   jruby -S gem install jruby-openssl
   
3. Next lets install the SQLite database gems.
   jruby -S gem install jdbc-sqlite3 activerecord-jdbc-adapter \
activerecord-jdbcsqlite3-adapter
   
4. Once we have installed the gems for SQLite, we can install Rails.
   jruby -S gem install rails mongrel warbler
   
5. Now that Rails is installed, we can create our example application. This will create our application.
   jruby -S rails new blog
   
6. Next we replace the following line in the Gemfile
   
gem 'sqlite3-ruby', :require => 'sqlite3'

   with the following:
   
if defined?(JRUBY_VERSION)
gem 'jdbc-sqlite3'
gem 'activerecord-jdbc-adapter'
gem 'activerecord-jdbcsqlite3-adapter'
gem 'jruby-openssl'
gem 'jruby-rack'
gem 'warbler'
else
gem 'sqlite3-ruby', :require => 'sqlite3'
end

   This allows us to run the application in JRuby, or Ruby.
   
7. Next we need to modify the config/database.yml file.
   
# SQLite version 3.x
# gem install sqlite3-ruby (not necessary on OS X Leopard)
development:
adapter: jdbcsqlite3
database: db/development.sqlite3
pool: 5
timeout: 5000

# Warning: The database defined as "test" will be erased and
# re-generated from your development database when you run "rake".
# Do not set this db to the same as development or production.
test:
adapter: jdbcsqlite3
database: db/test.sqlite3
pool: 5
timeout: 5000

production:
adapter: jdbcsqlite3
database: db/production.sqlite3
pool: 5
timeout: 5000

   
8. Next we need to migrate the database.
   jruby -S rake db:migrate
   
9. Finally we can start our new Rails 3 application.
   jruby -S rails server
   

That's it. You are riding on Rails in 9 steps.

References:

• JRuby:Wiki:GettingStarted
• JRuby and SQLite3 Living Together
• Deploy a Rails 3, Sqlite3 application in Tomcat using JRuby
  

Related articles by Zemanta

• SQLite 3.7.0 Released (sqlite.org)
• Ruby on Rails 3.0 sets sail gets off ground oh, chuff chuff (go.theregister.com)
• Multithreaded Rails is better than Async Rails, and Rainbows is cooler than Node (unlimitednovelty.com)

Why Movable Type, Drupal, or Wordpress on GlassFish?

The question of relevance has come up on why would you implement Movable Type, Drupal, or Wordpress on GlassFish. Is it because you can?

The answer is one of technology fundamentals and implementation strategies. I am a Java developer (if you could not figure that out from the blog title). I have access to GlassFish which I use for all of my web based application deployments. I want to be able to simplify my administration requirements by using a unified deployment platform. I also want to be able to combine the extensive libraries and frameworks that are available for Java. I want a simple intuitive administration console to handle most of my day-to-day needs. I want administration, and deployment to be scriptable. GlassFish solves a number of these issues, along with using Java, and Java based implementations of some popular languages like JRuby, and Jython.

First, GlassFish versions 2 and 3 are the reference implementations for Java Enterprise Editions (EE) 5 and 6 respectively. If you are doing enterprise software development, and want to use the latest reference versions, you should use GlassFish. I often write about Java Enterprise Edition (EE). I try to focus on the core technology since this keeps it compatible across other EE containers should you choose to move it to another container. GlassFish version 3 has made a number of positive steps in JEE 6 to make it easier to use. The new profiles in GlassFish make it easier to do web development.

Apache web server is very powerful. There is no question about that, but installing modules, and configuring it is not simple. If a module is not available in one of the pre-configured and installed versions on your system, you must compile it yourself. I am a very competent Apache administrator, and I have never had a simple download, and compile deployment. Let me contrast that with GlassFish, if you have Java 6 installed on your system, download and run it. If you are using JRuby, or Jython, GlassFish can handle it right out  of the box. In the case of JRuby, there have been a number of performance tests to show JRuby on Glassfish is faster that Ruby on WEBrick, or Mongrel. The Common Gateway Interface (CGI) servlet will allow you to take advantage of additional CGI technologies with simple configuration on a server wide basis, or on a per application basis.

Apache Web Server and GlassFish can take advantage of a number of frameworks. Apache Web Server can run Ruby applications with the appropriate module. However, it can not take advantage of other independent frameworks. Java on GlassFish allows Ruby developers to use Java frameworks like Swing within their applications. You can even create polyglot applications which use JRuby, Jython, and Clojure. This may be possible  with Apache Web Server, but I am unaware of it. This is a comment point for readers.

Simple and Intuitive administrative interface. That describes GlassFish administration console to a tee. I would even include elegant, and beautiful.

GlassFish Administration Console

Glassfish includes a very complete command-line interface. Anything you can do on the GUI based interface, you can do from the command-line. It also includes a number of advanced features which are not available in the adminstrative GUI.

Finally, as I noted above it has multiple configuration points with languages and technologies including Microsoft technologies.

I have found that GlassFish handles all of my Web based needs in a single platform. This combination of technology and integration points makes it easy to install relevant best of breed software like Drupal, Movable Type, or Redmine on the same platform and integrate functionality between them as necessary. It is very nice to have Redmine and Hudson CI running on the same platform. Combine it with Mercurial, and share a common SSO. This is not done easily on Apache Web Server, or any other platform.

I hope this clarifies my position on its relevance with Movable Type, Drupal, Wordpress, etc.

Book Review - NetBeans Ruby and Rails IDE with JRuby

I decided to write a quick review on the NetBeans Ruby and Rails IDE with JRuby book from Apress. The book is focused on NetBeans 6.5 and JRuby development. This is not a limitation on the book however. The book is really an introduction to how to use NetBeans to do Ruby development. The latest version of NetBeans (6.8) has a number of additional features (enhancements) over the version detailed in this book. Perhaps the authors can do an up-to-date version of the book to cover the latest enhancements. If not, perhaps I will consider taking up the mantle.

I really loved the book. I would give it 4/5 stars which if you have read my reviews is a brutal rating to get.

I performed a baseline install of NetBeans 6.5 including the plugins required for doing JRuby/Ruby development as noted in the book. The book follows along perfectly with the installer and IDE. I guess you could call this book the reference to the IDE for JRuby/Ruby development.

The first chapter details the installation and configuration of the IDE. The explanation is spot on, but NetBeans is also really to install and configure.

The second chapter covers your basic "Hello World" from both a basic JRuby project and from JRuby on Rails (JRoR).

The third chapter covers configuration of JRuby using the NetBeans gem manager, setting up servers, and configuring databases for use with the development environment. The section on gems with native extensions, and replacements is very helpful.

Chapters four and five cover Ruby and Rails projects in more detail. It demonstrates a number of the capabilities that the IDE.  I really like the Rails Console and example of how to use it.

Chapter six covers editing files and the capabilities that the IDE provides including code completion. This was the first real mainstream IDE to provide JRuby/Ruby code completion. It does it beautifully.

Chapter seven covers debugging and testing. The authors do a great job of explaining why NetBeans should be your choice of IDE for doing Ruby development.

JRuby itself is the topic of chapter eight. There is an example of how to use JRuby in Java projects. This is really cool. However, it should be noted that you need to make some changes for it to work on JSE5. This is noted on Page 136, but the code needs a slight modification to use JRubyScriptEngineManager instead of ScriptEngineManager.

Chapter nine covers Ruby on Rails (RoR) deployments using warbler. I have found warbler to be a great  tool and use it extensively to deploy applications to GlassFish v 2.x.

Chapter ten is all about the IDE. It shows the user a number of customizations available to make NetBeans customized to your style.  This is no small accomplishment. The NetBeans team have made a really great IDE and made it extremely flexible. This flexibility did not sacrifice simplicity. Eclipse is flexible too, but a a severe penalty to ease.

In summary, if you are thinking of trying JRuby, or Ruby development, and you want to give NetBeans a try, this is the book to buy 4/5 stars.

Errata

There is not much to report. My only real gripe is that the Mac short-cut keys are incorrect in a number of places. However, you will figure it out immediately. If it says <cmd> and it does not work... try <ctrl>.

(Page 43)  Item #2 refers to a diagram which is not correct. The diagram which it refers to is not in the book.

(Page 133) The diagram JVM arguments are incorrect. The correct argument is listed under the input box as part of the inline help.

Redmine 0.8.4 Deployment on GlassFish 2.1 using JRuby 1.3.1

Introduction

In this tutorial I will explain how to install Redmine 0.8.4 on GlassFish 2.1 using JRuby 1.3.1 with MySQL.

Required Software

• Redmine 0.8.4


• GlassFish 2.1


• NetBeans 6.7


• MySQL 5.1

Instructions

1. First we will need to download and install JRuby 1.3.1. The binaries can be found on the Kenai site.


2. Make sure that your PATH is set to point to your JRuby installation. You can check your install by typing jruby -v at the command prompt. You should see something similar to the listing below.
   

   dev:~ jyeary$ jruby -v

   jruby 1.3.1 (ruby 1.8.6p287) (2009-06-15 2fd6c3d) (Java HotSpot(TM) 64-Bit Server VM 1.6.0_15) [x86_64-java]



3. Run from the command line

   jruby -S gem update

   This will update all of the gems required to run our application.


4. Run from the command line

   jruby -S gem install jruby-openssl rails mongrel jdbc-mysql activerecord-jdbcmysql-adapter warbler

   This will install all of the gems required to run our application.


5. Download a copy of Redmine 0.8.4 and unzip it.


6. Using NetBeans 6.7.1, check the Tools --> Ruby Platform Manager to make sure that you install the JRuby 1.3.1 platform.
   
   
   
   


7. In NetBeans, create a new Ruby on Rails Application with Existing Sources. Next
   
   
   
   


8. Select the unzipped RoR Redmine application as the project folder.


9. Select the JRuby 1.3.1 Platform from the combo-box menu.


10. Select Mongrel for the server from the combo-box menu. Click Finish. NetBeans will create the RoR project and install Warbler which will create our war file for deployment on GlassFish.
    
    
    
    


11. We are now ready to configure the application. Follow the instructions for configuring the application here.


12. In the redmine-0.8.4 directory run the following command
    

    jruby -S warble config
    

    This will create the configuration file for warbler to build our war file for deployment on GlassFish.
    


13. Edit the warble.rb file and modify the config.dirs line to the following:
    

    config.dirs = %w(app config lib log vendor tmp files lang)

    This will make sure that we deploy all of the application relevant files in our war file.
    


14. Edit the warble.rb file and add the following line:
    

    config.gems = ["activerecord-jdbcmysql-adapter"]

    This will make sure that when we convert the application to a war file that the appropriate ActiveRecord JDBC drivers for MySQL are added to it.
    


15. Run the application to make sure that it runs correctly on Mongrel.


16. Run the following commands to create the war file
    

    jruby -S rake war:clean
    jruby -S rake war
    

    
    


17. Go to the Administrative Console on GlassFish. Select Web Applications and deploy the new redmine-0.8.4.war file.
    
    
    
    
    
    

Quercus PHP 3.2.1 on GlassFish 2.1

I am trying to consolidate a number of applications running on various platforms to GlassFish, if possible. So far I have been incredibly successful with Ruby using JRuby. Our project tracking software (bugs/news/wiki/forums/repository browser) are running on Redmine using JRuby.

Based on the success of using Ruby (RoR), I decided to trying moving some PHP applications over to GlassFish.

I read a great blog article by Ludovic Champenois called 100% Java Quercus PHP engine running in GlassFish Java EE 5 Application Server It describes how to use an open source engine called Quercus from Caucho. I tried to follow the directions, but could not get it to work. I imagine because the versions of GlassFish application server and Quercus may have been different. I was not deterred.

I came across a follow-up article by Arun Gupta called PHP in GlassFish using Caucho Quercus. This article was the missing link. The major difference being the placement of the jar files in the domain/domainXX/lib directory.

Here are the application versions I used to get a functional Caucho Quercus PHP implementation running on GlassFish v 2.1

Mac OS X 10.5.6 (Intel x86)

• GlassFish v 2.1 Build 60e ( 2.1 FCS)
• Quercus 3.2.1
• Java(TM) SE Runtime Environment (build 1.6.0_07-b06-146) Java HotSpot(TM) 64-Bit Server VM (build 1.6.0_07-b06-56, mixed mode)

Mac OS X 10.5.6 (PowerPC)

• GlassFish v 2.1 Build 60e ( 2.1 FCS)
• Quercus 3.2.1
• jsr223-api.jar (Project Phobos) Required for Java SE 5.
• Java(TM) 2 Runtime Environment, Standard Edition (build 1.5.0_16-b06-284) Java HotSpot(TM) Client VM (build 1.5.0_16-133, mixed mode, sharing)

When I created my projects I used the following web.xml It is based on the example web.xml in the Quercus 3.2.1 war file.

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<session-config>
   <session-timeout>
       30
   </session-timeout>
</session-config>

<description>Caucho Technology's PHP Implementation</description>
<servlet>
   <servlet-name>Quercus Servlet</servlet-name>
   <servlet-class>com.caucho.quercus.servlet.QuercusServlet</servlet-class>
<!-- Specifies the encoding Quercus should use to read in PHP scripts.
    -->
<!--
    <init-param>
      <param-name>script-encoding</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
    -->

<!-- Tells Quercus to use the following JDBC database and to ignore the
         arguments of mysql_connect().
    -->
<!--
    <init-param>
      <param-name>database</param-name>
      <param-value>jdbc/test</param-value>
    </init-param>
    -->

<!--
    <init-param>
      <param-name>ini-file</param-name>
      <param-value>WEB-INF/php.ini</param-value>
    </init-param>
    -->
</servlet>

<servlet-mapping>
   <servlet-name>Quercus Servlet</servlet-name>
   <url-pattern>*.php</url-pattern>
</servlet-mapping>
<welcome-file-list>
   <welcome-file>index.php</welcome-file>
</welcome-file-list>
</web-app>

This arrangement will allow you run a large number of applications including XWiki, and Drupal. Unfortunately for me, it can not run phpLDAPadmin which I needed.