rajika's web log

A Stream Input-Output System

2011-11-11T16:08:00.001+05:30

A Stream Input-Output System by Dennis M. Ritchie.
This is one of the best papers that I have read so far.

RIP DMR

2011-10-13T09:57:00.001+05:30

(September 9, 1941 — October 12, 2011)

Caching JMS objects in WSO2 ESB's JMS transport

2011-09-11T15:25:00.001+05:30

For high performance deployment of WSO2 ESB's JMS transport you can configure the option to cache the JMS objects ( producers/consumers, sessions, connections etc..) in WSO2 ESB. Following is the configuration that you need to add for axis2.xml in WSO2 ESB for configuring the caching of JMS objects for JMS sender.


 <transportSender name="jms" class="org.apache.axis2.transport.jms.JMSSender">
        <parameter name="default" locked="false">
            <parameter name="java.naming.factory.initial" locked="false">org.apache.activemq.jndi.ActiveMQInitialContextFactory</parameter>
            <parameter name="java.naming.provider.url" locked="false">tcp://localhost:61616</parameter>
            <parameter name="transport.jms.ConnectionFactoryJNDIName" locked="false">QueueConnectionFactory</parameter>
            <parameter name="transport.jms.ConnectionFactoryType" locked="false">queue</parameter>
            <parameter name="transport.jms.CacheLevel" locked="false">producer</parameter>
            <parameter name="transport.jms.Destination" locked="false">dynamicQueues/SimpleStockQuoteService</parameter>
            <parameter name="transport.jms.DestinationType" locked="false">queue</parameter>
        </parameter>
</transportSender>

But this has a limitation where all the JMS endpoint will share the same destination queue, which is not what we need in most cases. So what we need to do is to define connection factory per JMS endpoint basis and make use of that JMS connection factory definition in the JMS endpoint as follows.


     <address uri="jms:/?transport.jms.ConnectionFactory=default"/>

The strange /? combination is required because the JMS uri parameter passing logic assume the availability of ? in the JMS uri. This shows one more thing. How you can define a separate connection factory definition and use it in the JMS endpoint rather than embedding every parameter in the JMS url itself. As you may probably guess, you can cache the JMS objects for JMS listener side as well. But by default it's enabled.

RFC-6167 notes

2011-08-11T08:25:00.006+05:30

This post outline some key points of the RFC-6167. This specification defines a new URI scheme for JMS objects ( such as ConnectionFactories, Queues and Topics). Following are some of the key points.

1. The name of the URI Scheme is "jms".

2. Syntax of a JMS URI looks like below.

jms-uri = "jms:" jms-variant ":" jms-dest

     [ "?" param *( "&" param ) ]

  jms-variant = segment-nz-nc

  jms-dest = segment-nz ; specific meaning per variant

  param = param-name "=" param-value

  param-name = 1*(unreserved / pct-encoded)

  param-value = *(unreserved / pct-encoded)

  segment-nz-nc = <as defined in RFC 3986>

  path-rootless = <as defined in RFC 3986>

  unreserved = <as defined in RFC 3986>

  pct-encoded = <as defined in RFC 3986>

3. RFC-6168 only defines how to address JMS resources and DO NOT specify actions to be taken on those resources. Those operations are normally defined by the JMS API.

4. <jms-variant> can be either jndi, queue, topic or a vendor specific type(example : vnd.example.ex).

5. All the terminals that result from <jms-variant> and <jms-dest> are case sensitive.

6. Parameter can appear in any order and name of a parameter SHOULD NOT appear more than once. If same parameter appear more than once only the last parameter value should be considered.

7. Each variant can have query parameters specific to that variation. All such variant-specific parameters SHOULD use the name of the variant as the prefix to the parameter.
Example: Vendor specific jms-variant - vnd.example.ex and for a parameter called Parameter, it should name as vnd.example.exParameter.

8. Parameters that apply across multiple variants MUST NOT have a name that starts with the name of any known variants.

9. Examples URI.

jms:jndi:REQ_QUEUE?jndiURL=file:/C:/JMSAdmin

&jndiInitialContextFactory=com.sun.jndi.fscontext.RefFSContextFactory

&jndiConnectionFactoryName=CONNFACT

&replyToName=RESP_QUEUE

jms:jndi:REQ_QUEUE?jndiURL=file:/C:/JMSAdmin

&jndiInitialContextFactory=com.sun.jndi.fscontext.RefFSContextFactory

&jndiConnectionFactoryName=CONNFACT

&jndi-com.example.jndi.someParameter=someValue

jms:topic:REQ_QUEUE?timeToLive=1000

&priority=2

10. Shared parameters. Parameters which are available for all jms-variant are called shared parameters. These parameters are corresponds to various JMS headers that comes in the JMS message.

deliveryMode(JMSDeliveryMode header) - PERSISTENT | NON_PERSISTENT
timeToLive - lifetime in milliseconds
priority(JMSPriority) - a value between 0 and 9(inclusive)
replyToName(JMSReplyTo)/topicRelyToName - the queue name of the reply message and if using a topic variant should use topicReplyToName

11. The JNDI-specific parameters SHOULD only be processed when the URI variant is "jndi".

jndiInitialContextFactory - Fully qualified Java class name of the "InitialContextFactory" implementation class to use.
jndiURL - Specify the JNDI provider URL.

12. Additional JNDI parameters should be prefix with jndi-.
Ex: If the JNDI provider needs a parameter called com.example.jndi.someParameter and it should be provided in the URI as:
jndi-com.example.jndi.someParameter=someValue

13. A JMS URI MUST NOT specify both replyToName and topicReplyToName.

14. Characters "?" and "&" MUST BE encoded when they appear within section or in a query parameters.

15. The character ":" SHOULD BE escaped when appearing in the <jms-dest> portion of the syntax.

Debugging high CPU consumption Java problem using thread dumps

2011-08-03T16:29:00.004+05:30

I was trying to locate a problematic stack trace of a Java application which caused the CPU to go 100%. The best friend when come to debugging un-ordered CPU utilization of Java program in thread dumps. Here how you do this.

1. Locate the thread which eats up the CPU.


ps -C java -L -o pcpu,cpu,nice,state,cputime,pid,tid | less

Note that this assume the only Java process that runs on the system is the process that you want to debug.

This will out put something like below in Fedora Linux.


%CPU CPU  NI S     TIME   PID   TID
 0.1   -   0 S 00:00:00  8016  8016
 2.1   -   0 S 00:00:00  8016  8048
 1.1   -   0 S 00:00:00  8016  8049
 1.1   -   0 S 00:00:00  8016  8050
 1.0   -   0 S 00:00:00  8016  8051
 0.0   -   0 S 00:00:00  8016  8052
 0.0   -   0 S 00:00:00  8016  8053
 0.0   -   0 S 00:00:00  8016  8054
14.1   -   0 S 00:00:06  8016  8055
11.3   -   0 S 00:00:04  8016  8056
 0.0   -   0 S 00:00:00  8016  8057
 0.0   -   0 S 00:00:00  8016  8085
 0.0   -   0 S 00:00:00  8016  8086
 0.0   -   0 S 00:00:00  8016  8087
 2.3   -   0 S 00:00:00  8016  8088
25.4   -   0 S 00:00:09  8016  8090
11.2   -   0 S 00:00:04  8016  8091

With the information above you can conclude that the thread number(TID) of the problematic thread is 8090.

Update: You can sort the threads in a process according to their usage using following.


ps -mp <pid> -o THREAD


USER     %CPU PRI SCNT WCHAN  USER SYSTEM
rajika    3.2   -    - -         -      -
rajika    0.0  19    - futex_    -      -
rajika    0.2  19    - futex_    -      -
rajika    0.0  19    - futex_    -      -
rajika    0.0  19    - futex_    -      -
rajika    0.1  19    - futex_    -      -
rajika    0.0  19    - futex_    -      -
rajika    0.0  19    - futex_    -      -
rajika    0.0  19    - futex_    -      -
rajika    0.0  19    - futex_    -      -
rajika    0.0  19    - futex_    -      -
rajika    0.0  19    - sk_wai    -      -
rajika    0.3  19    - futex_    -      -
rajika    0.4  19    - futex_    -      -

2. Get a thread dump of the application


ps ax | grep java
kill -3 java-process-number

3. Convert the value in #1(8090) into it's hexadecimal value and locate the problematic stack trace using that value in the thread dump. The value that you need to look into is the nid value in the stack.


"[ThreadPool Manager] - Idle Thread" daemon prio=10 tid=0x00007f516c066800 nid=0x1a8f in Object.wait() [0x00007f51d85b9000]
   java.lang.Thread.State: WAITING (on object monitor)
 at java.lang.Object.wait(Native Method)
 - waiting on <0x00007f51b44b4610> (a org.eclipse.equinox.internal.util.impl.tpt.threadpool.Executor)
 at java.lang.Object.wait(Object.java:485)
 at org.eclipse.equinox.internal.util.impl.tpt.threadpool.Executor.run(Executor.java:106)
 - locked <0x00007f51b44b4610> (a org.eclipse.equinox.internal.util.impl.tpt.threadpool.Executor)

4. Once you know where to look in the source (#3) you can look into the source of the high CPU utilization problems

Short tutorial on WS-RM

2011-05-16T09:50:00.002+05:30

WS-Reliable Messaging( or WS-RM for short) is specification that defines reliable message delivery of between components.

When a WS-RM client talks to a WS-RM enable server there are three messages that goes between them. First the client requests the server with a WS-RM create sequence first try to create a sequence by sending a message with CreateSequence element. This is to initiate a WS-RM session and the request looks like below (note the SOAP body).


<?xml version='1.0' encoding='UTF-8'?> 
   <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"> 
      <soapenv:Header> 
         <wsa:To xmlns:wsa="http://www.w3.org/2005/08/addressing">http://localhost:8281/services/StockQuoteProxy</wsa:To> 
         <wsa:MessageID xmlns:wsa="http://www.w3.org/2005/08/addressing">urn:uuid:F6BE3F51CABFB86C131305006461276</wsa:MessageID> 
         <wsa:Action xmlns:wsa="http://www.w3.org/2005/08/addressing">http://schemas.xmlsoap.org/ws/2005/02/rm/CreateSequence</wsa:Action> 
      </soapenv:Header> 
      <soapenv:Body> 
         <wsrm:CreateSequence xmlns:wsrm="http://schemas.xmlsoap.org/ws/2005/02/rm"> 
            <wsrm:AcksTo> 
               <wsa:Address xmlns:wsa="http://www.w3.org/2005/08/addressing">http://www.w3.org/2005/08/addressing/anonymous</wsa:Address> 
            </wsrm:AcksTo> 
            <wsrm:Offer> 
               <wsrm:Identifier>urn:uuid:C9C5EC706B1630B02F70948019826771537414401</wsrm:Identifier> 
            </wsrm:Offer> 
         </wsrm:CreateSequence> 
      </soapenv:Body> 
   </soapenv:Envelope>

Once the WS-RM enabled server receive this request he responds with a create sequence response which looks like below.


<?xml version='1.0' encoding='UTF-8'?> 
   <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"> 
      <soapenv:Header xmlns:wsa="http://www.w3.org/2005/08/addressing"> 
         <wsa:MessageID>urn:uuid:8FBBE3295CC69847831305006465945</wsa:MessageID> 
         <wsa:Action>http://schemas.xmlsoap.org/ws/2005/02/rm/CreateSequenceResponse</wsa:Action> 
         <wsa:RelatesTo>urn:uuid:F6BE3F51CABFB86C131305006461276</wsa:RelatesTo> 
      </soapenv:Header> 
      <soapenv:Body> 
         <wsrm:CreateSequenceResponse xmlns:wsrm="http://schemas.xmlsoap.org/ws/2005/02/rm"> 
            <wsrm:Identifier>urn:uuid:8FBBE3295CC69847831305006465893</wsrm:Identifier> 
            <wsrm:Accept> 
               <wsrm:AcksTo> 
                  <wsa:Address xmlns:wsa="http://www.w3.org/2005/08/addressing">http://localhost:8281/services/StockQuoteProxy</wsa:Address> 
               </wsrm:AcksTo> 
            </wsrm:Accept> 
         </wsrm:CreateSequenceResponse> 
      </soapenv:Body> 
   </soapenv:Envelope>

Once the sequence is established, client sends the request to the server with the pre-negotiated sequence ID.


<?xml version='1.0' encoding='UTF-8'?> 
   <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"> 
      <soapenv:Header> 
         <wsa:To xmlns:wsa="http://www.w3.org/2005/08/addressing">http://localhost:8281/services/StockQuoteProxy</wsa:To> 
         <wsa:FaultTo xmlns:wsa="http://www.w3.org/2005/08/addressing"> 
            <wsa:Address>http://www.w3.org/2005/08/addressing/anonymous</wsa:Address> 
         </wsa:FaultTo> 
         <wsa:MessageID xmlns:wsa="http://www.w3.org/2005/08/addressing">urn:uuid:F6BE3F51CABFB86C131305006461045</wsa:MessageID> 
         <wsa:Action xmlns:wsa="http://www.w3.org/2005/08/addressing">urn:getQuote</wsa:Action> 
         <wsrm:Sequence xmlns:wsrm="http://schemas.xmlsoap.org/ws/2005/02/rm" soapenv:mustUnderstand="1"> 
            <wsrm:Identifier>urn:uuid:8FBBE3295CC69847831305006465893</wsrm:Identifier> 
            <wsrm:MessageNumber>1</wsrm:MessageNumber> 
            <wsrm:LastMessage /> 
         </wsrm:Sequence> 
      </soapenv:Header> 
      <soapenv:Body> 
         <m0:getQuote xmlns:m0="http://services.samples"> 
            <m0:request> 
               <m0:symbol>IBM</m0:symbol> 
            </m0:request> 
         </m0:getQuote> 
      </soapenv:Body> 
   </soapenv:Envelope>

Client keeps on sending above message till the server responds with a valid response message with 200 OK HTTP header. If the server is not ready with a response, it will respond with 202 Accepted HTTP header for all requests. Once the server is ready with a response it will send the response message with sequence ID as follows.


HTTP/1.1 200 OK 
Content-Type: text/xml; charset=UTF-8 
Date: Tue, 10 May 2011 05:47:48 GMT 
Transfer-Encoding: chunked 

85a 
<?xml version='1.0' encoding='UTF-8'?> 
   <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"> 
      <soapenv:Header> 
         <wsa:FaultTo xmlns:wsa="http://www.w3.org/2005/08/addressing"> 
            <wsa:Address>http://www.w3.org/2005/08/addressing/anonymous</wsa:Address> 
         </wsa:FaultTo> 
         <wsa:MessageID xmlns:wsa="http://www.w3.org/2005/08/addressing">urn:uuid:CD6DD195597E970CCC7102452795842-1496332077</wsa:MessageID> 
         <wsa:Action xmlns:wsa="http://www.w3.org/2005/08/addressing">//services.samples/SimpleStockQuoteServicePortType/getQuoteResponse</wsa:Action> 
         <wsa:RelatesTo xmlns:wsa="http://www.w3.org/2005/08/addressing">urn:uuid:F6BE3F51CABFB86C131305006461045</wsa:RelatesTo> 
         <wsrm:Sequence xmlns:wsrm="http://schemas.xmlsoap.org/ws/2005/02/rm" soapenv:mustUnderstand="1"> 
            <wsrm:Identifier>urn:uuid:C9C5EC706B1630B02F70948019826771537414401</wsrm:Identifier> 
            <wsrm:MessageNumber>1</wsrm:MessageNumber> 
            <wsrm:LastMessage /> 
         </wsrm:Sequence> 
         <wsrm:SequenceAcknowledgement xmlns:wsrm="http://schemas.xmlsoap.org/ws/2005/02/rm" soapenv:mustUnderstand="0"> 
            <wsrm:Identifier>urn:uuid:8FBBE3295CC69847831305006465893</wsrm:Identifier> 
            <wsrm:AcknowledgementRange Lower="1" Upper="1" /> 
         </wsrm:SequenceAcknowledgement> 
      </soapenv:Header> 
      <soapenv:Body> 
         <ns:getQuoteResponse xmlns:ns="http://services.samples"> 
            <ns:return xmlns:ax21="http://services.samples/xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="ax21:GetQuoteResponse"> 
               <ax21:change>-2.6700218511136207</ax21:change> 
               <ax21:earnings>-8.794748965262057</ax21:earnings> 
               <ax21:high>-187.17305566079403</ax21:high> 
               <ax21:last>187.8527959982049</ax21:last> 
               <ax21:lastTradeTimestamp>Tue May 10 11:17:47 IST 2011</ax21:lastTradeTimestamp> 
               <ax21:low>194.26444313628625</ax21:low> 
               <ax21:marketCap>4.0781086886418656E7</ax21:marketCap> 
               <ax21:name>IBM Company</ax21:name> 
               <ax21:open>196.0840596773702</ax21:open> 
               <ax21:peRatio>-17.81582827663666</ax21:peRatio> 
               <ax21:percentageChange>1.4459782819162954</ax21:percentageChange> 
               <ax21:prevClose>-184.65158740663455</ax21:prevClose> 
               <ax21:symbol>IBM</ax21:symbol> 
               <ax21:volume>18332</ax21:volume> 
            </ns:return> 
         </ns:getQuoteResponse> 
      </soapenv:Body> 
   </soapenv:Envelope>

Note the http status code.

Now both client and the server are done with the actual message exchange. Then client sends a request(terminate sequence) to terminate the sequence as follows:


<?xml version='1.0' encoding='UTF-8'?> 
   <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"> 
      <soapenv:Header> 
         <wsa:To xmlns:wsa="http://www.w3.org/2005/08/addressing">http://localhost:8281/services/StockQuoteProxy</wsa:To> 
         <wsa:MessageID xmlns:wsa="http://www.w3.org/2005/08/addressing">urn:uuid:F6BE3F51CABFB86C131305006468790</wsa:MessageID> 
         <wsa:Action xmlns:wsa="http://www.w3.org/2005/08/addressing">http://schemas.xmlsoap.org/ws/2005/02/rm/TerminateSequence</wsa:Action> 
         <wsrm:SequenceAcknowledgement xmlns:wsrm="http://schemas.xmlsoap.org/ws/2005/02/rm" soapenv:mustUnderstand="0"> 
            <wsrm:Identifier>urn:uuid:C9C5EC706B1630B02F70948019826771537414401</wsrm:Identifier> 
            <wsrm:AcknowledgementRange Lower="1" Upper="1" /> 
         </wsrm:SequenceAcknowledgement> 
      </soapenv:Header> 
      <soapenv:Body> 
         <wsrm:TerminateSequence xmlns:wsrm="http://schemas.xmlsoap.org/ws/2005/02/rm"> 
            <wsrm:Identifier>urn:uuid:8FBBE3295CC69847831305006465893</wsrm:Identifier> 
         </wsrm:TerminateSequence> 
      </soapenv:Body> 
   </soapenv:Envelope>

Server responds to the sequence termination message, accepting to terminate the sequence as follows.


<?xml version='1.0' encoding='UTF-8'?> 
   <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"> 
      <soapenv:Header xmlns:wsa="http://www.w3.org/2005/08/addressing"> 
         <wsa:ReplyTo> 
            <wsa:Address>http://localhost:8281/services/StockQuoteProxy</wsa:Address> 
         </wsa:ReplyTo> 
         <wsa:MessageID>urn:uuid:8FBBE3295CC69847831305006472014</wsa:MessageID> 
         <wsa:Action>http://schemas.xmlsoap.org/ws/2005/02/rm/TerminateSequence</wsa:Action> 
      </soapenv:Header> 
      <soapenv:Body> 
         <wsrm:TerminateSequence xmlns:wsrm="http://schemas.xmlsoap.org/ws/2005/02/rm"> 
            <wsrm:Identifier>urn:uuid:C9C5EC706B1630B02F70948019826771537414401</wsrm:Identifier> 
         </wsrm:TerminateSequence> 
      </soapenv:Body> 
   </soapenv:Envelope>

Note that although each of above messages are separate SOAP messages, in most cases they will be exchanged in a single socket connection as HTTP Keep-Alive header is used. As you have observed these messages go between the client and the server ( and when you monitor you should see three pair of request/response).

Unlike in WS-Security case when you enable WS-RM for a web service you can't see any WS-RM specific information on the service's WSDL. When you generate clients against a WS-RM enabled service you'll have to enable the required parameters at the client code.

IBM MQ version 6.0 , WSO2 ESB JMS transport and JMS ExceptionListener

2011-05-03T13:40:00.005+05:30

Recently I came across a client issue where a given patch was not doing what they want. I looked into the problem and here what went wrong and how that was resolved.

WSO2 ESB has a production ready JMS transport which is used by several customers. One of them use WSO2 ESB 2.0.1 with IBM MQ version 6.0. One day morning an issue was raised that JMS transport was not re-connecting after the broker went offline and comes online.

Ideally JMS transport should re-connect when the broker become available. Instead of this JMS transport logs the same exception repeatedly. The result is the storage is get filled up with unnecessary logs and the system runs out of space.
JMS transport was improved to log the exception following the same rate as re-connecting logic. The re-try logic is a simple series which double the previous value, which starts with an initial value of 10 seconds. So the time series will be;

10, 20, 40, 80, 160 (s) etc..

This patch which also has the re-connecting logic was tested with following JMS providers and received the given results.

IBM MQ version 6.0 - Re-connection FAILED.
IBM MQ version 7.0 - Re-connected.
ActiveMQ 5.3.1 - Re-connected.

When I look around I found that the IBM MQ version 6.0 has a bug in the notification mechanism of JMS broker failure. Check the bug report for more information. If you take a look at the section 4.3.8 of JMS specification, that specifies how the broker should notify any connection related problem. IBM MQ version 6.0.0 was lacking with this feature. But they have issued a patch which we can use to patch the IBM MQ JMS client jars.

Just follow the instructions and install the upgrade. It's always recommended to upgrade to the newest version ( 6.0.2.5). Once the upgrade is done replace the old MQ client jars(com.ibm.mq.jar, fscontext.jar, com.ibm.mqjms.jar, providerutil.jar, connector.jar, dhbore.jar) with new ones(can be found in $MQ_INSTALL_DIR/Java/lib).

Once this is done start WSO2 ESB with the following options also given by the patch.

wso2server.bat -DuseSynapseXML -DactivateExceptionListener=true

This should avoid the re-connecting problem of JMS transport.

A JMS proxy which process both SOAP and non-SOAP messages

2011-04-20T10:25:00.005+05:30

Recently I came across a client issue where the client wants to use the same JMS proxy for accepting SOAP messages and non-SOAP messages(REST) received on a same JMS queue using the same JMS proxy.

Basically a service exposed on JMS should be able to accept and process both SOAP and REST messages. Following configuration is a sample proxy configuration which is capable of doing this. That assume that the REST(POX) messages comes with the Content-Type application/xml. And SOAP messages comes with Content-Type application/soap+xml.


<proxy name="StockQuoteProxy" transports="jms">
        <target>
            <inSequence>
                <property action="set" name="OUT_ONLY" value="true"/>
            </inSequence>
            <endpoint>
                <address uri="http://localhost:9000/services/SimpleStockQuoteService"/>
            </endpoint>
            <outSequence>
                <send/>
            </outSequence>
        </target>
        <publishWSDL uri="file:repository/conf/sample/resources/proxy/sample_proxy_1.wsdl"/>
        <parameter name="transport.jms.ContentType">
            <rules>
                <jmsProperty>contentType</jmsProperty>
                <default>application/xml</default>
                <jmsProperty>contentType</jmsProperty>
                <default>application/soap+xml</default>
            </rules>
        </parameter>
</proxy>

The JMS transport try to decide the content type from the message using getStringProperty JMS API of JMS message and if fails try to stick to the default Contnet-Type given in the configuration. The name of the content type property can be given in jmsProperty because content-type not a standard in JMS world.

This is a cool feature if you want to use the same proxy to accept both SOAP and REST messages over JMS.

JMS Error - JNDI lookup of name QueueConnectionFactory returned a x.y.z while a interface javax.jms.ConnectionFactory was expected

2011-04-18T18:06:00.004+05:30

If you happen to experience this error when working with any WSO2 product you can resolve it by removing the geronimo-jms_1.1_spec-1.1.0.VERSION.jar from $CARBON_HOME/repository/components/lib. This occurs due the availability of multiple implementation of javax.jms.* in the system classpath. You'll notice the following familiar stack trace.

Caused by: org.apache.axis2.transport.base.BaseTransportException: JNDI lookup of name QueueConnectionFactory returned a org.apache.qpid.client.AMQConnectionFactory while a interface javax.jms.ConnectionFactory was expected
 at org.apache.axis2.transport.base.BaseUtils.handleException(BaseUtils.java:166)
 at org.apache.axis2.transport.jms.JMSUtils.lookup(JMSUtils.java:522)
 at org.apache.axis2.transport.jms.JMSConnectionFactory.(JMSConnectionFactory.java:92)
 at org.apache.axis2.transport.jms.JMSConnectionFactoryManager.loadConnectionFactoryDefinitions(JMSConnectionFactoryManager.java:58)
 at org.apache.axis2.transport.jms.JMSConnectionFactoryManager.(JMSConnectionFactoryManager.java:45)
 at org.apache.axis2.transport.jms.JMSListener.doInit(JMSListener.java:58)
 at org.apache.axis2.transport.base.AbstractTransportListenerEx.init(AbstractTransportListenerEx.java:62)
 at org.wso2.carbon.core.transports.AbstractTransportService.updateGlobalTransportParameters(AbstractTransportService.java:129)
 ... 41 more

This issue can occur if you are trying any product using with the JMS transport.

JMS transport now supports re-connecting automatically when the broker is online

2011-04-05T15:02:00.005+05:30

For some time now, the JMS transport that's used by WSO2 ESB suffers from a major limitation. That's to log the following stack trace repetitively if the broker goes offline. And worse is that the JMS transport will not re-connect although the broker comes online. The result is the disk will fill up with lots of logs.

2011-04-05 10:08:45,830 [-] [jms-Worker-18] ERROR ServiceTaskManager Error acquiring a JMS connection to : QueueConnectionFactory using JNDI properties : {java.naming.factory.initial=org.apache.activemq.jndi.ActiveMQInitialContextFactory, java.naming.provider.url=tcp://localhost:61616, interface=SimpleStockQuoteServicePortType, transport.jms.ConnectionFactoryType=queue, serviceType=proxy}javax.jms.JMSException: Could not connect to broker URL: tcp://localhost:61616. Reason: java.net.ConnectException: Connection refused
at org.apache.activemq.util.JMSExceptionSupport.create(JMSExceptionSupport.java:35)
at org.apache.activemq.ActiveMQConnectionFactory.createActiveMQConnection(ActiveMQConnectionFactory.java:280)
at org.apache.activemq.ActiveMQConnectionFactory.createActiveMQConnection(ActiveMQConnectionFactory.java:224)
at org.apache.activemq.ActiveMQConnectionFactory.createConnection(ActiveMQConnectionFactory.java:172)
at org.apache.axis2.transport.jms.JMSUtils.createConnection(JMSUtils.java:554)
at org.apache.axis2.transport.jms.ServiceTaskManager$MessageListenerTask.createConnection(ServiceTaskManager.java:809)
at org.apache.axis2.transport.jms.ServiceTaskManager$MessageListenerTask.getConnection(ServiceTaskManager.java:691)
at org.apache.axis2.transport.jms.ServiceTaskManager$MessageListenerTask.receiveMessage(ServiceTaskManager.java:489)
at org.apache.axis2.transport.jms.ServiceTaskManager$MessageListenerTask.run(ServiceTaskManager.java:414)
at org.apache.axis2.transport.base.threads.NativeWorkerPool$1.run(NativeWorkerPool.java:173)
at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:886)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:908)
at java.lang.Thread.run(Thread.java:619)
Caused by: java.net.ConnectException: Connection refused
at java.net.PlainSocketImpl.socketConnect(Native Method)
at java.net.PlainSocketImpl.doConnect(PlainSocketImpl.java:333)
at java.net.PlainSocketImpl.connectToAddress(PlainSocketImpl.java:195)
at java.net.PlainSocketImpl.connect(PlainSocketImpl.java:182)
at java.net.SocksSocketImpl.connect(SocksSocketImpl.java:366)
at java.net.Socket.connect(Socket.java:525)
at org.apache.activemq.transport.tcp.TcpTransport.connect(TcpTransport.java:435)
at org.apache.activemq.transport.tcp.TcpTransport.doStart(TcpTransport.java:401)
at org.apache.activemq.util.ServiceSupport.start(ServiceSupport.java:53)
at org.apache.activemq.transport.TransportFilter.start(TransportFilter.java:57)
at org.apache.activemq.transport.TransportFilter.start(TransportFilter.java:57)
at org.apache.activemq.transport.WireFormatNegotiator.start(WireFormatNegotiator.java:72)
at org.apache.activemq.transport.TransportFilter.start(TransportFilter.java:57)
at org.apache.activemq.transport.TransportFilter.start(TransportFilter.java:57)
at org.apache.activemq.ActiveMQConnectionFactory.createActiveMQConnection(ActiveMQConnectionFactory.java:260)

