Charles Moulliard's blog

Security Enforcement of the Microservices

Wed, 22 Jun 2016 00:00:00 +0200

Introduction

Securing an application is a common task that many developers will embrace during the Architecture design and coding phase of a project. Although, the securing of a Web Service, RESTfull endpoint could be achieved easily when the modules of a project are deployed within the same Java container, when they rely on the same Security Spec (JAAS, WS-Security, WS-Trust, JAX-RS) or Security Framework (Apache Shiro, Spring Security, …) the design could become really complex when we have to build a distributed application.

As the current trend is to split a Monolithic application into a collection of Microservices exposing the service as a RESTfull endpoint, Web Service, interconnected to each offer, our security officer will be very embarrassed to guide and provide recommendations for the actors of such a project.

The difficulty is not related to the Microservice Architecture itself but because:

The number of Services to be managed within such project is multiplied by a factor of 10x, 100x,
Each service, which is part of a logical/business domain, could be managed according to different Security Governance Rules (Basic Auth, Digest & Encryption),
The information transported between the services belong to a different confidentiality level (public, private, …)

For all these reasons, the security and the governance will become even more critical for the success of a Microservice Architecture. From a technical point of view, we will be faced to the following concerns : as the modules will be deployed within different type of Java Container (Apache Tomcat, JBoss WildFly, Apache Karaf, JBoss Swarm, Vert.x, …) , that each container addresses a specific need (Non Blocking, high throughput of connections, http/2 protocol, …) and that they doesn’t necessarily support/follow the JavaEE spec or JAXRS/JAXWS standards, different security patterns or frameworks will be required to resolve our security challenge.

To help the architects and developers to adopt the security approach which best fits the company requirements, practices, Microservices Architecture and their skills, we will investigate within this blog some patterns that you could easily implement within your project in order to secure your Microservices :

Interceptor
Web Container
Api Gateway

We will now present, detail and mitigate the approaches in order to measure the consequences of the adoption of the different patterns.

The use case that we will discuss is very simple and consists to secure a RESTfull Service which has been created using the Java Integration Framework - Apache Camel. As we can see within the following picture, the REST Service or Endpoint is exposed by a local HTTP Web container created using Eclipse Jetty. A client which is our HTTP Agent will issue HTTP requests using a HTTP method (GET, POST, DELETE, …) and a URL to access the Web resources of the service (“/rest/myservice/”).

Interceptor

The goal of the interceptor is to include within the flow of the code a class responsible to collect/handle the information passed through the HTTP Request like the Authorization Header, the http URI, URL and the credentials provided by the HTTP agent. The principe is presented within the next picture

Within the flow describing how a request or an exchange is processed, an interceptor is added before or after the call to the processor responsible to handle the logic declared within the application. This interceptor wraps your code and will act as a security guardian. This pattern is supported by the Apache Camel Framework using a Policy.

The interceptor can use the existing Security Frameworks/Technologies to handle the authentication/authorization process like JAAS, Apache Shiro, Spring Security, Apache WS4J, …) but you can also create your own Interceptor and plug it within the flow as we will demonstrate hereafter.

An Apache Camel interceptor will look the SimpleAuthenticationPolicy class where the wrap method will be called when the framework will consume an Exchange which corresponds to a HTTP Request received by the Jetty Server acting as a consumer.

public class SimpleAuthenticationPolicy implements AuthorizationPolicy {

    @Override
    public Processor wrap(RouteContext routeContext, Processor processor) {
        return new SimpleAuthenticationProcessor(processor, this);
    }
}

The SimpleAuthenticationProcessor class contains the logic needed to access the content of the Exchange when the processor will be called and of course, it will call the class/method responsible to authenticate ot authorize the incoming request applySecurityPolicy

@Override
public boolean process(Exchange exchange, AsyncCallback callback) {
    try {
        applySecurityPolicy(exchange);
    } catch (Exception e) {
        // exception occurred so break out
        exchange.setException(e);
        callback.done(true);
        return true;
    }
    return super.process(exchange, callback);
}

The last thing to be done is to register the interceptor within the Apache Camel Route definition in order to secure your Microservice.

  SimpleAuthenticationPolicy auth = new SimpleAuthenticationPolicy();
  
  // Definition of the RESTFull Endpoint using the REST DSL syntax
  restConfiguration()
      .component("jetty").scheme("http").host("0.0.0.0").port("9090")
      .bindingMode(RestBindingMode.json);

      // Service exposed at the path "/customerservice/customer/{id}
      rest("/customerservice").produces("json")
         .get("/customer/{id}")
         .to("direct:hello");

      from("direct:hello")
         .policy(auth) // Policy registered to authenticate the HTTP Request
         .beanRef("customerService","getCustomerDetail");

As you can see this approach is very flexible as you can plug whatever technology you prefer to use to secure the access to the REST service exposed as Endpoint by the Jetty Server.

Web Container

We can also enrich the architecture and use the features offered by the Jetty/Netty HTTP Server in order to

Enable the SSL/TLS Security layer to encrypt the data exchanged between the HTTP Agent and the Server,
Setup mutual TLS,
Restrict the access to the Web Resources using a SecurityConstraint associated with a user’s role.

// Describe the Authentication Constraint to be applied (BASIC, DIGEST, NEGOTIATE, ...)
Constraint constraint = new Constraint(Constraint.__BASIC_AUTH, "user");
constraint.setAuthenticate(true);

// Map the Auth Constraint with a Path
ConstraintMapping cm = new ConstraintMapping();
cm.setPathSpec("/*");
cm.setConstraint(constraint);

HashLoginService loginService = new HashLoginService("MyRealm",
        "myrealm.props");

ConstraintSecurityHandler sh = new ConstraintSecurityHandler();
sh.setAuthenticator(new BasicAuthenticator());
sh.setConstraintMappings(cm);
sh.setLoginService(loginService);

Authenticate the user using some JAAS Plugin (HashLogin with Property file, LDAP, JDBC)

As you can see within the next diagram, the security architecture proposed is more robust as managed by two distinct levels if you combine the Interceptor pattern with the HTTP Security model :

The Web HTTP Container will be responsible to Authenticate the user and restrict the access to the Web Resources,
The Connection between the HTTP agent and the Server is more secured as the data will be encrypted and the confidentiality of the data exchanged will be guarantee
The interceptor will become responsible to authorize the access to the Service

Time to mitigate the approach

It is time now to review the approach from a Security Officer point of view and to mitigate the approach. He/She will be very please about the solution as :

It offers a great level of flexibility to support the Java Standards (JAAS, WS-Security, …) or enacted by the company,
The applications developed will be independent of any third party tool or vendor to support the security,

But it will certainly complain that the approach is really intrusive, will require to develop some home security code to support the interceptor pattern. The management of the collection of the Microservices will be very difficult as we will suffer from a lack of governance & centralized capability as proposed by an Api Management platform to define in one place the security rules applied to the different services, the services secured, …

Pros	Cons
No product lock	Intrusive
Great Flexibility	Low Management Capability
Spec Managed	Lack of Governance

Gateway

The gateway pattern as depicted within the next diagram delegates the responsibility to manage the security aspect to an external player which is an interceptor acting as a proxy. This actor which is an Api Management Actor can be part of the same network segment where the Microservices are deployed or can be deployed behind a firewall to reenforce the security of the Services hosted by the Java containers.

The Apiman project has been developed to support this pattern and has the advantage that it can be deployed on premises. The role of the Api Management platform will be to :

Define centrally the different services/endpoints to be secured (REST, Web Service),
Select using the available plugins the Policies to be applied (Basic Auth, OAuth2, …),
Map the Web Resources, the Web Actions (GET, POST, PUT, DELETE) with the Services
Deploy within one to many Gateways (HTTP Web Server, Vert.x) the policies that the Server will use to intercept the HTTP requests

The management of the services and the governance is simplified for the Security officer using the Apiman Server.

This Web Console will allow to :

Manage the services according to an organization which abstract the related services,
Select the services to be secured and assign to an Api,
To group using a plan the policies to be applied to the different services,
To select the plugins to be used; Basic Authentication, Authorization, Black listed IP, White IP list, Throttle, Keycloak - OAuth2
To manage the different versions of the Apis published,
To integrate the gateway where the policies are applied top of the requests received,
To collect the metrics/statistics of the usage done

Conclusions

The adoption of an Api Management Platform will certainly offer more possibilities to govern the Microservices deployed in different Java containers and potentially non Java containers as offered by the Node.js technology.

