This page present some questions about OpenMOLE.
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
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
in order for OpenMOLE to be
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
Old versions of OpenMOLE software and documentation are available here
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:
If you are using the
authentication you might want to double check the user and
password you entered since one of them is more than likely incorrect.
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
shell command. Store it to a different file to avoid
overwriting the one already in place. You might also want to try a simple
authentication as explained in the SSH section
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.
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.
A simple call to
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
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
running along OpenMOLE to manage the replica of the files copied to execution environments.
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...
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.
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]
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))
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