JRuby and JNI and OS X.
Like practically everyone I sat down a few years back and picked up enough Ruby to write an address-book app in Rails. Nice enough language, a few nice features[0]. Still at the end of the day... YADTL, so ultimately YAWN[1].
All this is to say that I found myself yesterday facing the need to convert a trivial rails app into a java servlet, with the added complication that it uses a third-party C++ library to do the bulk of the work.
JRuby is a trivial install, and the application in question didn't make use of continuations, so rip out all the Rails code, and replace with a simple loop that takes requests from the cmdline instead of a POST parameter, and we're in business.
Well up to the point where it falls over because it needs the C++ library. Here's the first real hurdle. Apple's JDK for OS X is compiled as a 64-bit binary which can't link against 32-bit libraries[2], and by default the C compiler only produces 32-bit libraries.
$ file /usr/local/lib/libcrfpp.dylib /usr/local/lib/libcrfpp.dylib: Mach-O dynamically linked shared library i386A quick check on google yields these pages that suggest that I need to add
-arch i386 -arch x86_64 to the CXXFLAGS and LDFLAGS. So after modifying the Makefile to compile the library with the above flags and install it in /opt/local we have:
$ file /opt/local/lib/libcrfpp.dylib /opt/local/lib/libcrfpp.dylib: Mach-O universal binary with 2 architectures /opt/local/lib/libcrfpp.dylib (for architecture i386): Mach-O dynamically linked shared library i386 /opt/local/lib/libcrfpp.dylib (for architecture x86_64): Mach-O 64-bit dynamically linked shared library x86_64
Then we need to compile the SWIG generated JNI wrapper, which will also require the above parameters, but also needs to link against Apples JNI installation. Back to Google which provides this page from Apple that describes how to compile JNI on Darwin, which provides the include path and an additional link flag.
The command lines to compile the wrapper in question becomes:
g++ -arch i386 -arch x86_64 -c -I/System/Library/Frameworks/JavaVM.framework/Headers CRFPP_wrap.cxx g++ -arch i386 -arch x86_64 -dynamiclib -L/opt/local/lib -lcrfpp -o libCRFPP.jnilib CRFPP_wrap.o -framework JavaVM
Wanting to avoid calling System.loadLibrary from ruby code I wrote a quick wrapper class that could make the call in a static block:
package crfppwrapper;
import org.chasen.crfpp.Tagger;
public class CRFPP {
public static Tagger newTagger(String args) {
return new Tagger(args);
}
static {
System.loadLibrary("CRFPP");
}
}
Finally modify the relevant ruby file to link to the jar file:
require 'java' require 'lib/CRFPP-0.53.jar'and call the wrapper:
crfppwrapper.CRFPP.newTagger("...");
Finally modify the toplevel jruby script to pass the necessary java parameters to the jvm:
#!/usr/bin/env jruby -J-Djava.library.path=/opt/local/lib -J-cp .:lib/CRFPP-0.53.jar -w
And it worked. No more Rails; migrated to jruby; and ready to bundle into a trivial servlet that will reintroduce the POST parameter to the mix.
[0] The implicit closure parameter to every function and an elegant brace syntax for creating the closures themselves does lend itself to some wonderfully elegant idioms.
[1] Of course if you were coming from J2EE you were probably more than happy to exchange static-typing for configuration-by-convention.
[2] And all of a sudden I'm having flashbacks to horror of IRIX binary toolchain management in the late 90's.
