lbroudoux / eip-designer

A Sirius designer for Enterprise Integration Patterns

I have talked about EIP Designer at Red Hat - L'Entreprise Numérique - 2016 Paris on March 23st. Here are the slides of the prez.

I have talked about EIP Designer at SiriusCon 2015 Paris on December 3rd. Here are the slides of the prez.

eip-designer

A Sirius designer for Enterprise Integration Patterns (see http://www.enterpriseintegrationpatterns.com/ for introduction of what are EIP). It allows you to design integration routes using the common patterns and vocabulary used within Enterprise Application Integration or Enterprise Services Bus solutions.

Here's an overview of the design perspective :

Moreover designing routes, the goal of EIP Designer is also to give :

• acceleration to realization by allowing generation of route skeletons for common integration frameworks such as Spring Integration or Apache Camel,
• control onto final realization by providing parsers and comparators able to check that development was done respecting "original design".

Finally, we aim to provide adapters and bridges to allow the usage of EIP Designer from a more generic and abstract design solution such as a TOGAF or a Archimate Designer. Those one presenting the notion of Services and Services dependencies without a mean of describing orchestration process or integration routes ... everything we thought EIP is great at !

If you're looking for a deeper introduction on solution and project genesis, we invite you reading this InfoQ's article.

Build Status

Current development version is 0.4.1-SNAPSHOT.

Releases

Versions	Date	Update site
0.4.0	Dec. 18 2015	http://dl.bintray.com/lbroudoux/maven/eip-designer/0.4.0/
0.3.0	Sep. 21 2015	http://dl.bintray.com/lbroudoux/maven/eip-designer/0.3.0/
0.2.0	Aug. 06 2015	http://dl.bintray.com/lbroudoux/maven/eip-designer/0.2.0/
0.1.0	Jun. 16 2015	http://dl.bintray.com/lbroudoux/maven/eip-designer/0.1.0/

Installation

Pre-requisites

EIP Designer needs at least Eclipse Luna SR1 with modeling stuffs. We recommend using directly the Modeling Tools distribution of Eclipse available from download page.

After having installed and ran Eclipse, you also need to add Sirius 2.0. See the download page on http://www.eclipse.org/sirius on how to add Sirius to your Eclipse modeling installation.

Tested configurations

EIP Designer has been developped and tested on following configurations.

Eclipse version	Sirius version
Luna SR1	2.0
Mars SR2	3.1

Released versions

Find the correct update site URL in the above Releases table and just use this URL as an update site into your Eclipse installation within Install New Software.... More details on available features are mentioned below when talking about Usage, Generators and Bridges.

Development version

Want to live on the edge ? The development version of EIP Designer could either be :

• built from sources to get distributable and installable binary packages or,
• directly imported into Eclipse workbench for local tests.

For early testers, snapshot P2 repositories are regularly setup and provisioned here: http://dl.bintray.com/lbroudoux/maven/eip-designer/. Just use this URL to see if there's a snapshot for current version and use URL as an update site into your Eclipse installation within Install New Software....

Build from sources

In order to build from sources, you'll need Apache Maven (version >= 3.0). After having cloned the Github repository, just go to the repository root and run :

$ mvn clean install

This should build and install all binary plugins into your Maven local repository under the com.github.lbroudoux.dsl.eip group / sub directories.

Import into Eclipse

After having cloned the Github repository, just launch Eclipse and do a regular projet import (Import... > Existing Projects into Workspace) of all the projects located under /plugins and /features directories.

Now just launch a new Run As... > Eclipse Application to launch a new Workbench containing all imported plugins.

Usage

Designer

Using designer is rather simple and follow Eclipse Modeling and Sirius guidelines :

• Create a new Modeling Project within your workspace,
• Add to this project a new Eip Model resource (choose EIP Model as the root object for model),
• Update the Viewpoint selection for this project (right-click on project while being into Sirius perspective)

We provide a new viewpoint simply named Enterprise Integration Patterns and applicable when your project contains a *.eip resource as shown below.

Your project is now ready !

Designer provides only 2 diagrams :

• A Routes Catalog that just allows you to create and remove Route definitions within your model,
• A Route Diagram that allows you to specify a Route behaviour using the tools and semantics shown in top screenshot.

Generators

Generators are provided within features dedicated to specific generation target. For now, there's support for Apache Camel, Spring Integration and JBoss SwitchYard.

Check our Wiki documentation on how to use generators.

Parsers and comparators

Once features mentioned into Generators section are presents, comparison of implementations files with base model is made available through a new Compare With EIP Route context item within the traditional Compare With... submenu.

Then, select a Route definition within an EIP Model present into your workspace and you should be able to inspect differences onto a quite standard Compare dialog :

Bridges

One of our goal is also to provide an easy way to integrate EIP Designer with other solutions in order to offer a complementary viewpoint onto system design. For example, you may want to integrate EIP route design features with a Enterprise Architecture related designer in order to offer continuum between Service communication design and Service realization design.

Check our Wiki documentation on how to write a custom bridge !

TOGAF Designer

As an example, we provide a bridge for the TOGAF Designer from Obeo. This feature brings you a new contextual menu contribution for designing EIP route from Togaf Information System Service within diagrams as shown below :

As soon as you have choosen a target EIP Model as the container for the Service Route design, it initializes a complete EIP design for the Service realization and by bringing in every service dependencies identified within Togaf designer :

License

This software is licensed under the Apache 2 license, quoted below.

Copyright 2015 Laurent Broudoux

Licensed under the Apache License, Version 2.0 (the "License"); you may not
use this file except in compliance with the License. You may obtain a copy of
the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
License for the specific language governing permissions and limitations under
the License.

eip-designer's Issues

Add support for Service Reference cataloging within EIP Model

Service References maybe shared among many routes defined within the same model.
However, today Services References belongs to a specific Route and thus cannot easily be shared and reused by others. This led to duplication of Service references and finally lack of tracability on references usages.

This enhancement goal is to attach the Service References directly at the model level and bring a new designer view and tools to create, share and reuse references within routes.

Support of Aggregator in Camel extensions

Aggregator is not yet implemented for Camel generation & parsing.

Thus because in Camel, Aggregator cannot be directly mapped to a specific endpoint but should be considered as a property of other endpoints in the route definition (ex: split or multicast). This led to a difficult implementation ... but have no fear!

Add base support for Metadata in metaclasses

Because all EIP properties or specific EIP implementation properties are not intended to be supported by EIP Designer, we propose to add a generic metadata management feature. One should be able to add metadata to Route, Endpoint and Channel.

We also see Metadata as a great way to implement migration plan between integration solutions : specific parts that one want to keep a trace on might be injected into EIP model using metadata !

DSL evaluation for eip-designer - please take a look

Hello, greetings from the software engineering group from Beihang University, China. We have been working on the evaluation of Domain Specific Modeling Languages (DSMLs ), the main purpose is to find out the flaws of the design of the DSML. To test our evaluation framework, we evaluated your software design, mainly based on your ecore and odesign files, and found out that even though the overall quality of your software design is very good, there still exists some minor problems. The details are as follows:

rule-based evaluation

Firstly, we did some rule-based evaluation, mainly focusing on the graphic part.

Evaluation of Semiotic Clarity

We've checked your odesign file according to Goodman's theory of symbols[Goodman N. Languages of Art: An Approach to a Theory of Symbols[M]. Hackett publishing, Indianapolis, 1976.], and there are some minor problems that can decrease the semiotic clarity of your design as follows:

1. Deficit Elements

   There are some elements in your design that are not represented by any graphic symbols.

   Certainly, we know that some elements do not need to be assigned symbols to, but we believe it is best to check whether these elements really do not need symbols or they were just overlooked.

   • Adapter
   • Router
   • Filter
   • Transformer
   • Gateway
   • Splitter
   • Aggregator
   • ServiceActivator
   • Enricher
   • MessagePart
   • RoutingType
   • RecipientListRouter
   • InvocableEndpoint
   • ContentFilter
   • Resequencer
   • ExchangeType
   • Metadata
   • Metadatable

LLMS-based evaluation

Secondly, we did some LLMS-based evaluation, mainly focusing on the model part. Generally speaking, we try to make LLM act as a domain expert to provide multidimensional evaluations of your language design.

Model Completeness

We give your ecore design to LLM and ask the LLM to guess which domain your language is designed for. And then we ask LLM to add possible missing elements to your language (perhaps not taken into account in the first version of the design, but can be considered for inclusion in future versions). The results are as follows:

This set of meta models belongs to the field of Enterprise Integration Patterns (EIP), which mainly focuses on various components in message and event driven architectures and their interactions. This field is dedicated to solving the integration problem between applications and services, with a focus on asynchronous messaging systems.

Additional meta models and relationships can be supplemented as follows:

Element:

Queue: name; Dual;
Exchange: name; Type;
Binding: key;
Message: content; Headers;
Event: type; Payload;
Workflow: name; Steps;
ProcessManager: state;
CorrelationID: id;

Relationship:

Channel (1)<- boundTo ->Exchange (n)
Exchange (1)<- owns ->Binding (n)
Binding (1)<- toQueue ->Queue (1)
Message (1)<- publishedTo ->Channel (1)
Message (1)<- deliveredVia ->Queue (1)
Endpoint (1)<- listensOn ->Queue (1)
Event (1)<- triggeredOn ->Channel (1)
Workflow (1)<- triggers ->Event (n)
Workflow (1)<- execute ->ProcessManager (1)
ProcessManager (1)<- managers ->Workflow (n)
ProcessManager (1)<- uses ->CorrelationID (1)
Message (1)<- arrays ->CorrelationID (1)

These supplementary elements and relationships further enrich the meta model of enterprise integration patterns, adding descriptions of key concepts such as queues, switches, bindings, messages, events, workflows, and process managers, as well as the ways they interact with each other. These are factors that often need to be considered when implementing enterprise level integration.

We are not sure if these issues actually constitute a problem, the decision to fix them or not is still up to your team, looing forward to your respond, thanks!

Content Enricher not properly supported when generating Camel Xml

At that time, Content Enricher pattern is present into designer but not supported by Camel Xml generator. This made the resources generated for a route containing this pattern completely unusable.

EEF properties editors are missing

Since 0.0.3, EEF properties editors are missing ... plugin.xml file of editor plugin seems to have been recovered to an older version ...

Customize icon for new EI Model wizard

Remove default icon, add an EIP Designer one

Provide an implementation of Resequencer into Camel extensions

Resequencer EIP has to be implemented into Camel Integration generator and parser.

Content Enricher not properly supported when generating Camel Java

At that time, Content Enricher pattern is present into designer but not supported by Camel Java generator. This made the resources generated for a route containing this pattern completely unusable.

Provide an implementation of Publish-Subscribe channel in Spring extensions

Issue related to #15. Once support is done within Meta-model, it can be used to generate corresponding <int:publish-subscribe-channel/> in Spring integration route.

Parse Spring resource for persisting to EIP model

This is the concrete Spring integration implementation of issue #25

Provide an implementation of Router into Spring extensions

Router EIP has to be implemented into Spring Integration generator and parser.

Add samples for sandboxing designer, generators and bridges

Add Switchyard / SCA generation capabilities

This is a consequence as issue #18 completion.
Once Service references are formalized as a catalog within an EIP Model, it should be easy to add some generation capabilities regarding a whole system/component and its dependencies. As an SCA specification implementation, JBoss Switchyard brings such a global dependencies view.

Goal of this issue is the generation of a valid switchyard.xml file corresponding to an EIP Model.

Content Filter not properly supported when generating Camel Xml

At time, Content Filter pattern is present into designer but not supported for Camel Xml generation. This making the generation of a route containing pattern completely unusable.

Allow diagram creation and opening of Route diagram when bridging from another model

Currently when EIPModel is enriched from another model, details diagram on Route is not created : this should be done manually. This enhancement's goal is to automate the diagram creation and opening into workspace.

Add UI support for launching Camel generation

Generators must - for now - be launched using standard Eclipse launchers. This is OK in development phase but they must be integrated as UI plugin in workbench.

Upgrade to Java 7 as the required Java version

Some plugins are still using Java 6 ;-(

Promote link of ServiceRef may be incorrect into Switchyard SCA

When generating a promotion link of a ServiceRef, first invocation a component service should be assigned. Generator currently used the first invocation found event if it's not assigned to a Route really using the ref.
This led to incorrect reference links : SCA component may be bound to reference event if it does not realy use it !!

Parser and comparison of Java DSL Camel Route

For now, Camel extension is only able to parse and compare Route defined using the XML grammar. It should be enhanced to also support parsing and comparison of Route defied using the Java DSL.

Complete EIP model intialization when bridging from EA model

When initializing EIP model from EA one, only model elements declaration is done today. However, we could initialize a default EIP integration route with Gateway_In, Gateway_Out items and channels linking everything together. This would allow to quickly start EIP design thereafter ...

Add CDO support for EIP Models

EIP Model should be able to persist into CDO Model Repository (https://eclipse.org/cdo/) for better team and collaborative features support. CDO support should be added

• when saving model via designer,
• when reading model via comparators,
• when writing model via bridges.

Add support for base Camel and Blueprint Camel

The Camel routes generated for now are formated in order to be deployed in Switchyard or Fuse Service Works (the tools I used for now). However, one would want to deploy them to another container such as pure JSE application, Fuse, Karaf ...

The goal of this issue is to add support for multiple generation target for Caml Xml through Acceleo generation properties.

Add a decoration on Route depending on Exchange Type

When opening the Route Catalog diagram, there's no easy way to see the exchange type supported by Route. Adding a decorator icon should help ...

Fix Camel aggregation strategy reference in Java DSL

When generating Camel Java, improper attribute is used for referencing aggregation strategy (indeed I reuse the one from Xml DSL ;-) ).
Fix this.

Allow generation of a full blown Switchyard project

Complete generation of Siwtchyard in order to being able to directly import result as a new project.

Provide an implementation of Publish-Subscribe channel in Camel extensions

Issue is related to #15. Once support has been added in Meta-model, one can apply it to generate corresponding <multicast/> behaviour within a Camel route.

Support of Publish-Subscribe Message Channel pattern in designer

Designer only support point-to-point channel for now : an endpoint can only have one outgoing channel. Change this and allow multiple output channel for and endpoint in order to support the Publish-Subscribe message pattern.

Parse Camel resource for persisting to EIP model

This is Camel concrete implementation of issue #25

Align Camel Java Content Filter semantics on Camel Xml

Following issue #35, semantics of Content Filter pattern is no longer coherent in Camel Java vs Camel Xml. Realign this.

Add UI support for launching Spring generation

Generators must - for now - be launched using standard Eclipse launchers. This is OK in development phase but they must be integrated as UI plugin in workbench.

Parse resource and persist to existing EIP model

As we use parsers to build an in-memory model for comparing with original design, we'd like to allow this in-memory model to be merged and persist into an existing one. This will open the way to migration scenarios where you are using EIP tooling to migrate from one technology to another while retro-documenting existing resources.

Provide an implementation of Resequencer into Spring extensions

Resequencer EIP has to be implemented into Spring Integration generator and parser.

Generate Camel Java routes in a Java package

For now, Camel routes written using Java DSL are generated without a Java package structure. Allow user to specify a target package with a generation property.

Channel not deleted when deleting Conditional Route

When deleting a Conditional Route using diagram, attached Channel is not deleted thus letting model into an inconsistent state.

Missing icons for ServiceInvocation

Missing at least 1 icon :
java.util.MissingResourceException: The image resource 'full/obj16/ServiceInvocation' could not be located

Yann.