I just submitted a patch which let the JMS polling task to re-connect if the JMS broker becomes available.

When re-connect you should see the following log.

[2011-04-05 14:57:00,580] INFO - ServiceTaskManager Reconnection attempt : 2 for service :StockQuoteProxy was successful!

This is a major improvement if you plan to use the JMS transport in production. This improvement will be available with the next release of WSO2 ESB and AS.

GSOC project - Apache Synapse MSMQ adapter

2011-04-01T16:13:00.004+05:30

GSOC 2011 is now on!

I just filled a jira about a possible GSOC project for Apache Synapse. The project is to develop a transport for Apache Synapse to communicate with MSMQ.

Once the transport is in place Apache Synapse can act a MSMQ adapter.The basic requirement is to send/receive message to/from Apache Synapse to MSMQ. MSMQ's API are in C/C++ and C# so when we develop the transport we need to write the bridge library to communicate with Synapse Java APIs.

There is an experimental MSMQ transport that I wrote sometime back which can also refer for the subject.

If you like to take a part in the program this summer do let know.

Linux reboot() system call and LINUX_REBOOT_MAGIC2 argument

2011-03-24T15:56:00.009+05:30

If you look at the reboot() system call in Linux it has the following signature.

int reboot(int magic, int magic2, int cmd, void *arg);

You can try the man page of reboot() system call in the online man page using, man 2 reboot.

The second argument can be one of the following magic numbers.

LINUX_REBOOT_MAGIC2 - 672274793(0x28121969)
LINUX_REBOOT_MAGIC2A - 85072278(0x5121996)
LINUX_REBOOT_MAGIC2B - 369367448(0x16041998)
LINUX_REBOOT_MAGIC2C - 537993216(0x20112000)

These magic numbers has something very interesting. If you look into the hexadecimal values you can see a set of dates.

Internet suggests that these are the birth dates of famous Linux kernel developer Linus Torvalds and his three daughters.

Advice to systems researchers

2011-03-09T08:11:00.003+05:30

If you one of the programmers who is enjoying writing systems software, this advice collection will find useful to you.

Cloud Services Gateway ( CSG) user interfaces

2011-03-03T17:51:00.005+05:30

I have finished the UI for new CSG component and I am putting up some of them here.

1. Adding a new CSG server

2. New CSG server information

3. Publish a service to CSG server

4. Un publish from a CSG server

Cloud Services Gateway ( CSG)

2011-01-27T19:20:00.005+05:30

Cloud Services Gateway or CSG for short provides a very useful feature in a cloud deployment. This component let you to expose a private service to public in a securely manner!

I am in the process of re-writing the component according to its new architecture based on the following JMS model.

Refer the diagram.

