GEMOC Studio Documentation
Developer Guide

The source code of the [GEMOC Studio](http://gemoc.org/studio/) is currently spread among different git repositories in Eclipse organization.

This project relies on the presence of the correct git repositories (cloned with the correct name) to locally build a working studio.

First checkout the git repositories :

git clone  https://github.com/eclipse/gemoc-studio
git clone  https://github.com/eclipse/gemoc-studio-modeldebugging
git clone  https://github.com/eclipse/gemoc-studio-execution-moccml
git clone  https://github.com/eclipse/gemoc-studio-moccml
git clone  https://github.com/eclipse/gemoc-studio-execution-ale
git clone  https://github.com/eclipse/gemoc-studio-execution-java

Note: the repositories must keep their names (Ie. do not change the destination folder name) as the maven pom file expects to find them at specific locations.

Generate the protocols code

cd gemoc-studio-modeldebugging/protocols/generators/ts/JSONSchema2APIProtocolGenerator
npm run build
npm run  generate

Then compile the Eclipse Studio using maven:

cd gemoc-studio/dev_support/tycho_full_compilation
mvn package -Dmaven.repo.local=$PWD/localm2

We use one options:

If you prefer to use your own local maven repository (ie. in <HOME>/.m2/repository), remove the use of -Dmaven.repo.local, ie. use this command:

mvn package

If you already compiled and resolved all dependencies at least once (ie. if you filled your local maven repository with everything needed for the build), add the option -o to perform an offline only build, which is significantly faster since it skips checking all maven repositories online.

In the end, the result can be found in gemoc_studio/gemoc_studio/releng/org.eclipse.gemoc.gemoc_studio.product/target/products/, with one studio zip per platform.

The build also assemble complementary results:

If you have trouble to reproduce a bug in the CI or want to make sure that the CI will pass, you can run the maven build in a docker that mimic the CI environment.

docker-compose down && docker-compose up

or

docker build -t "gemoc/gemoc-full-compilation:latest" .

docker run -it -v $PWD/../../../..:/home/jenkins/src -v $PWD/cache-m2:/home/jenkins/.m2 --user 1000 gemoc/gemoc-full-compilation:latest ./build_gemoc.sh

docker-compose run gemoc_full_compilation system_test_only

docker run -it -v $PWD/../../../..:/home/jenkins/src -v $PWD/cache-m2:/home/jenkins/.m2 --user 1000 gemoc/gemoc-full-compilation:latest ./build_gemoc.sh linux

docker-compose run gemoc_full_compilation linux_offline

docker-compose run gemoc_full_compilation linux_no_system_test

docker-compose run gemoc_full_compilation linux_no_system_test_offline

docker build -t gemoc/gemoc-full-compilation:latest .
docker run -v $PWD/../../../..:/home/jenkins/src -v $PWD/cache-m2:/home/jenkins/.m2 gemoc/gemoc-full-compilation:latest

docker run -it -v $PWD/../../../..:/home/jenkins/src -v $PWD/cache-m2:/home/jenkins/.m2 --user 1000 gemoc/gemoc-full-compilation:latest /bin/bash

Some of the components provided as part of the GEMOC Studio are now available as pomfirst. This means that the jar are compiled and provided using maven dependency system (while the Eclipse studio is compiled using manifest dependency information using tycho).

Only a subset of the components are provided as pomfirst. You can still use them in your pomfirst build but will need to rebuild the dependencies for maven. (You can also open a request https://github.com/eclipse/gemoc-studio/issues for a given jar you may require).

The source code of the [GEMOC Studio](http://gemoc.org/studio/) is currently spread among different git repositories in Eclipse organization.

This project relies on the presence of the correct git repositories (cloned with the correct name) to locally build a working studio.

First checkout the git repositories :

git clone  https://github.com/eclipse/gemoc-studio
git clone  https://github.com/eclipse/gemoc-studio-modeldebugging
git clone  https://github.com/eclipse/gemoc-studio-execution-moccml
git clone  https://github.com/eclipse/gemoc-studio-moccml
git clone  https://github.com/eclipse/gemoc-studio-execution-ale
git clone  https://github.com/eclipse/gemoc-studio-execution-java

Note: the repositories must keep their names (Ie. do not change the destination folder name) as the maven pom file expects to find them at specific locations.

Generate the protocols code

cd gemoc-studio-modeldebugging/protocols/generators/ts/JSONSchema2APIProtocolGenerator
npm run build
npm run  generate

Then compile and install the pomfirst component:

cd gemoc-studio/dev_support/pomfirst_full_compilation
mvn install

The continuous integration of the project uses an integration repository with git submodules in order to have a complete build

Some synchronization jobs allow to automate the management of the git submodules. It uses a branch naming schema in order to automatically associate branches having the same names. (it uses https://github.com/gemoc/git-sync-tools) See the readme in https://github.com/gemoc/gemoc-studio-eclipse-integration/ for links to the synchronization jobs.

This is the official continuous integration for preparing new official releases.

The forked repositories are hosted in the https://github.com/gemoc organization. The associated CI is hosted by one of the initiative partner at https://ci.inria.fr/gemoc/job/gemoc-studio-eclipseforks-integration/

It works using the similar synchronization jobs as the main Eclipse integration.

As its goal is to help prepare pull request to the official repositories, the master branches of the community repositories are automatically synched using Eclipse repositories master branches.

^[89]

GEMOC addons mecanism is the simpliest way to contribute new features to GEMOC. Most of the features in GEMOC have been developed using it.

Basically, it uses Eclipse plugin extension point in order to provide additional feature to an existing engine.

The main extension point is org.eclipse.gemoc.gemoc_language_workbench.engine_addon which allows to declare a new class that implements the IEngineAddon interface.

4.1.1. Create an Addon

Minimal steps to get an addons:

• Create a plugin project (or contribute to an existing one)
• In the MANIFEST.MF or plugin.xml editor, open the extensions tab, Add, uncheck "Show only extension from the required plugins", search for "gemoc" and select the org.eclipse.gemoc.gemoc_language_workbench.engine_addon extension point, accept to add the dependency to the plugin. (see Figure 63, “New Extension for Engine Addon screenshot”)
• add an addon entry in the extension point (see Figure 64, “EngineAddon extension point details screenshot”) provide a name and a description that will help the end user to know if she wish to enable the addon or not in the launch tab when configuring her model execution.
• Create the class implementing org.eclipse.gemoc.xdsmlframework.api.engine_addon.IEngineAddon (a click on Class*: in the extension editor allows to open a wizard that simplify this task)
• you can now override any of the default methods of the interface (cf. Figure 57, “Execution Framework API Interfaces overview”). If the user select the addon in the launch tab, these methods will be called by the engine.

Figure 63. New Extension for Engine Addon screenshot

Figure 64. EngineAddon extension point details screenshot

Tip

An Engine addon may be generic and apply to any language, but it can also be language specific. In that case, you should prefer to add its code in the project containing the dsl file of the language and declare it in the plugin.xml.

This way, the addon will be available only for this specific language.

Figure 65. Add language specific Engine Addon on DSL

This can be useful in order to create language specific GUI (with input/output) and complex model animation. (see Section 3.2, “Define an animation representation using an engine addon”)

Tip

In the extension declaration, setting Default to true will activate the addon by default when creating a new launch configuration. The user is still able to disable the addon manually.

public class MyAddon implements IEngineAddon {

	@Override
	public void aboutToExecuteStep(IExecutionEngine<?> engine, Step<?> logicalStepToApply) {
		// do some refresh action
	}

	@Override
	public List<EngineAddonSortingRule> getAddonSortingRules() {  
		ArrayList<EngineAddonSortingRule> sortingRules = new ArrayList<EngineAddonSortingRule>();
		sortingRules.add(new EngineAddonSortingRule( this,
				EngineAddonSortingRule.EngineEvent.aboutToExecuteStep,
				EngineAddonSortingRule.Priority.BEFORE,
				Arrays.asList(IGemocDebugger.GROUP_TAG))); 
		return sortingRules;
	}
}

^[90]

As seen in Figure 49, “Components overview”, the framework is organized in several layers. The most complete layer is the GEMOC Framework which offers most of the advanced features. Thus, implementing an engine for a new technology consist in 2 main parts: