How to get jMoby

Using jMoby from CVS
The jMoby software is part of the Moby CVS repository - look for a subdirectory moby-live/Java.

Using binary distributions
There are several binary distributions, each of them focusing on some specific features. (Remember, however, that you can always get everything in one go from the CVS repository.)

Using jMoby for Maven
This is an option for those wanting to use jMoby libraries in their own Java projects.

The only thing you need to know is how to refer to the jMoby library in a Maven repository (you need to find the latest version number by browsing the given Maven repository):



Latest changes are available either as a summary or in details from the CVS repository.

Using jMoby from CVS

Once you checked out your local CVS copy (here is how to do it), go to the moby-live/Java subdirectory. All directory and files names used below assume that you are in this directory.

How to build it
What are the build targets
Where to put things
How to use it


How to build it

Before doing anything else you need to build all Java classes. Just type:
   ant install
or, if you have already installed it before, type:
   ant clean compile
In order to find what tasks are available, type:
   ant -projecthelp
The available task can be specified on the command line when invoking the Ant. For example:
   ant all
Default task is compile.

It also uses file (if such file exists either in this directory or in your home directory) - where you can specify your-site-specific properties. The properties - that can be set there - are described in more details in

What are the build targets

The build Ant's targets are based on file build.xml. There you can find all details what can be build, and what properties are used. Here are just main targets explained in more details.

There is also a graphical snapshot of our Ant tagrets (and here you can find how it was created).

Here are the common targets:

It compiles all sources in the src subdirectory. If you add there a source file but it is not yet ready to be compiled put it into a directory notyet (on any level below src). It also guarantees that CLASSPATH is correctly set before compilation (including all classes created from the src and all jar files from the lib directory).

It removes all generated files, including all compiled classes (but it does not remove third-party libraries from the lib directory). It is always good idea to make sure that all your changes are really compilable before you commit, by typing:
ant clean compile
It generates API documentation (into docs/API) for all classes, excluding those specifically mentioned in the property excluded.documented.packages and/or excluded.documented.files.

It creates several jar files (build/lib/*.jar) with all classes from src.

It creates a jar file (build/lib/RDFagent.jar) with classes for RDF Agent sub-project.

It creates all run-time scripts. The templates for these scripts are in src/config and they are created in build/run. Once there they contain fully qualified paths reflecting the location of your CVS copy, so they can be used without setting any CLASSPATH.

This target is called automatically by the compile target.

It calls many other targets to clean, compile, generate API and to build all binary distributions.

This is a special target fetching the Maven library (that is needed to fetch all jMoby dependencies). It is called automatically when you call ant install.

How to use it

Once built you can start many clients using pre-defined run-time scripts. All these scripts are in build/run directory.

You do not need to be in any particular directory to use these scripts. But you need to have java on your path (the scripts are too dumb to understand JAVA_HOME environment variable).

For example, try:

   ./build/run/run-cmdline-client -help
or, on Windows platforms:
   build\run\run-cmdline-client.bat -help
More details what individual clients actually do can be found in a separate document.

Using jMoby from binary distributions

The binary distributions are available from the main jMoby site (located on the same place as the main BioMoby pages).

Servlet for host MOBY services
Graphical end-user client
Servlets producing BioMoby graphs
RDF Agent

Servlet for host MOBY services

For your convenience, a base MOBY Servlet WAR file is available for developers wishing to develop MOBY Services using the general object access methods. Documentation on how to easily deploy such services can be found here.

Standalone graphical client

The Seahawk JAR contains a GUI client that can be used as a standalone browser, or it can be easily embedded in another Java application.

Servlets producing BioMoby graphs

This distribution is a war file - an archive that can be deployed in any Servlet engine (tested mostly with Tomcat from Apache). It contains several jMoby servlets, especially those producing jMoby graphs. It is meant for those who wish to deploy such servlets on their own machines (they do not need to have a Moby registry installed there, however).

The file is named jMoby-<date>.war. Take the latest version and put it (without unpacking it) where your servlet engine sits. For Tomcat it is here: <your-tomcat-home-directory>/webapps/. Then restart your Tomcat. It will unpack it and will create a directory webapps/jmoby. Before using it, you have to edit webapps/jmoby/WEB-INF/web.xml to reflect your local environment. Once done, start to use it (the URL depends how you edited the web.xml file).

Please report all problems, or submit features and wishes about these clients to Martin Senger.

RDF Agent

This distribution contains an RDF agent. The file is named rdfagent-<date>.[zip|tar.gz], take the latest version (pick up either .tar.gz or .zip - both are equivalent).

Unpack it. It creates a directory named rdfagent, go there, check the README file, and start using it.

What is the RDF Agent?

Instructions on downloading and installing the RDF Agent
Please report all problems, or submit features and wishes about these clients to Eddie Kawas.
Martin Senger
Last modified: Fri Feb 22 10:56:58 2008