E-mail
|
Key
This line was removed.
This word was removed. This word was added.
This line was added.
|
Changes (44)
View Page History{section}
{column}
{column}
h1. What is Petals ESB ?
...
[Petals ESB|http://petals.ow2.org] is an Open Source ([LGPL License|http://www.gnu.org/licenses/lgpl.html]) Enterprise Service Bus (ESB) provided by the [OW2 middleware consortium|http://www.ow2.org]. Petals ESB is build with and on top of agile technologies such as:
* The Java Business Integration (JBI) v1.0 specification ([http://www.jcp.org/en/jsr/detail?id=208]). This is the Java standard for enterprise application integration. Note that in 2008, Petals ESB has been certified by SUN Microsystems as a valid JBI implementation.
* The FRACTAL Software Component Framework provided by the OW2 consortium. Fractal is a modular and extensible component model that can be used with various programming languages to design, implement, deploy and reconfigure various systems and applications, from operating systems to middleware platforms and to graphical user interfaces. On the Petals ESB point of view, all the container services (such as service registry, message router, message transporter, discovery etc...) are provided by the Fractal framework. This is a major feature which allows core developers to specialize a Petals ESB distribution by choosing the software components to be used for specific needs.
...Components are plugged into a JBI environment and can provide or consume services through it in a loosely coupled way. The JBI environment then routes the exchanges between those components and offers a set of technical services. JBI is built on top of state-of-the-art SOA standards : service definitions are described in WSDL format and components exchange XML messages in a document-oriented-model way.
{center} !Environnement.jpg|height=345,width=600!{center}
The central part of the JBI specification is the Normalized Message Router (NMR), described as the "JBI Environment" in figure above. The NMR ensures loosely coupled communication by providing standard Service Provider Interfaces (SPI) that promote the exchange of XML documents between plugged JBI components and loose references via the use of their interface name.
...The JBI specification defines a set of artifacts which are used to add connectivity, bind/expose services and configure the Service Bus.
The main artefacts are the JBI components which are divided in two families :
* *Binding Components* (BC) are "connectors" which are used to interface the JBI bus with the rest of the Information System (Green boxes in figure above). Binding Components enable both the exposure of external resources in the bus and the exposure of services available on the bus for their use by external consumers: e.g. connections to Web services, FTP, Mail, Message-Oriented Middleware, or even standard business communications like EDI or ebXML.
* *Service Engines* (SE) provide the integration logic (Blue boxes in the figure above). They typically handle messages that pass through the bus in order to provide routing (e.g. content-based routing, priority-based routing), transformation (XSLT), orchestration (BPEL), log or audit features.
In order to activate endpoints in the JBI environment, artifacts named *Service Units* (SU) must be deployed on the JBI component (both BC and SE). The SU contains configuration file which are used by the JBI component consume or provide a JBI service. A SU has two modes:
...* The consumer (a JBI component) sets the message exchange (payload, attachments and properties) and send the message to the delivery channel
* The message bus is in charge of transmiting the message to the component which is providing the requested service
* The message bus is in charge of transmiting the message to the component which is providing the requested service
* The provider (a JBI component) receives the message exchange from its delivery channel and processes the message. Depending on the message pattern, a response, fault or acknowledgement can be set in the message exchange. The message exchange is then sent back to the consumer through the delivery channel.
h1. Petals ESB High Level Architecture
...The Petals ESB architecture has been defined using the software component paradigm. The following figure introduces the main components which are required to build the Petals ESB container.
{center} !High Level Architecture.jpg|height=450,width=600!{center}
Details about the software components are detailed in the next section.
...By assembling components implementations, it is possible to specialize a software for different needs. In the Petals ESB container context, we can easily replace a complex distributed registry by a local hastable and provide a simple standalone Petals ESB distribution (plus some distributed components). This is one of the interesting features the software component model provides.
One other powerful feature will be the possibility to replace software components at runtime. Even if this approach will never be used in production environment, let's imagine that you need to replace the JMS based communication channel by a HTTP one because your network topology or firewall settings have changed. This will be possible without stopping the container. Just stop the component (all the calls to this component are buffered during the operation), undeploy it then deploy and start the new component which provide the same interface. There is no impact on the container and all the buffered messages are then send to the new component\!
h2. Petals ESB Components
...* The *Transporter* is the mediator between the router and the communication channel. Its roles are :
** Sending messages to the endpoint resolved by the NMR. As explained in the inter node communication section, sending a message to an endpoint can be just an in memory process or if the endpoint is located on a foreign container, the message is serialized into the wire format then send to the foreign container.
** Sending messages to the endpoint resolved by the NMR. As explained in the inter node communication section, sending a message to an endpoint can be just an in memory process or if the endpoint is located on a foreign container, the message is serialized into the wire format then send to the foreign container.
** Receiving messages which is exactly the opposite of the sending role.
* The *Endpoint Registry* is in charge of storing the endpoint references and their service descriptions (WSDL descriptions). The endpoints are stored in a database in order to optimize their retrival.
* The *Network Service* is responsible of managing nodes whi want to join or leave the Petals ESB network.
{note}
This service must handle the state of the remote nodes by sending hello/ping messages…
{note}
{note}
This service must handle the state of the remote nodes by sending hello/ping messages…
{note}
* The *Topology Service* holds all the Petals ESB nodes configuration. The complete topology information of the Petals ESB network is updated when nodes are joining or leaving the network.
* The *Configuration Service* handles the configuration of the local Petals ESB container. This local configuration contains data for the container such as topology, server properties (name, timeouts, QoS, JAAS, SSL…) but also domain and subdomain informations.
* The *Repository Service* handles JBI artefacts resources needed at runtime by the container. When a JBI artefact is installed/deployed on the container, it is exploded in a distinct folder holded by the Repository Service. When the container is restarted, all the JBI resources are reloaded from their repository path. This allows JBI artefacts such as components to store/persist resources to be reused in their dedicated workspace.
...* The *JNDI Service* provides facilities to connect to a JNDI repository. In Petals ESB 1.x and 2.x, the JNDI repository is used to share knowledge between nodes such as JBI Endpoints and container configuration. This is a central point of the Petals ESB environment and you are, of course, free to choose the JNDI repository provided by Petals ESB or a third party one. This is possible by setting the JNDI factory properties at the domain level in the topology configuration. Petals ESB 3.0 comes with a new approach where the JNDI repository is replaced by an extensible and configurable distributed repository.
* The *Installation Service* role is to manage the installation (and provide the the lifecycle information) of the JBI components and shared libraries.
* The *Deployment Service* role is to manage the deployment (and provide the lifecycle information) of the service assemblies. The service units bundled into the service assemblies are deployed to the right component by this service implementation. As a result, JBI service consumers and providers are activated in the JBI and Petals ESB environment.
...h2. The Petals ESB JBI Container
The JBI container is a Java based library which can be used in several forms such forms such as standalone server, embedded in an entreprise application server, embedded in a standard Java application, … . The JBI container is generally called 'kernel' in Petals ESB and implements all the JBI specification.
There is no container lifecycle defined in the JBI specification. Starting Petals ESB instantiates all the software services needed to welcome the JBI artefacts, exchange messages between JBI services and some additional features which will be detailed later in this document.
...The JBI container can be seen as a service container and like a web application container, a JBI container is not useful when used alone. To use the container, artifacts needs to be installed/deployed into the container with the help of management operations.
{center} !Petals JBI Container.jpg!{center}
h2. Using a JBI Component
... - jbi.xml
- petals-COMPONENT-NAME.jar
- petals-COMPONENT-NAME.jar
- a.jar
- b.jar
{noformat}
{noformat}
...The Java classes, which are packaged into the component, are used to create the component class loader and the container links the component to the container with a context and the delivery channel used to send and receive JBI messages. Once these steps are achieved, the component is started but it can not receive and process JBI messages.
{center} !Using JBI Component.jpg!{center}
h2. Using a JBI Service Unit
...Once deployed, the messages, which are sent to the endpoint, will be delivered to the component the service unit is deployed on. It is up to the component to process the message and to return a message, a response, a fault, or nothing.
Processing a message is specific to the component implementation and is not defined in the service unit :
* A binding component will generally transform the message into another format (for example to a SOAP message) and do its job (for example invoking an external Web Service).
* A service engine will get the message and processes it (orchestration, transformation, apply rules). The engine will also potentially invoke other JBI services.
The service unit can not be used alone since the component to deploy the service unit onto is not defined in its descriptor.
The service unit can not be used alone since the component to deploy the service unit onto is not defined in its descriptor.
{center} !Using a JBI Service Unit.jpg!{center}
h2. Using a JBI Service Assembly
...Now that the container is started, the components are installed and the endpoints are activated with the help of the service unit deployment, services can be invoked and messages can be exchanged between service consumers and providers.
{center} !Using the JBI Environment.jpg!{center}
In the previous figure, a web service client calls a web service which is hosted by the JBI container. This web service is just a facade. The JBI service which is consumed by the facade can be changed as many time as needed. The only condition is to provide the same interface. This approach is extremely flexible since the JBI service can be a service composition of other JBI services (and recursively to reach atomic JBI services).
...A Petals ESB container can share its services and access services which are hosted by other containers in a transparent way. It means that on the service consumers and providers' point of view there is no additional configuration like in other JBI containers. Where other JBI containers provide a distributed approach by connecting containers with the use of JBI Binding Components plus huge configuration, Petals ESB provide this feature natively without any additional configuration.
{center} !Distributed Environment.jpg!{center}
The previous figure shows that multiple containers with their deployed JBI artifacts are completelu equal to a single container which holds all these artefacts. The following sections introduce the software modules which are needed to build this Distributed Entreprise Service Bus.
...The advantages of this distributed environment are :
* Container and connectors can be deployed close to the real services. This is a way to bypass communication constraints between JBI consumer and JBI provider like firewall issues and other network constraints.
* Container and connectors can be deployed close to the real services. This is a way to bypass communication constraints between JBI consumer and JBI provider like firewall issues and other network constraints.
* Complete control of the inter-container communication layer. As described in the previous point, each link between consumer and provider may have a specific configuration. Opening communication ports for JMS, HTTP, FTP, and more is never possible. Opening and securing only communication for one protocol is enough for the Petals ESB inter-communication protocol. A SOAP service client will be able to post a JMS message into a topic without any http or JMS port opening.
h2. Technical Registry
{warning}Since Petals ESB 3.0 release, some of the details of this section have changed. This documentation will be soon updated.{warning}
The Petals ESB JBI services, endpoints, interfaces, WSDL descriptions and container location are stored in an embedded technical registry. This registry is used by the Petals ESB containers to register services and to route the JBI messages to the right endpoint.
In order to have a unified vision, the registry entries are replicated among all the Petals ESB nodes using a Distributed HashTable over a multicast channel. This is quite equivalent to data flooding between registries so when an entry is added to the registry, the data is send to all the network registries. All the registries have a complete vision of the services hosted by all the containers.
{note:title=Note}
...In order to exchange (send/receive) messages between Petals ESB containers, Petals ESB extends the JBI specification by introducing a message transporter layer.
In a standard JBI implementation, the Normalized Message Router gets the local endpoint reference from the local registry and sends the message to a local JBI endpoint. In the Petals ESB approach, once the endpoint is retrieved from the local registry, the message and the endpoint reference are sent to the transport layer which is in charge to deliver the message to the JBI endpoint whereever the container it is hosted on. This is possible by getting by getting the foreign container information where the JBI services is hosted on from the technical registry. Once all the required information is retrieved, Petals ESB serializes the JBI message to the 'wire format' and send it to the foreign container. The response is sent back from the remote container is needed.
All the containers are linked together by the transporter layer. All the services providers and consumer scan potentially send messages to each other. All the links which were at the charge of the distributed application developer are now hidden by the Petals ESB container not only at the service level but also at the communication one.
{center} !Inter Nodes Communications.jpg!{center}
The previous figure illustrates two visions of the inter node communication which are totally equivalent. On the left side, all the containers are linked together by point to point communication channels. On the right side, all the containers can also communicate to each other but the links are totally hidden by an abstract communication layer. At the lower level, the links exist but are not important on the transport user point of view (in the Petals ESB case, the router layer does not care about links between containers).
JMS is the historical messaging system Petals uses to exchange messages between hosts (OW2 JORAM JMS implementation [http://joram.ow2.org]). Since Petals ESB 2.0, a new message transporter has been added. The OW2 DREAM project ([http://dream.ow2.org]) used for this transporter implemantation is a component-based framework dedicated to the construction of communication middleware. It provides a component library and a set of tools to build, configure and deploy middleware implementing various communication paradigms: group communications, message passing, event-reaction, publish-subscribe, etc... DREAM is alo build upon the FRACTAL component framework, which provides support for hierarchical and dynamic composition.
This communication abstraction is also important on the JBI service consumers and providers side. When standard applications need to create links between service consumers and providers (for example an application which wants to get weather forecast from a Yahoo service and get stock values from the Google service) needs to basically create the links between the client (application under development) and services (Yahoo, Google, and more). Of course, the ideal solution wil be to add an abstraction layer to all of this in case of service provider modification (URL, interface, …). interface, …). A solution such as an ESB already offers this abstraction layer since the links are the container responsability.
h2. Management
A specification section (chapter 6) is dedicated to the container management using JMX. It mainly deals with the JBI artefacts management such as installation, deployment, starting and stopping. Additionally, the specification defines a set of Apache Ant ([http://ant.apache.org]) taks to manage the container from Ant scripts.
Petals ESB implements and extends the management requirement of the specification in the way that additional JMX operations have been added to the specification ones. This is possible by extending the Managed Beans (MBeans) and adding new ones.
...h2. Monitoring
{warning}
{color:#333333}Since Petals ESB 3.0 release, some of the details of this section have changed. This documentation will be soon updated.{color}
{warning}
{color:#333333}Since Petals ESB 3.0 release, some of the details of this section have changed. This documentation will be soon updated.{color}
{warning}
Petals ESB provides various types of monitoring features :
* Use JMX to store and expose monitoring data. This approach uses the JMX features provided by the container and adds specific monitoring MBeans.
* Use the Fractal Framework. Since quite every JBI artefact (JBI component, JBI endpoint, …) and container module are Fractal components, Petals ESB uses the Fractal potential to provide very advanced monitoring data.
* Use JMX to store and expose monitoring data. This approach uses the JMX features provided by the container and adds specific monitoring MBeans.
* Use the Fractal Framework. Since quite every JBI artefact (JBI component, JBI endpoint, …) and container module are Fractal components, Petals ESB uses the Fractal potential to provide very advanced monitoring data.
There is actually some work to generalize these monitoring approaches to all the container software components and also to provide monitoring data in more standard ways (using OASIS WSDM specification and WS-\* seems to be good candidates). The following figure is a general vision of what is planned by planned by adding aspects/wrappers/controllers to Fractal software components :
{center}!Monitoring.jpg!{center}
{center} !Monitoring.jpg!{center}
h1. Kernel Features
...Petals ESB is not a simple distributed JBI container where all services can be accessed by all the consumers. To add some visiblity control containers can be classified by domains and subdomains.
{center}!Domains.jpg!{center}
{center} !Domains.jpg!{center}
* Petals ESB containers can only communicate with containers which belong to the same domain.
* Services can be declared as public or private so that private services are only accessible from containers which belong to the same subdomain.
This domain and subdomain settings are basically called 'topology' and are defined in the topology.xml file under the Petals ESB distribution configuration folder.
...To select the right endpoint, the AR interacts with the Endpoints Registry to get all the endpoints which provide a valid interface and filter the endpoint list by applying a strategy ({{org.ow2.petals.jbi.messaging.routing.strategy.Strategy interface}}).
The strategy is defined at the Message Exchange level ({{org.ow2.petals.routing.strategy}} property) set by the service consumer. Current strategies are : are :
* *random* : Randomly select an endpoint from the input endpoints list.
* *default* : Select a default strategy from the available ones. No comments in the code…
* *default* : Select a default strategy from the available ones. No comments in the code…
...h2. Router Module
{warning}
{color:#333333}Since Petals ESB 3.0 release, some of the details of this section have changed. This documentation will be soon updated.{color}
{warning}
{color:#333333}Since Petals ESB 3.0 release, some of the details of this section have changed. This documentation will be soon updated.{color}
{warning}
The router module has been decomposed into atomic modules ({{org.ow2.petals.jbi.messaging.routing.module.Module interface}}).
...The standard modules are:
* The *address resolver module* resolver module* (AR): The AR selects the good endpoint to send the message to.
* The *transport module* : In charge of communication with the transport layer to send/receive messages.
* The *authorization module* : Checks that the message can be send to the selected endpoint. This module uses JAAS for access authorization.
* The *authorization module* : Checks that the message can be send to the selected endpoint. This module uses JAAS for access authorization.
...h2. Transport layer
{warning}
{color:#333333}Since Petals ESB 3.0 release, some of the details of this section have changed. This documentation will be soon updated.{color}
{warning}
{color:#333333}Since Petals ESB 3.0 release, some of the details of this section have changed. This documentation will be soon updated.{color}
{warning}
The Transport layer, which is in charge of sending/receiving messages to/from the wire, is electing a message transport from the message exchange properties.
Selecting the right message transporter depends on the QoS the service consumer has defined in the {{org.ow2.petals.transport.qos message}} exchange property. Possible values are:
Selecting the right message transporter depends on the QoS the service consumer has defined in the {{org.ow2.petals.transport.qos message}} exchange property. Possible values are:
* *fast* : Assures that the message will be sent in the fast way. The message can be lost by the local container if something wrong happens and i twill not be possible to send it again.
* *reliable* : Assures that the message will be persisted in order to be ressent if something wrong happens.
...The same feature is also available for the uninstallation/undeployment steps. By deleting the artifacts from the uninstall folder, the kernel detects that the artifact must be stopped and undeployed/uninstalled.
Behind the scenes, the kernel calls the JMX management operations needed to process all these steps.
These hot deployment/undeployment features are similar to the web application deployment feature you can find when copying a WAR file into the webapps folder of an Apache Tomcat container.
...Since JBI messages are XML based and potentially contain redundant data, the compression feature has been added when exchanging messages between Petals ESB containers. This compression is done at transport level when a property ({{org.ow2.petals.transport.compress}}) is detected in the message exchange (set by the service consumer).
{column}
{column:width=350px}
{column:width=350px}
...