FAQ


This page present some questions about OpenMOLE.

Which Java version should I use?


OpenMOLE is fully working under OpenJDK 7 and 8. This is the recommended option. You can check which Java version you're running by typing java -version in a console.

If you use the closed-source Oracle Java virtual machine (which is probably the case if you are working on Mac or Windows), you have to install the Java Cryptography Extension (JCE) available at the bottom of this page in order for OpenMOLE to be fully functional.

JCE is an archive containing a bunch of files that you should replace in the jre/lib/security directory of your java installation. It enables strong cryptographic algorithms.

Another concern for Mac users are the concurrent versions of Java that are often present on the same system. Mac OS ships with a default Java 6 that is not suitable to execute OpenMOLE. You must install Java 7 ir greater and set the environment variable JAVA_HOME to the install location on your machine (typically the directory containing .../bin/java).

Where can I find the old versions of OpenMOLE?


Old versions of OpenMOLE software and documentation are available here.

OpenMOLE cannot connect to my environment using SSH


When one of the SSH authentications you've added to OpenMOLE is marked as failed, you can try these few steps to identify the problems.

If you are using OpenMOLE in console mode, enable the FINE level of logging in the console using: logger.level("FINE")

Password Authentication

If you are using the LoginPassword authentication you might want to double check the user and password you entered since one of them is more than likely incorrect.

SSH Keypair Authentication

In such a case, we'll have to investigate multiple options, as SSH public key authentications are sensitive to several configuration parameters.

Public key authentication has usually a higher priority than password-based authentication when trying to connect to a remote server. Thus, when you attempt an SSH connection to the the target environment, if your client asks you to enter a password (please note that a passphrase is different from a password), then your public key authentication is not taken into account.

SSH will skip your public key in case of bad configuration. The most common cases of badly configured keypairs are the following:
  • You haven't created an SSH keypair yet (using ssh-keygen). Private keys are usually stored in ~/.ssh/id_rsa or ~/.ssh/id_dsa, and should have a matching ~/.ssh/id_[rd]sa.pub next to them.
  • Permissions of your ~/.ssh folder must be set to drwx—— (700 in octal). Also, too permissive home directories (with write access given to the whole group for instance) might show problematic.
  • A ~/.ssh/authorized_keys file must be present on the remote system. It should at least contain a line matching the content of the ~/.ssh/id_[rd]sa.pub from your base system.
  • You entered a passphrase when you generated your SSH keys and cannot remember it. In such a case, it might be better to generate another keypair.

If you still could not solve your SSH authentication problems, another option is to recreate a public/private keypair using the ssh-keygen shell command. Store it to a different file to avoid overwriting the one already in place. You might also want to try a simple LoginPassword authentication as explained in the SSH section.

Adding the -vvv flag to your ssh command will give a lot more details on the communication between your client and the remote server. This will allow you to find out which authentication is successful as well as the order in which the authentication modes are tried.

Is OpenMOLE doing something?


If you think OpenMOLE is crashed or stuck for some reason, here are a few things you can check from your system to decide whether it's just a temporary slow down or if the platform did actually crash.

Using tools from the Java Development Kit

A simple call to jps from your command line will list all the instrumented JVMs on your system. If OpenMOLE is running, it is among these processes.

Now that you know OpenMOLE's process id, you can use jstack to print the eventual stack traces collected from OpenMOLE's threads. It's a bit low level but can at least give you enough material to thoroughly document your problem in the issue list or the mailing list.

The same procedure can be applied to the dbserver running along OpenMOLE to manage the replica of the files copied to execution environments.

Inspecting the temporary folders

OpenMOLE automatically creates temporary folders on the machine it's running in order to handle various inputs and outputs.

If you have access to the machine running OpenMOLE, change to your OpenMOLE's preferences folder down to the following path: /home/user/.openmole/my_machine/.tmp. List the content of this directory and change to the most recently created directory.

If you're using a remote environment, it should contain the tar archives used to populate new jobs on your remote computing environment, along with the input data files required by the task. The only presence of these files is a good indicator that OpenMOLE is functioning correctly and preparing the delegation of your workflow. Hardcore debuggers might want to go even deeper and extract the content of the tar archives to verify them, but this is out of scope.

However, touching on temporary file creation in OpenMOLE seamlessly leads us to our next entry...

I've reached my home folder size / file quota


OpenMOLE generates a fair amount of temporary files in the .openmole/mymachine/.tmp folder associated to your machine. Although these are deleted at the end of an execution, they can lead to a significant increase of the space occupied by your .openmole folder and of the number of files present in the same folder.

Because some systems place stringent limitations on these two quotas, you might want to move your .openmole folder to a file system not restricted by quotas in order to run your OpenMOLE experiment successfully. The simplest way to do so is to create a destination folder in the unrestricted file system and then create a symbolic link name .openmole in your home directory that points to this newly created folder. On a UNIX system, this procedure translates into the following commands.
# assumes /data is not restricted by quotas
cp -r ~/.openmole /data/openmole_data
rm -rf ~/.openmole
ln -s /data/openmole_data ~/.openmole

In order for this procedure to work, you'll want to ensure the target folder (/data/openmole in the example) can be reached from all the machines running your OpenMOLE installation.

Moving your .openmole to a different location is also strongly advised on remote execution hosts (typically clusters) on which you own a personal account used with OpenMOLE. In the case of remote environments, the OpenMOLE runtime and the input files of your workflow will be copied to the .openmole folder, again leading to problematic over quotas on these systems.

My sampling generates a type error


Combining samplings is straightforward in OpenMOLE, but can sometimes results in syntax errors a bit cryptic to new users. Let's take the example of a combined sampling made of a file exploration sampling and an integer range exploration:
(input in (workDirectory / "../data/").files withName inputName) x
i in (1 to 10)

This combined sampling will generate the following error when compiling the workflow:
found   : org.openmole.core.workflow.data.Prototype[Int]
required: org.openmole.core.workflow.sampling.Sampling

OpenMOLE cannot identify the integer range the valid sampling it is. Simply wrapping the expression in parentheses fixes the problem as shown in this correct version:
(input in (workDirectory / "../data/").files withName inputName) x
(i in (1 to 10))

My problem is not listed here


If you could not resolve your problems, feel free to post your problem on the mailing-list.

If you think your problem is induced by a bug in OpenMOLE, please report the issue exhaustively on our GitHub page.