Advanced concepts of WSO2 ESB and how things work within inside.

1. Chanaka Fernando
Senior Technical Lead
WSO2 Inc.
WSO2 ESB internals
and advanced
concepts

2. Agenda
• ESB Internal Architecture
• Transports and axis2 engine
• Synapse Runtime
• Solving common integration problems
• Extending the ESB with custom code
• ESB Connectors
Source : http://bonfirehealth.com/week-13-insights-spark-integration/

3. ESB Internal Architecture

High level architecture

4. ESB Internal Architecture

Component architecture (synapse)

5. Transports and axis2 engine

Axis2 Transport

6. Transports and axis2 engine
TransportListener
Implementations of this interface should specify how incoming messages are received
and processed before handing them over to the Axis2 engine for further Processing.
TransportSender
Implementations of this interface should specify how a message can be sent out from
the Axis2 engine.
TransportReceivers and TransportSenders are registered to the server using axis2.xml
file
Same axis2.xml file can be used to define transport configuration parameters
Editing axis2.xml need to be followed by a server restart
Value of the name attribute can be used to uniquely identify
the transport with ESB
<transportReceiver name="http"
class="org.apache.synapse.transport.nhttp.HttpCoreNIOListener“/>
<transportSender name="http"
class="org.apache.synapse.transport.nhttp.HttpCoreNIOSender“/>

7. Transports and axis2 engine
Message Builder
Identify the message using the content type and convert it to common XML. There is a
message builder associated with each content type. WSO2 ESB includes message
builders for text-based and binary content.
Message Formatter
The opposite partners of the message builders. The formatter converts the message
back to its original format by referencing the content type just before the message
handover to the transports.
<messageBuilder contentType="application/xml"
class="org.apache.axis2.builder.ApplicationXMLBuilder"/>
<messageFormatter contentType="application/xml"
class="org.apache.axis2.transport.http.ApplicationXMLFormatter"/>

8. Synapse Runtime
NHTTP transport

9. Synapse Runtime
NHTTP transport
The key advantage of this architecture is that it enables the ESB (mediators) to intercept
all the messages and manipulate them in any way necessary.
The main downside is every message happens to go through the Axiom layer, which is
not really necessary in cases like HTTP load balancing and HTTP header-based routing.
Also the overhead of moving data from one buffer to another was not always justifiable in
this model.
The default HTTP/HTTPS transport prior to ESB 4.6.0

10. Synapse Runtime
Binary Relay

11. Synapse Runtime
Binary Relay
A Message Builder, that takes the input stream and hides it inside a fake SOAP message
without reading it, and a Message Formatter that takes the input stream and writes it
directly to a output stream.
• Builder : org.wso2.carbon.relay.BinaryRelayBuilder
• Formatter :org.wso2.carbon.relay.ExpandingMessageFormatter
The Builder Mediator can be used to build the actual SOAP message from a message
coming in to ESB through the Message Relay.

12. Synapse Runtime
Passthrough Transport

13. Synapse Runtime
Passthrough Transport
Based on a single buffer model and completely bypassed the Axiom layer.
On-demand message parsing in the mediation engine.
The default HTTP/HTTPS transport since ESB 4.6.0.
<transportSender name="http"
class="org.apache.synapse.transport.passthru.PassThroughHttpSender“/>
<transportReceiver name="http"
class="org.apache.synapse.transport.passthru.PassThroughHttpListener“/>

14. Synapse Runtime
Passthrough Transport high level view

15. Synapse Runtime
Passthrough Transport state machine

16. Solving common integration problems
Message Transformations
• Possible to add , remove , edit elements in the
payload.
• Possible to transform into entirely different
message or different content type.
XML = > XML
XML => JSON
Mediators
XSLT
XQuery
PaylodFactory
Smooks
Enrich
Use mediators like XSLT and XQuery in
complex transformation.
• Payload Factory and Enrich mediator perform
better in simple transformation scenarios

17. Solving common integration problems
XML->JSON
<proxy name="JSONTempProxy">
<target>
<outSequence>
<property name="messageType" value="application/json" scope="axis2"/>
<send/>
</outSequence>
<endpoint>
<address uri=“...."/>
</endpoint>
</target>
</proxy>