A service (S) which is behind a firewall need to expose to public. Once a user say publish service S, CSG-agent will deploy that service in JMS transport. This will create a queue Q1 on Message broker (MB, which runs out side the firewall). And also a JMS proxy(P) will be deployed in ESB. This proxy will have a JMS endpoint for Q1. The ESB and MB will be out side the firewall. The JMS connections will be secured JMS connections. MB can live as a standalone component or within ESB ( so that they'll communicate using an in-VM link). An external client will see the JMS proxy(P) and will communicate with that. That proxy in turns will communicate with the actual service S.

If the service is two-way MEP, a reply queue also created(Q2) when use say publish S. The reply queue information will be passed to the JMS proxy P so that it'll be a two way JMS proxy( will send the message to JMS destination (Q1) will read the reply from another JMS destination(Q2)). An external client will interact with the proxy P. A dashed line show the reply path in the diagram.

The secured JMS connections will use the same Carbon credentials so that we can mange secured JMS connections using the Carbon credentials.

The benefit that a user will get through this is the user only have to add the CSG server configuration at CSG agent. Qpid broker component uses the same authentication model as Carbon so a user do not need to configure separate credentials for a user.

I got the proposed JMS model to work and I am in the process of integrating CSG with the Qpid component as the JMS provider. Note that we have a Qpid component which can start with in the Carbon itself. I am planning to finish this work soon.

Configuring JMS transport in WSO2 ESB 4../WSO2 Carbon 3.2.*

2011-01-26T20:14:00.005+05:30

Last couple of days I was trying to get the JMS stuffs working with WSO2 ESB trunk. We are in the process of building the next version of WSO2 ESB, version 4.0.0 (based on Carbon 3.2.0). It seems due to some of the class loading changes that was done most of the JMS stuffs are broken, somehow we are in the process of fixing them. Yesterday and today I was testing with ActiveMQ and Qpid and I am briefing the steps for reference.

ActiveMQ ( version 5.2.0)

Configuration for JMS transport sender/listener will remain the same as previous releases. Copy the following jars into $CARBON_HOME/lib/core/WEB-INF/lib folder.

activemq-core-5.2.0.jar
geronimo-j2ee-management_1.0_spec-1.0.jar

Qpid ( version 0.9)

Configuration for JMS transport sender/listener will remain the same as previous releases. Copy the following jars from Qpid into $CARBON_HOME/lib/core/WEB-INF/lib folder.

slf4j-api-1.6.1.jar
slf4j-log4j12-1.6.1.jar
qpid-client-0.9.jar
qpid-common-0.9.jar
mina-core-1.0.1.jar

Enjoy!

WSO2 Stratos 1.0.0 Released!

2010-11-15T12:57:00.001+05:30

Read the full release note here.

WSO2 ESB and SFTP file transfer

2010-11-12T13:13:00.006+05:30

Here is a sample configuration which you can use to transfer file from a one location to another location in the same SFTP server using ESB's VFS transport. I tested this using ESB 3.0.1.


<proxy name="SFTPVFSProxy" transports="vfs" startOnLoad="true" xmlns="http://ws.apache.org/ns/synapse">
    <target>
        <inSequence>
            <log level="full"/>
            <property name="File"
                      expression="fn:concat('test-', get-property('transport', 'FILE_PATH'))"
                      scope="default"/>
            <property name="transport.vfs.ReplyFileName"
                      expression="fn:concat(fn:substring-after(get-property('MessageID'), 'urn:uuid:'), '.xml')"
                      scope="transport"/>
            <property name="OUT_ONLY" value="true"/>
            <send>
                <endpoint name="endpoint_urn_uuid_A1546EFFD75FC9CCED785986339425964585275">
     <address uri="vfs:sftp://rajika:rajika123@10.100.1.12/home/rajika/out"/>
                </endpoint>
            </send>
        </inSequence>
    </target>
    <parameter name="transport.vfs.ActionAfterProcess">MOVE</parameter>
    <parameter name="transport.PollInterval">15</parameter>
    <parameter name="transport.vfs.MoveAfterProcess">vfs:sftp://rajika:rajika123@10.100.1.12/home/rajika/original</parameter>
 <parameter name="transport.vfs.FileURI">vfs:sftp://rajika:rajika123@10.100.1.12/home/rajika/in/test.xml</parameter>
 <parameter name="transport.vfs.MoveAfterFailure">vfs:sftp://rajika:rajika123@10.100.1.12/home/rajika/original</parameter>
    <parameter name="transport.vfs.FileNamePattern">.*.xml</parameter>
    <parameter name="transport.vfs.ContentType">application/xml</parameter>
    <parameter name="transport.vfs.ActionAfterFailure">MOVE</parameter>
</proxy>

We use the excellent JSCH library as a part of the commons-vfs library in VFS transport. If you want to enable debugging for the underline JSCH library you'll have to implement a small class with the required logic. Following is an example



public static class JSchLogger implements Logger {
     public boolean isEnabled(int level) {
         switch (level) {
             case FATAL:
                 return log.isFatalEnabled();
             case ERROR:
                 return log.isErrorEnabled();
             case WARN:
                 return log.isWarnEnabled();
             case INFO:
                 return log.isInfoEnabled();
             default:
                 return log.isDebugEnabled();
         }
     }

     public void log(int level, String message) {
         switch (level) {
             case FATAL:
                 log.fatal("[JSCH] " + message);
                 break;
             case ERROR:
                 log.error("[JSCH] " + message);
                 break;
             case WARN:
                 log.warn("[JSCH] " + message);
                 break;
             case INFO:
                 log.info("[JSCH] " + message);
                 break;
             default:
                 log.debug("[JSCH] " + message);
         }
     }
 }

The logger is given by:
private static final Log log = LogFactory.getLog(SftpClientFactory.class);

And the logger should be set into the JSch.
JSch.setLogger(new JSchLogger());

I just submitted a patch,VFS-441 for commons-vfs so that we can have this improvement with the next commons-vfs release.

How ever in the JSCH version 0.1.31 it seems that we have to provide the relative path for the file name where as in version 0.1.41 it accepts the absolute path.

While testing this you may also need to enable clear text password support for the remote sshd as describe here.

There is an entry that I wrote earlier on the same subject.

WSO2 ESB won the gold award in NBQSA 2010

2010-10-02T13:44:00.003+05:30

WSO2 ESB (the product that I am part of) won the gold award in NBQSA 2010.

Webinar on extending WSO2 ESB

2010-09-29T13:53:00.003+05:30

WSO2 ESB provided the most of the functionalities that requires to implement the integration scenarios. There are some situations where you will find some requirements that you can't implement with the provided functionality. So in such situations you'll need to extend the functionality of ESB to suite your requirements.

I'll be conducting a free webinar on Extending WSO2 ESB. The webinar will be on the following time.

1. Tuesday, 5th October 2010 9:00 AM - 10:00 AM (GMT)

2. Tuesday, 5th October 2010 10:00 AM - 11:00 AM (PDT)

We'll also write code in the session.

WSO2 ESB transactional use cases

2010-09-27T10:00:00.004+05:30

I wrote an article for WSO2 Oxygen tank describing few transaction use cases of WSO2 ESB. If you plan to implement transaction related use cases using WSO2 ESB you may find it useful.

Updating ESB configuration using a command line tool

2010-09-15T16:09:00.005+05:30

One thing that users are asking over and over is how to update the ESB configuration using a command line tool. Of course you have the option to use the nice management console or directly editing the synapse configuration files resides in $ESB_HOME/repository/cons/synapse-config. But it seems some time you'll need to do this just using a command line client. Here what you need to do.
1. Use authorization admin service to authorize (https://localhost:9443/services/AuthenticationAdmin?wsdl)
2. Once authorized use synapse-config-admin service(https://localhost:9443/services/ConfigServiceAdmin?wsdl) to update the synapse configuration.

You can easily do this by using a generated client for the WSDLs. Note that to view the each of the WSDLs you'll have to have a running ESB server.
When I have some time I'll put up a small client which is capable of updating the synapse configuration of a remote ESB server.

The WSO2 Enterprise Service Bus (ESB) 3.0.1 Released!

2010-09-09T10:53:00.001+05:30

WSO2 ESB team is please to announce the release of WSO2 ESB 3.0.1. This is basically a bug fix release. You can read the full release note here.

The pre-mediate sequence in ESB

2010-08-08T21:38:00.003+05:30

ESB has a very special feature. That's ESB configuration let you to define a mandatory sequence which will get executed for each message(request and response) which pass through the ESB. This will come in handy in certain situations in which you want to do some task per each request/reponse. To achieve this all you need to do is to define a sequence called "pre-mediate" in the configuration.


<sequence name="pre-mediate">
  <log level="full"/>
</sequence>

When a message comes to ESB it'll first check for any mandatory sequence and then continue with the normal proxy or message mediation flows.

WSO2 ESB Q&A - #5

2010-07-18T10:47:00.003+05:30

Question: How to configure WSO2 ESB to talk to an endpoint which requires Basic HTTP authentication ?

Applies To: WSO2 ESB 3.x.x, WSO2 ESB 2.x.x

Answer: Just set the following property in your in sequence with the required credentials.


<property name="Authorization" expression="fn:concat('Basic ', base64Encode('userName:myPassword'))" scope="transport"/>

Starting daytime service on fedora 11

2010-07-15T23:51:00.004+05:30

I was writing some unix network code in C and one of the clients want to access the daytime server which runs on the port 13. By default this is not enabled in fedora11. So first you need to download and install xinetd ( is the UNIX dameon which manages your internet services) and add the following daytime server rules to /etc/xinetd.conf , xinetd configuration file.


service daytime
{
  disable        = no
  type           = INTERNAL
  id             = daytime-stream
  socket_type    = stream
  protocol       = tcp
  user           = root
  wait           = no
}

Then restart the xinted service using /etc/xinted restart.

Clone+Aggregate sample

2010-07-07T22:44:00.002+05:30

It seems that WSO2 ESB sample index doesn't have a sample on Clone+Aggregate mediator pair. So I just put up a sample below. You'll need to deploy two instance of SimpleStockQuoteService to run the sample.


<?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns:syn="http://ws.apache.org/ns/synapse">
    <proxy name="StockQuoteProxy" startOnLoad="true">
        <target>
            <inSequence>
                <clone>
                    <target sequence="request1"/>
                    <target sequence="request2"/>
                </clone>
            </inSequence>
            <outSequence>
                <aggregate>
                    <completeCondition>
                        <messageCount min="-1" max="-1"/>
                    </completeCondition>
                    <onComplete xmlns:m0="http://services.samples" expression="//m0:getQuoteResponse">
                        <send/>
                    </onComplete>
                </aggregate>
            </outSequence>
        </target>
        <publishWSDL uri="file:repository/samples/resources/proxy/sample_proxy_1.wsdl"/>
    </proxy>
    <sequence name="request1">
        <send>
            <endpoint>
                <address uri="http://localhost:9000/services/SimpleStockQuoteService"/>
            </endpoint>
        </send>
    </sequence>
    <sequence name="request2">
        <send>
            <endpoint>
                <address uri="http://localhost:9003/services/SimpleStockQuoteService"/>
            </endpoint>
        </send>
    </sequence>
</definitions>

Process chains and fans

2010-06-26T19:33:00.001+05:30


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

int main(int argc, char *argv[]){
 int i, n;
 pid_t childpid = 0;

 if(argc != 2){
  fprintf(stderr, "Usage: %s processes\n", argv[0]);
  return 1;
 }
 n = atoi(argv[1]);
 for(i = 0; i < n; i++){
  if(childpid = fork()){
   break;
  }
 }
 return 0;
}


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

int main(int argc, char *argv[]){
 pid_t childpid = 0;
 int i, n;

 if(argc != 2){
  fprintf(stderr, "Usage: %s process\n", argv[1]);
  return 1;
 }
 n = atoi(argv[1]);
 for(i = 0; i < n; i++){
  if((childpid = fork()) <= 0){
   break;
  }
 }
 return 0;
}

Carbon now supports monitoring behind a firewall

2010-06-22T10:01:00.003+05:30

The carbon which is the underline frame work for WSO2 ESB now can be monitored using a remote JMX client which is behind a firewall. To facilitate this purpose I have introduced a new property for carbon.xml which you can specify as the remote port. The new configuration looks like below.


<Ports>
       <!-- The JMX Ports -->
       <JMX>
           <!--The port RMI registry is exposed-->
           <!--<RMIRegistryPort>9999</RMIRegistryPort>-->
           <!--The port RMI server should be exposed-->
           <!--<RMIServerPort>11111</RMIServerPort>-->
       </JMX>
</Ports>

You can also pass this ports at server start up time using the two system properties "com.wso2.rmiserver.port" and "com.sun.management.jmxremote.port" for RMIServer port and the RMIRegistry port respectively.

Following code fragment is from CarbonServerManager.java which shows how the JMX url is constructed according to provided port.


// Create an RMI connector and start it
if (rmiServerPortString != null) {
      int rmiServerPort = Integer.parseInt(rmiServerPortString);
      jmxURL = "service:jmx:rmi://" + NetworkUtils.getLocalHostname() + ":" +
                rmiServerPort + "/jndi/rmi://" + NetworkUtils.getLocalHostname() + ":" +
                            rmiRegistryPort + "/jmxrmi";
} else {
      jmxURL = "service:jmx:rmi:///jndi/rmi://" +
                NetworkUtils.getLocalHostname() + ":" + rmiRegistryPort + "/jmxrmi";
}
JMXServiceURL url = new JMXServiceURL(jmxURL);

With this improvment you'll be able to monitor any carbon based product using a JMX client which is behind a firewall.

More improvements to JMS transport

2010-06-21T16:54:00.003+05:30

I submitted two patches which adds some improvements to the JMS transport code.

1. The local JMS transaction improvement.
When using local JMS transactions (with the JMS transport) with Axis2 there was no way to signal the transport to rollback the transaction (session.rollback()) if there is any error in back end. This patch fix the problem by setting the property
"SET_ROLLBACK_ONLY" upon receiving an error at the message receiver. The transport already has the necessary code to handle the transaction( either to commit or rollback).

2. Throttling capability for JMS polling task.
In the current implementation of JMS polling it'll immediately re-try polling the queue. In some instance we need to control over this behaviour ( for example for throttling purposes). This patch fix that problem by introducing the following parameter for connection factory. Using this property you can specify the amount of time(in millisecond) that you want to suspend the current polling task. Zero or negative value assume that polling task does not block.


<parameter name="transport.jms.TaskSuspendDuration" locked="false">suspending-time-in-millisecond</parameter>

Bit Twiddling Hacks

2010-06-19T11:45:00.002+05:30

Read it here.

LLVM receives first ever SIGPLAN Software Systems Award

2010-06-08T20:18:00.000+05:30

Read the full story here.

The perl bindings for Apache Qpid C++ clients

2010-05-22T11:51:00.004+05:30

I am in the process of implementing the perl clients for Apache Qpid which has the same API as the C++ clients. The perl binding will be done using the swig framework. Basically we'll have a set of interface definition files for the C++ clients API which can use to generate perl clients. Of course we can use the same interface files to generate the other bindings such as Python, TCL, C# etc... Following digram describes the process of building a reusable perl module for perl clients using the swig framework.

I'll keep the progress post here. I am going to little bit busy in the coming two months as I have to provide on site development support for one of our clients in Germany. I normally find time to work on Apache Qpid on week ends, which this time I have some plans to travel around Germany. Any way stay tuned.

The broker component

2010-05-16T12:33:00.003+05:30

Update: Danushka will be working on this component, so you'll need to hang around his blog to find out more information.

I am going to start to develop a broker component for Carbon. The primary aim is to provide a persistence and broker functionality across Carbon. Once the task is completed users of Carbon should have an embedded broker such as Apache ActiveMQ which they can consume across the Carbon. In addition to the above main objective there are couple of other thing that can be found interesting.

1. Allow different broker implementations (for ex: Apache ActiveMQ, Qpid/Java) to be plugged without much effort.
2. Have an embedded broker which runs in the same JVM process(which use an in-VM link) which will increase the performance.
3. Easy to use interface for managing and monitoring brokers.

I have started a discussion how I'd like to see this at WSO2's architecture mailing list. Basically anybody who is interested in have their own broker implementations plugged into Carbon will have to implement the following interface. This define a common set of operations which use to manage ( for ex: create, destroy) and monitor( for ex: list, query) the broker.


/**
* The operation associated with the broker component. Interested parties who wish you plug
* their own broker impl. requires to implement this interface.
*/
public interface Broker {

 /**
  * Initilizes the environment where a broker can starts/creates.
  *
  * @param prop The configuration properties.
  */
 public void init(Properties prop);

 /**
  * Create/Start a new broker instance. The broker will start with a default broker
  * configurations which user can change according to his/her requirements. The broker
  * instance can be created/started in two ways.
  * 1. Using a in-VM link which will result an embedded broker which runs with the same
  * JVM process as the application.
  * 2. A remote broker.
  *
  * @param configFile The broker configuration file.
  */
 public void create(File configFile);

 /**
  * Destroys/Stops a broker instance.
  */
 public void destroy();


 /**
  * Lists all available brokers in the specified JMX context.
  *
  * @param jmxContext The jmx context.
  */
 public void list(Context jmxContext);

 /**
  * Returns selected messages in a specified destination
  *
  * @param destination the destination
  * @return Set of messsages.
  */
 public Message[] browse(Destination destination);

 /**
  * Returns useful broker statistics
  *
  * @param brokerName broker name
  * @return Stats. object
  */
 public Object bstat(String brokerName);

 /**
  * Deletes selected destination's messages that matches pattern.
  *
  * @param destination Destination.
  * @param pattern     Match this pattern.
  */
 public void purge(Destination destination, Pattern pattern);

 /**
  * Returns selected broker component's attributes and statistics
  *
  * @param component Destination.
  * @return The stats. and attributes.
  */
 public Object query(Destination component);
}

I'll post the progress here.

Intergrating WSO2 ESB with WebLogic JMS provider

2010-05-13T12:04:00.003+05:30

This guide provide the steps and configurations requires to use WSO2 ESB with WebLogic JMS provider.
Recently released WSO2 ESB 3.0.0 and WebLogic 10.3 server were used.

You'll need to copy the Weblogic JMS client jars - wlclient.jar and wljmsclient.jar( these jars can be found in $WL_HOME/wlserver_10.3/server/lib) into $ESB_HOME/repository/components/extensions.

You'll need to have the following JMS transport receiver and the sender configurations in axis2.xml.


<transportReceiver name="jms" class="org.apache.axis2.transport.jms.JMSListener">
 <parameter name="default" locked="false">
     <parameter name="java.naming.factory.initial">weblogic.jndi.WLInitialContextFactory</parameter>
     <parameter name="java.naming.provider.url">t3://localhost:7001</parameter>
     <parameter name="transport.jms.ConnectionFactoryJNDIName">weblogic.examples.jms.QueueConnectionFactory</parameter>
  <parameter name="transport.jms.ConnectionFactoryType" locked="false">queue</parameter>
    </parameter>
</transportReceiver>


<transportSender name="jms" class="org.apache.axis2.transport.jms.JMSSender"/gt&;

JMS to HTTP protocol switching

1. This is a modified version of the sample #250. The configuration is shown below.


<!--
~  Copyright (c) 2005-2008, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
~
~  WSO2 Inc. licenses this file to you under the Apache License,
~  Version 2.0 (the "License"); you may not use this file except
~  in compliance with the License.
~  You may obtain a copy of the License at
~
~    http://www.apache.org/licenses/LICENSE-2.0
~
~  Unless required by applicable law or agreed to in writing,
~  software distributed under the License is distributed on an
~  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
~  KIND, either express or implied.  See the License for the
~  specific language governing permissions and limitations
~  under the License.
~
-->

<!-- Introduction to switching transports - JMS to http/s -->
<definitions xmlns="http://ws.apache.org/ns/synapse">

 <proxy name="weblogic.examples.jms.exampleQueue" transports="jms">
     <target>
         <inSequence>
             <property action="set" name="OUT_ONLY" value="true"/>
         </inSequence>
         <endpoint>
             <address uri="http://localhost:9000/services/SimpleStockQuoteService"/>
         </endpoint>
         <outSequence>
             <send/>
         </outSequence>
     </target>
     <publishWSDL uri="file:repository/samples/resources/proxy/sample_proxy_1.wsdl"/>
     <parameter name="transport.jms.ContentType">
         <rules>
             <jmsProperty>contentType</jmsProperty>
             <default>application/xml</default>
         </rules>
     </parameter>
 </proxy>

</definitions>

2. You'll need to define a queue with the name "weblogic.examples.jms.exampleQueue" using the Web logic management console.

3. You can use the sample client QueueSend( lies in $WL_HOME/wlserver_10.3/samples/server/examples/src/examples/jms/queue) with the following payload to test the scenario.


<m:placeOrder xmlns:m="http://services.samples"><m:order><m:price>100.00</m:price><m:quantity>12</m:quantity><m:symbol>Cargills</m:symbol></m:order></m:placeOrder>

HTTP to JMS protocol switching

1. This is a modified version of the sample #251. The configuration is given below.


<!--
 ~  Copyright (c) 2005-2008, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
 ~
 ~  WSO2 Inc. licenses this file to you under the Apache License,
 ~  Version 2.0 (the "License"); you may not use this file except
 ~  in compliance with the License.
 ~  You may obtain a copy of the License at
 ~
 ~    http://www.apache.org/licenses/LICENSE-2.0
 ~
 ~  Unless required by applicable law or agreed to in writing,
 ~  software distributed under the License is distributed on an
 ~  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 ~  KIND, either express or implied.  See the License for the
 ~  specific language governing permissions and limitations
 ~  under the License.
 ~
 -->

<!-- Switching from http/s to JMS -->
<definitions xmlns="http://ws.apache.org/ns/synapse">

   <proxy name="StockQuoteProxy" transports="http">
       <target>
           <endpoint>
      <address uri="jms:/weblogic.examples.jms.exampleQueue?transport.jms.ConnectionFactoryJNDIName=weblogic.examples.jms.QueueConnectionFactory&java.naming.factory.initial=weblogic.jndi.WLInitialContextFactory&java.naming.provider.url=t3://localhost:7001&transport.jms.DestinationType=queue"/>
           </endpoint>
           <inSequence>
               <property action="set" name="OUT_ONLY" value="true"/>
               <property action="set" name="OUT_ONLY" value="true"/>
               <property action="remove" name="Content-Length" scope="transport"/>
               <property action="remove" name="Accept-Encoding" scope="transport"/>
               <property action="remove" name="User-Agent" scope="transport"/>
               <property action="remove" name="Content-Type" scope="transport"/>
               <property action="remove" name="Transfer-Encoding" scope="transport"/>
           </inSequence>
           <outSequence>
               <send/>
           </outSequence>
       </target>
       <publishWSDL uri="file:repository/samples/resources/proxy/sample_proxy_1.wsdl"/>
   </proxy>
</definitions>

2. You'll need to define a queue as in sample1. Just send a http message using the client in sample #251 and see this in action.

WSO2 ESB Q&A - #4

2010-05-08T08:51:00.003+05:30

Question: How can I share some properties between in path and out path of the message flow in WSO2 ESB?

Applies To: WSO2 ESB 3.x.x, WSO2 ESB 2.x.x

Answer: You can share a property using the message context between in path and out path in the message flow. For instance you can set a property to axis2 message context using property mediator in, in path and you can read that property using get-property XPath function in out sequence.

Synapse now supports using a temporary file in VFS transport

2010-05-05T15:16:00.002+05:30

I just submitted a patch for Apache synapse which makes it possible to use a temporary file when using VFS transport sender. This work like this. If you specify to use a temp file when uploading content to remote server, VFS transport sender will use a temporary file to upload the content and once uploading is completed it'll move the temp file to original file. This feature is very important if you plan to use VFS transport in a production environment. If you don't specify this there is a problem since one at the other end can start to process the file before the file has fully transferred.
A user can specify the optional parameter transport.vfs.UseTempFile if he/she wants to use a temp file when uploading.


<property name="transport.vfs.UseTempFile" value="true" scope="transport"/>

A full configuration will be like below.


<!-- Using the  file system as transport medium using VFS transport listener and sender -->
<definitions xmlns="http://synapse.apache.org/ns/2010/04/configuration">
    <proxy name="StockQuoteProxy" transports="vfs">
        <parameter name="transport.vfs.FileURI">file:///home/rajika/work/vfs/in</parameter> <!--CHANGE-->
        <parameter name="transport.vfs.ContentType">text/xml</parameter>
        <parameter name="transport.vfs.FileNamePattern">.*\.xml</parameter>
        <parameter name="transport.PollInterval">15</parameter>
        <parameter name="transport.vfs.MoveAfterProcess">file:///home/rajika/work/vfs/original</parameter> <!--CHANGE-->
        <parameter name="transport.vfs.MoveAfterFailure">file:///home/rajika/work/vfs/original</parameter> <!--CHANGE-->
        <parameter name="transport.vfs.ActionAfterProcess">MOVE</parameter>
        <parameter name="transport.vfs.ActionAfterFailure">MOVE</parameter>

        <target>
            <endpoint>
                <address format="soap12" uri="http://localhost:9000/services/SimpleStockQuoteService"/>
            </endpoint>
            <outSequence>
                <property name="transport.vfs.ReplyFileName"
                          expression="fn:concat(fn:substring-after(get-property('MessageID'), 'urn:uuid:'), '.xml')" scope="transport"/>
                <property name="transport.vfs.UseTempFile" value="true" scope="transport"/>
                <property action="set" name="OUT_ONLY" value="true"/>
                <send>
                    <endpoint>
                        <address uri="vfs:file:///home/rajika/work/vfs/out/"/> <!--CHANGE-->
                    </endpoint>
                </send>
            </outSequence>
        </target>
        <publishWSDL uri="file:repository/conf/sample/resources/proxy/sample_proxy_1.wsdl"/>
    </proxy>
</definitions>

With this patch in place VFS transport should be more suitable for production use.

WSO2 ESB 3.0.0 Released!

2010-05-03T10:10:00.001+05:30

The WSO2 Enterprise Service Bus (ESB) 3.0.0 Released!

The WSO2 ESB team is pleased to announce the release of version 3.0.0 of the Open Source Enterprise Service Bus (ESB).

WSO2 ESB is a fast, lightweight and user friendly open source Enterprise Service Bus (ESB) distributed under the Apache Software License v2.0. WSO2 ESB allows system administrators and developers to easily configure message routing, intermediation, transformation, logging, task scheduling, fail over routing and load balancing. It also supports transport switching, eventing, rule based mediation and priority based mediation for advanced integration requirements. The ESB runtime is designed to be completely asynchronous, non-blocking and streaming based on the Apache Synapse mediation engine.

WSO2 ESB 3.0.0 is developed on top of the revolutionary WSO2 Carbon platform (Middleware a' la carte), an OSGi based framework that provides seamless modularity to your SOA via componentization. This release also contains many new features and a range of optional components (add-ons) that can be installed to customize the behavior of the ESB. Further, any existing features of the ESB which are not required to your environment can be easily removed using the underlying provisioning framework of Carbon. In brief, WSO2 ESB can be fully customized and tailored to meet your exact SOA needs.

You can download this distribution from http://wso2.org/downloads/esb and give it a try.

How to Run

Extract the downloaded zip
Go to the bin directory in the extracted folder
Run the wso2server.sh or wso2server.bat as appropriate
Point your browser to the URL https://localhost:9443/carbon
Use "admin", "admin" as the username and password to login as an admin and create a user account
Assign the required permissions to the user through a role
If you need to start the OSGi console with the server use the property -DosgiConsole when starting the server. The INSTALL.txt file found on the installation directory will give you a comprehensive set of options and properties that can be passed into the startup script
Sample configurations can be started by the wso2esb-samples script passing the sample number with the -sn option (Please have a look at the samples guide for more information, on running samples)

New Features of WSO2 ESB 3.0.0

Priority based mediation through priority executors
WS-Discovery support and dynamic endpoint discovery
Message Relay for efficient pass through of messages
Component manager to install and uninstall features (provisioning support)
Common Internet File System (CIFS) support through the VFS transport
File locking functionality in the VFS transport to support concurrent polling
Smooks mediator for efficient message transformation
Enrich mediator for smart message manipulation
OAuth mediator for 2-legged OAuth support
Default endpoint UI
Hot deploy and hot update configuration elements (sequences, endpoints, proxy services etc)
Transport level statistics collection and monitoring
POX security support
Dependency detection and alerting for mediation configuration elements
Mediation statistics API and custom mediation statistics consumers
Multiple certificate/identity support in the NHTTP transport sender
Improved logging capabilities for the NHTTP transport
Templates based proxy service development in the UI
Dashboard to monitor server environment and runtime
Easy creation and management capabilities for dynamic sequences and endpoints
Pagination to service management, endpoint management and sequence management UIs
Obtaining resources like WSDL's through web proxy servers

Key Features of WSO2 ESB

Proxy services - facilitating synchronous/asynchronous transport, interface (WSDL/Schema/Policy), message format (SOAP 1.1/1.2, POX/REST, Text, Binary), QoS (WS-Addressing/WS-Security/WS-RM) and optimization switching (MTOM/SwA).
Non-blocking HTTP/S transports based on Apache HttpCore-NIO for ultrafast execution and support for thousands of connections at high concurreny with constant memory usage.
Built in Registry/Repository, facilitating dynamic updating and reloading of the configuration and associated resources (e.g. XSLTs, XSD, WSDL, Policies, JS configurations ..)
Easily extendable via custom Java classes (mediator and command)/Spring configurations, or BSF Scripting languages (Javascript, Ruby, Groovy, etc.)
Built in support for scheduling tasks using the Quartz scheduler.
Load-balancing (with or without sticky sessions)/Fail-over, and clustered Throttling and Caching support
WS-Security, WS-Reliable Messaging, Caching & Throttling configurable via (message/operation/service level) WS-Policies
Lightweight, XML and Web services centric messaging model
Support for industrial standards (Hessian binary web service protocol/ Financial Information eXchange protocol and optional Health Level-7 protocol)
Enhanced support for the VFS (File/FTP/SFTP), JMS, Mail transports with optional TCP/UDP transports and transport switching among any of the above transports
Support for message splitting & aggregation using the EIP and service callouts
Database lookup & store support with DBMediators with reusable database connection pools
WS-Eventing support with event sources and event brokering
Rule based mediation of the messages using the Drools rule engine
Transactions support via the JMS transport and Transaction mediator for database mediators
Internationalized GUI management console with user management for configuration development
Integrated monitoring support with statistics, configurable logging and tracing
JMX monitoring support and JMX management capabilities like, Graceful/Forceful shutdown/restart

Bugs Fixed in This Release

This release of WSO2 ESB comes with a number of bug fixes, both in the base framework and the ESB specific componenents. All the issues which have been fixed in ESB 3.0.0 are recorded at following locations:

Known Issues

Endpoint UI does not support selecting already existing endpoints as child endpoints when creating load balance/failover endpoints
HTTP GET requests performed on an endpoint that has a trailing '/' character, do not work properly
SOAP tracer does not work when the message relay is activated
The sequence editor and the built-in XML editors do not work properly on Google Chrome

All the open issues pertaining to WSO2 ESB 3.0 are reported at following locations:

How You Can Contribute

Mailing Lists

Join our mailing list and correspond with the developers directly.

Developer List : carbon-dev@wso2.org | Subscribe | Mail Archive
User List : esb-java-user@wso2.org | Subscribe | Mail Archive

Reporting Issues

WSO2 encourages you to report issues and your enhancement requests for the WSO2 ESB using the public JIRA.

You can also watch how they are resolved, and comment on the progress..

Discussion Forums

Alternatively, questions could be raised using the forums available.

WSO2 ESB Forum : Discussion forum for WSO2 ESB developers/users

Support

We are committed to ensuring that your enterprise middleware deployment is completely supported from evaluation to production. Our unique approach ensures that all support leverages our open development methodology and is provided by the very same engineers who build the technology.

For more details and to take advantage of this unique opportunity please visit http://wso2.com/support.

For more information about WSO2 ESB please see http://wso2.com/products/enterprise-service-bus.

-- The WSO2 ESB Team --

Proxy service fault handling improvements

2010-04-29T15:20:00.003+05:30

Synapse has an issue where it ignores the registered fault handler if an exception occurs in out sequence of a proxy configuration. I just submitted a patch to fix the problem.
Here are also some notes on synapse fault handling mechanism. Synapse( so WSO2 ESB) consider following types of errors as exceptions and handles them.

1. Transport errors (connection timeout, connection refused etc..)
2. Axis2 Faults.
3. Security related errors.
4. Registry access errors.
5. General errors.

You can define your own fault handler (by default Synpase assumes a log followed by a drop fault handler) and assign them sequences and proxy services.

For sequence:


<sequence onError="error-handler-sequence"  />

For proxy services:


<proxy>
     <target faultSequence="error-handler-sequence"/>
</proxy>

Synapse uses a stack based mechanisms to handle faults. The registered fault sequences will be pushed into the stack at start up and upon receiving one of the mentioned errors above the top most fault handler will be popped and will be used to handle that particular exception (I tend to remind the signal handling mechanism of an operating system). This efficient fault handling mechanism will save Synapse in a critical situation.

LLVM 2.7 Release!

2010-04-27T14:39:00.000+05:30

You can read the full release note here.

WSO2 ESB Q&A - #3

2010-04-24T10:56:00.002+05:30

Question: How to change the endpoint reference (EPR) dynamically ?

Applies To: WSO2 ESB 2.x.x, WSO2 ESB 3.x.x

Answer: If you want to change the endpoint address per message basis you can use a header mediator to change the To address based on the message content.


<header name="To" expression="XPath to create the address dynamically"/>

Exit handler in a C program

2010-04-22T09:55:00.003+05:30

You can register an exit handler in a C program which will execute at the end of the execution of the main function. This will only execute in a normal execution(which means at the end of return in main function) and needless to say this will not work in an abnormal exit or a kill by a CTRL+C ( which is the SIGKILL signal). Also note how last-register-first-execute when executing the exit handlers.


/* compiles with gcc -Wall -ansi -pedantic -o exit-handler exit-handler.c */
#include <stdio.h>
#include <stdlib.h>

static void callback();
static void callback1();

static void callback(){
 printf("I am a registered callback.\n");
}

static void callback1(){
 printf("I am the second registered callback\n");
}

int main(){
 if(atexit(callback)){
  fprintf(stderr, "Failed to register the call back\n");
  return 1;
 }
 if(atexit(callback1)){
  fprintf(stderr, "Failed to register the second callback\n");
  return 1;
 }
 printf("Just executing the main...\n");
 /* rest of the main */
 return 0;
}

Which out put:


[rajika@localhost ch2]$ ./exit-handler 
Just executing the main...
I am the second registered callback
I am a registered callback.
[rajika@localhost ch2]$

Advanced Message Queuing Protocol ( AMQP)

2010-04-17T18:46:00.003+05:30

AMQP specification grabbed my attention. I always had this interest towards MOM systems, so I thought I'd take a look at the AMQP specification. Mean while I am looking into Apache Qpid project which is one of the open source implementations of the AMQP specification.

XPath functions and properties avilable in WSO2 ESB

2010-04-15T14:36:00.003+05:30

The configuration language of WSO2 ESB is rich with XPath support. There are few built in XPath functions and properties which makes the life of a developer easy.

XPath functions
1. get-Property - This function returns the value of a named property.

XPath properties
1. $trp - This is a map of transport headers, you can refer to the individual transport headers using the format: $trp:transport-header-name.
2. $body - The body element. You can refer to an element using the format:
$body/getQuote will return the first getQuote element in the SOAP body.
3. $header - The header element, you can refer to an element using the format:
$header/wsa:To will return the fist was:To element in the SOAP header.
4. $ctx - Can use to retrieve synapse message context property, using the format: $ctx:RESPONSE will return the value of synapse message context property RESPONSE.
5. $axis2 - Can use to retive the axis2 message context property, using the format: $axis2:messageType which will return the value of axis2 message context property messageType.

You can find a complete description in the Configuration language guide in WSO2 ESB docs.

Following sample shows using this function and properties.


<definitions xmlns="http://ws.apache.org/ns/synapse">
   <proxy name="StockQuoteProxy">
       <target>
           <inSequence>
               <log level="custome">
                   <property name="Current date" expression="get-property('SYSTEM_DATE')"/>
                   <property name="$trp:Content-Type" expression="$trp:Content-Type"/>
                   <property name="$body" expression="$body/getQuote"/>
                   <property name="$header" expression="$header/wsa:To" xmlns:wsa="http://www.w3.org/2005/08/addressing"/>
                   <property name="$ctx:RESPONSE" expression="$ctx:RESPONSE"/>
                   <property name="$axis2:messageType" expression="$axis2:messageType"/>
               </log>
               <send>
                   <endpoint>
                       <address uri="http://localhost:9000/services/SimpleStockQuoteService"/>
                   </endpoint>
               </send>
           </inSequence>
           <outSequence>
               <send/>
           </outSequence>
       </target>
       <publishWSDL uri="file:repository/conf/sample/resources/proxy/sample_proxy_1.wsdl"/>
   </proxy>
</definitions>

Enabling Fast Infoset in WSO2 ESB

2010-04-08T08:59:00.004+05:30

Fast Infoset specifies a binary format for XML infosets that is an efficient alternative to XML. This guide describes how you can enable fast infoset support for WSO2 ESB 3.0.0, Iridium.
We are almost done with the WSO2 ESB 3.0.0 release and it'll be released shortly. In the mean time you can download the RC2 from here.
You need to copy the axis2-fastinfoset-1.6-wso2v1.jar to $ESB_HOME/repository/components/lib. You'll have to build the jar your self and it can be found here. Just get a check out of axis2 and build it.
Then add the following message formatter and message builder to the axis2.xml in $ESB_HOME/repository/conf.

Message formatters.


<!-- POX Message Formatter -->

<messageFormatter contentType="application/fastinfoset"
class="org.apache.axis2.fastinfoset.FastInfosetPOXMessageFormatter"/>

<!-- SOAP Message Formatter -->

<messageFormatter contentType="application/soap+fastinfoset"
class="org.apache.axis2.fastinfoset.FastInfosetMessageFormatter"/>

Message builders.


<!-- POX Message Builder -->

<messageBuilder contentType="application/fastinfoset"
class="org.apache.axis2.fastinfoset.FastInfosetPOXBuilder"/>

<!-- SOAP Message Builder -->

<messageBuilder contentType="application/soap+fastinfoset"
class="org.apache.axis2.fastinfoset.FastInfosetBuilder"/>

When sending a message out from ESB you can set the Content-Type to either application/soap+fastinfoset ( for SOAP messages) and application/fastinfoset ( for POX messages), you can set this property using a property mediator.

Deploying WSO2 ESB 3.x.x on JBoss

2010-04-04T22:11:00.002+05:30

Ruwani, one of the WSO2 ESB team members has written a step by step guide on deploying WSO2 ESB 3.0.0 on JBoss application server(version 5.1). You can read the full article here on the oxygen tank.

WSO2 ESB Q&A - #2

2010-03-24T16:20:00.004+05:30

Question: What are the transports supported by WSO2 ESB.

Applies To: WSO2 ESB 2.x.x, WSO2 ESB 3.x.x

Answer: Following transports are build into WSO2 ESB.

1. HTTP
2. JMS
3. mail
4. TCP
5. UDP
6. FIX
7. VFS(ftp, local files, sftp, zip, jar, tar, gzip,bzip, res, ram, mime,WebDAV, CIFS)
8. AMQP
9. HL7

Public key authentication for sftp in WSO2 ESBs VFS transport

2010-03-22T17:47:00.006+05:30

Another new feature in upcoming WSO2 ESBs vfs transport is the ability to authenticate using public key for sftp. You only need to specify the user name in the connection url, the transport will automatically look for ~/.ssh for the private key. To get this scenario working you'll need to add your public key into the remote servers ~/.ssh/authorized_keys. Following is an example.


<definitions xmlns="http://ws.apache.org/ns/synapse">
<proxy name="StockQuoteProxy" transports="vfs">
 <parameter name="transport.vfs.FileURI">vfs:sftp://user@host/home/user/test.xml</parameter> CHANGE
 <parameter name="transport.vfs.ContentType">text/xml</parameter>
 <parameter name="transport.vfs.FileNamePattern">.*\.xml</parameter>
 <parameter name="transport.PollInterval">15</parameter>

 <target>
   <inSequence>
     <header name="Action" value="urn:getQuote"/>
   </inSequence>                     
   <endpoint>
     <address uri="http://localhost:9000/services/SimpleStockQuoteService"/>
   </endpoint>
   <outSequence>
     <property action="set" name="OUT_ONLY" value="true"/>
     <send>
       <endpoint>
         <address uri="mailto:rajika@wso2.com"/> <!--CHANGE-->
       </endpoint>                                     
     </send>
   </outSequence>
 </target>
 <publishWSDL uri="file:repository/conf/sample/resources/proxy/sample_proxy_1.wsdl"/>
</proxy>
</definitions>

If you plan to use the user name, password combination for authentication you'll need to include your password in the connection url.


vfs:sftp://user:password@host/home/user/test.xml

Some instructions on planting the public key on the remote server avilable here.

Writing a class mediator for WSO2 ESB 3.0.0

2010-03-15T20:29:00.005+05:30

One way to extend the functionality of WSO2 ESB is to write a class mediator. Following is a sample class mediator which just log various properties in Synapse MessageContext to STDOUT. You can either deploy this mediator just as a normal jar or as an OSGi bundle.

1. Deploying as a normal jar.
You'll need to build a regular jar and put into $ESB_HOME/repository/components/lib and restart the server.
Following pom.xml will build the jar.


<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.wso2.carbon.mediator</groupId>
<artifactId>org.wso2.carbon.mediator</artifactId>
<packaging>jar</packaging>
<version>1.0-SNAPSHOT</version>
<name>org.wso2.carbon.mediator</name>
<url>http://maven.apache.org</url>
<repositories>
       <repository>
           <id>wso2-maven2-repository</id>
           <url>http://dist.wso2.org/maven2</url>
       </repository>
       <repository>
           <id>apache-Incubating-repo</id>
           <name>Maven Incubating Repository</name>
           <url>http://people.apache.org/repo/m2-incubating-repository</url>
       </repository>
       <repository>
           <id>apache-maven2-repo</id>
           <name>Apache Maven2 Repository</name>
           <url>http://repo1.maven.org/maven2/</url>
       </repository>
   </repositories>

   <build>
       <plugins>
           <plugin>
               <groupId>org.apache.maven.plugins</groupId>
               <artifactId>maven-compiler-plugin</artifactId>
               <version>2.0</version>
               <configuration>
                   <source>1.5</source>
                   <target>1.5</target>
               </configuration>
           </plugin>
       </plugins>
   </build>

   <dependencies>
       <dependency>
           <groupId>org.apache.synapse</groupId>
           <artifactId>synapse-core</artifactId>
           <version>1.4.0-wso2v1</version>
       </dependency>
   </dependencies>
</project>

2. Deploying as an OSGi bundle.
You can place your OSGi bundle inside $ESB_HOME/repository/components/dropins and restart the server.

Following pom.xml build the OSGi bundle.


<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.wso2.carbon.mediator</groupId>
<artifactId>org.wso2.carbon.mediator</artifactId>
<packaging>bundle</packaging>
<version>1.0-SNAPSHOT</version>
<name>org.wso2.carbon.mediator</name>
<url>http://maven.apache.org</url>
 <repositories>
         <repository>
             <id>wso2-maven2-repository</id>
             <url>http://dist.wso2.org/maven2</url>
         </repository>
         <repository>
             <id>apache-Incubating-repo</id>
             <name>Maven Incubating Repository</name>
             <url>http://people.apache.org/repo/m2-incubating-repository</url>
         </repository>
         <repository>
             <id>apache-maven2-repo</id>
             <name>Apache Maven2 Repository</name>
             <url>http://repo1.maven.org/maven2/</url>
         </repository>
     </repositories>

     <build>
         <plugins>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
                 <version>2.0</version>
                 <configuration>
                     <source>1.5</source>
                     <target>1.5</target>
                 </configuration>
             </plugin>
             <plugin>
                 <groupId>org.apache.felix</groupId>
                 <artifactId>maven-bundle-plugin</artifactId>
                 <version>1.4.0</version>
                 <extensions>true</extensions>
                 <configuration>
                     <instructions>
                         <Bundle-SymbolicName>org.test</Bundle-SymbolicName>
                         <Bundle-Name>org.test</Bundle-Name>
                         <Export-Package>
                             org.wso2.carbon.mediator.*,
                         </Export-Package>
                         <Import-Package>
                             *; resolution:=optional
                         </Import-Package>
                     </instructions>
                 </configuration>
             </plugin>
         </plugins>
     </build>

     <dependencies>
         <dependency>
             <groupId>org.apache.synapse</groupId>
             <artifactId>synapse-core</artifactId>
             <version>1.4.0-wso2v1</version>
         </dependency>
     </dependencies>
</project>

Following is the sample class mediator.


package org.wso2.carbon.mediator;

import org.apache.synapse.MessageContext;
import org.apache.synapse.Mediator;
import org.apache.synapse.mediators.AbstractMediator;
import org.apache.synapse.mediators.base.SequenceMediator;

import java.util.Map;
import java.util.Set;
import java.util.Iterator;

/**
* This mediator just log the data packed inside SynpaseMessageConext to STDIN
*/
public class SynapseMessageContextMediator extends AbstractMediator {

 public boolean mediate(MessageContext msgCtx) {

     log.info("Starting " + getClass().getName() + " mediator..");
     Set propKeySet = msgCtx.getPropertyKeySet();
     Iterator iterator = propKeySet.iterator();
     int i = 0;
     while (iterator.hasNext()) {
         Object obj = iterator.next();
         log.info("Property key" + (i++) + ": " + obj.toString());
     }

     if (msgCtx.getFaultTo() != null && msgCtx.getFaultTo().getAddress() != null) {
         log.info("Fault to EPR: " + msgCtx.getFaultTo().getAddress());
     }

     if (msgCtx.getFrom() != null && msgCtx.getFrom().getAddress() != null) {
         log.info("From EPR: " + msgCtx.getFrom().getAddress());
     }

     if (msgCtx.getEnvelope() != null) {
         log.info("Soap envelope: " + msgCtx.getEnvelope());
     }

     if (msgCtx.getMessageID() != null) {
         log.info("Message ID: " + msgCtx.getMessageID());
     }

     if (msgCtx.getRelatesTo() != null) {
         log.info("Relates to: " + msgCtx.getRelatesTo());
     }

     if (msgCtx.getReplyTo() != null) {
         log.info("ReplyTo: " + msgCtx.getReplyTo());
     }

     if (msgCtx.getTo() != null) {
         log.info("To: " + msgCtx.getTo());
     }

     if (msgCtx.getWSAAction() != null) {
         log.info("WSAAction: " + msgCtx.getWSAAction());
     }

     if (msgCtx.getWSAMessageID() != null) {
         log.info("WSAMesage ID: " + msgCtx.getWSAMessageID());
     }

     if (msgCtx.getSoapAction() != null) {
         log.info("SOAPAction: " + msgCtx.getSoapAction());
     }

     log.info("MTOM ?:" + msgCtx.isDoingMTOM());
     log.info("REST ?:" + msgCtx.isDoingPOX());
     log.info("SWA ?:" + msgCtx.isDoingSWA());
     log.info("POST ?:" + !msgCtx.isDoingGET());
     log.info("SOAP 11 ?:" + msgCtx.isSOAP11());
     log.info("Response ?:" + msgCtx.isResponse());

     log.info("End of " + getClass().getName() + " mediator.");
     return true;
 }
}

And finally following is a sample synpase.xml which shows the new mediator is in used.


<definitions xmlns="http://ws.apache.org/ns/synapse">
  <log/>
  <class name="org.wso2.carbon.mediator.SynapseMessageContextMediator"/>
  <send/>
</definitions>

WSO2 ESB start up script options

2010-03-14T00:17:00.003+05:30

Following command line options are available to the start up script of WSO2 ESB 3.0.0. Note the two options --cleanCache and --reset options are not any more which we had in 2.x.x series of WSO2 ESB. This is because in 3.0.0 version we'll use the synapse.xml to load the configuration, before when you start the server in second time the configuration is read from registry not from the synapse.xml.


[rajika@localhost bin]$ ./wso2server.sh -h
Usage: wso2server.sh [command] [system-properties]

command:
--debug   Start the server in remote debugging mode.
  port: The remote debugging port.
--run  Run the server
--start  Start Carbon as a Unix daemon in the background
--console Start Carbon as a Unix daemon in the foreground
--stop  Stop the Carbon Unix daemon
--status Get the status of the Carbon Unix daemon
--dump  Print a thread dump of the Carbon Unix daemon
--restart Restart the Carbon Unix daemon
--cleanRegistry Clean registry space. [CAUTION] All Registry data will be lost.
--version What version of the product are you running?

system-properties:
-DhttpPort  Overrides the HTTP port defined in the transports.xml file
-DhttpsPort  Overrides the HTTPS port defined in the transports.xml file
-DosgiConsole=[port] Start Carbon with Equinox OSGi console.
   If the optional 'port' parameter is provided, a telnet port will be opened
-DosgiDebugOptions=[options-file]
   Start Carbon with OSGi debugging enabled.
   If the optional 'options-file is provided, the OSGi debug options will be loaded from it.
-Dsetup   Clean the Registry & other configuration, recreate DB, re-populate the configuration, and start Carbon
-Dcarbon.registry.root The root of the Registry used by this Carbon instance
-Dwso2.transports.xml Location of the transports.xml file.
-Dweb.location  The directory into which UI artifacts included in an Axis2 AAR file are extracted to
--n    Number of instances to start if you have installed the Multiple-instance Feature
--portsgiven   In Multiple-instance case if you want to give the ports manually using ports-config.xml
--lbdisable   In Multiple-instance case if you wants to disable load-balancing configuration

Unix systems programming

2010-03-13T21:13:00.003+05:30

I started to read the book, Unix systems programming, it's a great book if you are one of the people out there who like to write system software. I am enjoying reading the book.
The book also has a website of its own.

UTF-8 history

2010-03-10T21:45:00.002+05:30

I am reading the UTF-8 history. It's really a cool work invented by some cool people.

WSO2 ESB Q&A - #1

2010-03-07T12:27:00.005+05:30

I thought I'd start a series of posts about a particular question on WSO2 ESB and the answer. The source for the Q&A will be WSO2 ESB forum, mailing lists( carbon-dev, esb-user) of WSO2 ESB and other related areas. This particularly will follow like a Question and Answer format which some times can be a FAQ, a scenario which a esb user trying to implement or a question on the user mailing list. The format of the post will be as follows.

Heading: WSO2 ESB Q&A - #post-number
Question: The problem, use case of the FAQ related to WSO2 ESB
Applies to: WSO2 ESB version the Q&A applies to.
Answer: The answer to the above question.

Here goes the first one.

Question: What are the JMS message providers ( or the Java Message Oriented Middleware APIs) supports by WSO2 ESB ?

Applies To: WSO2 ESB 2.x.x, WSO2 ESB 3.x.x (release is on the way)

Answer: Following JMS providers are know to be work with WSO2 ESB.

1. Apache ActiveMQ - read more..
2. Jboss Messaging - read more..
3. IBM WebShpere MQ - read more..
4. SwiftMQ
5. RabitMQ
6. Apache Qpid

My vim configuration and color scheme

2010-03-06T22:13:00.007+05:30

I am a vim user. I use it for writing C code and editing text files. In all this time I am using a nice colour scheme for vim which let me to work hours in front of the computer screen. The colour scheme shows the key words, character strings, operators etc.. in green colour which gave me a pleasant feeling. Following is a screen shot of a C source file open with my vim configuration and the vim colour scheme. Here are my .vimrc and the vim colour scheme files. I am posting them here thinking that some one else will find it useful.

The improved WSO2 ESB management console

2010-03-01T20:00:00.008+05:30

There a lot of cool features in the upcoming WSO2 ESB 3.0.0 release. All most all of the new features are now implemented in the trunk. Another cool feature is the new, improved management console of the ESB. As a part of improving the userbility of the management console most of the editors are now improved. ProxServie UI, Endpoint UI, LocalEntry UI are few to mention. And also the management console is now equipped with a dashboard which are powered by Gadgets. Following are few screen shots of the improved user interfaces. Stay tune to experience the power of the new management console.

The improved left panel, where only the required menus items are displayed.

The enhanced proxy service editor.

The enhanced endpoint editor.

Child endpoint editors only display the most used options.

The enhanced local entry editor.

The new embedded dashboard for the WSO2 ESB.

Linear Algebra course materials from MIT

2010-02-27T20:09:00.004+05:30

I was listening to the linear algebra course by Professor Gilbert Strang of MIT in this evening. They are truly amusing.
Thanks for sharing (which gives the chance of more people to access the knowledge free of charge). If you like to donate to the OCW effort instructions are here.

WSO2 ESB now supports POX security

2010-02-26T15:30:00.007+05:30

With the fix of the CARBON-5466, WSO2 ESB now supports POX (Pure Old XML) security. This feature will be available with the upcoming Iridium based release of WSO2 ESB (version 3.0.0). If you like to try this out a public alpah2 is aviable here to download.
We'll try to add security to the echo service and try to invoke it through the web browser.
1). Go to the Service List and select echo service.

2). Go to the Service dashboard and select enable security for the echo service. And then enable UT(username token) for the echo service.

3). Select 'admin' as the group where this service can be access securely.

4). Copy the new https endpoint URL of the echo service.