Some additional benefits about this technology concern also :

The disappearance of the coopling between the Services and the frameworks required to authenticate/authorize the access to the Microservices,
The centralization in one place of the Apis, consumers of the services,
The collection/aggregation of the metrics/statistics about the usage of the services which is required within some institutions where Security Audit are performed regularly

There are nevertheless some drawbacks as summarized within the next table as a new technology must be investigated and adopted within the company, the performance could be impacted as a Proxy HTTP Server will interrupt the normal flow between the HTTP Agent and the Service, the project will become dependent of the Api Product used and new processes will be defined within the company to support the Api platform like also the actors in charge to maintain the security governance and the infrastructure.

Pros	Cons
Centralized governance policy configuration	Performance
Loose coupling	New Architecture Brick
Tracking of APIs and consumers of those APIs	Plugins available
Gathering statistics/metrics	Product locked
Simplify security audit

While the usage of the Interceptor completed with the Web Container Security Model will be adopted by many companies when the number of the Microservices to secure is not important or when few security standards should be supported, it is evident that the Gateway Pattern will become the defacto standard within large institutions where the security audit and the governance aspects are non negotiable.

Another benefit of the Api Management Platform when it is used top of a Virtualized environment as proposed by the OpenShift/Kubernetes Cloud platform is the fact that the MicroServices deployed and running as Pod will be automatically discovered !

Camel & Rest DSL in Action !

Wed, 23 Mar 2016 00:00:00 +0100

Since the release 2.15 of Apache Camel, a new Domain Specific Language or DSL has been developed to simplify the definition/creation of the REST endpoints and their syntax. This DSL syntax contains 2 words that we will use to :

Configure the component and endpoint (restConfiguration())
Define the action to be performed (GET, PUT, POST or DELETE) and path to access the service (rest().verb())

The syntax exists in Java or in XML format. Here is a an example where the path of the application is defined to access this URL resource “/blog” and where the HTTP verb “put” is defined for the the subpath “/article”. A parameter has been added using as convention the syntax “{id}”. The format to be used when the HTTP endpoint produce an HTTP Response or process a HTTP request can be specified as you can see using “produces(“”)” or “consumes(“”).

rest("/blog/").id("rest-blog-service")
       .produces("application/json")
       .consumes("application/json")

       .put("/article/{id}").id("rest-put-article")
       .type(Blog.class)
       .to("direct:add");

The formal descritpion of the REST DSL language is designed here

One of the benefit of the DSL is that it does not rely on any Java Specification (jax-rs 1.0, …) and annotations but allows to design in one place the services to be mapped/exposed behind the REST endpoints. The second benefit is that the syntax is supported by many Apache Camel components and by consequence, you have the possibility to design your project using one for them or to combine them.

camel-netty-http
camel-netty4-http
camel-jetty
camel-restlet
camel-servlet
camel-spark-rest
camel-undertow

To configure the component/endpoint and their corresponding properties (enable CORS, port, hostname, contextPath, bindingMode, …), you will use the restConfigure() DSL word as showed hereafter

restConfiguration().component("servlet")
   .enableCORS(true)
   .bindingMode(RestBindingMode.json)
   .dataFormatProperty("prettyPrint", "true");

So, when Apache Camel will read the Java REST DSL or XML DSL syntax, it will instantiate using the factory class of the component selected an endpoint, set the fields of the component or endpoint object and next a HTTP handler responsible to process for a specific URL path the processing of the HTTP Request and HTTP response will be created and registered within the corresponding HTTP Web container.

Remark : As the implementation of the HTTP handler like also the verbs used (OPTION, CORS) is component dependent, I recommend that you evaluate them to verify/validate the one which is able to best process your HTTP requests.

To help you to work with this new REST DSL syntax, this project hosted on FuseByExample github repository has been created.

It provides a real application designed to manage Blog Articles (Create, Search, Delete). It will allow you to post Blog Article that we save into an ElasticSearch backend. The result posted within the NoSQL JSon Databae can be consulted using a Kibana Dashboard created for the purpose of this project.

To document the REST DSL Api of the REST endpoints managed by Apache Camel, we have used the Camel Swagger Servlet has been configured in order to allow the Swagger UI to get the json stream generated by Camel from the REST DSL syntax parsed within the project. The Servlet can be registered using a web.xml file or when you deploy the project on JBoss Fuse which is an OSGI container by using the Blueprint IoC container and a OSGI HTTP Service

<service interface="javax.servlet.http.HttpServlet">
        <service-properties>
            <entry key="alias" value="/rest/api-docs/*"/>
            <entry key="init-prefix" value="init."/>
            <entry key="init.cors" value="true"/>
            <entry key="init.base.path" value="${swaggerBasePath}"/>
        </service-properties>
        <bean class="org.apache.camel.component.swagger.DefaultCamelSwaggerServlet"/>
    </service>

    <!-- to setup camel servlet with OSGi HttpService -->
    <reference id="httpService" interface="org.osgi.service.http.HttpService"/>

The Service properties fields define the fields to be configured for the Swagger Servlet that Swagger will use to setup the path to access the JSON doc generated and path also to access the endpoint deployed on the server.

You can find the required info about how to configure and use the Camel-Swagger component here. A new component has been created recently within the Apache Camel project as Swagger has refactored its API to use Java as language instead of Scala.

Drools & jBPM run on OSGi container JBoss Fuse !

Fri, 22 Aug 2014 00:00:00 +0200

We have worked hard this year to improve the Drools - Business Logic integration Platform to make it OSGI compliant. The modules of the project have been reviewed to :

Export/import correctly the packages required by the bundles when deployed into an OSGI container like Apache Felix,
Register some OSGI services,
Design a new OSGI classloader to load the Drools resources (drl, bpmn, bpmn2) packaged into the bundles

Moreover, the project provides now a features XML file to provision the different modules (drools, drools-decision-table,bpm, …) into JBoss, fuse] or Apache Karaf

Since the release 6.1.0 of Drools/jBPM, you can capitalize the efforts done and deploys BRMS onto the [JBoss, fuse]](https://www.jboss.org/products/fuse/overview/) Java Container which is a Multi-Technology OSGI Platform running your Integration projects with these technologies :

Typically a BRMS project can be designed as a bundle containing the knowledge repository, session, resources and rules to be fired. Using the BundleActivator class, the project can be started directly by the OSGI container when the event “start” will be called. This is not the only thing that you can do as you can also use a Dependency Injection framework supported by JBoss, fuse] product :

to design your architecture. No matter which injection mechanism you prefer to use, JBoss, fuse] will scan the bundles deployed and will create with the classloader of the bundle create the corresponding Application Context (Spring, Blueprint, Weld, …) to register the beans discovered as singletons objects.

To help you to start your project, a quickstart github repository has been created covering different scenario presented here They cover the different strategies described below but also how to externalize the rules, use rules defined in an Microsoft Excell spreadsheet and run some business processes (using or not a persistent layer).

One of the key benefit to use BRMS on the JBoss, fuse] platform is that you can integrate it easily with the Camel Integration framework to collect data from different sources, validate or enrich them and next inject such info into the Ksession before to fire the rules. Such a scenario is described here and a quick demo is attached to this post too to show you BRMS and Apache Camel in action.

BRMS & Camel Live !

Publication about Introduction to Apache Camel (Part I)

Tue, 01 Oct 2013 00:00:00 +0200

In June of this year 2013, I have published a first article about Apache Camel in the Java Review jaxenter.

This article which is part of a series will introduce you core and more advanced features :

How routing take place,
Why Camel is called DSL/Fluent API,
How type conversion is done between the objects,
Data Formatting
…

about this Java Integration Framework.

The second part will cover data formatting between objects and formats currently supported by Apache Camel but also mapping tools !

Cloud Integration with Fabric Camel (Part I)

Thu, 28 Jun 2012 00:00:00 +0200

Since the launch of fuse ESB 7, fuse MB 7 and in fact the official release of fuse Fabric, Camel has moved in a new era called “Cloud Integration where machines, services are distributed everywhere.
fuseSource (which is now part of RedHat company) is the leader of “Integration Everywhere” has supported the development of the Fabric project to facilitate the creation of such integration project in the “cloud”.

With Fabric, the information of the Camel endpoints are registered in a global registry which can be accessed by the different machines part of the cloud.

This mechanism which is presented here :

You Tube link of the video : http://www.youtube.com/watch?v=CO1WcTFivT0

