Functional Documentation

Overview

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.

Configuration

Edit this section Report an issue

Storages

Edit this section Report an issue

SQL Configuration

Edit this section Report an issue

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).

Repository

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
Field	Description
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.

GUI & API

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

Edit this section Report an issue

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.

GUI & API

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
jarFile	Zipped maven content
filename	The name of the file
groupId	Group Id of the dependency
artifactId	Artifact Id of the dependency
version	Version number of the dependency
classifier	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 {
                        @Override
                        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.

Example: http://localhost:8080/meveo/maven/org/apache/commons/commons-math3/3.6.1/commons-math3-3.6.1.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

Application

Edit this section Report an issue

Configuration

Edit this section Report an issue

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

Name

Property Code

Description

Max Upload Size

meveo.fileUpload.limitInMb

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.

Execution

Edit this section Report an issue

File Explorer

Edit this section Report an issue

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

GUI & API

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.

Export a module that is related to file(s)

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
zipFile	Zipped module with files
filename	The name of the file

Logs

Edit this section Report an issue

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 /!\