5). Open your favourite web browser and type the URL as 'https://localhost:8243/services/echo/echoString' and invoke the echo service restful manner. You'll be promoted with the famous dialogue box to enter the username and the password.

Synapse config admin now supports syntax highlighting

2010-02-24T16:15:00.007+05:30

The synapse config admin component which displays the in memory synapse configuration now supports syntax highlighting. Since the synpase configuration language is XML this will be a nice feature if you manually edit the configuration using the config admin component. This feature will be available with the upcoming WSO2 ESB 3.0.0 release. Following is a screen shot of the new look.

Priority based mediation in WSO2 ESB

2010-02-23T20:26:00.003+05:30

Another exiting new feature of upcoming Iridium based release of WSO2 ESB (version 3.0.0) is priority based mediation. With this new feature you can configure WSO2 ESB to serve high priority messages more. This will also grantee that when the load is low still the low priority messages are served. Supun has written a detailed description (part1, part2) about the new priority based mediation supports in WSO2 ESB.

Experimental MSMQ transport for WSO2 ESB

2010-02-20T11:03:00.003+05:30

Some time back I wrote a MSMQ transport for WSO2 ESB. It's still in the experimental stage (meaning that the code is not released, not QAed , not much feature support). But I thought I'd put a note here about the current status so that the work won't go unnoticed.
The aim of the MSMQ transport is to connect to a MSMQ broker running on a Windows machine. Microsoft Message Queuing or MSMQ is the message queueing implementation developed by Microsoft. And it's distributed as a part of their operating system. So you can use this transport to connect to a MSMQ from WSO2 ESB.
MSMQ has a API for C/C++, so that C/C++ programs can use the broker functionality. The bride that was used which connect the Java programs to MSMQ C/C++ API is the library developed by Dino Chiesa ( This is a summary of the usage of the library).
Currently only text message are supports by the transport. I am planing to use the Camel:msmq library to bride the ESB together with MSMQ when I have some time. If you like to have a look at the code and give a try the code is here. If the things didn't work as expected, you'll need some C/C++ programming skills to get things working.
Following are two examples which shows the MSMQ transport listener and the MSMQ transport sender in action respectively.


<definitions xmlns="http://ws.apache.org/ns/synapse">
    <proxy name="SimpleStockQuoteService" transports="msmq">
        <target>
            <inSequence>
                <property action="set" name="OUT_ONLY" value="true"/>
            </inSequence>
            <endpoint>
                <address uri="http://localhost:9000/services/SimpleStockQuoteService"/>
            </endpoint>
            <outSequence>
                <send/>
            </outSequence>
        </target>
        <publishWSDL uri="file:repository/conf/sample/resources/proxy/sample_proxy_1.wsdl"/>
    </proxy>
</definitions>


<definitions xmlns="http://ws.apache.org/ns/synapse">
    <proxy name="StockQuoteProxy" transports="http">
        <target>
            <endpoint>
      <address uri="msmq:SimpleStockQuoteService"/>
            </endpoint>
            <inSequence>
                <property action="set" name="OUT_ONLY" value="true"/>
            </inSequence>
            <outSequence>
                <send/>
            </outSequence>
        </target>
        <publishWSDL uri="file:repository/conf/sample/resources/proxy/sample_proxy_1.wsdl"/>
    </proxy>
</definitions>

You'll also need to have the following configuration for MSMQ transport listener/sender in axis2.xml


<transportSender name="msmq" class="org.apache.axis2.transport.msmq.MSMQSender"/>
<transportListener name="msmq" class="org.apache.axis2.transport.msmq.MSMQListener"/>

WSO2 ESB's VFS transport now supports accessing a windows share

2010-02-10T09:35:00.005+05:30

The upcoming Iridium ( this is the code name for upcoming carbon 3.0.0 release) based release of WSO2 ESB (version 3.0.0) is now support accessing a windows share through a CIFS, which stands for Common Internet File System( such as a Samba server, or a Windows share). This feature is added into the VFS transport of WSO2 ESB.

URI Format

smb://[ username [: password ]@] hostname [: port ][ absolute-path ]

Examples

smb://somehost/home

Currently a patched version of commons-vfs is used by WSO2 ESB due to the issue reported. Following is an example configuration.


<!--
~  Licensed to the Apache Software Foundation (ASF) under one
~  or more contributor license agreements.  See the NOTICE file
~  distributed with this work for additional information
~  regarding copyright ownership.  The ASF licenses this file
~  to you under the Apache License, Version 2.0 (the
~  "License"); you may not use this file except in compliance
~  with the License.  You may obtain a copy of the License at
~
~   http://www.apache.org/licenses/LICENSE-2.0
~
~  Unless required by applicable law or agreed to in writing,
~  software distributed under the License is distributed on an
~   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
~  KIND, either express or implied.  See the License for the
~  specific language governing permissions and limitations
~  under the License.
-->

<!-- Using the  file system as transport medium using VFS transport listener and sender -->
<definitions xmlns="http://ws.apache.org/ns/synapse">
 <proxy name="StockQuoteProxy" transports="vfs">
     <parameter name="transport.vfs.FileURI">smb://host/vfs/in/test.xml</parameter> CHANGE
     <parameter name="transport.vfs.ContentType">text/xml</parameter>
     <parameter name="transport.vfs.FileNamePattern">.*\.xml</parameter>
     <parameter name="transport.PollInterval">15</parameter>
     <parameter name="transport.vfs.MoveAfterProcess">smb://host/vfs/original</parameter> CHANGE
     <parameter name="transport.vfs.MoveAfterFailure">smb://host/vfs/original</parameter> CHANGE
     <parameter name="transport.vfs.ActionAfterProcess">MOVE</parameter>
     <parameter name="transport.vfs.ActionAfterFailure">MOVE</parameter>

     <target>
         <endpoint>
             <address format="soap12" uri="http://localhost:9000/services/SimpleStockQuoteService"/>
         </endpoint>
         <outSequence>
             <property name="transport.vfs.ReplyFileName"
                       expression="fn:concat(fn:substring-after(get-property('MessageID'), 'urn:uuid:'), '.xml')" scope="transport"/>
             <property action="set" name="OUT_ONLY" value="true"/>
             <send>
                 <endpoint>
                     <address uri="vfs:smb://host/vfs/out"/> CHANGE
                 </endpoint>
             </send>
         </outSequence>
     </target>
     <publishWSDL uri="file:repository/conf/sample/resources/proxy/sample_proxy_1.wsdl"/>
 </proxy>
</definitions>

As a result of moving into the latest version of commons-vfs libraries following transport are also available in the WSO2 ESB's VFS transport.

1. FTP
2. Local file
3. HTTP and HTTPs
4. SFTP
5. Temporary Files
6. Zip, tar and jar
7. gzip, bzip2
8. res
9. ram
10. mime
11. WebDAV
12. CIFS

More information is available here.

JMS two way routing scenario with WSO2 ESB

2010-02-05T13:55:00.003+05:30

Following sample configuration shows how to use the JMS transport of WSO2 ESB in a synchronous JMS two way (request-response) scenario.


<!-- Switching from http/s to JMS -->
<definitions xmlns="http://ws.apache.org/ns/synapse">
    <proxy name="StockQuoteProxy" transports="http">
        <target>
            <endpoint>
  <address uri="jms:/SimpleStockQuoteService?transport.jms.ConnectionFactoryJNDIName=QueueConnectionFactory&java.naming.factory.initial=org.apache.activemq.jndi.ActiveMQInitialContextFactory&java.naming.provider.url=tcp://localhost:61616&transport.jms.DestinationType=queue"/>
            </endpoint>            
            <inSequence>                            
              <property action="set" name="JMS_REPLY_TO" value="dynamicQueues/ReplyQueue" scope="axis2"/>
              <property action="set" name="transport.jms.ContentTypeProperty" value="Content-Type" scope="axis2"/>
            </inSequence>
            <outSequence>
              <property action="remove" name="TRANSPORT_HEADERS" scope="axis2"/>
              <send/>
            </outSequence>
        </target>
    </proxy>
</definitions>

WSO2 Enterprise Service Bus 2.1.3 Released!

2010-02-03T11:33:00.000+05:30

The WSO2 ESB team is pleased to announce the release of version 2.1.3 of the Open Source Enterprise Service Bus (ESB). This is an enhanced and improved release of the WSO2 ESB 2.1.2 which went out on November 2009.

WSO2 ESB is a lightweight and easy-to-use Open Source Enterprise Service Bus (ESB) available under the Apache Software License v2.0. WSO2 ESB allows administrators to simply and easily configure message routing, intermediation, transformation, logging, task scheduling, load balancing, failover routing, event brokering, etc.. The runtime has been designed to be completely asynchronous, non-blocking and streaming based on the Apache Synapse core.