requires some Fabric agents which are used to communicate with the registry (= Fabric ensemble). This ensemble is in fact a Zookeeper server which will contain configurations, profiles and of course services registered. When a Camel producer wants to publish a camel exchange, it will perform a lookup in the registry to find endpoints using as a key the name associated to a fabric group. The endpoints available are returned as a list :

zk:list -r -d fabric/registry/camel
endpoints/local/00000000000 = jetty:http://0.0.0.0:9090/fabric
endpoints/local/00000000001 = jetty:http://0.0.0.0:9191/fabric

As Fabric agents which are deployed in Fabric containers can be added or removed dynamically according to the needs, this list is continuously refreshed. The endpoint registered could be of type Jetty, CXF, Mina, Netty, JMS as they are able to transport information from a machine to another using HTTP, JMS, TCP/IP … protocols.

The other advantage of this mechanism is that the Camel producer when communicating with Fabric will use a internal loabalancer if more than one Camel route exposing the service has been deployed in several Fabric containers.

To deploy a Fabric Camel project, you just need to use some of the Fabric commands to create the profiles of the camel routes exposed as service and also used to consume the services.

With such profiles, we can create Fabric containers and deploy the camel routes as the following video will show you

Youtube Link of the video : http://www.youtube.com/watch?v=RUg2rgY4BME

Remark : The code of the demo is available here : https://github.com/fusesource/fuse/tree/master/fabric/fabric-examples/fabric-camel-cluster-loadbalancing

Enjoy Cloud Integration Camel Rider !

Real Time HTML5 application with Websocket and ActiveMQ/camel

Thu, 26 Apr 2012 00:00:00 +0200

As part of my presentation, I have prepared some examples to dig into what Apache ActiveMQ and Camel propose to work with HTML5 and WebSocket technology.

Developing “Real Time Web Applications” has always been painful not matter if the technology used was based on Java Applet, Adobe Flash, Adobe ShockWave, Microsoft Silverlight and the protocol (HTTP, RMI, …).

Since HTML5 publication (2009) and the work done by W3C and IETF organisations, we now have a standard rfc-6455 that we can use to exchange in a bi-directional way “messages” between the browser and the Web Server. Only one HTTP(s) request is required to initiate the WebSocket communication and later on the exchange of data frames (text or bytes).

ActiveMQ (release 5.6) like Camel (release 2.10) proposes a WebSocket Transport Connector or Endpoint using Jetty WebServer WebSocket implementation (v7.5). This allow not only to retrieve data from topics but when combining the EIP patterns of Camel and some components like : sql, jpa, file, rss, atom, twitter, … we can “aggregate”, “enrich” or “filter” content receive from feed providers before to publish them for feed consumers.

ActiveMQ uses Stomp as a wired format to send WebSockets messages between the WebSocket server running within the ActiveMQ broker and the Web browser. In this context, we must use one of the two javascript libraries available stomp.js, stomple to develop the project

