Che Assemblies

An assembly is a Maven module that produces a build artifact. In case of Eclipse Che, this is either a .war with jars in it, or a Tomcat assembly, which is a Tomcat web server with custom configuration and artifacts, copied to webapps. The following are Eclipse Che assemblies:

A successful build of this module produces an ide.war file, which is then deployed with Tomcat (produced by assembly-main) as a ROOT.war that contains dependencies packages as JAR files. It also contains the _app directory with JavaScript, CSS, and other resources that are loaded into the IDE.html file when the IDE is initialized.

This module inherits che-ide-gwt-app that it its turn has che-ide-full in dependencies. So, che-ide-full is where all of the client side plugin dependencies are declared.

However, if you build a custom assembly and your plugin provides client side changes, it is root pom.xml of assembly-ide-war that dependencies should be added to. See: IDE Extensions.

This is the module that is most often extended with custom plugins.

The build artifact of this module contains all server-side plugins components packaged as JAR files. Root pom.xml contains dependencies to all plugins that get deployed with the workspace agent, and this is where dependencies to custom plugins should be added. Once built, assembly-wsagent-war is copied to webapps of ws-agent Tomcat as ROOT.war. This is the module that is most often extended with custom plugins.

This module packages ROOT.war into Tomcat’s webapps and adds configuration files. This Tomcat is packaged as a tar.gz archive that is then placed into main Tomcat produced by the assembly-main build.

The core of Che platform as a workspace server that includes workspace API, user profile and settings, implementation of runtime infrastructure. Usually used as a dependency in custom assemblies, however, it is possible to extend it, for example, by providing support of a new infrastructure.

This is the main assembly that packages all Che components into a Tomcat server. These components include wsmaster as api.war, User Dashboard as dashboard.war, documentation - docs.war and Swagger UI - swagger.war, agents like terminal and ws-agent (those are packaged into lib directory in the root of the resulting archive where Che master picks them up and serves, thus making them downloadable for installers).

You may build your own custom assembly of Che. To do so, there is no need to clone or copy the entire Che source code. All artifacts can be used as dependencies. Also, unlike assemblies in Che source code, custom assemblies can use minimal artifacts for server and client side.

See an example of a custom Che assembly that brings in two plug-ins - server- and client-side. You may clone this repository and use it as a basis for your custom Che assembly.

Note that this example uses core artifacts as dependencies both for client:

and server side:

Core artifacts contain a bare minimum set of platform components and plugins to be able to create and start a workspace, create or import a project, open and edit files in the editor.

You may use full artifacts that include all standard Che plugins:

Client side:

You may include a full IDE artifact and exclude a particular plugin:

Server side:

These two pom.xml files are entrypoints to adding custom plugins. This assembly includes two plugins, which are declared in:

Your custom plug-in packaged as a JAR file is automatically added to the inherited wsagent artifact if both are declared as dependencies in pom.xml. As a result, the final .war artifact will contain a custom JAR file.

In the pom.xml file, update both:

and

Keep the versions consistent to avoid build failures and incompatibilities. It is also recommended to keep versions of own artifacts aligned with a parent version.

Now that you have got some knowledge about Che assemblies and own cloned a sample assembly, take a closer look at Eclipse Che client and server-side plug-ins.