WSO2 ESB 2.1.3 is developed on top of the revolutionary Carbon platform (Middleware a' la carte), and is based on the OSGi framework to achieve the better modularity for your SOA architecture. This also contains a lots of new features and many other optional components to customize the behavior of the server. Further, if you do not want any of the built in features, you can uninstall those features without any trouble. In other words, this ESB can be customized to your SOA needs.

You can download this distribution from http://wso2.org/downloads/esb and give it a try.

How to Run

Extract the downloaded zip
Go to the bin directory in the extracted folder
Run the wso2server.sh or wso2server.bat as appropriate
Point your browser to the URL https://localhost:9443/carbon
Use "admin", "admin" as the username and password to login as an admin and create a user account
Assign the required permissions to the user through a role
If you need to start the OSGi console with the server use the property -DosgiConsole when starting the server. The INSTALL.txt file found on the installation directory will give you a comprehensive set of options and properties that can be passed into the startup script
Samples configurations can be started by the wso2esb-samples script passing the sample number with the -sn option, please have a look at the samples guide for more information, on running samples

New Features of WSO2 ESB 2.1.3

This ESB release is based on the award winning WSO2 Carbon "Middleware a' la carte", an OSGi based SOA platform, version 2.0.3 by WSO2 Inc.
HTTP binary relaying support for ultra fast mediation via the ESB
New mediation statistics viewer
API for accessing mediation statistics at runtime
Enhanced remote registry support
Ability to edit dynamic sequences saved in the registry from the UI editor
Rule based mediation powered by Drools
Fine grained autherization for services via the Entitlement mediator
Enhanced WS-Eventing support and Event Sources making it an even broker
Enhanced AJAX based sequence, endpoint and proxy service editors
Enhanced permission model with the user management
Enhanced REST/GET and other HTTP method support
P2 based OSGi provisioning support, for optional features like service management, runtime governance and so on..
Many bug fixes, UI enhancements and usability improvements

Key Features of WSO2 ESB

Proxy services - facilitating synchronous/asynchronous transport, interface (WSDL/Schema/Policy), message format (SOAP 1.1/1.2, POX/REST, Text, Binary), QoS (WS-Addressing/WS-Security/WS-RM) and optimization switching (MTOM/SwA).
Non-blocking HTTP/S transports based on Apache HttpCore for ultrafast execution and support for thousands of connections at high concurreny with constant memory usage.
Built in Registry/Repository, facilitating dynamic updating and reloading of the configuration and associated resources (e.g. XSLTs, XSD, WSDL, Policies, JS, Configurations ..)
Easily extendable via custom Java class (mediator and command)/Spring mediators, or BSF Scripting languages (Javascript, Ruby, Groovy, etc.)
Built in support for scheduling tasks using the Quartz scheduler.
Load-balancing (with or without sticky sessions)/Fail-over, and clustered Throttling and Caching support
WS-Security, WS-Reliable Messaging, Caching & Throttling configurable via (message/operation/service level) WS-Policies
Lightweight, XML and Web services centric messaging model
Support for industrial standards (Hessian binary web service protocol/ Financial Information eXchange protocol and optional Helth Level-7 protocol)
Enhanced support for the VFS(File/FTP/SFTP)/JMS/Mail transports with optional TCP/UDP transports and transport switching for any of the above transports
Support for message splitting & aggregation using the EIP and service callouts
Database lookup & store support with DBMediators with reusable database connection pools
WS-Eventing support with event sources and event brokering
Rule based mediation of the messages using the Drools rule engine
Transactions support via the JMS transport and Transaction mediator for database mediators
Internationalized GUI management console with user/permission management for configuration development and monitoring support with statistics, configurable logging and tracing
JMX monitoring support and JMX management capabilities like, Gracefull/Forcefull shutdown/restart

Get Involved

Help us improve this product by reporting any issues you many have: WSO2 ESB JIRA.

You can also watch how they are resolved, and comment on the progress.

Contact Us

Get in touch with the product team via the mailing lists:

Developer List : esb-java-dev@wso2.org | Subscribe | Mail Archive
User List : esb-java-user@wso2.org | Subscribe | Mail Archive

To subscribe to the above mailing lists see http://wso2.org/mail

Alternatively, questions can also be raised in the forum: http://wso2.org/forum/187

Support

For more details and to take advantage of this unique opportunity please visit http://wso2.com/support

For more information about WSO2 ESB please see http://wso2.com/products/enterprise-service-bus or visit the WSO2 Oxygen Tank developer portal for addition resources.

Thank You!
The WSO2 ESB team

Local JMS transaction support in WSO2 ESB

2010-01-25T12:35:00.006+05:30

This is another example showing the JMS local transaction support in action. In this senario a JMS message will be read from a JMS queue and a record will be added into the database. In a failure case ( for ex: the same record is avialble in the database) the transaction will be rollback and the jms message will be re-delivered to the JMS queue. I have tested the following scenario with activemq JMS provider.


<definitions xmlns:syn="http://ws.apache.org/ns/synapse">
<proxy name="StockQuoteProxy" transports="jms" startOnLoad="true">
   <target faultSequence="myFaultHandler">
       <endpoint>
           <address uri="http://localhost:9000/services/SimpleStockQuoteService"/>
       </endpoint>
       <inSequence>
           <property name="OUT_ONLY" value="true"/>
           <dbreport>
               <connection>
                   <pool>
                       <password>esb</password>
                       <user>esb</user>
                       <url>jdbc:derby://localhost:1527/esbdb;create=false</url>
                       <driver>org.apache.derby.jdbc.ClientDriver</driver>
                   </pool>
               </connection>
               <statement>
                   <sql>INSERT into company values ('MSFT','c1',0.0)</sql>
               </statement>
           </dbreport>
       </inSequence>
       <outSequence>
           <send/>
       </outSequence>
   </target>
   <publishWSDL uri="file:repository/samples/resources/proxy/sample_proxy_1.wsdl"/>
   <parameter name="transport.jms.ContentType">
       <rules xmlns="http://ws.apache.org/ns/synapse">
           <jmsProperty>contentType</jmsProperty>
           <default>application/xml</default>
       </rules>
   </parameter>
</proxy>
<sequence name="myFaultHandler">
   <makefault version="soap11">
       <code xmlns:tns="http://www.w3.org/2003/05/soap-envelope" value="tns:Receiver"/>
       <reason expression="get-property('ERROR_MESSAGE')"/>
   </makefault>
   <property name="SET_ROLLBACK_ONLY" value="true" scope="axis2"/>
</sequence>
<sequence name="fault">
   <log level="full">
       <property name="MESSAGE" value="Executing default "fault" sequence"/>
       <property name="ERROR_CODE" expression="get-property('ERROR_CODE')"/>
       <property name="ERROR_MESSAGE" expression="get-property('ERROR_MESSAGE')"/>
   </log>
   <drop/>
</sequence>
<sequence name="main">
   <log/>
   <drop/>
</sequence>
</definitions>

You can note how the transaction is rollback if a failure occurs in the fault sequence.
You can test the sample very similar to sample #250, in the ESB documentation.

You also need to configure the JMS transport receiver(in axis2.xml) to participate in the local JMS transaction with the transport.jms.SessionTransacted property set to true which gives the following configuration (Note that there is a bug which need to fix to get this working).


<transportReceiver name='jms' class='org.apache.axis2.transport.jms.JMSListener'>
<parameter name='default' locked='false'>
     <parameter name='java.naming.factory.initial' locked='false'>org.apache.activemq.jndi.ActiveMQInitialContextFactory</parameter>
     <parameter name='java.naming.provider.url' locked='false'>tcp://localhost:61616</parameter>
     <parameter name='transport.jms.ConnectionFactoryJNDIName' locked='false'>QueueConnectionFactory</parameter>
<parameter name='transport.jms.ConnectionFactoryType' locked='false'>queue</parameter>
<parameter name='transport.jms.SessionTransacted' locked='false'>true</parameter>
    </parameter>
</transportReceiver>

WSO2 ESB endpoint timeout, retry and suspend related configuration

2010-01-23T00:33:00.006+05:30

Update: I just submitted a patch to Synapse to rename the action element name to responseAction in timeout configuration to give a more meaningful name to the element.
It seems that timeout, retry and the suspend related configuration of WSO2 ESB bit messy. So I just post the configuration here for information. Also note that the suspenDurationOnFailure element is there for backward compatibility with Synpase 1.2.
Supun also has written an article on oxygen tank which you can read for more information.


<timeout>
   <duration>time in millisecond(default is 60s, the nHttp time out)</duration>
   <action>discard|fault</action>
</timeout>

<markForSuspension>
   <errorCodes>the comma seprated error codes</errorCodes>
   <retriesBeforeSuspension>integer</retriesBeforeSuspension>
   <retryDelay>delay between each retry in milliseconds </retryDelay>
</markForSuspension>

<suspendOnFailure>
   <errorCodes>the comma seprated error codes</errorCodes>
   <initialDuration>initial duration to suspend the endpoint in milisecond</intialDuration>
   <progressionFactor></progressionFactor>
   <maximumDuration>maximum duration to suspend the endpoint in milisecond</maximumDuration>
</suspendOnFailure>

If you have specified the suspenDurationOnFailure only the duration will consider as the initial duration and the progression factor is default to 1.0(float). If you have specified both suspenDurationOnFailure and suspendOnFailure both elements the values in suspenDurationOnFailure will be override by the values of suspendOnFailure.

More distributed JMS transaction examples

2010-01-18T21:14:00.005+05:30

This is another example of WSO2 ESB JMS distributed transaction support. In this scenario a record will be delete from a database and will add that to a JMS queue. In failure case no record will be deleted from the database and no record is added to the JMS queue. This also requires that you deploy WSO2 ESB on JBoss application server.


<definitions xmlns:syn="http://ws.apache.org/ns/synapse">
   <proxy name="StockQuoteProxy" transports="http" startOnLoad="true">
       <target>
           <inSequence>
               <property name="OUT_ONLY" value="true"/>
               <transaction action="new"/>
               <log level="custom">
                   <property name="text" value="** Start the Transaction**"/>
               </log>
               <dbreport useTransaction="true">
                   <connection>
                       <pool>
                           <password>esb</password>
                           <user>esb</user>
                           <dsName>java:jdbc/XADerbyDS</dsName>
                           <url>localhost:1099</url>
                           <icClass>org.jnp.interfaces.NamingContextFactory</icClass>
                       </pool>
                   </connection>
                   <statement>
                       <sql>insert into company values('IBM','c1',56)</sql>
                   </statement>
               </dbreport>
               <send>
                   <endpoint>
                       <address uri="jms:/SimpleStockQuoteService?transport.jms.ConnectionFactoryJNDIName=QueueConnectionFactory&java.naming.factory.initial=org.apache.activemq.jndi.ActiveMQInitialContextFactory&java.naming.provider.url=tcp://localhost:61616&transport.jms.DestinationType=queue"/>
                   </endpoint>
               </send>
               <transaction action="commit"/>
               <log level="custom">
                   <property name="text" value="** Commit the Transaction**"/>
               </log>
           </inSequence>
           <outSequence>
               <send/>
           </outSequence>
           <faultSequence>
               <log level="custom">
                   <property name="text" value="** Rollback the Transaction**"/>
               </log>
               <transaction action="rollback"/>
           </faultSequence>
       </target>
       <publishWSDL uri="file:/home/rajika/work/tx/esb/repository/samples/resources/proxy/sample_proxy_1.wsdl"/>
   </proxy>
   <sequence name="fault">
       <log level="full">
           <property name="MESSAGE" value="Executing default "fault" sequence"/>
           <property name="ERROR_CODE" expression="get-property('ERROR_CODE')"/>
           <property name="ERROR_MESSAGE" expression="get-property('ERROR_MESSAGE')"/>
       </log>
       <drop/>
   </sequence>
</definitions>

Help finding information of missing people in Haiti earthquake

2010-01-17T10:55:00.004+05:30

If you like to embed this gadget in your website information available here.

Regular expression theories

2010-01-12T06:52:00.004+05:30

I found these articles really interested in reading by Russ Cox. He clearly explains how Ken Thompson's NFA based regular expression engine is faster than that of the Perl's one. Thanks for the great article.

JavaCC parser rule file for simple-java programming language

2010-01-10T21:55:00.007+05:30

I just wrote a JavaCC parser rule file( sjava.jj) for simple-java (which basically a subset of Java programming language). I'll write a hand code parser for the same language when I have some time.


options {
IGNORE_CASE = true;
}

PARSER_BEGIN(sjava)

public class sjava {

}

PARSER_END(sjava)

SKIP:
{
<" ">
|   <"\n">
|   <"\t">
|   <"//"(~["\n"])*"\n">
}

SKIP:
{
<"/*">:IN_COMMENT
}

<IN_COMMENT>
SKIP:
{
<"*/">:DEFAULT
|   <"/*">:NESTTED_IN_COMMENT
|   <~[]>
}

<NESTTED_IN_COMMENT>
SKIP:
{
<"*/">:IN_COMMENT
|   <~[]>
}

TOKEN: /* Resrved word*/
{
<ELSE: "else">
|   <FOR: "for">
|   <WHILE:"while">
|   <RETURN:"return">
|   <CLASS:"class">
|   <DO:"do">
|   <FALSE:"false">
|   <TRUE:"true">
|   <IF:"if">
}

TOKEN: /* Integer Literals */
{
<INTEGER_LITERAL: (["0"-"9"])+>
}

TOKEN: /* Identifiers */
{
<IDENTIFIER: ["a"-"z","_"](["a"-"z","0"-"9"])*>
}

TOKEN: /* Symbols*/
{
<PLUS: "+">
|   <MINUS:"-">
|   <MULTIPLY:"*">
|   <DIVIDE:"/">
|   <EQUAL:"==">
|   <GREATER_THAN:">">
|   <NOT:"!">
|   <LEFT_BRACE:"{">
|   <LEFT_BRACKET:"[">
|   <RIGHT_BRACKET:"]">
|   <PERIOD:".">
|   <COMMA:",">
|   <GREATER_THAN_OR_EQUEAL:">=">
|   <SEMICOLON:";">
|   <AND:"&&">
|   <RIGHT_BRACE:"}">
|   <LEFT_PARENTHESIS:"(">
|   <RIGHT_PARAENTHESIS:")">
|   <NOT_EQUAL:"!=">
|   <LESS_THAN_OR_EQUEAL:"<=">
|   <LESS_THAN:"<">
|   <GETS:"=">
|   <OR:"||">
}

The enhanced JMS transport

2010-01-10T10:05:00.001+05:30

The WS-Commond JMS transport which powered the WSO2 ESB JMS transport has several advance configuration options for local JMS transactions and JTA transactions. It seems the documentation is missing, so I just put the configuration options here for your information.


<transportReceiver name="jms" class="org.apache.axis2.transport.jms.JMSListener">
<parameter name="myTopicConnectionFactory">
<parameter name="java.naming.factory.initial">org.apache.activemq.jndi.ActiveMQInitialContextFactory</parameter>
<parameter name="java.naming.provider.url">tcp://localhost:61616</parameter>
<parameter name="transport.jms.ConnectionFactoryJNDIName">TopicConnectionFactory</parameter>
<parameter name="transport.jms.ConnectionFactoryType">topic</parameter>
<parameter name="transport.jms.JMSSpecVersion">1.0.2b</parameter>
</parameter>

<parameter name="myQueueConnectionFactory">
<parameter name="java.naming.factory.initial">org.apache.activemq.jndi.ActiveMQInitialContextFactory</parameter>
<parameter name="java.naming.provider.url">tcp://localhost:61616</parameter>
<parameter name="transport.jms.ConnectionFactoryJNDIName">QueueConnectionFactory</parameter>
<parameter name="transport.jms.ConnectionFactoryType">queue</parameter>
<parameter name="transport.jms.JMSSpecVersion">1.1</parameter>
</parameter>

<parameter name="default">
<parameter name="java.naming.factory.initial">org.apache.activemq.jndi.ActiveMQInitialContextFactory</parameter>
<parameter name="java.naming.provider.url">tcp://localhost:61616</parameter>
<parameter name="transport.jms.ConnectionFactoryJNDIName">ConnectionFactory</parameter>
</parameter>
</transportReceiver>

<transportSender name="jms" class="org.apache.axis2.transport.jms.JMSSender">
<parameter name="myTopicConnectionFactory">
<parameter name="java.naming.factory.initial">org.apache.activemq.jndi.ActiveMQInitialContextFactory</parameter>
<parameter name="java.naming.provider.url">tcp://localhost:61616</parameter>
<parameter name="transport.jms.ConnectionFactoryJNDIName">TopicConnectionFactory</parameter>
<parameter name="transport.jms.JMSSpecVersion">1.0.2b</parameter>
<parameter name="transport.jms.CacheLevel">producer</parameter>
</parameter>

<parameter name="myQueueConnectionFactory">
<parameter name="java.naming.factory.initial">org.apache.activemq.jndi.ActiveMQInitialContextFactory</parameter>
<parameter name="java.naming.provider.url">tcp://localhost:61616</parameter>
<parameter name="transport.jms.ConnectionFactoryJNDIName">QueueConnectionFactory</parameter>
<parameter name="transport.jms.JMSSpecVersion">1.0.2b</parameter>
<parameter name="transport.jms.CacheLevel">producer</parameter>
</parameter>

<parameter name="default">
<parameter name="java.naming.factory.initial">org.apache.activemq.jndi.ActiveMQInitialContextFactory</parameter>
<parameter name="java.naming.provider.url">tcp://localhost:61616</parameter>
<parameter name="transport.jms.ConnectionFactoryJNDIName">ConnectionFactory</parameter>
<parameter name="transport.jms.CacheLevel">connection</parameter>
</parameter>
</transportSender>

The Transport Listener and Sender both allows the user to configure one or more logical JMS Connection Factories, which are named definitions as shown above. Any remaining parameters maybe defined at the service level via the services.xml. The applicable set of parameters for a service would be the union of the properties from the services.xml and the corresponding logical connection factory. A description of the each of the additional configuration options available in the following table.

Transport level			Listening	Sending
JNDI	java.naming.factory.initial	The JNDI InitialContext factory class	Required
	java.naming.provider.url	JNDI Provider URL	Required
	java.naming.security.principal	Username for JNDI access
	java.naming.security.credentials	Password for JNDI access
Transactions	transport.Transactionality	Desired transactionality. One of none /local / jta	Defaults to none
	transport.UserTxnJNDIName	JNDI name to be used to obtain a UserTransaction	Defaults to "java:comp/UserTransaction"
	transport.CacheUserTxn	Generally its safe and more efficient to cache the UserTransaction reference from JNDI. One of true/ false	Defaults to true
	transport.jms.SessionTransacted	Should the JMS Session be transacted. One of true/ false	Defaults to true when local transactions are used
	transport.jms.SessionAcknowledgement	JMS Session acknowledgement mode to be used. One of AUTO_ACKNOWLEDGE \| CLIENT_ACKNOWLEDGE \| DUPS_OK_ACKNOWLEDGE \|SESSION_TRANSACTED	Defaults to AUTO_ACKNOWLEDGE
Connection	transport.jms.ConnectionFactory	Name of the logical connection factory this service will use	Defaults to "default"
	transport.jms.ConnectionFactoryJNDIName	The JNDI name of the JMS ConnectionFactory	Required
	transport.jms.ConnectionFactoryType	Type of ConnectionFactory – queue / topic	Suggested to be specified
	transport.jms.JMSSpecVersion	JMS API Version One of "1.1" or "1.0.2b"	Defaults to 1.1
	transport.jms.UserName	The JMS connection username
	transport.jms.Password	The JMS connection password
Destinations	transport.jms.Destination	JNDI Name of the Destination	Defaults to Service name
	transport.jms.DestinationType	Type of Destination – queue / topic	Defaults to a queue
	transport.jms.DefaultReplyDestination	JNDI Name of the default reply Destination
	transport.jms.DefaultReplyDestinationType	Type of the reply Destination – queue / topic	Same type as of Destination
Advanced	transport.jms.MessageSelector	Optional message selector to be applied
	transport.jms.SubscriptionDurable	Is the subscription durable? (For Topics) – true / false	Defaults to false
	transport.jms.DurableSubscriberName	Name to be used for the durable subscription	Required when subscription is durable
	transport.jms.PubSubNoLocal	Should messages published by the same connection (for Topics)be received? – true / false	Defaults to false
	transport.jms.CacheLevel	The JMS resource cache level. One of none / connection / session /consumer / producer / auto	Defaults to auto
	transport.jms.ReceiveTimeout	Time to wait for a JMS message during polling. Negative means wait forever, while 0 means do not wait at all. Anything else, is a millisecond value for the poll	Defaults to 1000ms
	transport.jms.ConcurrentConsumers	Number of concurrent consumer tasks (~threads) to be started to poll for messages for this service. For Topics, this should be always 1, to prevent the same message being processed multiple times	Defaults to 1
	transport.jms.MaxConcurrentConsumers	Will dynamically scale the number of concurrent consumer tasks(~threads) until this value; as the load increases. Should always be 1 for Topics.	Defaults to 1
	transport.jms.IdleTaskLimit	The number of idle (i.e. poll without receipt of a message) runs per task, before it dies – to recycle resources, and to allow dynamic scale down.	Defaults to 10
	transport.jms.MaxMessagesPerTask	The maximum number of successful message receipts to limit per Task lifetime.	Defaults to –1 which implies unlimited messages
Reconnection	transport.jms.InitialReconnectDuration	Initial reconnection attempt duration	Defaults to 10,000ms
	transport.jms.ReconnectProgressFactor	Factor used to compute consecutive reconnection attempt durations, in a geometric series	Defaults to 2 (i.e. exponential)
	transport.jms.MaxReconnectDuration	Maximum limit for a reconnection duration	Defaults to 1 hour
	transport.jms.PublishEPR	One or more JMS URL's to be showed as the JMSEPRs on the WSDL or the service. Allows the specification of a custom EPR, and/or hiding of internal properties from a public EPR (e.g.credentials). Add one as LEGACY to retain auto generated EPR, when adding new EPRs

Legacy Mode and Payload handling	Wrapper	Binary and Text payload wrapper element to be specified as "{ns}name" where ns refers to a namespace and name the name of the element	Default binary wrapper {http://ws.apache.org/commons/ns/payload}binary Default text wrapper {http://ws.apache.org/commons/ns/payload}text
	Operation	operation name to be specified as "{ns}name" where ns refers to the namespace and name the name of the operation	Defaults to urn:mediate

Compiling, running LLVM, llvm-gcc and running the llvm nightly tester

2009-12-30T22:42:00.001+05:30

This is about how to compile and run Low Level Virtual machine(LLVM). And also there will be a description how to run the LLVM nightly tester.

First LLVM comes with two pieces.
1. LLVM suite - This contains all the tools, libraries and header files needed
to use the low level virtual machine. It contains an assembler, disassembler,
bitcode analyzer and bit code optimizer. It also contains a test suite which
can use to test LLVM tools and the GCC front end.

2. GCC front end - This provides a version of GCC which compiles C/C++ into
LLVM bitcode.

There is a third, optional piece called llvm-test. It's a suite of program
which can use to further test LLVM.

Machine configuration and the software required.
1, Fedora Core 11 -kernel version 2.6.30.9-96.fc11.x86_64
2. GCC version - 4.4.1
3. The standard gun tool chain for building C/C++ sources.

Conventions.
SRC_ROOT - The main LLVM source location in the file system.
SRC_LLVM_GCC - The llvm-gcc source location in the file system.

Building LLVM, LLVM-gcc and running the test suite

1). Check out the LLVM source from the trunk.


svn co http://llvm.org/svn/llvm-project/llvm/trunk llvm

2). If you like to get the LLVM test suite check it out from the trunk


cd llvm/projects.
svn co http://llvm.org/svn/llvm-project/test-suite/trunk llvm-test

By placing this inside llvm project folder, it'll be automatically configured and will be update when you update the working copy using svn up.

3). Check out llvm-gcc from the trunk


svn co http://llvm.org/svn/llvm-project/llvm-gcc-4.2/trunk dst-directory

4). Configuring the LLVM build. Create an object folder,
ex, llvm-object.


cd llvm-objects
SRC_ROOT/configure --prefix=/install/path [other options]

Run the configure script located in the main LLVM source tree.

5). After configuring you can compile the LLVM build. There are three types of builds.

a). Debug build - Compile libraries and tools with debug info. The default build
of th trunk. Pass --disable-optimized option to configure script or ENABLE_OPTIMIZED=0 to the make command below to get a
debug build. ex:
SRC_ROOT/configure --prefix=/home/rajika/projects/llvm/llvm-objects --disable-optimized

b). Release (Optimize) build - The build will comple the tools and the
libraries without debug info. You need to pass --enable-optimized option to
the configure script or ENABLE_OPTIMIZED=1 to the make command(below) when compiling, to get a release build.

c). Profile build - These builds are for use with profiling. So that the code
can be profile using a profiling tool such as gprof. This can be started by
specifying ENABLE_PROFILING=1 on the make command below.

5). Compiling the LLVM source. Issue make command while in the llvm-objects
folder to compile the LLVM source tree.


make

Note that various options can be passed into make command to override the
default values given by configure script.
make ENABLE_OPTIMIZED=1 - Perform a release build.
make ENABLE_OPTIMIZED=1 DISABLE_ASSERTIONS=1 - Perform a release build without assertions enabled.
make ENABLE_OPTIMIZED=0 - Perform a debug build.

6). Configuring and building llvm-gcc. Create an object folder for llvm-gcc
objects, ex: dst-directory-objects.


cd dst-directory-objects
SRC_LLVM_GCC/configure --prefix=/home/rajika/projects/llvm/dst-directory-objects --enable-languages=c --enable-checking --enable-llvm=/home/rajika/projects/llvm/llvm-objects
--disable-bootstrap --disable-multilib --program-prefix=llvm-

where SRC_LLVM_GCC stands for the source tree location of the llvm-gcc.

7). Build and install the compiler.


make
make install

8). Re-build and install llvm(Remember last time we didn't configure with llvm-gcc).


SRC_ROOT/configure --prefix=/home/rajika/projects/llvm/llvm-objects --disable-optimized --with-llvmgccdir=/home/rajika/projects/llvm/dst-directory-objects
make
make install

You'll need to add the binray directories of the LLVM and llvm-gcc to PATH enviornment varible so that you can access the binraries from any where.
At this point you can test a sample program using llvm tool chains to see how the installation works.

9). Running the test suite.
The LLVM test suite consits of two parts.

a). Code fragments - This is refered to as DejaGNU test and live in llvm/test folder. These are small code fragments that specify a feature of LLVM or trigger a bug in LLVM.

b). Whole program - This is refered to as "Test suite" and are in the test-suite module in subversion. Once check out it lives in the llvm/project/llvm-test folder. These are whole programs which can compile and link to a stand-alone program that can be executed.

10). Running DejaGNU test. Go to the llvm-object directory. And run the DejaGNU test.


make check

11). Running the llvm-test test suite. Go to the llvm-object folder.


cd llvm-objects/projects/llvm-test (The LLVM object location)
make (or make TEST=nightly report report.html , if you like to run the nightly test and to generate the report)

References:
1. http://llvm.org/docs/GettingStarted.html
2. http://llvm.org/docs/GCCFEBuildInstrs.html
3. http://llvm.org/docs/TestingGuide.html

DBLookup mediator now support looking up multiple entries

2009-12-27T15:23:00.000+05:30

I just submitted a patch for Apache synapse, which will help to retrieve more than one entry from a database using DBLookup mediator. I have added a new attribute(optional) for result element which can use to specify the row that you want to retrieve. Following are few examples of the new configuration.


<dblookup>
   <connection>
       <pool>
           <driver>org.apache.derby.jdbc.ClientDriver</driver>
           <url>jdbc:derby://localhost:1527/esbdb;user=esb;password=esb</url>
           <user>esb</user>
           <password>esb</password>
       </pool>
   </connection>
   <statement>
       <sql>select * from company where name =?</sql>
       <parameter expression="//m0:getQuote/m0:request/m0:symbol"
                  xmlns:m0="http://services.samples" type="VARCHAR"/>
       <result name="company_id" column="id"/>
       <result name="company_price_0" column="price" rowIndex="2"/>
       <result name="company_price_1" column="price" rowIndex="4"/>
   </statement>
</dblookup>

Getting start with development of WSO2 ESB and Carbon

2009-12-12T18:44:00.000+05:30

In time to time I see some users ask how to get start with the development of WSO2 ESB. This post carry out some points which will help them.
WSO2 ESB and it's dependent sub projects have developed in Java programming language. So it's assume that you have some Java programming experience. If you are new to Java you can refer one of the good books available in the market. And also you'll also need some understanding on build tools such as ant, maven and version control systems such as subversion. If you new to these things I'd recommend you the following online tutorials.

1. ant - Apache ant tutorial
2. maven - Apache maven tutorial
3. subversion - The subversion tutorial

WSO2 ESB is depend on two things. First it depeneds on Apache synase, the lightweight enterprise service bus from Apache and also it depends on WSO2 Carbon. The ESB capabilities are given by Apache synapse and the compartmentalize architecture is given by Carbon. It is important that you have some understanding on these. So start with following.

1. Apache synapse articles -
- http://wso2.org/library/2559
- http://wso2.org/library/3422
2. WSO2 carbon articles :
- http://wso2.org/library/articles/getting-started-wso2-carbon
- http://wso2.org/library/articles/stuff-works-wso2-carbon

While reading about synapse and carbon next thing you can do is to get your hand dirty with the source code. So check out the latests sources from the subversion and build them your self. WSO2 ESB depend on number of other project so you need to build them to build WSO2 ESB. So check out each of the following source and issue the following command to build each and every project.


mvn clean install -Dmaven.test.skip=true

When you are building carbon-component project ( project h.) below) build only the ESB specific components. Because it contains all the components which are used by other product as well.


mvn clean install -Dmaven.test.skip=true -Dproduct=esb