18. Solving common integration problems
Message Validation

19. Solving common integration problems
Message Validation
<validate>
<schema key="temp-msg.xsd"/>
<on-fail>
<makefault version="soap11">
<code xmlns:tns="http://www.w3.org/2003/05/soap-
envelope" value="tns:Receiver"/>
<reason value="Invalid Request!!!"/>
</makefault>
<property name="RESPONSE" value="true"/>
<header name="To" action="remove"/>
<send/>
</on-fail>
</validate>

20. Solving common integration problems
Service Chaining

21. Extending ESB with custom code
Scheduler Task
MessageInjector
Default Task implementation
Inject messages into “Main” flow
Support simple scheduling and cron statements
Support for JavaBean like property settings
import org.apache.synapse.ManagedLifecycle;
import org.apache.synapse.task.Task;
public class HelloWorldTask implements Task , ManagedLifecycle
{
private String message;
public String getMessage () {
}
public void setMessage(String message) { }
}

22. Extending ESB with custom code
Extending the ESB with Class mediator
Messages coming in to ESB can be processed from custom java code
Class mediator gets the same privilege as an internal ESB mediator
Needs to implement AbstractMediator interface
Parameters can be passed through setter methods
Message can be altered inside the mediate method through MessageContext object
Can be built as a jar file or as an osgi bundle

23. Extending ESB with custom code
Extending the ESB with Class mediator
import javax.xml.namespace.QName;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.synapse.MessageContext;
import org.apache.synapse.mediators.AbstractMediator;
public class DiscountQuoteMediator extends AbstractMediator {
public boolean mediate(MessageContext mc) {
String price = mc.getEnvelope().getBody().getFirstElement().getFirstElement().
getFirstChildWithName(new QName("http://services.samples/xsd",
"last")).getText();
System.out.println("Original price: " + price);
System.out.println("Discounted price: " + discountedPrice);
return true;
}
public void setTraceState(int traceState) {
traceState = 0;
}
public int getTraceState() {
return 0;

24. ESB Connectors
A connector is a ready made and convenient tool to reach publicly available web API’s.
Simplified configuration to access external api
‘Cloud to Cloud’ and ‘Cloud to Enterprise’ Integration
On premise integration
Connecting with systems located in your enterprise perimeter Ex: SAP, Database,
SOAP/REST web service
Can be proprietary/ legacy systems
Security is a less concern when connecting with these systems
Performance is a critical factor for business success
Cloud integration
Connecting with a publicly available cloud APIs
Ex: Twitter, Salesforce, Google Spreadsheet
Security needs to be handled carefully when connecting to public APIs
Performance is not critical when connecting to cloud APIs
Configuration driven approach to perform different operations on the cloud platform

25. ESB Connectors
Use Case I – Connect to cloud API and extract data

26. ESB Connectors
Use Case II – Cloud to Cloud integration

27. ESB Connectors
Use Case III – On premise to cloud integration
soa
p

28. ESB Connectors
Writing a custom connector to public API
A connector is a collection of templates that define operations users can call from their
ESB configurations to easily access specific logic for processing messages.
Typically, connectors are used to wrap the API of an external service. For example,
there are several default connectors provided with the ESB that call the APIs of services
like Twitter and JIRA.
Creating a connector involves the following high-level tasks:
Research the APIs provided by the service for which you want to create a connector.
Decide which API you are going to use to write the connector. For example, JIRA
provides a REST API and Java API. If you choose the REST API, you can create your
connector and operations entirely from XML configuration files. If you choose a Java
API, you create XML configuration files that define your connector and point to your
Java classes that define the operations.
Use the connector core libraries to write your connector.
After you create the files, you package them in a ZIP file, which you can then add to
an ESB instance.

29. ESB Connectors
Writing a custom connector to public API
Here are some useful resources for step by step guides to write a connector for a public
API
http://chanakaindrajith.blogspot.com/2014/04/getting-started-with-wso2-esb-
connectors.html
https://docs.wso2.com/display/ESB481/Creating+a+Connector
http://wso2.com/library/articles/2014/02/how-to-write-a-esb-connector/

30. Questions

31. Thank You