This guide helps you get started with Meveo. It covers server configuration and use of the default database. Advanced deployment options are not covered. For a deeper description of features or configuration options, consult the other reference guides.



SQL Configuration

SQL Configuration is introduced in version 6.6.0. The idea is to have an option to store different studies on different database locations. For example, study a is stored on data source a while study b is on data source b. By default, the MEVEO manage connection is still available and save as the "default" SqlConfiguration and linked to a "default" repository stored in a database. Unchanged, this is still where the CETs are saved.

SQL Connection Provider

The default repository and SQL configuration are checked on the application start and created if they don’t exist yet in the database. The code for this feature is in class SQLConnectionProvider. This class also contains the methods to open a new SQL connection with a given SQL configuration. See SQLConnectionProvider.getSession(SQLConfiguration).


A repository is a storage object that holds the connection setting for the different data sources. Currently, there are three supported data sources SQL, Neo4j and Binary or files.

The data on two or more SQL data sources are not merged, that is why a repository filter is provided on both API and GUI.

SQL Configuration Table

Here are the fields of the table SqlConfiguration:

Table 1. SQL Configuration Table



String driverClass

The class used to load this data source, the appropriate jar must be in the classpath. By default, PostgreSQL and Neo4j are already loaded.

String url

This is the URL of this data source. For example jdbc:postgresql://localhost:5432/meveo.

String username

The data source’s username.

String password

The data source’s password.

String dialect

The data source’s dialect. Hibernate uses dialect configuration to know which database you are using so that it can switch to the database-specific SQL generator code whenever necessary.

boolean initialized

True if this data source has already been initialized.


In the GUI, A new CRUD page is created for SQL Configuration. It is available under Administration / Storages / SQL Configuration menu.

An API endpoint is created for SQL Configuration CRUD operations accessible at /api/rest/sql/configurations. Available operations are CREATE, UPDATE, DELETE, LIST, FIND.

Here is an example request for creating an SQL Configuration:

Endpoint: /api/rest/sql/configurations
Method: POST
    "code": "POSTGRESQL2",
    "description": "PostgreSQL Database",
    "driverClass": "org.postgresql.Driver",
    "url": "jdbc:postgresql://localhost/meveo",
    "username": "meveo",
    "password": "meveo",
    "dialect": "org.hibernate.dialect.PostgreSQLDialect"

Maven Configuration

Before a Script is compiled by adding all the jar dependencies of the project and Wildfly’s libraries. Maven configuration allows adding a jar from another source repository at runtime using the Aether library.

Data Model

Remote repository is save in the database.

Table 2. Remote Repository Fields
Field Description

String code

Code of the remote repository

String url

Remote repository URL. Example http://repository.jboss.org/nexus/content/groups/public-jboss.


Remote repository can be modified under the Configuration / Maven configuration menu.

An API endpoint is available under /mavenConfiguration/remoteRepository URL.

Supported operations are:

  • POST - Create or update

  • GET - Returns the list of repositories

  • DELETE - Deletes a repository with a given code

An example POST request

        "code": "JBOSS_PUBLIC",
        "url": "http://repository.jboss.org/nexus/content/groups/public-jboss"
Uploading a Jar Dependency

A jar dependency can be uploaded in 2 ways.

1.) GUI. Which is accessible from Configuration / Maven configuration menu.

Using the GUI, a remote repository can be added by specifying the code and the URL.

2.) API. With the endpoint /mavenConfiguration/upload and method=POST.

A maven configuration dependency model contains the following fields.

Table 3. Maven Configuration Dependency Fields
Field Description


Zipped maven content


The name of the file


Group Id of the dependency


Artifact Id of the dependency


Version number of the dependency


Classifier of the dependency

Script Integration

To add a dependency using maven configuration, a new parameter is added when compiling a script which is mavenDependencies. This new dependency will be use when compiling and running the script. So the script should not throw any compilation issue even if the jar file is not a project dependency or in Wildfly’s library.