a). https://svn.apache.org/repos/asf/webservices/axis2/trunk/java
b). https://svn.apache.org/repos/asf/webservices/commons/trunk/modules/transport
c). https://svn.apache.org/repos/asf/webservices/rampart/trunk/java
d). http://svn.apache.org/repos/asf/webservices/sandesha/trunk/java
e). https://svn.apache.org/repos/asf/synapse/trunk/java
f). https://wso2.org/repos/wso2/trunk/carbon-orbit
g). https://wso2.org/repos/wso2/trunk/carbon
h). https://wso2.org/repos/wso2/trunk/carbon-components
i). https://wso2.org/repos/wso2/trunk/esb/java

Basically ESB is a collection of carbon-components. So actually most of the time you'll be fixing issues in carbon components. So just create the project files for carbon-components either for eclispe or InteliJ IDEA using the following command.


mvn idea:idea or mvn eclispe:eclipse

Now you can open the project using your faviorite IDE and start developments of WSO2 ESB. To understand how a carbon-component is written you can look into one of the many carbon-components available(they all are written in the same way following the same pattern). Just browse through carbon JIRAs where all the currently reported bugs can be found and try to fix them. I'd suggest with low priority one because that will help you to start with the work. If you have any question just ask on the carbon-dev mailing list, or if you need to discuss something related to architecture just send an email to aritecture@wso2.org (both requires you to subscribe before posting).

Happy hacking.Good luck!

WSO2 ESB on IBM JDK (J9)

2009-11-27T07:30:00.000+05:30

From the version 2.1.2(based on carbon version 2.0.2) onwards WSO2 ESB fully support running on IBM JDK(J9). Just add the following parameter to $ESB_HOME/conf/transports.xml under https to run it on IBM JDK.


<parameter name="algorithm">IBMX509</parameter>

Embedding spider monkey in C/C++ application

2009-11-18T08:15:00.000+05:30

I have used Spilder moneky (the javascript C engine) within axis2/c. Here I am posting an example which let's you to embed Spider monkey in your C/C++ application. Note that it also has an error handler which will report the compilation errors of the script.
To compile the source you need to build Spider monkey and need to have the required headers.


gcc -I/usr/include/smjs/* -L/usr/lib test-js.c  -DXP_UNIX -ljs


#include 
#include 
#include  

JSClass js_global_object_class = {
    "global",
    0,
    JS_PropertyStub,
    JS_PropertyStub,
    JS_PropertyStub,
    JS_PropertyStub,
    JS_EnumerateStub,
    JS_ResolveStub,
    JS_ConvertStub,
    JS_FinalizeStub,
    JSCLASS_NO_OPTIONAL_MEMBERS
}; 

void js_xml_msg_recv_error_handler(
        JSContext *ctx,
        const char *msg,
        JSErrorReport *er);

char* js_xml_msg_recv_invoke_wsmsg(
  const char *script,
  const char *op_name);

int main()
{
 js_xml_msg_recv_invoke_wsmsg("./test.js","test");
}

char* js_xml_msg_recv_invoke_wsmsg(
        const char *script,
        const char *op_name)
{
   
    JSRuntime *rt = NULL;
    JSContext *cx = NULL;
    JSObject *obj = NULL;
    jsval rval;
    JSString *str = NULL;
    JSBool ok;
    JSBool sucess;
    FILE *file = NULL;
    JSScript *string = NULL;
    jsval arg[1];
    JSString *jsstring = NULL;
    char *pay_load = NULL;
    char *result_string = NULL;

    rt = JS_NewRuntime(8L * 1024L * 1024L);
    if(!rt){
        fprintf(stderr,"[js] failed to initialize JS Runtime");
        return NULL;
    }
    cx = JS_NewContext(rt, 8L * 1024L * 1024L);
    if(!cx){
        fprintf(stderr, "[js] failed to initialize JS Context");
        JS_DestroyRuntime(rt);
        return NULL;
    }
    JS_SetErrorReporter(cx, js_xml_msg_recv_error_handler);
    obj = JS_NewObject(cx, &js_global_object_class, NULL, NULL);
    if(!obj){
        fprintf(stderr, "[js] failed to create global object");
        JS_DestroyContext(cx);
        JS_DestroyRuntime(rt);
        return NULL;
    }
    JS_InitStandardClasses(cx, obj);
    if(script){
        file = fopen(script, "r"); 
        if(file == NULL){   /* TODO, may be need to set service not found error?*/
            fprintf(stderr, "[js] can not open script file");
            return NULL;
        }
        string = JS_CompileFile(cx, obj, script);
        if(string == NULL){
            fprintf(stderr, "[js] failed to compile the script");
            return NULL;
        }
        sucess = JS_ExecuteScript(cx, obj, string, &rval);
        if(sucess == JS_FALSE){
            fprintf(stderr, "[js] failed to execute the script");
            return NULL;
        }
        pay_load = "hello world!"; 
        if(pay_load == NULL){
            fprintf(stderr, "[js] pay load not set");
            return NULL;
        }
        jsstring = JS_NewStringCopyN(cx, pay_load, strlen(pay_load));
        if(jsstring == NULL){
            fprintf(stderr, "[js] failed to copy the execution string");
            return NULL;
        }
        arg[0] = STRING_TO_JSVAL(jsstring);
        if(sucess == JS_TRUE){
            ok = JS_CallFunctionName(cx, obj, op_name, 1, arg, &rval); /* check to see weather
                                                                                   operation not found*/
            if(ok == JS_FALSE){
                fprintf(stderr, "[js] operation not  found");
                return NULL;
            }
            str = JS_ValueToString(cx, rval);
            result_string = JS_GetStringBytes(str); 
   printf("Result: %s\n", result_string);
        }
        
    }
    JS_DestroyContext(cx);
    JS_DestroyRuntime(rt);
 return result_string;
}

void js_xml_msg_recv_error_handler(
            JSContext *ctx,
            const char *msg,
            JSErrorReport *er)
{
    char *ptr = NULL;
    char *line = NULL;
    int len;
    if(er->linebuf != NULL){
        len = er->tokenptr - er->linebuf + 1;
        ptr = (char *)malloc(len);
        memset(ptr, '-', len);
        ptr[len - 1] = '\0';
        ptr[len - 2] = '^';
        len = strlen(er->linebuf) + 1;
        line = (char *)malloc(len);
        strncpy(line, er->linebuf, len);
        line[len - 1] = '\0';
    }
    else{
        len = 0;
        ptr = (char *)malloc(1);
        line = (char *)malloc(1);
        ptr[0] = '\0';
        line[0] = '\0';
    }
    while(len > 0 && (line[len - 1] == '\r' || line[len - 1] == '\n')){
        line[len- 1] = '\0';
        len--;
    }
    fprintf(stderr,"JS Eror : %s\n File:%s:%u\n", msg, er->filename, er->lineno);
    if(line[0]){
        fprintf(stderr,"%s\n%s\n", line, ptr);
    }
    free(ptr);
    free(line);
}

The java script example


function test(payload){
 var x  = "<note><date>2002-08-01</date><to>Tove</to><from>Jani</from><heading>Reminder</heading><body>Don't forget me this weekend!</body></note>";
 var note = new XML(x);
 return note.date;
}

Javascript binding for Axis2/C server side

2009-11-15T19:06:00.000+05:30

Some time back I wrote a small message receiver which embedded the Spider monkey(which is the Javascript engine of the firefox web browser) to Axis2/C server side. This let you to write Web services in Javascript and deploy them in Axis2/C. When developing web services in Javascript E4X support is used with an XML in/out model. When I have some time I am planning to plug other popular javascript engines such as V8, Tracemonkey so the one can choose the engine at compile time. I just re-compiled the message receiver with the Axis2/C trunk. These are the updated steps.

1.Compile and installed the Spider monkey- Javascript C engine.
Refer here: http://developer.mozilla.org/en/SpiderMonkey_Build_Documentation.
I placed all the header files in src and Linux_All_DBG.OBJ folders(after building the JS engine) into /usr/include/smjs(created by myself) and the libjs.so into /usr/lib folders.

2. Place the js_xml_in_out_msg_recv.c, axis2_js_common.h and Makefile.am inside /src/core/receivers/ [2].

3. Compile and install axis2/c.

4. Compile the sample client echojs.c. You can use the build.sh file for this[2].

5. Create a folder called echojs under deploy/services directory and place the services.xml and the echojs.js file inside that[2].

6. Add the following entry to the services.xml, put the path of test.js here
Put the script path to the value of Script parameter.


< name="script">/home/rajika/projects/axis2c/c/deploy/services/echojs/echojs.js

Just drop the services.xml in [2].

7. Invoke the sample client in step 4 using ./echojs. If you run into shared libraray problems try exporting LD_LIBRARY_PATH to libjs.so location

References:

[1] - http://en.wikipedia.org/wiki/E4X
[2] - https://wso2.org/repos/wso2/people/rajika/axis2-js-binding/

Using WSO2 ESB with Informix database server

2009-09-13T11:38:00.000+05:30

Informix is a very stable, solid database server from IBM. This post describe how to use it with WSO2 ESB.
You need to install the Informix JDBC driver. Just download it from here. Just run the installer and install the driver to a place of your choice( let that location be $INFORMIX_JDBC).
Now copy the jars in $INFORMIX_JDBC/lib to $ESB_HOME/repository/components/extensions/ folder. You'll need to use the username and the password which was given when creating the IBM IDS in the conection properties in the synapse configuration. You can use the same set up as sample #361 with the following configuration to run the sample.


<definitions xmlns="http://ws.apache.org/ns/synapse">
    <sequence name="main">
        <in>
            <send>
                <endpoint>
                    <address uri="http://localhost:9000/services/SimpleStockQuoteService"/>
                </endpoint>
            </send>
        </in>

        <out>
            <log level="custom">
                <property name="text"
                          value="** Reporting to the Database **"/>
            </log>
            <dbreport>
                <connection>
                    <pool>
                        <driver>com.informix.jdbc.IfxDriver</driver>
                        <url>jdbc:informix-sqli://localhost:1533/testDB:informixserver=server1;user=informix;password=test123</url>
                        <user>informix</user>
                        <password>test123</password>
                    </pool>
                </connection>
                <statement>
                    <sql>update company set price=? where name=?</sql>
                    <!--<sql>delete from company where name=?</sql>-->
                    <parameter expression="//m0:return/m1:last/child::text()"
                               xmlns:m0="http://services.samples" xmlns:m1="http://services.samples/xsd"  type="FLOAT"/>
                    <parameter expression="//m0:return/m1:symbol/child::text()"
                               xmlns:m0="http://services.samples" xmlns:m1="http://services.samples/xsd"  type="VARCHAR"/>
                </statement>
            </dbreport>
            <send/>
        </out>
    </sequence>
</definitions>

Java Transaction Processing

2009-08-31T17:57:00.000+05:30

In last couple of days I was trying to get the transaction mediator and the JMS transport transaction working in WSO2 ESB. After some work I was able to get them working, still some work are left.
I was fairly new to transactions, so I bought the book Java Transaction Processing and referred in my work. That's a very good book, in which everything are into the point. This book has two complete samples describing the concepts in chapter 4 and 5. You can download them book's website. Authors have given instructions to run them in Oracle Application server and database. I just tried them on JBoss Application server (version 5.0.1 GA). Following the instruction to run them in JBOSSAS.

Step1
To compile the sample webapp you need to set the J2EE_HOME into $JBOSS_HOME on the top of common.xml and add the following jars to compile the source files.


<?xml version="1.0" encoding="iso-8859-1"?>

<!-- The envirnmnet attribute only works on certains operatin systems.

hence you may have to hard code the J2EE_HOME and JAVA_HOME

location in this file.-->

<property environment="env"/>

<property name="JAVA_HOME" value="${env.JAVA_HOME}"/>



<property name="J2EE_HOME" value="/home/rajika/installtion/jboss/jboss-5.1.0.GA"/>





<path id="common.class.path">

<pathelement location="."/>

<pathelement location="${J2EE_HOME}/client/jboss-logging-jdk.jar"/>

<pathelement location="${J2EE_HOME}/client/jboss-logging-log4j.jar"/>

<pathelement location="${J2EE_HOME}/client/jboss-logging-spi.jar"/>

<pathelement location="${J2EE_HOME}/client/jboss-mdr.jar"/>

<pathelement location="${J2EE_HOME}/client/jboss-messaging-client.jar"/>

<pathelement location="${J2EE_HOME}/client/jboss-javaee.jar"/>

<pathelement location="${J2EE_HOME}/common/lib/servlet-api.jar"/>

<pathelement location="./build" />

</path>

<property name="common.class.path" refid="common.class.path"/>



<target name="common">

<echo message="BuildName: ${ant.project.name}" />

<echo message="BuildHome: ${basedir}" />

<echo message="BuildFile: ${ant.file}" />

<echo message="BuildJVM: ${ant.java.version}" />

</target>

Then you can compile using the default ant command.

Step 2
Samples need to have two databases available and two XA-data sources which can be used to connect to those two database. I used derby as the database. Following are the two xa-datasource decelerations.


<?xml version="1.0" encoding="UTF-8"?>