$(document).ready(function() {
var client, destinationQuotes;
$('#connect_form').submit(function() {
var url = $("#connect_url").val();
client = Stomp.client(url);

// the client is notified when it is connected to the server.
var onconnect = function(frame) {

var stockTable = document.getElementById("stockTable");
var stockRowIndexes = {};

client.subscribe(destinationQuotes, function(message) {
var quote = JSON.parse(message.body);
$('.' + "stock-" + quote.symbol).replaceWith("" +
"" + quote.symbol + "" +
"" + quote.open.toFixed(2) + "" +
"" + quote.last.toFixed(2) + "" +
"" + quote.change.toFixed(2) + "" +
"" + quote.high.toFixed(2) + "" +
"" + quote.low.toFixed(2) + "" +
"");
...

client.connect(login, passcode, onconnect);

and of course the WebSocket protocol must be enable.

<transportconnectors><br/>
    <transportconnector name="websocket" uri="ws://0.0.0.0:61614"></transportconnector>
</transportconnectors><br/>

Camel does not need a special format to exchange the data between its WebSocket endpoint and the browser as JSon text will be send through the WebSocket Data Frames to the browser. We must just expose a Camel Route as a WebSocket Server.

1
2
3
4
5
6
7
8
public class WebSocketStockPricesRoute extends RouteBuilder {
    @Override
    public void configure() throws Exception {
       from("activemq:topic:stockQuoteTopic")
       .log(LoggingLevel.DEBUG,"&gt;&gt; Stock price received : ${body}")
       .to("websocket:stockQuoteTopic?sendToAll=true");
     }
}

and use in the browser the WebSocket HTML5 js script.

var socket;
$('#connect_form').submit(function () {

var stockTable = document.getElementById("stockTable");
var stockRowIndexes = {};
var host = $("#connect_url").val();
socket = new WebSocket(host);

// Add a connect listener
socket.onopen = function () {
$('#msg').append('<div class="event">
Socket Status: ' + socket.readyState + ' (open)</div>
');
}

socket.onmessage = function (msg) {
// $('#msg').append('<div class="message">
Received: ' + msg.data + "</div>
");

var quote = JSON.parse(msg.data);

....

In both cases, you can combine other javascript librairies (jquery, jquery-ui) to improve the design of the JSon objects to be displayed in the browser. Here are some screenshots about the demos

Stock Trader

Chat Room

Twitter and News Feed Code can be retrieved from fuseByExample web site.

Look to “websocket-activemq-camel” git hub project.

Enjoy WebSocket with Apache Camel and ActiveMQ !

Apache Camel at CamelOne

Fri, 13 Apr 2012 00:00:00 +0200

fuseSource organises for the second time an event dedicated to the famous Apache Camel EIP Framework - CamelOne, the 15th and 16nd of May. This conference is not only a vitrine dedicated to Apache Camel Integration framework or, fuse]Source products but related technologies like ESB, SOA, BPM, Cloud, MOM, HTML5, Big Data and Real Time applications will be presented through a panel of different CamelOne talks and speakers (Rob Davies, James Strachan, Claus Ibsen, Hiram Chirino, Tony Shan, Robin Howlett, Dan Kulp, Jon Anstey, Kai Wahner, Charles Moulliard, Jazon Van Zyl, …).

A special attention was also given this year to present projects deployed and running in Enterprise :

Christian Mueller - Atos,
Rob Terpilowski - Lynden,
Matt Pavlovich - Media Driver
David Reiser, Ram Raju and Shane Kent – Department of Transportation,
Robin Howlett - Silver Chalice

proving that Apache Camel is not only used by early adopters but is now part of the Enterprise Software Architecture like RDBMS and Web Technologies

If your are not yet registered, I recommend to do it to have the chance to meet some Apache Committers and people working every day with SOA and Integration projects. This is incredible opportunity which is only offered one time a year. Do not forget that the CamelOne conference include also a program to train people on Apache Camel, ActiveMQ and Apache ServiceMix.

CamelOne 2012 Logo

3 reasons to use, fuse]Source Documentation

Fri, 13 Apr 2012 00:00:00 +0200

As an Apache Committer but also, fuse]Source Consultant and Solution Architect, the documentation and its quality is a critical factor in my day by day work. Until now, even using google search engine, that was difficult to find in one place all the information required and a wasting time. This situation has changed and I will give you three reasons to use/adopt fuseSource documentation for your Apache Camel, Apache ServiceMix and Apache Karaf projects.

Reason 1 :, fuse] maintains history of Apache releases

Apache websites use Atlassian Confluence to maintain content publishes for each Apache project. This tool does not allow to create a history of the different releases of Camel by example (2.6, 2.7, 2.8). This is not the case with, fuse]Source documentation which allow you to browse a specific version like the current. And with the help of google, you can make specific search like that

    site:fusesource.com/docs/router/2.8/ "followed by the keywords"
    site:fusesource.com/docs/router "followed by the keywords"

Reason 2 : Javadoc and Schema are well documented

Javadoc & XML Schema are also 2 interesting examples as there is no XML Schema javadoc on Apache websites for by example Spring DSL language. This is completely different on, fuse]Source web site as you can read the documentation and discover what are the tags or attributes to be used for specific Apache Camel DSL words. Here is an example containing the options proposed for Apache Camel Dataformat.
Reason 3 : New chapters have been added

, fuse]Source documentation contains missing pieces of information or cover in depth points which are described poorly on Apache websites or in an disparate way. So take the time to read the following chapters when you need more info about Transactions, Security, …

- [Camel and Transactions](http://fusesource.com/docs/router/2.8/transactions/front.html)
- [Camel and WebServices](http://fusesource.com/docs/router/2.8/camel_cxf/front.html)
- [fuse ESB - Security guide](http://fusesource.com/docs/esb/4.4.1/esb_security/front.html)
- [Transactions with, fuse] ESB](http://fusesource.com/docs/esb/4.4.1/camel_tx/front.html)
- [ActiveMQ - Security](http://fusesource.com/docs/esb/4.4.1/amq_security/front.html)
- [ActiveMQ - Tuning Guide](http://fusesource.com/docs/esb/4.4.1/amq_tuning/front.html)

Run a Google Web Toolkit 2 project on Apache Karaf/ServiceMix

Fri, 16 Dec 2011 00:00:00 +0100

To simplify the development of Web projects on Apache Karaf/Apache ServiceMix, we have created archetypes to setup WAR or WAB projects. They are very basic but they can be enriched with framework like Struts 2, Wicket, plain JSP or MyFaces JSF as they are currently supported on Apache Karaf - ServiceMix.

For the GWT users, it exists now an archetype which will create a GWT 2.4 project. To create such a project, you must generate a project from the archetype

mvn archetype:generate \
   -DarchetypeGroupId=org.ops4j.pax.web.archetypes\
   -DarchetypeArtifactId=wab-gwt-archetype \
   -DarchetypeVersion=2.1.2 \
   -DgroupId=com.mycompany \
   -DartifactId=hello \
   -Dversion=1.0

    <a href="https://cmoulliard.github.io/assets/images//archetype-creation.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="279" src="https://cmoulliard.github.io/assets/images//archetype-creation.png" width="320"/></a>

build next the WAB using hello/mvn clean install and deploy it on Apache Karaf

Fig. 1 : GWT deployed on Apache Karaf

Verify that the web site is well registered :

Fig. 2 : Web site deployed on Apache Karaf

Next, you can navigate to your application in your browser and click on the button to say Hello.

Fig. 3 : Hello Message of GWT in the browser

Remark : A WAB project is nothing more than a WAR excepted it is packaged as a bundle file, that we have removed the WEB-INF/lib dependencies and create a MANIFEST file containing the OSGI metadata of the packages to be imported.

Apache Camel, Cxf, ActiveMQ & ServiceMix at Devoxx

Mon, 21 Nov 2011 00:00:00 +0100

This year, I get the chance to present 2 talks at the Devoxx event,

one for University Talk and the other for Hands on Lab. With the help of Gert Vanthienen, we took the time to present in more detail what finally we can design as solution, architecture with Apache projects like Camel, CXF, ActiveMQ and ServiceMix and move it into a scalable, high-available platform.

That was a great challenge as this is not really easy to introduce “integration” which is not so sexy comparing to a Web Development framework, an iPhone or Android application.

But times are changing and a lot of developers / architects are interested by agile approaches that we develop at Apache foundation.

With fuse IDE tool,

we can now accelerate the creation of a project using Apache Camel. The wysiwig editor and EIPs patterns allow you to quickly create new routes while the runtime editor enable to review existing project. IDE is more than a tool as it allows to run and deploy the routes in, fuse] ESB, Tomcat application servers or locally. The tool is not yet finalized (release 2.1 should be available soon) but it offers a lot of possibilities to facilitate integration projects, tracing of messages (= exchanges) and investigation about time passing through the different processors.

Integration projects are moving into cloud space and this is what we have presented next with, fuse]Source Fabric. Fabric is not a new hype but a strategy to reduce impact of OSGI dependencies calculation, provisioning of Apache Camel routes on local, remote or cloud instances using Apache Zookeeper as registry of artefacts to be deployed (features, jars, configurations). It offers also elastic services when deploying services into the cloud.

</a>

For those who were not there, here are the links of the presentation like also the hands on lab material that we have used in the afternoon to develop a real Japa Application Project (Spring, JPA, Web) on, fuse] ESB.

Presentation : http://www.slideshare.net/cmoulliard/devoxx-2011-integrationcamelcxfservicemixactivemq
Hands on Lab : https://github.com/cmoulliard/Devoxx-2011-HandsOnLab
fusesource Fabric : http://fabric.fusesource.org/
fusesource : Leader in Integration OpenSource

Remark : The step by guide is available on the github repo like also the skeleton (zip file)

Talks about Integration with Camel & ESB

Thu, 24 Feb 2011 00:00:00 +0100

This year, I plan to make some talks about Apache ServiceMix, Apache Camel, apache ActiveMQ and show how easy it is to build integration solutions with Apache technologies.

Take free time, a two break hours and joint me during one of the following events :

Agenda

The purpose of this presentation/demo is to show you how easy it is to design integration between systems (web services, file systems, database, queue engine) using the projects Camel, ServiceMix and ActiveMQ of the foundation Apache.

First part :

Presentation of the projects Camel, ServiceMix and ActiveMq
Description of the topologies proposed : messaging, osgi, web, … High-availability and scalability (ServiceMix and/or ActiveMQ)

Second part :

Making of of the demo solution
Transpose it into camel DSL language Coding of WebService (using Apache CXF), DAO and Persistence layer (Spring + Hibernate JPA) and Web layer (Apache Wicket), Development of Camel routes, Packaging and Deployment. Demo

Measure elapsed time with Camel

Wed, 23 Feb 2011 00:00:00 +0100

With the last version of Apache Camel, we provide a event notifier support class which allow to keep information about what happen on Exchange, Route and Endpoint. One of the benefit of this class is that you can easily audit messages created in Camel Routes, collect information and report that in log by example.

When developing an application, it is very important to calculate/measure elapsed time on the platform to find which part of your code, processor or system integrated which is the bad duck and must be improved.

In three steps, I would show you How to enable this mechanism to report :

Time elapsed to call an endpoint (could be another camel route, web service, …)
Time elapsed on the route exchange

STEP 1 - Create a Class implementing the EventNotifierSupport

public class AuditEventNotifier extends EventNotifierSupport {

    public void notify(EventObject event) throws Exception {
        if (event instanceof ExchangeSentEvent) {
            ExchangeSentEvent sent = (ExchangeSentEvent) event;
            log.info(">>> Took " + sent.getTimeTaken() + " millis to send to external system : " + sent.getEndpoint());
        }

        if (event instanceof ExchangeCompletedEvent) {
            ExchangeCompletedEvent exchangeCompletedEvent = (ExchangeCompletedEvent) event;
            Exchange exchange = exchangeCompletedEvent.getExchange();
            String routeId = exchange.getFromRouteId();
            Date created = ((ExchangeCompletedEvent) event).getExchange().getProperty(Exchange.CREATED_TIMESTAMP, Date.class);
            // calculate elapsed time
            Date now = new Date();
            long elapsed = now.getTime() - created.getTime();
            log.info(">>> Took " + elapsed + " millis for the exchange on the route : " + routeId);
        }
    }

    public boolean isEnabled(EventObject event) {
        return true;
    }

    protected void doStart() throws Exception {

        // filter out unwanted events
        setIgnoreCamelContextEvents(true);
        setIgnoreServiceEvents(true);
        setIgnoreRouteEvents(true);
        setIgnoreExchangeCreatedEvent(true);
        setIgnoreExchangeCompletedEvent(false);
        setIgnoreExchangeFailedEvents(true);
        setIgnoreExchangeRedeliveryEvents(true);
        setIgnoreExchangeSentEvents(false);
    }

    protected void doStop() throws Exception {
        // noop
    }
}

Not really complicated and the code is explicit. Check the doStart() method to enable/disable the events for which you would like to gather information.

This example uses only Exchange.CREATED_TIMESTAMP property but the next version of Camel 2.7.0 will provide you the property exchange.RECEIVED_TIMESTAMP and so you will be able to calculate more easily the time spend by the exchange to call the different processors till it arrives at the end of the route.

This example collects Date information but you can imagine to use this mechanism to check if your route processes the message according to SLA, ….

STEP 2 - Instantiate the bean in Camel Spring XML

<!-- Event Notifier -->
<bean id="auditEventNotifier" class="com.sfr.audit.AuditEventNotifier">
</bean>

By adding this bean definition, Camel will automatically register it to the CamelContext created.

STEP 3 - Collect info from nto the log

18:10:46,060 | INFO  | tp1238469515-285 | AuditEventNotifier               | ?                                   ? | 68 - org.apache.camel.camel-core - 2.6.0.fuse-00-00 | >>> Took 3 millis for the exchange on the route : mock-HTTP-Server
18:10:46,062 | INFO  | tp2056154542-293 | AuditEventNotifier               | ?                                   ? | 68 - org.apache.camel.camel-core - 2.6.0.fuse-00-00 | >>> Took 25 millis to send to external system : Endpoint[http://localhost:9191/sis]
18:10:46,077 | INFO  | tp2056154542-293 | AuditEventNotifier               | ?                                   ? | 68 - org.apache.camel.camel-core - 2.6.0.fuse-00-00 | >>> Took 103 millis for the exchange on the route : ws-to-sis

Secure Web Services - WS-Security

Fri, 24 Sep 2010 00:00:00 +0200

Security is one of the important key in the success of a IT project but most of the time only user authentication or data encryption are taken into account. So security of the application is often not adressed or leave aside due to complexity of the implementation. One of the reason explaining this situation comes from the fact that solutions or frameworks proposed to secure an application are difficult to configure and maintain. And this remark prevalls over the specification WS-Security.

In large company having deployed WS-Services to allow intra or inter connection between applications, Web application authentication with HTTPS protocol mechanisms are use to secure platforms. That means that users discovering the credentials used to connect to the web server can potentially have access to the services of the company.

WS-Security offers a way to authenticate the user connected to a web service or allow also a user to be trusted on the web server it is connected. This mechanism is interesting because it reinforce the security but provides also a way to restrict access to unauthorized users to web services.

Apache Camel and CXF frameworks offers a simplify way to implement this with only few lines of code and spring beans definition. Let’s see that in action :

STEP 1

We only need to use JAAS api to authenticate the user using the following java package “javax.security.auth.callback” and the project WS4J of Apache. Here is a simple example authenticate a user using a list and the password provided.

package org.apache.camel.example.reportincident;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import javax.security.auth.callback.Callback;
import javax.security.auth.callback.CallbackHandler;
import javax.security.auth.callback.UnsupportedCallbackException;

import org.apache.ws.security.WSPasswordCallback;

/**
 * Callback handler to handle passwords
 */
public class UTPasswordCallback implements CallbackHandler {

    private Map<String, String> passwords = new HashMap<String, String>();

    public UTPasswordCallback() {
        passwords.put("claus", "sualc");
        passwords.put("charles", "selrahc");
        passwords.put("james", "semaj");
        passwords.put("abcd", "dcba");
    }

    /**
     * Here, we attempt to get the password from the private alias/passwords map.
     */
    public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException {

        String user = "";

        for (Callback callback : callbacks) {
            WSPasswordCallback pc = (WSPasswordCallback) callback;
            user = pc.getIdentifier();

            String pass = passwords.get(user);
            if (pass != null) {
                pc.setPassword(pass);
                return;
            }
        }

        // Password not found
        throw new IOException("Password does not exist for the user : " + user);
    }

    /**
     * Add an alias/password pair to the callback mechanism.
     */
    public void setAliasPassword(String alias, String password) {
        passwords.put(alias, password);
    }
}

STEP 2

This is here that the magic will operates as we will use Spring beans definition with Apache Web Services Framework - CXF and Apache Camel to expose the web service

Instantiate your WS4J bean

    <bean id="wss4jInInterceptor" class="org.apache.cxf.ws.security.wss4j.WSS4JInInterceptor">
        
        <constructor-arg></constructor-arg>
    </bean>    <bean id="wss4jInInterceptor" class="org.apache.cxf.ws.security.wss4j.WSS4JInInterceptor">
        <constructor-arg>
            <map>
                <entry key="action" value="UsernameToken Timestamp">
                    <entry key="passwordType" value="PasswordDigest">
                        <entry key="passwordCallbackClass" value="org.apache.camel.example.reportincident.UTPasswordCallback">
                            </entry>
                    </entry>
                </entry>
            </map>
            </constructor-arg>
        </bean>

Add it as an interceptor to CXF to allow CXF to authenticate the user using the credentials provided in the SOAP header definition.

<cxf:cxfendpoint id="reportIncident" address="http://localhost:9080/camel-example-reportincident/webservices/incident" wsdlurl="etc/report_incident.wsdl" serviceclass="org.apache.camel.example.reportincident.ReportIncidentEndpoint">        
        <cxf:ininterceptors>
            <ref bean="loggingInInterceptor">
                <ref bean="wss4jInInterceptor"></ref>
                
                <cxf:outinterceptors>
                    <ref bean="loggingOutInterceptor"> <!--  <ref bean="wss4jOutInterceptor"> --></ref>
                    </cxf:outinterceptors>
                
                <cxf:cxfendpoint id="reportIncident" address="http://localhost:9080/camel-example-reportincident/webservices/incident" wsdlurl="etc/report_incident.wsdl" serviceclass="org.apache.camel.example.reportincident.ReportIncidentEndpoint">
                    <cxf:ininterceptors></pre>
    Here is an example of the SOAP header
    <pre name="code" class="xml"><soap:envelope soap="http://schemas.xmlsoap.org/soap/envelope/">
        <soap:header>
            <wsse:security wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd" mustunderstand="1">
                
                <wsu:timestamp wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" id="Timestamp-2">
                    
                    <wsu:created>2010-09-24T07:31:06.308Z</wsu:created>                    
                    <wsu:expires>2010-09-24T07:36:06.308Z</wsu:expires>
                    </wsu:timestamp>
                
                <wsse:usernametoken wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd" wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" id="UsernameToken-1">
                    
                    <wsse:username>charles</wsse:username>                    
                    <wsse:password type="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordDigest">KoNvkEh9jwgvxTfcTza6+kHkKNI=</wsse:password>                    
                    <wsse:nonce encodingtype="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-soap-message-security-1.0#Base64Binary">havIKNKvlRuatlp3CncMKw==</wsse:nonce>                    
                    <wsu:created>2010-09-24T07:31:06.306Z</wsu:created>
                    </wsse:usernametoken>
                </wsse:security>
            </soap:header>
        
        <soap:body>
            <ns2:inputreportincident ns2="http://reportincident.example.camel.apache.org">
                <incidentid>222</incidentid>
                
                <incidentdate>2010-07-14</incidentdate>
                <givenname>Charles</givenname>
                <familyname>Moulliard</familyname>
                <summary>Bla</summary>
                <details>Bla bla</details>
                <email>cmoulliard@apache.org</email>
                <phone>0011 22 33 44</phone>
                </ns2:inputreportincident>
            </soap:body>
        </soap:envelope>

And finally, declare your camel route using the web services

<camel:camelcontext id="camel" xmlns="http://camel.apache.org/schema/spring/camel-spring.xsd">
        
<camelcontext id="camel">
  <route>
      <from uri="cxf:bean:reportIncident">
        <convertbodyto type="org.apache.camel.example.reportincident.InputReportIncident">

        <setheader headername="CamelFileName">
          <method bean="filenameGenerator" method="generateFilename">
        </method>

        <to uri="velocity:etc/MailBody.vm">
        <to uri="file://target/subfolder">
          <transform>
            <method bean="myBean" method="getOK">
            </method>
          </transform>

To play with the example, follow this example of Camel CXF and enjoy it !

fuse Community Day - Paris - 14th of October

Thu, 23 Sep 2010 00:00:00 +0200

The, fuse] Community Day will take place the 14th of October in Paris. Feel free to sign up here and come to see Claus Ibsen, Guillaume Nodet, Rob Davies and myself presenting news about OSGI, SOA, Camel and ESB and some of our customers showing that in action (Lionel Cons - CERN, Cédric Bourgeois - Atos Worldwide, Jean Folly-Kpodar - Osmocom).

Parse / Format fixed length message with camel-bindy

Fri, 18 Jun 2010 00:00:00 +0200

Camel-bindy which is a data formatting tool to parse / format non XML message will be enriched in the next camel release 2.4. This new version will allow to work with Fixed Length message.

A Fixed Length message as its name mention it contains data positioned at a fixed position which is by far different from Comma Separate Value format where we use a separator.

So, you will be able able to model your message like that :

@FixedLengthRecord(length = 60, paddingChar = ' ')
public static class Order {

    @DataField(pos = 1, length = 2) private int orderNr;
    @DataField(pos = 3, length = 2) private String clientNr;
    @DataField(pos = 5, length = 9) private String firstName;
    @DataField(pos = 14, length = 5, align = "L") private String lastName;
    @DataField(pos = 19, length = 4) private String instrumentCode;
    @DataField(pos = 23, length = 10) private String instrumentNumber;
    @DataField(pos = 33, length = 3) private String orderType;
    @DataField(pos = 36, length = 5) private String instrumentType;
    @DataField(pos = 41, precision = 2, length = 7) private BigDecimal amount;
    @DataField(pos = 48, length = 3) private String currency;
    @DataField(pos = 51, length = 10, pattern = "dd-MM-yyyy") private Date orderDate;

to parse/format the following text :

"10A9 PaulineM ISINXD12345678BUYShare2500.45USD01-08-2009"

The tool allows to add ‘padding’ characters and to align “LEFT” or “ RIGHT” the string in the field.

More info are available on the wiki web page of camel-bindy : http://camel.apache.org/bindy.html

Run Camel route in ServiceMix 3.3.x

Tue, 30 Mar 2010 00:00:00 +0200

Even if Apache ServiceMix (ESB) was mainly designed as a JBI container, it is perfectly possible to use camel routes and camel components (bindy, file, jms, …) on this platform. This allows by example to :

Combine JBI binding components or Services with Camel routes,
Use a camel component when the binding component does not exist,
Deploy camel as Service Unit in Service Assembly

Here is a small example showing that in action. The creation of the project is very simple as you have to create a Service Unit. If you work with maven, you can use the servicemix plugin which will allow to create the maven project. Otherwise, you can create the maven structure manually.To be able to deploy camel next, you must create a Service Assembly (= SA) who will include the Service Unit. Don’t be afraid and follow the tutorial described here for that part of the work.

When the project is ready, you create a camel-context.xml file in the directory src/main/resources. This file which is a spring xml file will contain the camel routes + beans definitions or will point to your packages if you prefer to code your routes using Camel Java DSL language instead of Spring DSL language.Remark : in my example, I use Spring DSL language.The route is very basic and will create a message containing the text “Hello World from SMX3!” as body value. The message is copied in an activemq queue called “in”. A second route take the messages and send it to the log. The log message is readable from the console where ServiceMix 3.3.x has been started.In the Spring file, you must add the camel bean “org.apache.camel.component.jms.JmsComponent” definition to instantiate a connection factory to the queueing engine. The broker is created and started at the launch of ServiceMix3 so you don’t need to do anything else here !

<beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"       xsi:schemaLocation="
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd       http://camel.apache.org/schema/spring
       http://camel.apache.org/schema/spring/camel-spring.xsd">
       
       <bean id="activemq" class="org.apache.camel.component.jms.JmsComponent">        
          <property name="connectionFactory">
            <bean class="org.apache.activemq.ActiveMQConnectionFactory">
                <property name="brokerURL" value="tcp://localhost:61616"/>
            </bean>
          </property>
        </bean>
        
       <camelContext xmlns="http://camel.apache.org/schema/spring">
        <package>org.apache.servicemix.samples</package>
         
        <route>
            <from uri="timer:myTimerEvent?fixedRate=true&amp;period=15000"/>           
            <setBody>
                <constant>Hello World from SMX3 !</constant>
            </setBody>           
            <to uri="activemq:queue:in"/>
            </route>
         
        <route>
            <from uri="activemq:queue:in"/>           
            <to uri="log:org.apache.servicemix.samples.camel.ExampleCamelRoute"/>
            </route>
        </camelContext>
     </beans>

To allow Camel to work with its jms component, the following dependency must be added in the pom of the camel-su.

<dependencies>
  <dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-core</artifactId>
    <version>2.2.0</version>
  </dependency>
  <dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-spring</artifactId>
    <version>2.2.0</version>
  </dependency>
  <dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-jms</artifactId>
    <version>2.2.0</version>
  </dependency>
</dependencies>

To compile the project, simply launch the command “mvn install” to generate the SU and do the same for the SA. When the Service Assembly jar file is available, copy it in the hotdeploy directory of ServiceMix 3 server and check the log.This example which is very basic can be extended with another camel components. In that case, don’t forget to add their dependency in the SU pom as the camel lib must be added in the lib directory of the SU.

Have fun with that !

Is Webservice Reliable Messaging (WS-RM) the ugly duck of the WS-* story ?

Fri, 26 Feb 2010 00:00:00 +0100

The Webservice Reliable Messaging (WS-RM) specification has been designed a couple of years ago (2005) but few projects used it. Different reasons could explain this situation, the complexity of the specification, the cost to implement it and the lack of use cases. Personally, I think that developers and architects adopt a low profile when designing a solution and spend times developing alternative solutions providing functionality similar to what WS-RM propose.

WS-RM is not the ugly duck of the story and need more attention from community because it allows you to design solutions where you will be able to

Guaranty message (= web services) delivery, which is required by example in financial order processing, alarm monitoring systems, …
Control the communication between the client and the server (retransmission, …)
Implement asynchronous solution by decoupling the request from the reply

Well, what I have presented could be assimilated to a style exercise or a faith act and you will adhere or not. To convince you about the interests to use WS-RM, I will show you How easy it is to design such a solution using Apache CXF framework. This process can be achieved in three simple steps

STEP 1 : Turn on your WSDL contract into a WS-addressing

WS-addressing needs to be used because the communication between the client and server will be governed by the Reliable Message Server which is running on a different port address number. This decoupling is required to allow to retransmit message, acknowledge the messages received and guaranty the delivery

Here is one way that you can adopt :

<!-- Service definition -->
<wsdl:service name="ReportIncidentEndpointService">
  <wsdl:port name="ReportIncidentPort" binding="tns:ReportIncidentBinding">
    <soap:address location="http://localhost:8080/cxf/camel-example/incident">
      <!-- <wswa:usingaddressing wswa="http://www.w3.org/2005/02/addressing/wsdl"> -->
      <wswa:usingaddressing wswa="http://www.w3.org/2005/02/addressing/wsdl"></wswa:usingaddressing>
    </soap:address>
  </wsdl:port>
</wsdl:service>

the other consists in to use a Policy Rule (= WS-Policy)

<wsp:policy wsp="http://www.w3.org/2006/07/ws-policy">
  <wsam:addressing wsam="http://www.w3.org/2007/02/addressing/metadata">
    <wsp:policy></wsp:policy>
  </wsam:addressing>
</wsp:policy>

STEP 2 : Activate the Reliable Server

Now that the WSDL contract is modified, we need to add the Reliable Server to the configuration of our platform. I will show you using a spring xml configuration file but you can use the Apache CXF classes in your java code if you want

To activate the RM server, you simply needs to add the tags wsa:addressing and wsrm-mgr in the bus definition of Apache CXF. Different parameters are available like retransmission interval, acknowledge interval. I will not digg into these ones and if you need information, I invite you to check Apache CXF javadoc and specifications.

By example< it is possible to activate also the persistence manager of the RM server ;-)

<cxf:bus>
  <cxf:features>
    <cxf:logging>
      <wsa:addressing>
        <wsrm-mgr:reliablemessaging>
          <wsrm-policy:rmassertion>
            <wsrm-policy:baseretransmissioninterval milliseconds="4000">
              <wsrm-policy:acknowledgementinterval milliseconds="2000"></wsrm-policy:acknowledgementinterval>
              <wsrm-mgr:destinationpolicy>
                <wsrm-mgr:ackspolicy intramessagethreshold="0"></wsrm-mgr:ackspolicy>
              </wsrm-mgr:destinationpolicy>
            </wsrm-policy:baseretransmissioninterval>
          </wsrm-policy:rmassertion>
        </wsrm-mgr:reliablemessaging>
      </wsa:addressing>
    </cxf:logging>
  </cxf:features>
</cxf:bus>

If you use CXF in combination with the Routing engine Apache Camel, you don’t need to do additional things as the Apache CXF endpoint who will consume the web servicesmessages will be drived by the RM server of CXF.

Here is an example of Camel integration with CXF

<!-- webservice endpoint -->
<cxfcamel:cxfendpoint id="reportIncident" address="http://localhost:8080/cxf/camel-example/incident" serviceclass="org.apache.camel.example.reportincident.ReportIncidentEndpoint" s="http://reportincident.example.camel.apache.org"></cxfcamel:cxfendpoint>
<!-- Camel route -->
<camel:camelcontext trace="true" xmlns="http://camel.apache.org/schema/osgi">
  <route>
    <from uri="cxf:bean:reportIncident">// messages are consumed from CXF endpoint
      <convertbodyto type="org.apache.camel.example.reportincident.InputReportIncident">// the body of the WS message is converted directly into a POJOI
        <to uri="bean:webservice">// We call a POJO to save the reportincident in a DB
          <inOnly uri="osgiqueuingservice:queue:in">
          // We put the object in a queue
          <transform>
            <method bean="feedback" method="setOk">// We provide a feedback message as the WS is of type request/replyt</method>
          </transform>
        </to>
      </to>
    </convertbodyto>
  </from>
</route>
</camel:camelcontext>

STEP : Verify

If you use a java client using Apache CXF java classes, you can easily enable the logging of the IN/OUT WS messages exchanged with the RM server and the application.

The following trace shows that :

a sequence has been started
each message is identified ‘’ with a UID
Within a sequence, the messages send receive a messageID
The server acknowledge the reception (= processing) of the messages

>>>>> Invoking reportIncident ... for accident : 024-févr.-2010 9:48:39 org.apache.cxf.transport.http.HTTPConduit setUpDecoupledDestinationINFO: creating decoupled endpoint: http://localhost:9999/camel-example/incident2010-02-24 09:48:39.796::INFO:  Logging to STDERR via org.mortbay.log.StdErrLog2010-02-24 09:48:39.828::INFO:  jetty-6.1.212010-02-24 09:48:39.921::INFO:  Started SelectChannelConnector@localhost:999924-févr.-2010 9:48:40 org.apache.cxf.ws.rm.Proxy invokeINFO: Sending out-of-band RM protocol message {http://schemas.xmlsoap.org/ws/2005/02/rm}CreateSequence.24-févr.-2010 9:48:41 org.apache.cxf.interceptor.LoggingOutInterceptor$LoggingCallback onCloseINFO: Outbound Message
---------------------------ID: 1Address: http://localhost:8080/cxf/camel-example/incidentEncoding: UTF-8Content-Type: text/xmlHeaders: {SOAPAction=["http://schemas.xmlsoap.org/ws/2005/02/rm/CreateSequence"], Connection=[Keep-Alive], Accept=[*/*]}Payload:<soap:envelope soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:header>
  <action xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">http://schemas.xmlsoap.org/ws/2005/02/rm/CreateSequence</action>
  <messageid xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">urn:uuid:508b8914-1621-4992-ae2d-2249d417069a</messageid>
  <to xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">http://localhost:8080/cxf/camel-example/incident</to>
  <replyto xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">
    <address>http://localhost:9999/camel-example/incident</address>
  </replyto>
</soap:header>
<soap:body>
  <createsequence xmlns="http://schemas.xmlsoap.org/ws/2005/02/rm" ns2="http://schemas.xmlsoap.org/ws/2004/08/addressing">
    <acksto>
      <ns2:address>http://localhost:9999/camel-example/incident</ns2:address>
    </acksto>
    <expires>PT0S</expires>
    <offer>
      <identifier>urn:uuid:b12e4ccf-3bec-4f76-85f6-2b64f24745b5</identifier>
      <expires>PT0S</expires>
    </offer>
  </createsequence>
</soap:body>
</soap:envelope>
--------------------------------------24-févr.-2010 9:48:41 org.apache.cxf.interceptor.LoggingInInterceptor loggingINFO: Inbound Message
----------------------------ID: 1Response-Code: 202Encoding: UTF-8Content-Type: text/xml; charset=utf-8Headers: {content-type=[text/xml; charset=utf-8], Content-Length=[532], Server=[Jetty(6.1.x)]}Payload:<soap:envelope soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:header>
  <messageid xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">urn:uuid:73d86df6-7d45-42df-8008-2a4ca48682fd</messageid>
  <to xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</to>
  <replyto xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">
    <address>http://schemas.xmlsoap.org/ws/2004/08/addressing/role/none</address>
  </replyto>
</soap:header>
<soap:body></soap:body>
--------------------------------------24-févr.-2010 9:48:41 org.apache.cxf.interceptor.LoggingInInterceptor loggingINFO: Inbound Message
----------------------------ID: 2Address: /camel-example/incidentResponse-Code: 200Encoding: UTF-8Content-Type: text/xml; charset=UTF-8Headers: {content-type=[text/xml; charset=UTF-8], connection=[keep-alive], Host=[localhost:9999], Content-Length=[1006], User-Agent=[Progress, fuse] Services Framework 2.2.6-fuse-01-00], Content-Type=[text/xml; charset=UTF-8], Accept=[*/*], Pragma=[no-cache], Cache-Control=[no-cache]}Payload:
<soap:envelope soap="http://schemas.xmlsoap.org/soap/envelope/">
  <soap:header>
    <action xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">http://schemas.xmlsoap.org/ws/2005/02/rm/CreateSequenceResponse</action>
    <messageid xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">urn:uuid:c8e59735-7738-40b2-98c1-28be15274b35</messageid>
    <to xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">http://localhost:9999/camel-example/incident</to>
    <relatesto xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">urn:uuid:508b8914-1621-4992-ae2d-2249d417069a</relatesto>
  </soap:header>
  <soap:body>
    <createsequenceresponse xmlns="http://schemas.xmlsoap.org/ws/2005/02/rm" ns2="http://schemas.xmlsoap.org/ws/2004/08/addressing">
      <identifier>urn:uuid:b35dff50-43cb-43ad-9c9e-4b59f7cb55e7</identifier>
      <expires>P0Y0M0DT0H0M0.0S</expires>
      <accept>
        <acksto>
          <ns2:address>http://localhost:8080/cxf/camel-example/incident</ns2:address>
        </acksto>
      </accept>
    </createsequenceresponse>
  </soap:body>
</soap:envelope>
--------------------------------------
24-févr.-2010 9:48:41 org.apache.cxf.ws.rm.soap.RMSoapInterceptor updateServiceModelInfoINFO: Updating service model info in exchange24-févr.-2010 9:48:41 org.apache.cxf.interceptor.LoggingOutInterceptor$LoggingCallback onCloseINFO: Outbound Message
---------------------------
ID: 3Address: http://localhost:8080/cxf/camel-example/incidentEncoding: UTF-8Content-Type: text/xmlHeaders: {SOAPAction=["http://reportincident.example.camel.apache.org/ReportIncident"], Connection=[Keep-Alive], Accept=[*/*]}Payload:
<soap:envelope soap="http://schemas.xmlsoap.org/soap/envelope/">
  <soap:header>
    <action xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">http://reportincident.example.camel.apache.org/ReportIncident</action>
    <messageid xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">urn:uuid:85a1ebac-5293-4daa-a656-987967aa2a4d</messageid>
    <to xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">http://localhost:8080/cxf/camel-example/incident</to>
    <replyto xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">
      <address>http://localhost:9999/camel-example/incident</address>
    </replyto>
    <wsrm:sequence ns2="http://schemas.xmlsoap.org/ws/2004/08/addressing" wsrm="http://schemas.xmlsoap.org/ws/2005/02/rm">
      <wsrm:identifier>urn:uuid:b35dff50-43cb-43ad-9c9e-4b59f7cb55e7</wsrm:identifier>
      <wsrm:messagenumber>1</wsrm:messagenumber>
    </wsrm:sequence>
  </soap:header>
  <soap:body>
    <ns2:inputreportincident ns2="http://reportincident.example.camel.apache.org">
      <incidentid>0</incidentid>
      <incidentdate>29-04-2009</incidentdate>
      <givenname>moulliard</givenname>
      <familyname>charles</familyname>
      <summary>This is a web service incident</summary>
      <details>This is a web service incident - details</details>
      <email>cmoulliard@gmail.com</email>
      <phone>+222 10 50 22</phone>
    </ns2:inputreportincident>
  </soap:body>
</soap:envelope>
--------------------------------------
24-févr.-2010 9:48:41 org.apache.cxf.interceptor.LoggingInInterceptor loggingINFO: Inbound Message
----------------------------
ID: 3Response-Code: 202Encoding: UTF-8Content-Type: text/xml; charset=utf-8Headers: {content-type=[text/xml; charset=utf-8], Content-Length=[532], Server=[Jetty(6.1.x)]}Payload:
<soap:envelope soap="http://schemas.xmlsoap.org/soap/envelope/">
  <soap:header>
    <messageid xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">urn:uuid:37dceb90-e1f5-4014-9749-8d4ae7eebb13</messageid>
    <to xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</to>
    <replyto xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">
      <address>http://schemas.xmlsoap.org/ws/2004/08/addressing/role/none</address>
    </replyto>
  </soap:header>
  <soap:body></soap:body>
--------------------------------------
2010-02-24 09:48:41.937::INFO: seeing JVM BUG(s) - cancelling interestOps==024-févr.-2010 9:48:42 org.apache.cxf.interceptor.LoggingInInterceptor loggingINFO: Inbound Message
----------------------------
ID: 4Address: /camel-example/incidentResponse-Code: 200Encoding: UTF-8Content-Type: text/xml; charset=UTF-8Headers: {content-type=[text/xml; charset=UTF-8], connection=[keep-alive], Host=[localhost:9999], Content-Length=[1057], User-Agent=[Progress, fuse] Services Framework 2.2.6-fuse-01-00], Content-Type=[text/xml; charset=UTF-8], Accept=[*/*], Pragma=[no-cache], Cache-Control=[no-cache]}Payload:
  <soap:envelope soap="http://schemas.xmlsoap.org/soap/envelope/">
    <soap:header>
      <action xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">http://reportincident.example.camel.apache.org/ReportIncidentEndpoint/ReportIncidentResponse</action>
      <messageid xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">urn:uuid:6163b07e-c983-47f7-8699-c4670b61a213</messageid>
      <to xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">http://localhost:9999/camel-example/incident</to>
      <relatesto xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">urn:uuid:85a1ebac-5293-4daa-a656-987967aa2a4d</relatesto>
      <wsrm:sequence ns2="http://schemas.xmlsoap.org/ws/2004/08/addressing" wsrm="http://schemas.xmlsoap.org/ws/2005/02/rm">
        <wsrm:identifier>urn:uuid:b12e4ccf-3bec-4f76-85f6-2b64f24745b5</wsrm:identifier>
        <wsrm:messagenumber>1</wsrm:messagenumber>
      </wsrm:sequence>
    </soap:header>
    <soap:body>
      <ns2:outputreportincident ns2="http://reportincident.example.camel.apache.org">
        <code>OK</code>
      </ns2:outputreportincident>
    </soap:body>
  </soap:envelope>
--------------------------------------
>>>> Result - code : OK
24-févr.-2010 9:48:43 org.apache.cxf.interceptor.LoggingInInterceptor loggingINFO: Inbound Message
----------------------------
ID: 5Address: /camel-example/incidentResponse-Code: 200Encoding: UTF-8Content-Type: text/xml; charset=UTF-8Headers: {content-type=[text/xml; charset=UTF-8], connection=[keep-alive], Host=[localhost:9999], Content-Length=[955], SOAPAction=["http://schemas.xmlsoap.org/ws/2005/02/rm/SequenceAcknowledgement"], User-Agent=[Progress, fuse] Services Framework 2.2.6-fuse-01-00], Content-Type=[text/xml; charset=UTF-8], Accept=[*/*], Pragma=[no-cache], Cache-Control=[no-cache]}Payload:
  <soap:envelope soap="http://schemas.xmlsoap.org/soap/envelope/">
    <soap:header>
      <action xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">http://schemas.xmlsoap.org/ws/2005/02/rm/SequenceAcknowledgement</action>
      <messageid xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">urn:uuid:f57c0b96-fcc3-4543-bbc3-fd15a54622e7</messageid>
      <to xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">http://localhost:9999/camel-example/incident</to>
      <replyto xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">
        <address>http://schemas.xmlsoap.org/ws/2004/08/addressing/role/none</address>
      </replyto>
      <wsrm:sequenceacknowledgement ns2="http://schemas.xmlsoap.org/ws/2004/08/addressing" wsrm="http://schemas.xmlsoap.org/ws/2005/02/rm">
        <wsrm:identifier>urn:uuid:b35dff50-43cb-43ad-9c9e-4b59f7cb55e7</wsrm:identifier>
        <wsrm:acknowledgementrange lower="1" upper="1"></wsrm:acknowledgementrange>
      </wsrm:sequenceacknowledgement>
      <soap:body></soap:body>
--------------------------------------
24-févr.-2010 9:48:43 org.apache.cxf.ws.rm.soap.RMSoapInterceptor updateServiceModelInfoINFO: Updating service model info in exchange24-févr.-2010 9:48:44 org.apache.cxf.ws.rm.Proxy invokeINFO: Sending out-of-band RM protocol message {http://schemas.xmlsoap.org/ws/2005/02/rm}SequenceAcknowledgement.24-févr.-2010 9:48:44 org.apache.cxf.interceptor.LoggingOutInterceptor$LoggingCallback onCloseINFO: Outbound Message
---------------------------
ID: 6Address: http://localhost:8080/cxf/camel-example/incidentEncoding: UTF-8Content-Type: text/xmlHeaders: {SOAPAction=["http://schemas.xmlsoap.org/ws/2005/02/rm/SequenceAcknowledgement"], Connection=[Keep-Alive], Accept=[*/*]}Payload:
      <soap:envelope soap="http://schemas.xmlsoap.org/soap/envelope/">
        <soap:header>
          <action xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">http://schemas.xmlsoap.org/ws/2005/02/rm/SequenceAcknowledgement</action>
          <messageid xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">urn:uuid:c5584570-c10f-49cc-a3ef-c2c53363ec66</messageid>
          <to xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">http://localhost:8080/cxf/camel-example/incident</to>
          <replyto lns="http://schemas.xmlsoap.org/ws/2004/08/addressing">
            <address>http://schemas.xmlsoap.org/ws/2004/08/addressing/role/none</address>
          </replyto>
          <wsrm:sequenceacknowledgement ns2="http://schemas.xmlsoap.org/ws/2004/08/addressing" wsrm="http://schemas.xmlsoap.org/ws/2005/02/rm">
            <wsrm:identifier>urn:uuid:b12e4ccf-3bec-4f76-85f6-2b64f24745b5</wsrm:identifier>
            <wsrm:acknowledgementrange lower="1" upper="1"></wsrm:acknowledgementrange>
          </wsrm:sequenceacknowledgement>
          <soap:body></soap:body>
--------------------------------------
24-févr.-2010 9:48:44 org.apache.cxf.interceptor.LoggingInInterceptor loggingINFO: Inbound Message
----------------------------
ID: 6Response-Code: 202Encoding: UTF-8Content-Type: text/xml; charset=utf-8Headers: {content-type=[text/xml; charset=utf-8], Content-Length=[532], Server=[Jetty(6.1.x)]}Payload:
          <soap:envelope soap="http://schemas.xmlsoap.org/soap/envelope/">
            <soap:header>
              <messageid xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">urn:uuid:786ad464-fb01-452a-9036-63c383955133</messageid>
              <to xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</to>
              <replyto xmlns="http://schemas.xmlsoap.org/ws/2004/08/addressing">
                <address>http://schemas.xmlsoap.org/ws/2004/08/addressing/role/none</address>
              </replyto>
            </soap:header>
            <soap:body></soap:body>
--------------------------------------
24-févr.-2010 9:49:12 org.apache.cxf.transport.http_jetty.JettyHTTPServerEngine shutdown
          </soap:envelope>
        </soap:header>
      </soap:envelope>
    </soap:header>
  </soap:envelope>
</soap:envelope>
</soap:envelope>

Conclusion

Awesome, isn’it. Even, if you continue to doubt about this specification, I’m pretty sure that in the future you will take it into account into your decision process regarding to what has been developed here.

New features for Apache Camel Bindy (non XML binding framework)

Fri, 20 Nov 2009 00:00:00 +0100

Today has been a very productive day. I have found the time to update the documentation about the Apache Camel Tutorial on OSGI and commit the last new features added to camel-bindy : the non XML binding framework used to parse or generate CSV, FIX, … messages

This new version of bindy includes important new features like :

Required (@DataField) to check mandatory field
Position (@DataField and @KeyValuePairField) when the CSV/FIX message to be generate contain fields which are placed at a different position then those used to parse it
Section which allow to define the class containing by example the header, body or footer section

and

OneToMany which allow to :
Read a FIX message containing repetitive groups (= group of tags/keys)
Generate a CSV with repetitive data

More info can be find here.

Tutorial part 1 about Apache Camel and OSGI (reviewed)

Mon, 02 Nov 2009 00:00:00 +0100

Last friday, I have spend some times to update the part 1 of the Apache Camel tutotrial. This tutorial shows how you can easily and quickly build and deploy a small SOA project using Camel 2.0 top of Apache Felix Karaf 1.0.0

The second part of this tutorial will be upgraded soon and will include a new section about integration tests with Pax Exam.

Apache Camel Group on Linkedln

Mon, 02 Nov 2009 00:00:00 +0100

Apache Camel has now its Group on Linkedin web site : http://www.linkedin.com/groups?home=&gid=2447439&trk=anet_ug_hm

Feel free to join us to discuss / exchange ideas / news and jobs about your favorite mediation and router framework.