For example let’s create a script that depends to commons-math3 dependency which is not a dependency of the project.

    "code" : "org.meveo.test.script.FunctionIO",
    "script" : "
                package org.meveo.test.script;
                import org.apache.commons.math3.util.CombinatoricsUtils;
                import org.meveo.service.script.Script;
                import java.util.HashMap;
                import java.util.Map;
                import org.meveo.admin.exception.BusinessException;
                port org.apache.commons.cli.HelpFormatter;
                import org.apache.commons.cli.Options;
                import org.apache.commons.cli.ParseException;

                public class FunctionIO extends Script {
                        public void execute(Map <String, Object> methodContext) throws BusinessException {
                                long factorial = CombinatoricsUtils.factorial(10);
                                Options options = new Options();
                                options.addOption("p", "print", false, "Send print request to printer.")
                                        .addOption("g", "gui", false, "Show GUI Application")
                                        .addOption("n", true, "No. of copies to print");

                                HelpFormatter formatter = new HelpFormatter();
                                formatter.printHelp("CLITester", options);

                                String result = "factorial(10)=" + factorial;
                                methodContext.put(RESULT_VALUE, result);
    "mavenDependencies": [
                    "groupId": "org.apache.commons",
                    "artifactId": "commons-math3",
                    "version": "3.6.1",
                    "classifier": "",
                    "coordinates": ""
    "fileDependencies": [
                    "path": "D:\Java\.m2\repository\commons-cli\commons-cli\1.4\commons-cli-1.4.jar"
                    "path": "D:\Javaglowroot"

Note that for this demonstration, I have also added a file dependency which will look for a file in the local machine when compiling a script.

MEVEO as a Maven Repository

Starting from version 6.6.0, MEVEO can act as a maven repository. Which means that a jar file that will be use as dependency to script can be uploaded and reference from it.

The URL of the repository is <MEVEO_URL>/maven/<groupId>/<artifactId>/<version>/<jar_file>-<version>.jar.

Note that the directory structure must exists as well as the file inside the providers.rootDir property value. For example d:/temp/meveo/.m2/org/apache/commons/commons-math3/3.6.1/commons-math3-3.6.1.jar



This section list the application properties that is used by the MEVEO system.


Property Code


Max Upload Size


This property sets the maximum file size the JSF components can handle. The maximum value it can accept is 100MB and is defined in JBoss application server in src/main/webapp/WEB-INF/undertow-handlers.conf. Which means, if we set this property to 150MB and uploaded a file with that size the system should throw an error.


File Explorer

When creating, updating or deleting a entity module, the file will be generated and stored to file explorer directory for the user’s provider.


For GUI, File explorer can be modified under the Services / File explorer menu.

An API for managing the app file system preset in a specific folder.

Supported operations are:

  • POST - Create directory from where to list files, zip file, zip directory, suppress file, suppress directory, upload file

  • GET - Returns the list of files or list directory from where to list files, download file

Add file/folder from File Explorer to Module

1.) GUI.From Services / File explorer menu, a file/folder can be added to a module by "Add To Module" button.

2.) API.The URL of module <MEVEO_URL>/module/<code>/file/add and method=POST. Example: http://localhost:8080/meveo/module/moduleModule/file/add. With path="\classes\org\meveo".

Note <code> is the code of module and path of file must exists inside the File Explorer.

When exporting a module that is related to file(s), automatically zip it.

A module that is related to file(s) can be exported and automatically zipped in 2 ways.

1.) GUI.From Deployment / Module menu, selcet the module(s) containing the file(s) then click "Export Selection" button.

2.) API. Which is accessible with /api/rest/module/export and method=GET.

Import a zipped module with files

When importing a zipped module with files, put them into the file explorer under the same path.

A zipped module with files can be imported in 2 ways.

1.) GUI.From Deployment / Module menu, click "Import Data" button and select a zipped module to import.

2.) API.A zipped module is imported with api/rest/module/importZip and method=POST. A module upload model contains the following fields.

Table 4. Module Upload Fields
Field Description


Zipped module with files


The name of the file


Log explorer

The log explorer can be accessed through the menu at Execution > Logs > Log explorer.

The page has two inputs:

  • Log file: the location of the log file. This corresponds to the meveo.log.file property of the meveo-admin.properties file.

  • Offset: the number of lines to offset. Default value is 50.

And 4 buttons:

  • Read: it will display the last X lines (X = Offset) to the console

  • Refresh: only appears once Read or Continuous reading has been hit once. Allows to append into the console the logs written between the previous refresh / read

  • Continuous reading: append new logs to the console every seconds

  • Pause: only appears when Continuous reading is active. Pauses the continous reading

/!\ If you chose a "0" offset and you click the Read button, nothing will happen until you hit the Refresh button /!\