<datasources>
 <xa-datasource>
     <jndi-name>jdbc/XADerbyDS1</jndi-name>

     <!-- uncomment to enable interleaving <interleaving/> -->

     <isSameRM-override-value>false</isSameRM-override-value>
     <xa-datasource-class>org.apache.derby.jdbc.ClientXADataSource</xa-datasource-class>

     <!-- path to the database. (${jboss.server.data.dir}${/}derby${/}default didn't work on win) -->
     <xa-datasource-property name="portNumber">1527</xa-datasource-property>
     <xa-datasource-property name="DatabaseName">txtest1</xa-datasource-property>
     <!--<xa-datasource-property name="portNumber">1527</xa-datasource-property>-->
     <xa-datasource-property name="User">test</xa-datasource-property>
     <xa-datasource-property name="Password">test123</xa-datasource-property>

     <!-- corresponding type-mapping in the standardjbosscmp-jdbc.xml (optional) -->
     <metadata>
         <type-mapping>Derby</type-mapping>
     </metadata>
 </xa-datasource>
</datasources>


<?xml version="1.0" encoding="UTF-8"?>

<datasources>
 <xa-datasource>
     <jndi-name>jdbc/XADerbyDS</jndi-name>

     <!-- uncomment to enable interleaving <interleaving/> -->

     <isSameRM-override-value>false</isSameRM-override-value>
     <xa-datasource-class>org.apache.derby.jdbc.ClientXADataSource</xa-datasource-class>

     <!-- path to the database. (${jboss.server.data.dir}${/}derby${/}default didn't work on win) -->
     <xa-datasource-property name="portNumber">1527</xa-datasource-property>
     <xa-datasource-property name="DatabaseName">txtest</xa-datasource-property>
     <!--<xa-datasource-property name="portNumber">1527</xa-datasource-property>-->
     <xa-datasource-property name="User">test</xa-datasource-property>
     <xa-datasource-property name="Password">test123</xa-datasource-property>

     <!-- corresponding type-mapping in the standardjbosscmp-jdbc.xml (optional) -->
     <metadata>
         <type-mapping>Derby</type-mapping>
     </metadata>
 </xa-datasource>
</datasources>

Note that you need two database instances (here txtest and txtest1). And I am running Derby in network mode(not in embeded mode). And also drop the derby jars(derby.jar, derbynet.jar, derbyclient.jar and derby-plugin.jar) into $JBOSS_HOME/server/default/lib folder. Following sql query was used to create the database table.


create table EMP (EMPNO int primary key, ENAME varchar(40), JOB varchar(40), MGR int, SAL double, COMM double, DEPTNO int);

Step3
You also need to have a jboss-web.xml, for the sample web application which map the resource with the defined resourcs in web.xml. You can place the following jboss-web.xml inside web/WEB-INF so that when you run ant it'll automatically goes into the webapp.


<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<display-name>SampleJDBCServlet</display-name>
<servlet>
<servlet-name>SampleJDBCServlet</servlet-name>
<servlet-class>book.ch4.sample.xa.SampleJDBCServlet</servlet-class>
</servlet>
<servlet>
<servlet-name>SampleJMSServlet</servlet-name>
<servlet-class>book.ch5.sample.xa.SampleJMSServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>SampleJDBCServlet</servlet-name>
<url-pattern>/jdbcsample</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>SampleJMSServlet</servlet-name>
<url-pattern>/jmssample</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
<resource-ref>
<res-ref-name>jdbc/XADerbyDS</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
<res-sharing-scope>Shareable</res-sharing-scope>
</resource-ref>
<resource-ref>
<res-ref-name>jdbc/XADerbyDS1</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
<res-sharing-scope>Shareable</res-sharing-scope>
</resource-ref>
</web-app>

Also note the proper JNDI names for the two datasources(You can see the bounded JNDI name when the JBOSS server startup). This datasource name is require when looking up through the code. I only added the chapter 4 sample.

Step4
Now you can run ant and build the samples.ear. You'll need the .war inside that archive to deploy into JBoss. Unzip the samples.ear and deploy the samples-web.war into $JBOSS_HOME/server/default/deploy. Place your brower to http://localhost:8080/samples-web/. To see the transaction in action try to insert a record which is already in databse2. You'll see the whole transaction is rollback(no recored is delete from database1 and no recored is added into databse2).

Transactional ESB - Part 2, The JMS transport transaction

2009-08-27T10:36:00.001+05:30

This is the part 2 of describing WSO2 ESB's transaction support. You can see the part 1.

The part 1 was on the transaction mediator. This post will describe the JMS transport transaction support. The JMs transport transaction support both local and distributed transaction.

This also was tested with JBoss(5.0GA version), you'll need to follow part 1 of the series which describes the steps for deploying WSO2 ESB on JBoss application server and using transaction mediator. We'll use the inbuilt JMS provider service in JBoss as the JMS provider. When deploying WSO2 ESB on JBoss as in part 1 you'll need to remove the geronimo JTA/JMS jars, so we'll have to expose the jms jars through the servlet bridge. You'll only need to do this when you deploy WSO2 ESB on an application server. Once you run the script open the launch.ini in $JBOSS_HOME/server/default/deploy/esb.war/WEB-INF/eclipse with your text editor and add the following entry there. Then save the file.


javax.jms, \

In Jboss you have to define the queues manually so you'll need to have a queue called StockQuoteProxy since we need to deploy our proxy service through JMS transport. Just drop the following file into $JBOSS_HOME/server/default/deploy folder. The other queues which you can see there for some services which use WSO2 ESB for its work.


<?xml version="1.0" encoding="UTF-8"?>

<!--
Messaging Destinations deployment descriptor.

$Id: destinations-service.xml 81998 2008-12-03 06:46:29Z scott.stark@jboss.org $
-->

<server>

<!--
The Default Dead Letter Queue. This destination is a dependency of an EJB MDB container.
-->

<mbean code="org.jboss.jms.server.destination.QueueService"
name="jboss.messaging.destination:service=Queue,name=XKMS"
xmbean-dd="xmdesc/Queue-xmbean.xml">
<depends optional-attribute-name="ServerPeer">jboss.messaging:service=ServerPeer</depends>
<depends>jboss.messaging:service=PostOffice</depends>
</mbean>

<mbean code="org.jboss.jms.server.destination.QueueService"
name="jboss.messaging.destination:service=Queue,name=wso2carbon-sts"
xmbean-dd="xmdesc/Queue-xmbean.xml">
<depends optional-attribute-name="ServerPeer">jboss.messaging:service=ServerPeer</depends>
<depends>jboss.messaging:service=PostOffice</depends>
</mbean>

<mbean code="org.jboss.jms.server.destination.QueueService"
name="jboss.messaging.destination:service=Queue,name=StockQuoteProxy"
xmbean-dd="xmdesc/Queue-xmbean.xml">
<depends optional-attribute-name="ServerPeer">jboss.messaging:service=ServerPeer</depends>
<depends>jboss.messaging:service=PostOffice</depends>
</mbean>


<mbean code="org.jboss.jms.server.destination.QueueService"
name="jboss.messaging.destination:service=Queue,name=echo"
xmbean-dd="xmdesc/Queue-xmbean.xml">
<depends optional-attribute-name="ServerPeer">jboss.messaging:service=ServerPeer</depends>
<depends>jboss.messaging:service=PostOffice</depends>
</mbean>


</server>

The senario which we use to demostrate the transaction capabilties is reading a JMS message fron a queue and updating a database in the same single transaction. The synapse configuration is shown below. So in a sucessful intransaction the JMS message will be read from the message queue and the database will be updated. In a failure senario(adding duplicate entries to the database) the message will be aviable in the queue and the no records will be added into the database. We'll use a proxy service which will be exposed throught JMS transport and the proxy service will read the JMS message from the queue and will update the database. Finally the message will send to the endpoint.


<definitions xmlns="http://ws.apache.org/ns/synapse">

<proxy name="StockQuoteProxy" transports="jms">
   <target faultSequence="myFaultHandler">
       <inSequence>
           <!--<transaction action="use-existing-or-new"/>-->
           <log level="custom">
               <property name="text" value="** Reporting to the Database esbdb**"/>
           </log>
           <dbreport useTransaction="true" xmlns="http://ws.apache.org/ns/synapse">
               <connection>
                   <pool>
                       <dsName>java:jdbc/XADerbyDS</dsName>
                       <icClass>org.jnp.interfaces.NamingContextFactory</icClass>
                       <url>localhost:1099</url>
                       <user>esb</user>
                       <password>esb</password>
                   </pool>
               </connection>
               <statement>
                   <sql>INSERT into company values ('IBM','c4',12.0)</sql>
               </statement>
           </dbreport>
           <!--<transaction action="commit"/>-->
           <send>
               <endpoint>
                   <address uri="http://localhost:9000/services/SimpleStockQuoteService"/>
               </endpoint>
           </send>
       </inSequence>
   </target>
   <publishWSDL uri="file:/home/rajika/work/esb_repo/repository/samples/resources/proxy/sample_proxy_1.wsdl"/>
   <parameter name="transport.jms.ContentType">
       <rules>
           <jmsProperty>contentType</jmsProperty>
           <default>application/xml</default>
       </rules>
   </parameter>
</proxy>
<sequence name="myFaultHandler">
   <log level="custom">
       <property name="text" value="** An fault occurs the transaction will rollback**"/>
   </log>
   <!--<transaction action="rollback"/>-->
</sequence>

</definitions>

Figure1: JMS transport transaction in use.

You'll also need to have a xa-datasource for Derby and the derby client drivers(derby.jar, derbyplugin.jar, derbynet.jar, derbyclient.jar) also in place(see Part 1 for more information). Following is the xa-datasources definitions for derby database. You'll have to drop this configuration file into $JBOSS_HOME/server/default/deploy folder.


<?xml version="1.0" encoding="UTF-8"?>

<datasources>
<xa-datasource>
 <jndi-name>jdbc/XADerbyDS</jndi-name>

 <!-- uncomment to enable interleaving <interleaving/> -->

 <isSameRM-override-value>false</isSameRM-override-value>
 <xa-datasource-class>org.apache.derby.jdbc.ClientXADataSource</xa-datasource-class>

 <!-- path to the database. (${jboss.server.data.dir}${/}derby${/}default didn't work on win) -->
 <xa-datasource-property name="portNumber">1527</xa-datasource-property>
 <xa-datasource-property name="DatabaseName">esbdb</xa-datasource-property>
 <!--<xa-datasource-property name="portNumber">1527</xa-datasource-property>-->
 <xa-datasource-property name="User">esb</xa-datasource-property>
 <xa-datasource-property name="Password">esb</xa-datasource-property>

 <!-- corresponding type-mapping in the standardjbosscmp-jdbc.xml (optional) -->
 <metadata>
     <type-mapping>Derby</type-mapping>
 </metadata>
</xa-datasource>
</datasources>

The JMS transport transaction support both local and distributed transaction.

Local JMS transaction
Local JMS transaction let you to divide parts of the message consumptions into individual transaction. From message production to queue can be a one transaction and from that queue to message consumption can be a another transaction. To have local transaction you need to configure the JMS transport receiver(in axis2.xml) as follows.


<transportReceiver name='jms' class='org.apache.axis2.transport.jms.JMSListener'>
<parameter name='default' locked='false'>
<parameter name='java.naming.factory.initial'>org.jnp.interfaces.NamingContextFactory</parameter>
<parameter name='java.naming.provider.url'>jnp://localhost:1099</parameter>
<parameter name='java.naming.factory.url.pkgs'>org.jboss.naming:org.jnp.interfaces</parameter>
<parameter name='transport.jms.ConnectionFactoryJNDIName'>ConnectionFactory</parameter>
<parameter name="transport.Transactionality">local</parameter>
</parameter>
</transportReceiver>

Distributed (JTA) JMS transaction
The WSO2 ESB JMS transport transaction also support distributed JMS transaction. To have a distributed transaction you'll need to have the following configuration for JMS transport receiver in axis2.xml.


<transportReceiver name='jms' class='org.apache.axis2.transport.jms.JMSListener'>
<parameter name='default' locked='false'>
<parameter name='java.naming.factory.initial'>org.jnp.interfaces.NamingContextFactory</parameter>
<parameter name='java.naming.provider.url'>jnp://localhost:1099</parameter>
<parameter name='java.naming.factory.url.pkgs'>org.jboss.naming:org.jnp.interfaces</parameter>
<parameter name='transport.jms.ConnectionFactoryJNDIName'>ConnectionFactory</parameter>
<parameter name="transport.Transactionality">jta</parameter>
<parameter name="transport.UserTxnJNDIName">java:comp/UserTransaction</parameter>
</parameter>
</transportReceiver>

The complete list of parameters now you can have with the new enhance JMS transport can be found here[1].

Once you deployed everything you can run the JMS client which distribute with the WSO2 ESB to test the scenario.

Finally we are ready to run the client, use the following command line options(using the same ant build file in $ESB_HOME/samples/axis2Client). You need to have the traditional StockQuote service deployed, look at sample #250 for more detail.


ant jmsclient -Djms_type=pox -Djms_dest=queue/StockQuoteProxy -Djms_payload=MSF -Djava.naming.provider.url=jnp://localhost:1099 -Djava.naming.factory.initial=org.jnp.interfaces.NamingContextFactory

To test the failure senario try adding a duplicate entry to the database (you'll need to create the table with a primary key).

References:
[1] - The enhanced JMS transport

[2] - The transaction mediator

JBoss mysql xa-datasource configuration

2009-08-24T22:30:00.000+05:30

If you are using a JBOss data source for mysql in a distributed transaction environment you need to define xa-datasource for mysql. The configuration looks like below and you can just drop into $JBOSS_HOME/server/default/deploy folder.


<datasources>
     <xa-datasource>
         <jndi-name>MySQLDS</jndi-name>
         <xa-datasource-property name="URL">jdbc:mysql://localhost:3306/esbdb</xa-datasource-property>
         <xa-datasource-class>com.mysql.jdbc.jdbc2.optional.MysqlXADataSource</xa-datasource-class>
         <user-name>test</user-name>
         <password>test123</password>
         <track-connection-by-tx>true</track-connection-by-tx>
         <exception-sorter-class-name>org.jboss.resource.adapter.jdbc.vendor.MySQLExceptionSorter</exception-sorter-class-name>
         <valid-connection-checker-class-name>org.jboss.resource.adapter.jdbc.vendor.MySQLValidConnectionChecker</valid-connection-checker-class-name>
         <min-pool-size>1</min-pool-size>
         <max-pool-size>10</max-pool-size>
         <idle-timeout-minutes>10</idle-timeout-minutes>
         <metadata>
             <type-mapping>mySQL</type-mapping>
         </metadata>
     </xa-datasource>
 </datasources>

And you'll see this datasource is bound to the JNDI name MySQLDS once the server starts.


22:38:28,273 INFO  [ConnectionFactoryBindingService] Bound ConnectionManager 'jboss.jca:service=DataSourceBinding,name=MySQLDS' to JNDI name 'java:MySQLDS'

Transactional ESB - Part 1, The transaction mediator

2009-08-21T18:22:00.000+05:30

Update(27/08/09) - The original transaction mediator implementation had some problem with multiple data sources, basically it didn't work with more than one data source. The transaction mediator has been implemented using the TransactionManager interface. I submitted a patch for the transaction mediator to use UserTransaction interface instead. In addition to this there is another patch for DBReport mediator which lets you to use it together with transaction mediator.

ESB 2.1.0 is now out!. In this release there are few new features that you can try out. ESB comes with a number of pre-built samples which can be used to try out ESB easily.
One of the major enhancements is the transaction support built into ESB. Transaction plays a major role in today's business oriented world and when comes to SOA, transaction adds an important value to your platform. Having good transaction support in your business will definitely save you though you only see the value of a transactional system only at a failure. See Paul's blog to see a description of this new feature.

The transaction support in ESB is twofold.
1. The transaction mediator.
2. Transaction support in JMS transport.

This blog will be about transaction mediator. A separate blog will follow about using JMS transport transaction.

Transaction Mediator
A new synapse mediator has been added which adds the distributed transaction support using Java Transaction API(JTA) (The java transaction API allows application to perform distributed transactions that is, transactions that access and update data on two or more networked computer resources, an example would be to have two databases or a database and a message queue such as JMS). So if you perform distributed transactions this mediator is for you. The synapse configuration language has been extended to add explicit transaction markers. It's the responsibility of the user to define when to start, commit and rollback the transaction. For ex: we can mark start of a transaction at the start of a database commit and end of the transaction at the end of database commit and we can rollback the transaction in fault sequence(if an error occurs).

Transaction mediator has the following configuration.


<transaction action="new|use-existing-or-new|fault-if-no-tx|commit|rollback|suspend|resume">
</transaction>

The action attribute has the following meanings.
1. new - Create a new jta transaction. Generate a fault if a transaction already exist.
2. use-existing-or-new - Create a new jta transaction. Do nothing if a transaction exist.
3. fault-if-no-tx - Generate a fault if no transaction exist. Do nothing if a transaction exist.
4. commit - Commit transaction. Generate a fault if no transaction exist.
5. rollback - Rollback transaction. Generate a fault if no transaction exist.
6. suspend - Suspend transaction. Generate a fault if no transaction exist.
7. resume - Resume transaction. Generate a fault if no transaction exist.

Each of this can be use to mark the required action of the transaction process. Following is a step by step guide which describe the transaction mediator in action. It demonstrates how we can update a database table which is a part of a distributed transaction.

The transaction manager is the primary component of the distributed transaction support infrastructure, however the JDBC driver (the resource adapter) and the application server should have the following two characteristics.

1. The driver should implement the JDBC 2.0 API(including the optional package interfaces XADataSource and XAConnection) or higher and the JTA interface XAResource.

2. The application server should provide a DataSource class that is implemented to interact with the distributed transaction infrastructure and a connection pooling model for performance improvements.

In the following example we use the JBoss JTA provider, so we need to deploy WSO2 ESB in JBoss application server. See this post on deploying WSO2 ESB on JBoss app server. It hasn't tested yet with a standalone JTA provider such as[1], and a separate blog will follow on configuring a standalone JTA provider for transaction mediator.

1. Unzip a WSO2 ESB 2.1 distributionto a place of your choice. And then remove the geronimo-jta_1.1_spec-1.1.0.wso2v1.jar from the distribution. This is because we are using the implementation of the javax.transaction.TransactionManage interface) provided by JTA provider (here JBoss). If we have both in classpath there is a classloader problem which causes the transaction mediator to not to work.

2. Then run the ruby script which creates a war web app of WSO2 ESB which can deploy on Jboss. This will also copy all the required configuration files, libraries and others to run WSO2 ESB on Jboss successfully. See the post on deploying esb on JBOSS.

3. We are going to use a similar configuration like sample 361, so drop the derby client drivers(derby.jar, derbynet.jar, derbyclient.jar and derby-plygin.jar) driver into repository/components/extensions in the CARBON_HOME of step 2 and also into $JBOSS_HOME/server/default/lib. Following sql query was used to create the database.


CREATE table company(name varchar(10) primary key, id varchar(10), price double);

4. The synpase configuration is as follows. In the in-squence we will send a message to a service and in the out-sequence we will delete an entry from 1st database and will update the second database with that entry. If we try to add an entry which is already there in second database we'll rollback the whole transaction( No records will be deleted from 1st database and no recored will be added to second database).


<definitions xmlns="http://ws.apache.org/ns/synapse">

<sequence name="myFaultHandler">
    <log level="custom">
        <property name="text" value="** Rollback Transaction**"/>
    </log>
    <transaction action="rollback"/>
    <send/>
</sequence>

<sequence name="main" onError="myFaultHandler">
    <in>
        <send>
            <endpoint>
                <address uri="http://localhost:9000/services/SimpleStockQuoteService"/>
            </endpoint>
        </send>
    </in>

    <out>
        <transaction action="new"/>

        <log level="custom">
            <property name="text" value="** Reporting to the Database esbdb**"/>
        </log>
        <dbreport useTransaction="true" xmlns="http://ws.apache.org/ns/synapse">
            <connection>
                <pool>
                    <dsName>java:jdbc/XADerbyDS</dsName>
                    <icClass>org.jnp.interfaces.NamingContextFactory</icClass>
                    <url>localhost:1099</url>
                    <user>esb</user>
                    <password>esb</password>
                </pool>
            </connection>
            <statement>
                <!--<sql>update company set price=? where name =?</sql>-->
                <sql>delete from company where name =?</sql>
                <!--<parameter expression="//m0:return/m1:last/child::text()"-->
                           <!--xmlns:m0="http://services.samples" xmlns:m1="http://services.samples/xsd"-->
                           <!--type="DOUBLE"/>-->
                <parameter expression="//m0:return/m1:symbol/child::text()"
                           xmlns:m0="http://services.samples" xmlns:m1="http://services.samples/xsd"
                           type="VARCHAR"/>
            </statement>
        </dbreport>

        <log level="custom">
            <property name="text" value="** Reporting to the Database esbdb1**"/>
        </log>
        <dbreport useTransaction="true" xmlns="http://ws.apache.org/ns/synapse">
            <connection>
                <pool>
                    <dsName>java:jdbc/XADerbyDS1</dsName>
                    <icClass>org.jnp.interfaces.NamingContextFactory</icClass>
                    <url>localhost:1099</url>
                    <user>esb</user>
                    <password>esb</password>
                </pool>
            </connection>
            <statement>
                <!--<sql>update company set price=? where name =?</sql>-->
                <sql> INSERT into company values ('IBM','c4',12.0)</sql>
                <!--<parameter expression="//m0:return/m1:last/child::text()"-->
                           <!--xmlns:m0="http://services.samples" xmlns:m1="http://services.samples/xsd"-->
                           <!--type="DOUBLE"/>-->
                <!--<parameter expression="//m0:return/m1:symbol/child::text()"-->
                           <!--xmlns:m0="http://services.samples" xmlns:m1="http://services.samples/xsd"-->
                           <!--type="VARCHAR"/>-->
            </statement>
        </dbreport>
        <transaction action="commit"/>
        <send/>
    </out>
</sequence>
</definitions>

5. You'll also need to define two datasources for derby in Jboss. Drop the following datasources deceleration for derby into $JBOSS_HOME/server/default/deploy.


<?xml version="1.0" encoding="UTF-8"?>

<datasources>
<xa-datasource>
  <jndi-name>jdbc/XADerbyDS</jndi-name>

  <!-- uncomment to enable interleaving <interleaving/> -->

  <isSameRM-override-value>false</isSameRM-override-value>
  <xa-datasource-class>org.apache.derby.jdbc.ClientXADataSource</xa-datasource-class>

  <!-- path to the database. (${jboss.server.data.dir}${/}derby${/}default didn't work on win) -->
  <xa-datasource-property name="portNumber">1527</xa-datasource-property>
  <xa-datasource-property name="DatabaseName">esbdb</xa-datasource-property>
  <!--<xa-datasource-property name="portNumber">1527</xa-datasource-property>-->
  <xa-datasource-property name="User">esb</xa-datasource-property>
  <xa-datasource-property name="Password">esb</xa-datasource-property>

  <!-- corresponding type-mapping in the standardjbosscmp-jdbc.xml (optional) -->
  <metadata>
      <type-mapping>Derby</type-mapping>
  </metadata>
</xa-datasource>
</datasources>


<?xml version="1.0" encoding="UTF-8"?>

<datasources>
<xa-datasource>
  <jndi-name>jdbc/XADerbyDS1</jndi-name>

  <!-- uncomment to enable interleaving <interleaving/> -->

  <isSameRM-override-value>false</isSameRM-override-value>
  <xa-datasource-class>org.apache.derby.jdbc.ClientXADataSource</xa-datasource-class>

  <!-- path to the database. (${jboss.server.data.dir}${/}derby${/}default didn't work on win) -->
  <xa-datasource-property name="portNumber">1527</xa-datasource-property>
  <xa-datasource-property name="DatabaseName">esbdb1</xa-datasource-property>
  <!--<xa-datasource-property name="portNumber">1527</xa-datasource-property>-->
  <xa-datasource-property name="User">esb</xa-datasource-property>
  <xa-datasource-property name="Password">esb</xa-datasource-property>

  <!-- corresponding type-mapping in the standardjbosscmp-jdbc.xml (optional) -->
  <metadata>
      <type-mapping>Derby</type-mapping>
  </metadata>
</xa-datasource>
</datasources>

6. We are using a variation of sample 361. So you can follow the same steps to and run the sample client.


ant stockquote -Daddurl=http://localhost:9000/services/SimpleStockQuoteService -Dtrpurl=http://localhost:8280/ -Dsymbol=SUN

7. Have a look at the database table, you can see the table entry has been updated successfully.

8. Now try to add an entry say symbol SUN again into the second database. You'll get an exception for duplicate entries and the whole transaction will be rolled back.
Note:
If you come across ClassCast exceptions make sure you don't have any *jta.jar in the app specially check the $CARBON_HOME/repository/components/dropins folder.
[1]-http://www.atomikos.com/

Switching transport from JMS to https in WSO2 ESB deplyed in JBoss5

2009-07-30T10:09:00.000+05:30

This post going to describe how you can switch transports (here from JMS to http/s) when WSO2 ESB is deployed in JBoss. The JMS provider will be the inbuilt JMS provider in JBoss application server.

This was tested with the following.

WSO2 ESB 2.1
JBoss-5.0.0.GA

A detailed description how WSO2 ESB2.1 can be deployed in JBoss can be found here.
1. Before running the script do the followings. Please remove the jar geronimo-jms_1.1_spec-1.1.0.wso2v1.jar from the ESB2.1 distribution. The problem is this classes clashes with the JMS jars ship with JBoss application server.

2. Next starts the JBoss application server. You'll end up with having the following execpetion.


10:27:28,124 INFO  [STDOUT] 10:27:28,123 FATAL [CarbonServerManager] WSO2 Carbon initialization Failed
org.apache.axis2.deployment.DeploymentException: javax/jms/JMSException
at org.apache.axis2.deployment.AxisConfigBuilder.processTransportSenders(AxisConfigBuilder.java:712)
at org.apache.axis2.deployment.AxisConfigBuilder.populateConfig(AxisConfigBuilder.java:121)
at org.wso2.carbon.core.CarbonAxisConfigurator.populateAxisConfiguration(CarbonAxisConfigurator.java:259)
at org.wso2.carbon.core.CarbonAxisConfigurator.getAxisConfiguration(CarbonAxisConfigurator.java:179)
at org.apache.axis2.context.ConfigurationContextFactory.createConfigurationContext(ConfigurationContextFactory.java:64)
at org.wso2.carbon.core.CarbonConfigurationContextFactory.createNewConfigurationContext(CarbonConfigurationContextFactory.java:76)
at org.wso2.carbon.core.init.CarbonServerManager.initializeCarbon(CarbonServerManager.java:310)
at org.wso2.carbon.core.init.CarbonServerManager.removePendingItem(CarbonServerManager.java:228)
at org.wso2.carbon.core.init.OSGiAxis2ServicesListener.bundleChanged(OSGiAxis2ServicesListener.java:82)
at org.eclipse.osgi.framework.internal.core.BundleContextImpl.dispatchEvent(BundleContextImpl.java:916)
at org.eclipse.osgi.framework.eventmgr.EventManager.dispatchEvent(EventManager.java:220)
at org.eclipse.osgi.framework.eventmgr.EventManager$EventThread.run(EventManager.java:330)
Caused by: java.lang.NoClassDefFoundError: javax/jms/JMSException
at java.lang.Class.getDeclaredConstructors0(Native Method)
at java.lang.Class.privateGetDeclaredConstructors(Class.java:2357)
at java.lang.Class.getConstructor0(Class.java:2671)
at java.lang.Class.newInstance0(Class.java:321)
at java.lang.Class.newInstance(Class.java:303)
at org.apache.axis2.deployment.AxisConfigBuilder.processTransportSenders(AxisConfigBuilder.java:697)

This is due to a class loading problem which is describes here. To avoid this do the following. Shut down the JBOss server and open the jar org.wso2.carbon.servletbridge_1.0.0.jar located in $CARBON_HOME/repository/components/plugins directory. Open the jar with archive manager and open the MANIFEST.MF in the jar. We know, this is not the proper way to do it and we are working on it getting it right.

Your MANIFEST.MF will looks like follows.


Manifest-Version: 1.0
Bundle-Name: Servletbridge Extension Bundle
Bundle-ManifestVersion: 2
Fragment-Host: system.bundle; extension:=framework
Bundle-SymbolicName: org.wso2.carbon.servletbridge
Export-Package: org.wso2.carbon.bridge; version=1.0.0, org.wso2.carbon
.server.transports; version=1.0.0, javax.servlet; version=2.5, javax.
servlet.http; version=2.5, javax.servlet.resources; version=2.5
Bundle-Version: 1.0.0

Add javax.jms to the list of Export-Package, so that it will looks like below, or just copy the following into the MNIFEST.MF


Manifest-Version: 1.0
Bundle-Name: Servletbridge Extension Bundle
Bundle-ManifestVersion: 2
Fragment-Host: system.bundle; extension:=framework
Bundle-SymbolicName: org.wso2.carbon.servletbridge
Export-Package: org.wso2.carbon.bridge; version=1.0.0, org.wso2.carbon
.server.transports; version=1.0.0, javax.servlet; version=2.5, javax.
servlet.http; version=2.5, javax.servlet.resources; version=2.5,javax.jms
Bundle-Version: 1.0.0

3. Now you need to configure the Queues in JBoss JMS provider. We are using the sample 250. Add the following stockquote-proxy-service.xml into $JBOSS_HOME/server/default/deploy so that it will create the required queues. WSO2 ESB uses WSO2 carbon underline and it requires few other services to run. So we create queues for those services as well.


<server>
<!--       The Default Dead Letter Queue. This destination is a dependency of an EJB MDB container.    -->
<mbean code="org.jboss.jms.server.destination.QueueService" name="jboss.messaging.destination:service=Queue,name=XKMS" dd="xmdesc/Queue-xmbean.xml">
 <depends name="ServerPeer">jboss.messaging:service=ServerPeer
 <depends>jboss.messaging:service=PostOffice
</mbean>

<mbean code="org.jboss.jms.server.destination.QueueService" name="jboss.messaging.destination:service=Queue,name=wso2carbon-sts" dd="xmdesc/Queue-xmbean.xml">
 <depends name="ServerPeer">jboss.messaging:service=ServerPeer</depends>
 <depends>jboss.messaging:service=PostOffice</depends>
</mbean>

<mbean code="org.jboss.jms.server.destination.QueueService" name="jboss.messaging.destination:service=Queue,name=StockQuoteProxy" dd="xmdesc/Queue-xmbean.xml">
 <depends name="ServerPeer">jboss.messaging:service=ServerPeer</depends>
 <depends>jboss.messaging:service=PostOffice</depends>
</mbean>


<mbean code="org.jboss.jms.server.destination.QueueService" name="jboss.messaging.destination:service=Queue,name=echo" dd="xmdesc/Queue-xmbean.xml">
 <depends name="ServerPeer">jboss.messaging:service=ServerPeer</depends>
 <depends>jboss.messaging:service=PostOffice</depends>
</mbean>
</server>

4. Now it's time to run the client. Your the following client to run. Add the following JBoss JMS client libraries into client's class path. These jars can be found inside client folder within Jboss discribution.

jnp-client.jar
jboss-logging-jdk.jar
jboss-logging-log4j.jar
jboss-logging-spi.jar
jboss-messaging-client.jar
jboss-aop-client.jar
jboss-mdr.jar

The set up is same as sample# 250, just deploy the Simple StockQuote service on simple axis2 server. Just follow the sample guide.


/*
*  Licensed to the Apache Software Foundation (ASF) under one
*  or more contributor license agreements.  See the NOTICE file
*  distributed with this work for additional information
*  regarding copyright ownership.  The ASF licenses this file
*  to you under the Apache License, Version 2.0 (the
*  "License"); you may not use this file except in compliance
*  with the License.  You may obtain a copy of the License at
*
*   http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing,
*  software distributed under the License is distributed on an
*   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
*  KIND, either express or implied.  See the License for the
*  specific language governing permissions and limitations
*  under the License.
*/

package samples.userguide;

import javax.jms.BytesMessage;
import javax.jms.Queue;
import javax.jms.QueueConnection;
import javax.jms.QueueConnectionFactory;
import javax.jms.QueueSender;
import javax.jms.QueueSession;
import javax.jms.TextMessage;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.util.Properties;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.IOException;

public class GenericJMSClient {
 private QueueConnection connection;
 private QueueSession session;
 private QueueSender sender;

 private static String getProperty(String name, String def) {
     String result = System.getProperty(name);
     if (result == null || result.length() == 0) {
         result = def;
     }
     return result;
 }

 public static void main(String[] args) throws Exception {

     String dest  = getProperty("jms_dest", "dynamicQueues/JMSTextProxy");
     String type  = getProperty("jms_type", "text");
     String param = getProperty("jms_payload",
         getRandom(100, 0.9, true) + " " + (int) getRandom(10000, 1.0, true) + " IBM");
     String sMsgCount = getProperty("jms_msgcount", null);

     GenericJMSClient app = new GenericJMSClient();
     int msgCount = sMsgCount == null ? 1 : Integer.parseInt(sMsgCount);
     app.connect(dest);
     if ("text".equalsIgnoreCase(type)) {
         for (int i=0; i\n" +
                 "    \n" +
                 "        " + getRandom(100, 0.9, true) + "\n" +
                 "        " + (int) getRandom(10000, 1.0, true) + "\n" +
                 "        " + param + "\n" +
                 "    \n" +
                 "");
         }
     } else {
         System.out.println("Unknown JMS message type");
     }
     app.shutdown();
 }

 private void connect(String destName) throws Exception {
     Properties env = new Properties();
     String factoryURL = getProperty("java.naming.factory.url.pkgs","org.jboss.naming:org.jnp.interfaces");
     String connectionFactoryName = getProperty("transport.jms.ConnectionFactoryJNDIName","ConnectionFactory");
     if (System.getProperty("java.naming.provider.url") == null) {
         env.put("java.naming.provider.url", "tcp://localhost:61616");
     }
     if (System.getProperty("java.naming.factory.initial") == null) {
         env.put("java.naming.factory.initial",
             "org.apache.activemq.jndi.ActiveMQInitialContextFactory");
     }
     if(factoryURL != null){
         env.put("java.naming.factory.url.pkgs", factoryURL);
     }
     if(connectionFactoryName != null){
         env.put("transport.jms.ConnectionFactoryJNDIName", connectionFactoryName);
     }
     InitialContext ic = new InitialContext(env);
     QueueConnectionFactory confac = (QueueConnectionFactory) ic.lookup("ConnectionFactory");
     connection = confac.createQueueConnection();
     session = connection.createQueueSession(false, QueueSession.AUTO_ACKNOWLEDGE);
     sender = session.createSender((Queue)ic.lookup(destName));
 }

 private void shutdown() throws Exception {
     sender.close();
     session.close();
     connection.close();
 }

 private void sendBytesMessage(byte[] payload) throws Exception {
     BytesMessage bm = session.createBytesMessage();
     bm.writeBytes(payload);
     sender.send(bm);
 }

 private void sendTextMessage(String payload) throws Exception {
     TextMessage tm = session.createTextMessage(payload);
     sender.send(tm);
 }

 public static byte[] getBytesFromFile(String fileName) throws IOException {

     File file = new File(fileName);
     InputStream is = new FileInputStream(file);
     long length = file.length();

     byte[] bytes = new byte[(int) length];

     int offset = 0;
     int numRead = 0;
     while (offset < numread =" is.read(bytes,">= 0) {
         offset += numRead;
     }

     // Ensure all the bytes have been read in
     if (offset < rand =" Math.random();"> 0.5 ? 1 : -1) * varience * base * rand))
         * (onlypositive ? 1 : (rand > 0.5 ? 1 : -1));
 }

}

5. Run the client with following argument.


ant jmsclien -Djms_type=pox -Djms_dest=queue/StockQuoteProxy -Djms_payload=MSFT -Djava.naming.provider.url=jnp://localhost:1099
-Djava.naming.factory.initial=org.jnp.interfaces.NamingContextFactory

Getting JBossMessaging(JBM) working with Apache Synpase

2009-07-27T21:41:00.000+05:30

This is a step by step guide to get JBossMessaging(JBM) working with synapse latest trunk(SNAPSHOT). You need to download JBM from here. I tested with Beta3 release.

1. Download JBM and put the following jars into synapse lib folder

jbm-core-client.jar
jbm-jms-client.jar
jnp-client.jar
jbm-transports.jar
netty.jar

The fist three jars can be found in the client folder and the last two jars can be found in the lib folder once you unzipped JBM distribution.

2. Add the following entry to axis2.xml which can be found in $SYNAPSE_HOME/repository/conf/axis2.xml


<transportreceiver name="jms" class="org.apache.axis2.transport.jms.JMSListener">
  <parameter name="java.naming.factory.initial">org.jnp.interfaces.NamingContextFactory</parameter>
  <parameter name="java.naming.provider.url">jnp://localhost:1099</parameter>
  <parameter name="java.naming.factory.url.pkgs">org.jboss.naming:org.jnp.interfaces</parameter>
  <parameter name="transport.jms.ConnectionFactoryJNDIName">ConnectionFactory</parameter>
</transportreceiver>

<transportsender name="jms" class="org.apache.axis2.transport.jms.JMSSender">
</transportsender>

3. Add the following entry to the jbossmq-jms configuration file(config/stand-alone/non-clustered/jbm-jms.xml once you unzipped the JBM distribution) to define the queue for the service.


<queue name="StockQuoteProxy">
 <entry name="StockQuoteProxy">
</entry>
</queue>

4. Change the sample JMS client which comes with synapse distribution to have the JBM releated JNDI configurations.


Properties env = new Properties();
if (System.getProperty("java.naming.provider.url") == null) {
           //env.put("java.naming.provider.url", "tcp://localhost:61616");
           env.put("java.naming.provider.url", "jnp://localhost:1099");
}
if (System.getProperty("java.naming.factory.initial") == null) {
           //env.put("java.naming.factory.initial","org.apache.activemq.jndi.ActiveMQInitialContextFactory");
           env.put("java.naming.factory.initial","org.jnp.interfaces.NamingContextFactory");
}
env.put("java.naming.factory.url.pkgs","org.jboss.naming:org.jnp.interfaces");
env.put("transport.jms.ConnectionFactoryJNDIName","ConnectionFactory");

5. Run the sample client.


ant jmsclient -Djms_type=pox -Djms_dest=StockQuoteProxy -Djms_payload=MSFT

CMake based build system for Axis2/C

2009-07-25T21:40:00.000+05:30

This post is about the new CMake based build system for Axis2/C. Once the patch applies to the Axis2/C trunk the Axis2/C community will benefit from it.

CMake is a cross platform build system. It generates build files for native build environments(i.e. Makefile for UNIX/Linux, VS Projects/Workspaces for Windows and Xcode for Apple). It's doing the same job as popular GNU build tools(autoconf, automake, Libtool). CMake has a lot of cool features. Some of are listed below. And CMake is opensource.

CMake features
1. Manage, complex and large build environments (eg: KDE4)
2. Very Flexible and Extensible.
3. Very simple script language for build script writing.
4. Support both in-source and out-source builds.
5. Cross compiling.
6. Integrated testing and packaging tools(CTest, CPack)

Instructions to use CMake build system for Axis2/C on UNIX/Linux
The build has written to run as a out of source build. This mean that the build files and then object files will be generated out side of the main source tree.
Once you checkout the soure from the trunk, issue the following commands to build Axis2/C using CMake. You need to have CMake installed(2.6 or above) on your system.

1. export AXIS2C_HOME=/path/where/you/want/axis2c/to/live
(e.g.: export AXIS2C_HOME=/home/rajika/project/axis2c/axis2-build/deploy)

2. mkdir axis2c-build(assuming you are at /home/rajika/project/axis2c/)

3. cd axis2c-build

4. cmake ../ (you have checked out the Axis2/C source into /home/rajika/project/axis2c/)

5. make

6. make install

Done!. You'll see all the binaries are available inside deploy directory together with the libraries and the configuration files requires to run the server and the samples successfully.

It built within less than 20 seconds in my laptop(running Fedora 10 with gcc 4.3.2 with Dual core processors-2.20GHz,2.20GHz and with 3GB of physical memory). Following are few screen shots of Axis2/C CMake build in action. You'll notice the cool CMake features there.

A separate blog will follow describing how to extend the new build system when extending Axis2/C using samples(client+services), transports and message receivers.

WSO2 Enterprise Service Bus (ESB) 2.1.0 Released!

2009-07-10T17:19:00.000+05:30

The WSO2 ESB team is pleased to announce the release of version 2.1.0 of the Open Source Enterprise Service Bus (ESB).

WSO2 ESB is a lightweight and easy-to-use Open Source Enterprise Service Bus (ESB) available under the Apache Software License v2.0. WSO2 ESB allows administrators to simply and easily configure message routing, intermediation, transformation, logging, task scheduling, load balancing, failover routing, event brokering, etc.. The runtime has been designed to be completely asynchronous, non-blocking and streaming based on the Apache Synapse core.

WSO2 ESB 2.1.0 is developed on top of the revolutionary Carbon platform (Middleware a' la carte), and is based on the OSGi framework to achieve the better modularity for your SOA architecture. This also contains a lots of new features and many other optional components to customize the behavior of the server. Further, if you do not want any of the built in features, you can uninstall those features without any trouble. In other words, this ESB can be customized to your SOA needs.

You can download this distribution from http://wso2.org/downloads/esb and give it a try.
How to Run

1. Extract the downloaded zip
2. Go to the bin directory in the extracted folder
3. Run the wso2server.sh or wso2server.bat as appropriate
4. Point your browser to the URL https://localhost:9443/carbon
5. Use "admin", "admin" as the username and password to login as an admin and create a user account
6. Assign the required permissions to the user through a role
7. If you need to start the OSGi console with the server use the property -DosgiConsole when starting the server. The INSTALL.txt file found on the installation directory will give you a comprehensive set of options and properties that can be passed into the startup script
8. Samples configurations can be started by the wso2esb-samples script passing the sample number with the -sn option, please have a look at the samples guide for more information, on running samples

Key Features of WSO2 ESB

* Proxy services - facilitating synchronous/asynchronous transport, interface (WSDL/Schema/Policy), message format (SOAP 1.1/1.2, POX/REST, Text, Binary), QoS (WS-Addressing/WS-Security/WS-RM) and optimization switching (MTOM/SwA).
* Non-blocking HTTP/S transports based on Apache HttpCore for ultrafast execution and support for thousands of connections at high concurreny with constant memory usage.
* Built in Registry/Repository, facilitating dynamic updating and reloading of the configuration and associated resources (e.g. XSLTs, XSD, WSDL, Policies, JS, Configurations ..)
* Easily extendable via custom Java class (mediator and command)/Spring mediators, or BSF Scripting languages (Javascript, Ruby, Groovy, etc.)
* Built in support for scheduling tasks using the Quartz scheduler.
* Load-balancing (with or without sticky sessions)/Fail-over, and clustered Throttling and Caching support
* WS-Security, WS-Reliable Messaging, Caching & Throttling configurable via (message/operation/service level) WS-Policies
* Lightweight, XML and Web services centric messaging model
* Support for industrial standards (Hessian binary web service protocol/ Financial Information eXchange protocol and optional Helth Level-7 protocol)
* Enhanced support for the VFS(File/FTP/SFTP)/JMS/Mail transports with optional TCP/UDP transports and transport switching for any of the above transports
* Support for message splitting & aggregation using the EIP and service callouts
* Database lookup & store support with DBMediators with reusable database connection pools
* WS-Eventing support with event sources and event brokering
* Rule based mediation of the messages using the Drools rule engine
* Transactions support via the JMS transport and Transaction mediator for database mediators
* Internationalized GUI management console with user/permission management for configuration development and monitoring support with statistics, configurable logging and tracing
* JMX monitoring support and JMX management capabilities like, Gracefull/Forcefull shutdown/restart

New Features of the WSO2 ESB 2.1.0

* This ESB release is based on Carbon "Middleware a' la carte" which is an OSGi based SOA platform version 2.0 by WSO2 Inc.
* Rule based mediation via Drools
* Fine grained autherization for services via the Entitlement mediator
* Reliable-Messaging specification 1.1 support
* Enhanced WS-Eventing support and Event Sources making it an even broker
* Enhanced AJAX based sequence, endpoint and proxy service editors
* Enhanced transport configuration management through the graphical console
* Enhanced integrated registry and search functionalities with versionning, notifications, rating of resources, and commenting
* Enhanced remote registry support
* Default persistence to the registry for the configuration elements
* Enhanced permission model with the user management
* Enhanced REST/GET and other HTTP method support
* P2 based OSGi feature support, for optional features like service management, runtime governance and so on..

How You Can Contribute
Mailing Lists

Join our mailing list and correspond with the developers directly.

* Developer List : esb-java-dev@wso2.org | Subscribe | Mail Archive
* User List : esb-java-user@wso2.org | Subscribe | Mail Archive

Reporting Issues

WSO2 encourages you to report issues and your enhancement requests for the WSO2 ESB using the public JIRA.

You can also watch how they are resolved, and comment on the progress..
Discussion Forums

Alternatively, questions could be raised using the forums available.

WSO2 ESB Forum : Discussion forum for WSO2 ESB developers/users
Training

WSO2 Inc. offers a variety of professional Training Programs, including training on general Web services as well as WSO2 ESB, Apache Synapse, Apache Axis2 and number of other products.

For additional support information please refer to http://wso2.com/training/course-catalog/
Support

WSO2 Inc. offers a variety of development and production support programs, ranging from Web-based support up through normal business hours, to premium 24x7 phone support.

For additional support information please refer to http://wso2.com/support/

For more information on WSO2 ESB, visit the WSO2 Oxygen Tank (http://wso2.org)

We welcome your feedback on this implementation. Thank you for your interest in WSO2 ESB.

-- The WSO2 ESB Team --

Deploying wso2 ESB on JBOSS application server

2009-06-15T21:00:00.000+05:30

This is a step by step guide describing deploying WSO2 ESB on jboss-5.1.0.GA on linux platform. The steps should be same for windows as well.

Step1
* Download, unzip and install JBOSS 5.1 GA.

Step2
* Download, unzip WSO2 ESB 2.0.2
* Copy conf, database, repository and resources directories in to a folder namely wso2esb (Eg: /home/rajika/wso2esb)

Step3
* Create a new folder called wso2esb.war in location JBOSS_HOME/server/default/deploy directory.
Where JBOSS_HOME point to the JBOSS unzipped location in Step1.
* Copy the WEB-INF folder located in wso2esb-2.0.2/webapps/ROOT/WEB-INF to JBOSS_HOME/server/default/deploy/wso2esb.war

Step4
* Open file JBOSS_HOME/server/default/deploy/jbossweb.sar/server.xml and paste the following entry.
Note: Remember to replace the keystoreFile path to the place where you have unzipped wso2 esb.


<Connector protocol="HTTP/1.1" SSLEnabled="true"
           port="8443" address="${jboss.bind.address}"
           scheme="https" secure="true" clientAuth="false"
           keystoreFile="/home/rajika/work/esb-repo/resources/security/wso2carbon.jks"
           keystorePass="wso2carbon" sslProtocol="TLS">
</Connector>

Step5
* Open file carbon.xml which can be found at location wso2esb/conf directory.
Edit the ServerURL element as https://localhost:8443/wso2esb/services/
* Save and close the carbon.xml file

Step6
* Open registry.xml which can be found at location wso2esb/conf directory.
Edit the DB URL as jdbc:h2:/home/rajika/work/esb-repo/database/WSO2CARBON_DB
* Save and close the registry.xml file.

Step7
* Open user-mgt.xml which can be found at location wso2esb/conf directory.
Edit the DB URL as jdbc:h2:/home/rajika/work/esb-repo/database/WSO2CARBON_DB
* Save and close the user-mgt.xml file.

Step8
* Open file axis2.xml which can be found at location wso2esb/conf directory.
Edit the port as

8080
8443
* Save and close the axis2.xml file

Step9
* export CARBON_HOME=/where/you/placed/esb-repo
* Run JBOSS using run.sh script which can be found inside bin directory.
* Point your web browser to https://localhost:8443/esb/carbon.
Note: You can edit the context root in axis2.xml (contextRoot parameter)

Following is a ruby script which automate the process. Again remember to edit the locations to suit your requirement.


require 'rexml/document'
include REXML

#Set esb_repo (Any directory in the local file system), CARBON_BIN_HOME(Home directory of the CARBON binary distribution) and JBOSS_HOME (Home directory of the jboss binary)

$esb_repo = "/home/rajika/work/esb-repo"
$CARBON_BIN_HOME= "/home/rajika/projects/esbjava/java/modules/distribution/target/wso2esb-2.1.0.SNAPSHOT"
$JBOSS_HOME= "/home/rajika/installtion/jboss/jboss-5.1.0.GA"

############################################################################################################

def createCarbonDirs()

system("mkdir #$esb_repo")
system("mkdir #$esb_repo/conf")
system("mkdir #$esb_repo/repository")
system("mkdir #$esb_repo/database")
system("mkdir #$esb_repo/resources")
system ("cp -r #$CARBON_BIN_HOME/conf/* #$esb_repo/conf/ ")
system ("cp -r #$CARBON_BIN_HOME/repository/* #$esb_repo/repository/ ")
system ("cp -r #$CARBON_BIN_HOME/database/* #$esb_repo/database/ " )
system ("cp -r #$CARBON_BIN_HOME/resources/* #$esb_repo/resources/ ")

end

################################################################################################################

def createJbossDirs()

system("mkdir #$JBOSS_HOME/server/default/deploy/esb.war")
system("mkdir #$JBOSS_HOME/server/default/deploy/esb.war/WEB-INF")
system ("cp -r #$CARBON_BIN_HOME/webapps/ROOT/WEB-INF/* #$JBOSS_HOME/server/default/deploy/esb.war/WEB-INF ")

end

###############################################################################################################

def enableHTTPSInjboss()

jboss_xml_file= "#{$JBOSS_HOME}/server/default/deploy/jbossweb.sar/server.xml"
carbon_ks_path="#$esb_repo/resources/security/wso2carbon.jks"
file = File.open("#{jboss_xml_file}", "r")
doc2 = Document.new(file)
#puts doc2
doc2.root.elements['Service'].add_element("Connector", {"maxSpareThreads" => "76", "port" => "8443", "protocol" => "HTTP/1.1", "address" => "${jboss.bind.address}", "SSLEnabled" => "true", "maxThreads" => "150", "scheme" => "https", "secure" => "true", "clientAuth" => "false", "sslProtocol" => "TLS", "keystoreFile" => "#{carbon_ks_path}", "keystorePass" => "wso2carbon"})
formatter = REXML::Formatters::Default.new
File.open("#{jboss_xml_file}", 'w') do |result|
formatter.write(doc2, result)
 end
end

#################################################################################################################

def updateCarbonxml()
carbon_xml_file= "#$esb_repo/conf/carbon.xml"
 File.open("#{carbon_xml_file}") do |config_file|
  # Open the document and edit the port (carbon.xml)
   config = Document.new(config_file)
   puts config.root.elements['ServerURL']
   config.root.elements['ServerURL'].text = 'https://localhost:8443/esb/services/'
   
    # Write the result to the same file.
   formatter = REXML::Formatters::Default.new
   File.open("#{carbon_xml_file}", 'w') do |result|
     formatter.write(config, result)
   end
end
end


####################################################################################################################

def updateRegistryxml()
registry_xml_file= "#$esb_repo/conf/registry.xml"
db_path = "jdbc:h2:#$esb_repo/database/WSO2CARBON_DB"
 File.open("#{registry_xml_file}") do |config_file|
  # Open the document and edit the port (registry.xml)
   config = Document.new(config_file)
   puts config.root.elements[2].elements['url']
   config.root.elements[2].elements['url'].text = "#{db_path}"
   
     #Write the result to the same file.
   formatter = REXML::Formatters::Default.new
   File.open("#{registry_xml_file}", 'w') do |result|
    formatter.write(config, result)
   end
end
end

#############################################################################################################################

def updateusermgtxml()
usermgt_xml_file= "#$esb_repo/conf/user-mgt.xml"
db_path = "jdbc:h2:#$esb_repo/database/WSO2CARBON_DB"
 File.open("#{usermgt_xml_file}") do |config_file|
  # Open the document and edit the port (user_mgt.xml)
   config = Document.new(config_file)
   puts config.root.elements[1].elements['URL']
   config.root.elements[1].elements['URL'].text = "#{db_path}"
   
     #Write the result to the same file.
   formatter = REXML::Formatters::Default.new
   File.open("#{usermgt_xml_file}", 'w') do |result|
    formatter.write(config, result)
   end
end
end

#############################################################################################################################

def updateCarbonaxis2xml()
axis2_xml_file= "#$esb_repo/conf/axis2.xml"
synapse_xml_file="#$esb_repo/conf/synapse.xml"
carbon_ks_path="#$esb_repo/resources/security/wso2carbon.jks"
trustore_path = "#$esb_repo/resources/security/client-truststore.jks"
 File.open("#{axis2_xml_file}") do |config_file|
  # Open the document and edit the port (axis2.xml)
   config = Document.new(config_file)
   #puts config.root.elements['transportReceiver[@name="http"]'].elements['parameter']
   config.root.elements['transportReceiver[@name="http"]'].elements['parameter'].text = '8280'
   config.root.elements['transportReceiver[@name="https"]'].elements['parameter'].text = '8243'
   config.root.elements['transportReceiver[@name="https"]'].elements['parameter[@name="keystore"]'].elements['KeyStore'].elements['Location'].text="#{carbon_ks_path}"
   config.root.elements['transportReceiver[@name="https"]'].elements['parameter[@name="truststore"]'].elements['TrustStore'].elements['Location'].text="#{trustore_path}"
   config.root.elements['parameter[@name="contextRoot"]'].text='/esb'
   
   config.root.elements['transportSender[@name="https"]'].elements['parameter[@name="keystore"]'].elements['KeyStore'].elements['Location'].text="#{carbon_ks_path}"
   config.root.elements['transportSender[@name="https"]'].elements['parameter[@name="truststore"]'].elements['TrustStore'].elements['Location'].text="#{trustore_path}"
   
   config.root.elements['parameter[@name="SynapseConfig.ConfigurationFile"]'].text="#{synapse_xml_file}"
   
     #Write the result to the same file.
   formatter = REXML::Formatters::Default.new
   File.open("#{axis2_xml_file}", 'w') do |result|
   formatter.write(config, result)
   end
end
end

###############################################################################################################################
createCarbonDirs()
createJbossDirs()
updateCarbonxml()
updateRegistryxml()
updateusermgtxml()
updateCarbonaxis2xml()
enableHTTPSInjboss()
#startTomcat()

One country..one nation..

2009-05-19T00:55:00.000+05:30

New endpoint UI

2009-05-08T16:08:00.000+05:30

I re-wrote the endpoint UI component which is a part of carbon components. Now it is just like the sequences component which has a tree like structure representing the parent child relation ship, show that a user can add loadbalance and failover endpoints (of course which has child endpoints) more easily. This new UI will be available with the new up coming carbon release. Followings are few screenshots of new endpoint UI.

Apache Axis2/C 1.6.0 Released

2009-04-22T11:23:00.001+05:30

We are pleased to announce the release of Apache Axis2/C version 1.6.0.
You can download this release from
http://ws.apache.org/axis2/c/download.cgi

Key Features
============

1. Support for one-way messaging (In-Only) and
request response messaging (In-Out)
2. Client APIs : Easy to use service client API and
more advanced operation client API
3. Transports supported : HTTP
* Inbuilt HTTP server called simple axis server
* Apache2 httpd module called mod_axis2 for server side
* IIS module for server side. Supports IIS 5.1, 6 and 7.
* Client transport with ability to enable SSL support
* Basic HTTP Authentication
* Digest HTTP Authentication
* libcurl based client transport
* CGI interface
4. Transports supported : HTTPS
* HTTPS Transport implementation using OpenSSL
5. Transports supported : TCP
* for both client and server side
6. Transports supported : AMQP
* AMQP Transport implementation using Apache Qpid
* Available only in Linux platforms.
* At an experimental stage. Please refer the INSTALL file to
build this.
7. Transport proxy support (HTTP)
* Proxy Authentication (Basic/Digest)
8. Module architecture, mechanism to extend the SOAP processing
model.
9. WS-Addressing support, both the submission (2004/08) and
final (2005/08) versions, implemented as a module.
10. MTOM/XOP support.
11. AXIOM, an XML object model optimized for SOAP 1.1/1.2 messages;
This has complete XML infoset support.
12. XPath support for Axiom XML Object model
13. XML parser abstraction
* Libxml2 wrapper
* Guththila pull parser support
14. Both directory based and archive based deployment models for
deploying services and modules
15. Description hierarchy providing access to static data of Axis2/C
runtime (configuration, service groups, services, operations and
messages)
16. Context hierarchy providing access to dynamic
Axis2/C runtime information (corresponding contexts to map to
each level of description hierarchy)
17. Message receiver abstraction
* Inbuilt raw XML message receiver
18. Code generation tool for stub and skeleton generation for a given
WSDL (based on Java tool)
* Axis Data Binding (ADB) support
19. REST support (more POX like) using HTTP POST, GET, HEAD, PUT and
DELETE
* Support for RESTful Services
20. Comprehensive documentation
* Axis2/C Manual
21. WS-Policy implementation called Neethi/C, with WS-SecurityPolicy
extension

Major Changes Since Last Release
==============================

==

1. XPath support for Axiom XML object model
2. CGI support
3. Improvements to MTOM to send, receive very large attachments
4. Improvements to AMQP transport
5. Improvements to WSDL2C codegen tool
6. Many bug fixes.
7. Memory leak fixes

We welcome your early feedback on this implementation.

Thanks for your interest in Axis2/C !!!

-- Apache Axis2/C Team --

rajika's web log

A Stream Input-Output System

RIP DMR

Caching JMS objects in WSO2 ESB's JMS transport

RFC-6167 notes

Debugging high CPU consumption Java problem using thread dumps

Short tutorial on WS-RM

IBM MQ version 6.0 , WSO2 ESB JMS transport and JMS ExceptionListener

A JMS proxy which process both SOAP and non-SOAP messages

JMS Error - JNDI lookup of name QueueConnectionFactory returned a x.y.z while a interface javax.jms.ConnectionFactory was expected

JMS transport now supports re-connecting automatically when the broker is online

GSOC project - Apache Synapse MSMQ adapter

Linux reboot() system call and LINUX_REBOOT_MAGIC2 argument

Advice to systems researchers

Cloud Services Gateway ( CSG) user interfaces

Cloud Services Gateway ( CSG)

Configuring JMS transport in WSO2 ESB 4.*.*/WSO2 Carbon 3.2.*

WSO2 Stratos 1.0.0 Released!

WSO2 ESB and SFTP file transfer

WSO2 ESB won the gold award in NBQSA 2010

Webinar on extending WSO2 ESB

WSO2 ESB transactional use cases

Updating ESB configuration using a command line tool

The WSO2 Enterprise Service Bus (ESB) 3.0.1 Released!

The pre-mediate sequence in ESB

WSO2 ESB Q&A - #5

Starting daytime service on fedora 11

Clone+Aggregate sample

Process chains and fans

Carbon now supports monitoring behind a firewall

More improvements to JMS transport

Bit Twiddling Hacks

LLVM receives first ever SIGPLAN Software Systems Award

The perl bindings for Apache Qpid C++ clients

The broker component

Intergrating WSO2 ESB with WebLogic JMS provider

WSO2 ESB Q&A - #4

Synapse now supports using a temporary file in VFS transport

WSO2 ESB 3.0.0 Released!

The WSO2 Enterprise Service Bus (ESB) 3.0.0 Released!

How to Run

New Features of WSO2 ESB 3.0.0

Key Features of WSO2 ESB

Bugs Fixed in This Release

Known Issues

How You Can Contribute

Mailing Lists

Reporting Issues

Discussion Forums

Support

Proxy service fault handling improvements

LLVM 2.7 Release!

WSO2 ESB Q&A - #3

Exit handler in a C program

Advanced Message Queuing Protocol ( AMQP)

XPath functions and properties avilable in WSO2 ESB

Enabling Fast Infoset in WSO2 ESB

Deploying WSO2 ESB 3.x.x on JBoss

WSO2 ESB Q&A - #2

Public key authentication for sftp in WSO2 ESBs VFS transport

Writing a class mediator for WSO2 ESB 3.0.0

WSO2 ESB start up script options

Unix systems programming

UTF-8 history

WSO2 ESB Q&A - #1

My vim configuration and color scheme

The improved WSO2 ESB management console

Linear Algebra course materials from MIT

WSO2 ESB now supports POX security

Synapse config admin now supports syntax highlighting

Priority based mediation in WSO2 ESB

Experimental MSMQ transport for WSO2 ESB

WSO2 ESB's VFS transport now supports accessing a windows share

JMS two way routing scenario with WSO2 ESB

WSO2 Enterprise Service Bus 2.1.3 Released!

How to Run

New Features of WSO2 ESB 2.1.3

Key Features of WSO2 ESB

Get Involved

Contact Us

Configuring JMS transport in WSO2 ESB 4../WSO2 Carbon 3.2.*