Tools

In the tools we found two types of tools:

  • the tools that we used in the project Petals (to build it, to generate report, etc).
  • the tools that are around the project (tools to administrate the container, to help to developp it, etc).
We consider categories of tools :
  • Ant tasks : some ant tasks are already defined in the JBI specifications and we may add some new tasks specific to Petals
  • Maven plugins : as we use Maven for build and deployment, we plan to provide the necessary plugin
  • Eclipse plugins : as part of the STP project, we will propose some tools for Petals
  • Administration tools : via an administration console

Maven 2 plugins

As we used Meven 2 to manage the Petals development, we had to develop our own Maven 2 plugins.

JBI Maven plugin

In order to simplify the building of the JBI archive for the JBI components, we developped our own JBI Maven plugin.

Cobertura summary report Maven plugin?

We use the Cobertura report Maven plugin to generate tests coverage report. But as we have a highly structured project with a lot of subprojects, it was not easy to visualize the coverage reports. Thus we developped a Cobertura summary report Maven plugin.

Cobertura report Maven plugin?

Above we mentionned that we use Cobertura for the tests coverage, but we had some problems with the Cobertura Maven 2 plugin from Codehaus. So we fixed it and added some features to it.

Ant Tasks

The JBI specification defines Ant tasks used to administrate the JBI container. These taks are implemented in the petals-ant project. Additionally, we have extended the specification to provide other usefull tasks.

Web administration interface

We provide a very simple Web console to administrate everything on Petals. More details here.

JMX administration

As we used MX4J as JMX implementation, the HTTP adaptor of MX4J is used to administrate Petals.

Eclipse plugins

There are several types of plugins to be provided in STP to support JBI containers and more specifically Petals for:
  • Service Creation
  • Service packaging
  • Test
  • Petals runtime support

Service Creation

Some wizards will be provided to create a JBI Service Engine or Binding Component.

This wizards will be based on a Binding component and Service Engine framework (including the Message Listener, a service unit manager skeleton, ...)

Tasks to be supported by these wizards are :

  • Generation of the component structure
  • Generation of the deployment descriptors
  • Generation of the WSDL to be provided to the JBI container by the component
  • Generation of the Service Unit Manager
These wizards will either use a POJO as the base for code generation, or generate an empty class for implementation.

Service packaging

A plugin will provide the capability to prepare for the deployment of JBI components, service units and service assemblies to a JBI compliant container:
  • Create the jbi deployment descriptor for a component
  • Create and package a Service unit descriptor
  • Create and package a Service assembly

Tests

The project will provide a Universal Test Client for JBI components. Such a client will be associated with a specific Binding Component and will give the opportunity to test a JBI component deployed on the container.

Typical steps are :

  • The test client gets the service WSDL
  • The plugin generates an interface from the service WSDL to neter parameters
  • Users can specify some JBI metadata
  • The plugin sends the message to the client and displays the results

Petals runtime support

Some tasks specific to Petals will be provided to :
  • Support Petals runtime inside Eclipse for debugging purpose
  • Package and configure Petals distributions by integrating several JBI components with the Petals runtime