I know, I know. It's got native code in it, and that's bad. It's using
JNI, and that's bad. But dammit, for the life of me I couldn't see
enough negatives to using Java Native Access that would outweigh the
incredible positives. For example, the new POSIX interface I just committed:
import com.sun.jna.Library;
public interface POSIX extends Library {
public int chmod(String filename, int mode);
public int chown(String filename, int owner, int group);
}
Given this library, it takes a whopping *one line of code* to wire up
the standard C library on a given platform:
import com.sun.jna.Native
POSIX posix = (POSIX)Native.loadLibrary("c", POSIX.class);
That's. It.
So the idea behind JNA (jna.dev.java.net) is to use a foreign function
interface library (libffi in this case) to wire up C libraries
programmatically. This allows loading a library, inspecting its
contents, and providing interfaces for those functions at runtime. They
get bound to the appropriate places in the interface implementation, and
JNA does some magic under the covers to handle converting types around.
And so far, it appears to do an outstanding job.
With this code in JRuby, we now have fully complete chmod and chown
functionality. Before, we had to either shell out for chmod or use Java
6 APIs that wouldn't allow setting executable bits, and we always had to
shell out for chown because there's no Java API for it. Now, both work
*flawlessly*.
The potential of this is enormous. Any C function we haven't been able
to emulate, we can just use directly. Symlinks, fcntl, file stats and
tests, process spawning and control, on and on and on. And how's this
for a wild idea: with a bit of trickery, we could actually wire up Ruby
C extensions, just by providing JNI/JRuby-aware implementations of the
Ruby C API functions.
So there it is. I went ahead and committed a trunk build of JNA, and I'm
working with the JNA guys to get a release out. We'll have to figure out
the platform-specific bits, probably by just shipping a bunch of
pre-built libraries (not a big deal; the JNI portion is about 26k), but
the result will be true POSIX functionality in JRuby...the "last mile"
of compatibility will largely be solved.
- Charlie
---------------------------------------------------------------------
To unsubscribe from this list please visit:
http://xircles.codehaus.org/manage_email
