Charith's Blog SPOT

Patterns in Science

2011-11-14T03:57:00.000-08:00

In science we see problems , solutions and explanations . Most interesting thing about this is we can see same solutions get repeated in different ways in different branches of science.

In this blog i’m going to explain a common solution pattern we see.

Recently i wrote and published an article named “Implementing Store and Forward Messaging Patterns With WSO2ESB Part 1” which explains how to implement store and forward messaging patterns using WSO2 Enterprise service bus.

One problem solved using Store and forwarded messaging patters is integrating systems that accepts different message rates or traffic patterns. As an example say there is a system that provides a service but that service can accept messages below a certain rate say 500msg/sec.
Requirement is to integrate it with another system. Now say if that system produces messages at average rate of 400msg/sec but it can have message rate spikes (ex : 800msg/sec). So One way to solve this problem is to have an intermediate storage for messages inside the message flow where message will get stored and then forwarded it to the destination at a constant rate. (Above mention article gives an example to implement this kind of a scenario).

But if we look around we can see same generic problem is solved using the same generic solution in different scenarios.

Scenario 1.

Irrigation systems :

Problem : In rain season we get lot of excess water which can’t be applied to the cultivation directly.
Solution : Store water in tanks and release them in a slow rate throughout the year.

Scenario 2

AC to DC conversion :

Problem : How to deliver a smooth constant DC voltage output from a AC source when we use a full wave or half wave rectification circuit using a diode bridge to do the conversion.

Solution : After rectification use a Capacitor to store the charges and let it discharge at its slow discharge rate which will results a somewhat smooth DC current.

And also the same pattern is indirectly used on old Sri Lanken irrigation systems to reduce the output water pressure of the Water Tanks.We call it “Bisokutuwa”. see http://www.sinhalaya.com/network/index.php?topic=557.0

So we can see in all these scenarios we have used the generic solution “store and forward” to solve the generic problem of “integrating different output rates with different input rates”.

Understanding and Terminating the Enemy- Deadlocks

2011-08-20T21:20:00.001-07:00

Concurrent programming is hard. And its even hard when you do it badly. Deadlocks are one of the classical enemies you must try to avoid when writing a concurrent program. Because if you face any deadlocks in your program its really hard to find and fix them.

In this post i’m trying to explain what deadlocks are and I’ll explain how to debug a program to find and fix deadlocks.

There are different definitions for deadlock personally i prefer the following definition since i feel its the perfect one.

“A set of processes is deadlocked if each process in the set is waiting for an event that only another process in the set can cause (including itself)” [1]

There are four necessary conditions to be there in a program if its leading to a deadlock. Which means if a program ended up in a deadlock state it that program will satisfy following four conditions.

Mutual exclusion : The resources that must involve in the problem must only have mutually exclusive access. Which means only an one thread/ process can have the access to the resources at one time.
Hold and wait : There are threads / processors that hold resource/s and wait for another.
Non preemptive - The resources that are held by one processes can’t be forcefully released.
Circular wait condition : The processes in the system form a circular list or chain where each process in the list is waiting for a resource held by the next process in the list

There will be no deadlocks in a program if it does not satisfy all these conditions .

I’ll explain a simple programming example that will demonstrate a simple deadlock.

public class Resource {



private Object lockA = new Object();



private Object lockB = new Object();





public void accessA() {

  synchronized (lockA) {



      //Access resource A

      System.out.println("GOT A waiting for B");

      synchronized (lockB) {

          //Access resource B

      }



  }

  System.out.println("Done accessA");

}



public void accessB() {

  synchronized (lockB) {

      //Access resource B

      System.out.println("GOT B waiting for A");

      synchronized (lockA) {

          //Access resource A

      }

  }

  System.out.println("Done accessB");

}

}

Look at the above Resource class. It got two public methods accessA and accessB. and two locks that protect resources A and resource B from accessing them in parallel.

if two threads try to invoke this two methods in parallel there can be a deadlock scenario where thread 1 will get the lock for A and waiting for B without releasing the lock for A and other thread will get lock for B and wait for the lock for A. This is the simplest scenario that a deadlock can happen between two threads.

If we look at the program you can see all the necessary conditions are satisfied by that program.

Mutual exclusion : resource A and B are Mutual exclusive resources ( Only one thread can access a resource at one time).
Hold and wait : The threads that invoke accessA and accessB methods will hold one resource and wait for another.
Non preemptive : In this program there is not way for us to signal a thread to release a resource forcefully.
Circular wait condition : thread1 <-> thread2

Now lets look at how we can eliminate deadlocks. I do not think there is such mechanical way to remove deadlocks from programs. And some times we will have to understand the lock access order of the program and change them in a such a way that they won’t endup in a cycle/s.If its not possible one thing we can do is track the lock order and detect possible deadlocks and forcefully terminate that thread or resource access.(Preemption)

When writing a complex concurrent program with lot of locks its hard to keep track of the lock order. So identifying possible deadlocks in program can be really useful when writing complex program. And it will be a great advantage if we can have a tool that can be used to identify possible deadlocks. I came across this tool JCarder[2] which i find really useful when analyzing programs for deadlocks. And the major advantage i see here is i could integrate it with integration tests.

JCarder detect possible deadlocks by instrumenting programs byte code and tracking the lock order in runtime. Which means it may not detect all the deadlocks in your program as a given execution will not cover all the code.

you can run your program with jcarder by passing vm parameter -javaagent:path/to/jcarder.jar

ex :

java -javaagent:path/to/jcarder.jar -jar yourprogram.jar

Then when your program executes jcarder will dump logs to a file which can be used later to analyze the deadlocks.

Then you can stop the program when you want and run the analyzer with command

java -jar jcarder.jar

Following is the report i got when i execute the above explained program.

Loaded from database files:

Nodes: 2

Edges: 2 (excluding 0 duplicated)



Cycle analysis result:

Cycles:          1

Edges in cycles: 2

Nodes in cycles: 2

Max cycle depth: 2

Max graph depth: 2



Ignoring 0 gated cycle(s).

Ignoring 0 almost identical cycle(s).

Finally if deadlocks are found it will generate a .dot file which can be visualized using dotty

ex :
$dotty jcarder_result_0.dot
or
$dot -T png -o example.png jcarder_result_0.dot

Following is the output i got for my program which clearly shows the deadlock.

Deadlocks are hard to debug and terminate so its always better to write programs carefully so that there won’t be any deadlocks :)

[1]http://homepages.uel.ac.uk/u0214248/Harriet3.htm
[2]http://www.jcarder.org/

WSO2 Enterprise Service Bus 4.0.0 Released!

2011-06-12T19:07:00.000-07:00

The WSO2 ESB team is pleased to announce the release of version 4.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 4.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/esband give it a try.

Brand New Features in this Release

HTTP relay transport - Pure streaming HTTP transport based on Java NIO for ultra fast HTTP routing
Deployment synchronizer - Easily synchronize the configuration across a cluster of Carbon Servers
Message stores and processors - For advanced enterprise messaging and QoS enforcement (eg: in-order delivery, exactly once delivery)
Mediation templates - The concept of reusable functions to the ESB configuration language
Message broker - Built-in JMS provider/broker powered by Apache Qpid
FTPS support via file transport - Transfer files over SSH connections
Conditional router mediator - Implement advanced and complex routing logic at ease
URL rewrite mediator - Rewrite URLs and URL fragments efficiently
Custom XPath extensions - User defined custom XPath extensions support
New HL7 transport (optional) - Send and receive HL7 messages over MLLP and other transports
New eventing implementation - A powerful event broker with extensive support for WS-Eventing and topic management
Event mediator - Publish events to topics defined in the built-in event broker
LDAP user store - Built-in LDAP service based on Apache Directory Server
Dynamic registry keys and endpoint URL support - Construct registry lookup keys and endpoint URLs dynamically at mediation time

Enhancements in this Release

Improved Smooks mediator
Enhanced support for service chaining with the receiving sequence support in the send mediator
Improved weighted round robin algorithm for the load balance endpoint
Improvements to caching
Automatic schema imports from the WSDLs added to the registry (for proxy services)
Automatic schema imports from the schema files added to the registry (for validate mediator)
Support for setting properties at the endpoint level
Enhanced Enrich Mediator
Improved support for batch transfers in FIX transport
Validation support for the ESB configuration editor (source view)
Proxy service UI enhancements
Enhanced menu layouts
Local transport for fast in-VM service calls

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 ultra-fast execution and support for thousands of connections at high concurrency 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 components. All the issues which have been fixed in ESB 4.0.0 are recorded at following locations:

Known Issues

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

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
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)

How to 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

We encourage you to report issues, documentation faults and feature requests regarding WSO2 ESB through the public ESB JIRA. You can use the Carbon JIRA to report any issues related to the Carbon base framework or associated Carbon components.

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 --

Web Service Orchestration with an ESB

2011-02-15T21:11:00.000-08:00

Web service orchestration can be thought as a process of combining and coordinating of different web services based on a predefined pattern to give a desired result.

Web Service Orchestration is one of many features that comes with an ESB (see [1]). Even though Business process servers can be used for this kind of tasks , using a business process server for a simple service orchestration scenario will be a waste of time. So in this blog post i’ll explain how we can use an ESB for service orchestration which will be a much simpler task.. I’ll be using WSO2 ESB 3.0.1 for this.

Let’s 1st come up with a scenario.

There are consultants who can give us some advices on life when we are in need. So lets try to have a consulting service.

But to consult a “Life guru” or the consultant 1st we need to get a ticket and then go to the “Life guru ” with that ticket.

Following is the high level message flow for this scenario

1) Client invoke ESB proxy service with Parameters name and age
2) ESB store the details and invoke Ticketing Service
3) Ticketing service return a ticket
4 ) ESB invoke consulting service with details name , age and ticket number
5) Consulting service returns the life advice
6) ESB pass the life advice to the client.

To implement this 1st we need to have some Services. So i’ll be creating two axis2 pojo services [2] for this.

1. TicketCounterService - input : void output : ticket number
2. ConsultingService - input : name , age , ticketnumber output : life advice

After having those service created and deployed (i used axis2 for service deployment).
Having those services deployed we can go in to the implementation of the ESB logic.

In WSO2 esb we will be creating a proxy service that excepts users name and age.It will then invoke the other services and then return the life advice back to the user.

We can use WSO2 ESB console to create the proxy service. I have choose to create a custom proxy and named it as ConsultingProxyService. and also i’m publishing a wsdl from this proxy so that there will be contract between ESB and the client.

Since ESB proxy must only accept users name and age. I edited the ConsultingServices wsdl by removing the ticket number input parameter.

Final Proxy service configuration will look like this.



<proxy name="ConsultingProxyService" transports="https http" startOnLoad="true" trace="disable">
    <target>
        <inSequence>
            <property xmlns:char="http://charith.wickramarachchi.org" name="cname" expression="//char:name" scope="default"/>
            <property xmlns:char="http://charith.wickramarachchi.org" name="cage" expression="//char:age" scope="default"/>
            <enrich>
                <source type="inline">
                    <p:getTicket xmlns:p="http://charith.wickramarachchi.org"/>
                </source>
                <target type="body"/>
            </enrich>
            <property name="count" value="1" scope="default" type="STRING"/>
            <send>
                <endpoint name="endpoint_urn_uuid_29C989B1BAE1F0A05F46088096875141764187336">
                    <address uri="http://localhost:8080/axis2/services/TicketCounterService"/>
                </endpoint>
            </send>
            <log level="custom">
                <property name="Status" value="TicketCounterService Invoked"/>
                <property name="cname" expression="get-property('cname')"/>
                <property name="cage" expression="get-property('cage')"/>
            </log>
        </inSequence>
        <outSequence>
            <switch source="get-property('count')">
                <case regex="1">
                    <property name="count" value="2" scope="default" type="STRING"/>
                    <xslt key="consultingServiceTransfrom">
                        <property name="cname" expression="get-property('cname')"/>
                        <property name="cage" expression="get-property('cage')"/>
                    </xslt>
                    <log level="full">
                        <property name="Status" value="Case2 Invoked"/>
                    </log>
                    <send>
                        <endpoint name="endpoint_urn_uuid_29C989B1BAE1F0A05F44795543807521144284854">
                            <address uri="http://localhost:8080/axis2/services/ConsultingService"/>
                        </endpoint>
                    </send>
                </case>
                <case regex="2">
                    <send/>
                </case>
            </switch>
        </outSequence>
    </target>
    <publishWSDL uri="file:///home/charith/Public/blogg/ServiceChaining/ConsultingProxyService.wsdl"/>
</proxy>

When a message comes to the proxy service 1st it will go in to the insequence of the proxy service. Where 1st it will store the name and age details in the message context. and then we will replace the body of the message with getTicket request message to invoke the Ticketconuter service. and then invoke the TocketCounter service. We also add the property named count to track the status of the service orchestration process.



<inSequence>
             <property xmlns:char="http://charith.wickramarachchi.org" name="cname" expression="//char:name" scope="default"/>
             <property xmlns:char="http://charith.wickramarachchi.org" name="cage" expression="//char:age" scope="default"/>
             <enrich>
                 <source type="inline">
                     <p:getTicket xmlns:p="http://charith.wickramarachchi.org"/>
                 </source>
                 <target type="body"/>
             </enrich>
             <property name="count" value="1" scope="default" type="STRING"/>
             <send>
                 <endpoint name="endpoint_urn_uuid_29C989B1BAE1F0A05F46088096875141764187336">
                     <address uri="http://localhost:8080/axis2/services/TicketCounterService"/>
                 </endpoint>
             </send>
             <log level="custom">
                 <property name="Status" value="TicketCounterService Invoked"/>
                 <property name="cname" expression="get-property('cname')"/>
                 <property name="cage" expression="get-property('cage')"/>
             </log>
         </inSequence>

The reply to the getTicket request will comes to the out sequence of the proxy service. Where we use the count value to determine the response type. If the count value is 1 then its a response from the ticket counter service.


<case regex="1">
                     <property name="count" value="2" scope="default" type="STRING"/>
                     <xslt key="consultingServiceTransfrom">
                         <property name="cname" expression="get-property('cname')"/>
                         <property name="cage" expression="get-property('cage')"/>
                     </xslt>
                     <log level="full">
                         <property name="Status" value="Case2 Invoked"/>
                     </log>
                     <send>
                         <endpoint name="endpoint_urn_uuid_29C989B1BAE1F0A05F44795543807521144284854">
                             <address uri="http://localhost:8080/axis2/services/ConsultingService"/>
                         </endpoint>
                     </send>
                 </case>

There we set the proerty count to 2 which means we are now going to invoke to ConsultingService. But for that we need to create the request message for that. Thats were we need the message transformation feature in an ESB. WSO2 ESB have few ways of transforming messages.(Ex : Enrichmediator , XSLT mediator) since i have used Enrich mediator before i’ll use XSLT mediator in this.

The request for CunsultingService must contain name , age and ticket number. But we only have ticket number with in the response message body. That’s where we are going to use the message context properties we added in the in-sequence. Since we are in a single communication session that message context properties will be preserved. So I m going to pass them as XSLT mediator properties so that i can use them in the xslt transformation .

following is the xslt transformation .



<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:fn="http://www.w3.org/2005/02/xpath-functions" exclude-result-prefixes="fn" version="2.0">
         <xsl:param name="cname"/>
         <xsl:param name="cage"/>
         <xsl:template xmlns:char="http://charith.wickramarachchi.org" match="//char:getTicketResponse ">
             <char:consult>
                 <!--Optional:-->
                 <char:name>
                     <xsl:value-of select="$cname"/>
                 </char:name>
                 <!--Optional:-->
                 <char:age>
                     <xsl:value-of select="$cage"/>
                 </char:age>
                 <!--Optional:-->
                 <char:ticket>
                     <xsl:value-of select="//char:return"/>
                 </char:ticket>
             </char:consult>
         </xsl:template>
     </xsl:stylesheet>

The response of the Consulting service will also come to the out sequence but now it will hit the case 2 of the switch since we have set the property count to 2 in the case 1 . In that case we just send the response back to the client


<case regex="2">
                     <send/>
                 </case>

Now we are done with the implementation.

Now i m going to invoke the Proxy service with SOAP request


<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:char="http://charith.wickramarachchi.org">
<soapenv:Header/>
<soapenv:Body>
   <char:consult>
      <!--Optional:-->
      <char:name>Charith</char:name>
      <!--Optional:-->
      <char:age>25</char:age>
   </char:consult>
</soapenv:Body>
</soapenv:Envelope>

and i received the response


<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
<soapenv:Body>
   <ns:consultResponse xmlns:ns="http://charith.wickramarachchi.org">
      <ns:return>Hello Charith Since your age is 25 Now its a good time to have some fun</ns:return>
   </ns:consultResponse>
</soapenv:Body>
</soapenv:Envelope>

I have uploaded all the source codes , configurations , xslt file , and web service archives to [3] so that you can try out your self.

[1]http://en.wikipedia.org/wiki/Enterprise_service_bus#Salient_characteristics
[2]http://axis.apache.org/axis2/java/core/docs/pojoguide.html
[3]http://rapidshare.com/files/448188843/esb-service-chaining.zip

Play with your byte-code using Javassist

2010-12-26T21:46:00.000-08:00

I came to know about this nice tool named javassist which is a cool java byte code manipulation tool.It provides users with a very easy to use API to modify / create java classes in the Runtime. It provides some API to do that using a Java like syntax so that we can easily hack the byte code without knowing any thing in-depth about the byte code structure.

In this blog post I'll explain you a simple example on how to use this tool.This will show how we can use javassist to change the byte code of a compiled class to change a method implementation in Runtime.

Step 1

Download javassist library from http://sourceforge.net/projects/jboss/files/Javassist/3.14.0.GA/

Step 2

Create a new directory and copy javassist.jar to that directory.

Step 3

Create Two java source file named HelloWorld.java and ByteCodeInjector.java in that directry

HelloWorld.java


public class HelloWorld {


   public static void main(String[] args) {
       new HelloWorld().sayHello();
   }

   public void sayHello(){
       System.out.println("Hello!!! This is the original version!!!");
   }
}

ByteCodeInjector.java


import javassist.CannotCompileException;
import javassist.CtClass;
import javassist.CtMethod;
import javassist.NotFoundException;

import java.io.IOException;

import static javassist.ClassPool.getDefault;


public class ByteCodeInjector {

   public static final String CLASS_NAME = "HelloWorld";
   public static final String METHOD = "sayHello";

   public static void main(String[] argos) throws Exception{
       modifyByteCode(CLASS_NAME,METHOD);
   }

   public static void modifyByteCode(String className ,String methodName)
           throws NotFoundException, CannotCompileException, IOException {
       //Get the Class implementation byte code
       CtClass ctClass = getDefault().get(className);

       //Get the method from the Class byte code
       CtMethod method= ctClass.getDeclaredMethod(methodName);

       /**
        * Creating the new Method implementation
        */
       StringBuffer content = new StringBuffer();
       content.append("{\n System.out.println(\"Hello!!! This is the Modified version!!!\");\n } ");

       /**
        * Inserting the content
        */
       method.setBody(content.toString());
       System.out.println("Replacing Method \' sayHello\' s body with new implementation : " + content);
       //modify the actual class File
       ctClass.writeFile();
   }
}

Step 4

Compile the two java sources adding the javassist.jar to your class path

$javac -cp javassist.jar:. HelloWorld.java ByteCodeInjector.java

Step 5

Run the HelloWorld class and see the out put

$java HelloWorld

Hello!!! This is the original version!!!

Step 6

Now Run the ByteCodeInjector class. That class will change the method implementation of the Helloworld:sayHello()

$java -cp javassist.jar:. ByteCodeInjector

Replacing Method ' sayHello' s body with new implementation : {

System.out.println("Hello!!! This is the Modified version!!!");

}

Now if you run the HelloWorld class you must see a output like

Hello!!! This is the Modified version!!!

Enjoy!!!

References

[1]http://www.csg.is.titech.ac.jp/~chiba/javassist/tutorial/tutorial.html

How to write a Axis2 Message Builder

2010-11-12T11:01:00.000-08:00

Apache Axis2 is a open source SOAP/ Web services engine which consists of many extension points. Message Builders and Message Formatters are two ways we can extend the axis2 transport framework.In this post i’m going to explain the idea of Message builders and how we can implement a custom message builder and use it.

As i mentioned above Axis2 is a SOAP engine. So it only accept SOAP messages for processing. So then a problem comes that how we can use axis2 with non-soap invocations like REST. So to convert row non soap content coming from a transport to a SOAP content we can use Message builders.

This can really be useful when your in coming message have a non-xml format and you need to invoke a web service or process it with the axis2 engine with the given content information.

Its simple to Write your own Message builder.
First what you have to do is write a class implementing org.apache.axis2.builder.Builder interface in the Axis2 Kernal module.

The Builder method signature we need to implement look like this.


public OMElement processDocument(InputStream inputStream, String contentType,
                              MessageContext messageContext) throws AxisFault

As we see here we have three input parameters

input stream : Stream of the raw payload
content type : content type of the message that Builder is registered with.
message context : axis2 message context

Here we can use input stream to create the SOAP info set from the coming message and its not a must to consume the input stream inside the builder.And we can use Axis2 message context to set any message context property information we get from the content or to get information from the message context that we need to build the message.

After we implement the Message builder we need to register it in the axis2 configuration (axis2.xml) with a content type. So messages that comes with that content type will be intercepted by the registered Message builder .

Example configuration in axis2.xml of that will look like this


 < messageBuilder contentType="application/xml"
                        class="org.apache.axis2.builder.ApplicationXMLBuilder"/>

For a recent project i had to implement a custom Message builder to parse a Email coming in a plan text format and create a SOAP Info set out of it to processing.The Message builder solution become ideal for that problem since i had no control over the system that send the Mails.

Dead Letter Channel Enterprise Application Integration Pattern

2010-04-17T23:45:00.001-07:00

Dead Letter Channel Pattern belongs to the Category of Message Channel patterns which describes the Message transport level attributes.

Idea of having a dead letter channel is to handle Message failures. Message failures can be occurred due to several reasons.

Transport level failures
Due to bad Configuration
Message Expiration
Problem with Message Consumer end

In a failure Message will be routed to the dead letter channel. So that it can act as a Message archive mechanism , Re router or a special channel to process the bad messages.

Having a Message archive system will be useful since later a Dead message can be viewed and re-delivered to the intended end point manually by a admin console.This will be useful to identify the Configuration problems

Message Re-delivery is also a major part of a dead letter channel implementation. If we take a normal scenario like simple DB quarries or web-service calls some times a message will fail because of the endpoint have a higher load or some other temporary issues with the endpoint . So simply re -delivering the message after a certain time interval will cause message to be delivered successfully.

Apache Synapse is a Open source esb and a message Mediation framework that support several Enterprise application integration patterns. For this summer(2010) Google Summer of code program I applied for the proposal of Implementing A Dead Letter Channel for Apache synapse. This is the link to my proposal .

Invoking WebServices using Axis2 SMS Transport

2009-12-22T20:18:00.000-08:00

In a previous blog I have explained the overview design of the Axis2 SMS Transport. Since Last week Axis2 Transport team announced Axis2 Transport 1.0 release in which SMS transport got released. I think its time to give some examples on how to use the SMS transport.

SMS Transport currently have two SMS implementations

SMPP protocol implementation
GSM implementation

where SMPP protocol implementation allow you to connect the axis2 to a SMSC and get messages form it. And GSM implementation allow you to connect a simple GSM modem to the computer that Axis2 is running and use that to send receive SMS form Axis2( its recommended not to use GSM implementation when your message traffic is higher than 6msgs per min).

SMS Transport allow Axis2 users to do following

Invoke a in only Web Service operation using a SMS
Invoke a in out Web service operation and receive a reply
Use Axis2 client and send messages out as a SMS

In this blog I 'll discuss how to use SMS Transport to invoke a simple a Web Service using a RPC type SMS via GSM implementation

Environment :

OS: Ubuntu 9.04

JDK : 1.6.0

Axis2 Version : 1.5.1

Modem : Huawei E220

Following are the Steps that need to be taken

Add Runtime Libs to Axis2 to Start with SMS Transport
Configure Axis2
Deploy our Simple service
Start Axis2
invoke service using a SMS.

Adding Runtime libs

add following file to the Axis2-HOME/lib directory

```
axis2-transport-sms-1.0.0.jar
```
```
axis2-transport-base-1.0.0.jar
```
smslib-3.4.1.jar
mail-1.4.jar

Now we need to add Java communication API libs needed for the SMS lib

go to jre home and goto lib/ext/ directory and add following files

comm.jar
libLinuxSerialParallel.so
libLinuxSerialParallel_g.so

Now we are Axis2 two is ready to start with Axis2 .

Configuring Axis2

Goto Axis2-HOME/conf folder where you find the axis2.xml file which is the configuration file used for Axis2 configuration.

Then add following to the Transport section.

SMS Transport Receiver configuration


<transportreceiver name="sms" class="org.apache.axis2.transport.sms.SMSMessageReciever">
<parameter name="smsImplClass">org.apache.axis2.transport.sms.gsm.GSMImplManager</parameter>
<parameter name="com_port">/dev/ttyUSB0</parameter>
<parameter name="gateway_id">modem.ttyUSB0</parameter>
<parameter name="baud_rate">115200</parameter>
<parameter name="manufacturer">HUAWEI</parameter>
<parameter name="model">E220</parameter>
</transportreceiver>

SMS Transport Sender configuration


<transportsender name="sms" class="org.apache.axis2.transport.sms.SMSSender">
<parameter name="smsImplClass">org.apache.axis2.transport.sms.gsm.GSMImplManager</parameter>
<parameter name="com_port">/dev/ttyUSB0</parameter>
<parameter name="gateway_id">modem.ttyUSB0</parameter>
<parameter name="baud_rate">115200</parameter>
<parameter name="manufacturer">HUAWEI</parameter>
<parameter name="model">E220</parameter>
</transportsender>

Now Axis2 is ready. Now lets write a Simple Axis2 Service

Deploy Axis2 Service

Following is the Sample POJO Axis2 Service Class I wrote to demonstrate this


package sample.sms.test;



public class SampleInOutService {


public String sayHello(String name) {

 return "Hello " + name;
}


}

Make a service archive of this POJO class and put that in the Axis2-HOME/repository/services directory.

Start Axis2

Then Start Axis2 by going to Axis2-HOME/bin and executing the shell script axis2server.sh.

If every thing goes ok you will see a log like this at the end

[INFO] Version: 3.4.1

[INFO] JRE Version: 1.6.0_06

[INFO] JRE Impl Version: 10.0-b22

[INFO] O/S: Linux / i386 / 2.6.28-14-generic

[INFO] GTW: modem.ttyUSB0: Starting gateway, using Generic AT Handler.

[INFO] GTW: modem.ttyUSB0: Opening: /dev/ttyUSB0 @115200

[INFO] GTW: modem.ttyUSB0: GSM: Registered to home network.

[INFO] GTW: modem.ttyUSB0: MEM: Storage Locations Found: SM

[INFO] GTW: modem.ttyUSB0: Gateway started.

[Axis2] Started in Port :/dev/ttyUSB0

[INFO] [SimpleAxisServer] Started

Now we are done now we can invoke the sayHello operation by sending a SMS message to the modem

following is the SMS

SampleInOutService:sayHello:name=charith

send that SMS to the modems phone number and you will get a SMS saying Hello charith

You can use SMS Transport Mixing implementations. ex : send messages using SMPP and recive via GSM modem.

This Transport will be useful when your going to implement your EDA (Event driven architecture) since users will be able to generate events and/or get notifications of events via SMSs

More details of SMS Transport can be found at SMS Transport documentation

Semaphores explained -- A Java approch

2009-10-18T07:09:00.000-07:00

Semaphore can be considered as a variable or Data Structure that can be used to archive mutual exclusion in a Parallel Programming environment.

One good real life example to explain this is the tablet mechanism that is used in old railway system. Where when a train enters a Train Station it need to get a tablet from the Station master to proceed to the next station. When the train get the tablet that means there will be no other train in the railway track till it reaches the next station. When The train arrived to the next station it must give back the tablet to the station master so that he can signal the station that train has come from that line is cleared now (line is clear )

So getting a tablet is like acquiring a lock in the train line so that other trains that are in need of acquiring the line need to wait till the train reaches the next station and release the lock ( give the tablet back).

This signal system still in use in Sri Lanken Railway line in some parts where there is only one rail track between two stations.

Above explained situation is an example for the Binary Semaphore. where it supports two operations up() and down() . A binary semaphore can have only two values 0 and 1 .(NOTE that up() , down() operations are atomic operations )

when someone call a up on semaphore if its value is 0 then it increment it to one and return so that execution can proceed. But if its value is 1 then that up call block the process execution till some one make the semaphore value to 0 (wait till a down call);

In a down call if semaphore value is 1 it decrement it can return. If its 0 then the down call will block the process execution till the semaphore value set to one (wait till a up call).

This little idea is extended to an idea called Counting Semaphores there we can have more than two values for the semaphore. So that process can call multiple up s /down s till it get blocked.Which means more that one thread can pass the through before it blocked.

Now its time to look in to how this going help to solve a mutual exclusion problem.

Following is a famous problem in Concurrent programming text books lets see how we can solve it.

Bill and Ben work in a cafe that specialises in a soup and sandwich combination.

Bill makes two rounds of sandwiches while, at the same time, Ben makes two bowls of soup. When the sandwiches and soup are ready Bill and Ben each, they serve a soup and sandwich combination to a customer. These actions are repeated throughout the day.

[Note: Bill cannot serve until Ben has made the soup and Ben cannot serve until Bill has made the sandwiches.]

So as the Problem explained Before Serving sandwiches and soup Bill and Ben need to sync up.

Which means there can be no two customers in the shop at any time that has only served one item.(soup/sandwich)

If we model Bill and Ben as two processes that executes parallely it must be like follows

process Bill {

while (true) {

// Bill makes sandwiches //

SYNCH 1;

// Bill delivers //

}

process Ben {

while (true) {

// Ben makes soup //

SYNCH 2;

// Ben delivers //

}

To implement this Processes I'll be using the Java Language. Java has inbuilt semaphore implementation in java.util.concurrent.Semaphore

Its a counting Semaphore implementation. For this case since we only need a binery semaphore I'll will use it with permit value 1. which means only 1 thread is permitted to acquire it at a time.

I'll use the operations acquire and release operations which are smiler to up and down operations .

First lets look in to the code.



import java.util.concurrent.Semaphore;

public class Cafe {
private  final Semaphore bill = new Semaphore(1);
private  final Semaphore ben = new Semaphore(1);


public static void main(String[] args) throws InterruptedException {
  //Cafe opening
  new Cafe().openCafe();
 // Cant keep it open for long time.... :D
 Thread.sleep(1000);
 System.exit(0);
}


private void openCafe () throws InterruptedException {
  // allocating them to the work
  bill.acquire();
  ben.acquire();


  Thread benProcess = new Thread(new Ben());
  Thread billProcess = new Thread(new Bill());
  //work started
  benProcess.start();
  billProcess.start();


}
class Bill implements Runnable {

  public void run() {
      int i=0;
      while(true) {
          System.out.println("[Bill] finished making 1 sandwitch");
          System.out.println("[Bill] finished making 2 sandwitchs");

          try {

              //bill says i m done
              bill.release();
              // bill wait till ben done
              ben.acquire();
          } catch (InterruptedException e) {
              System.out.println("Process interrupted....");
          }

          System.out.println("[Bill Serves...Sandwitch to customer "+ ++i+" ]");
      }
  }
}

class Ben implements Runnable {

  public void run() {
      int i=0;
      while(true) {
          System.out.println("[Ben] finished making 1 Soup");
          System.out.println("[Ben] finished making 2 Soup");

          try {

              // ben says i m done
              ben.release();
              // ben waits till bill done
              bill.acquire();
          } catch (InterruptedException e) {
              System.out.println("Process interrupted....");
          }

          System.out.println("[Ben Serves... Soup to Customer "+ ++i+"]");
      }
  }
}
}

So if we looked in to the code Bill and Ben are implemented as two runnable s . At the start We create a Cafe allocate Ben and Bob work and tell them to start work.

If we look in to Bill Process what it does is it creates two Sandwiches and tell that I, m done by releasing bill semaphore and waits till Ben finished by trying to acquire the ben semaphore.

And Ben does other way around.

So it guarantees that Ben cant serve till Bill finish and Bill cant till Ben finishes.

So at the end when the processors executing parallely the condition of there can be no two customers in the shop at any time that has only served one item.(soup/sandwich) is satisfied.

Following is sample console out put I got

[Ben] finished making 1 Soup
[Ben] finished making 2 Soup
[Bill] finished making 1 sandwitch
[Bill] finished making 2 sandwitchs
[Ben Serves... Soup to Customer 1]
[Ben] finished making 1 Soup
[Ben] finished making 2 Soup
[Bill Serves...Sandwitch to customer 1 ]
[Bill] finished making 1 sandwitch
[Bill] finished making 2 sandwitchs
[Ben Serves... Soup to Customer 2]
[Ben] finished making 1 Soup
[Ben] finished making 2 Soup
[Bill Serves...Sandwitch to customer 2 ]
[Bill] finished making 1 sandwitch
[Bill] finished making 2 sandwitchs
[Ben Serves... Soup to Customer 3]
[Ben] finished making 1 Soup
[Ben] finished making 2 Soup
[Bill Serves...Sandwitch to customer 3 ]

......... goes on

You can see the condition is satisfied.
Hope this helps to improve your understanding on Semaphores...

Executing maven test with the ant run plugin--A Real experiance.

2009-08-19T19:01:00.000-07:00

Few days back i got a unexpected result with using the maven ant run task with a patch i submitted for the unit tests for the SMS Transport(which is my GSoC project).So i thought it would be useful if i blog my experiance and how i solved that issue.

So i'll start with my xml segment in the pom.


<plugin>
      <groupid>org.apache.maven.plugins</groupid>
      <artifactid>maven-antrun-plugin</artifactid>
      <executions>
          <execution>
              <id>build-repo</id>
              <phase>test-compile</phase>
              <configuration>
                  <tasks>
                      <mkdir dir="target/test-resources/samples/conf">
                      <mkdir dir="target/test-resources/samples/repository/modules">
                      <mkdir dir="target/test-resources/samples/repository/services">
                      <mkdir dir="target/test-resources/samples/repository/services/SampleService/org/apache/axis2/transport/sms">
                      <mkdir dir="target/test-resources/samples/repository/services/SampleService/META-INF">
                      <copy file="${settings.localRepository}/org/apache/axis2/addressing/${axis2.version}/addressing-${axis2.version}.mar" tofile="target/test-resources/samples/repository/modules/addressing.mar">
                      <copy file="target/test-classes/org/apache/axis2/transport/sms/SimpleInOutMessageReceiver.class" tofile="target/test-resources/samples/repository/services/SampleService/org/apache/axis2/transport/sms/SimpleInOutMessageReceiver.class">
                      <copy file="conf/axis2.xml" tofile="target/test-resources/samples/conf/axis2.xml">
                      <copy file="repository/services/SampleService/META-INF/MANIFEST.MF" tofile="target/test-resources/samples/repository/services/SampleService/META-INF/MANIFEST.MF">
                      <copy file="repository/services/SampleService/META-INF/services.xml" tofile="target/test-resources/samples/repository/services/SampleService/META-INF/services.xml">
                  </copy>
              </copy>
              <goals>
                  <goal>run</goal>
              </goals>
          </copy>
      </copy>
  </copy>

</mkdir></mkdir></mkdir></mkdir></mkdir></tasks></configuration></execution></executions></plugin>

As you see there is only some mkdir and copy tasks listed in the test-compile phase

So When I run the tests test where executed successfully(mvn clean install / mvn test)
And also when i skip the tests with mvn clean install -Dtest=false the build was successful.

The problem comes when i try to skip the test with mvn clean install -Dmaven.test.skip=true
when i do that follwing error appiers

[ERROR] BUILD ERROR
[INFO] ------------------------------

------------------------------------------
[INFO] An Ant BuildException has occured: Warning: Could not find file /home/charith/projects/transport/modules/sms/target/test-classes/org/apache/axis2/transport/sms/SimpleInOutMessageReceiver.class to copy.

So If you look in to the ant run plugin the copy tasks are listed in the "test-compile" phase so its seems correct to assume that those tasks will not execute when we skip the tests.And it seems that assumption is correct when we use the -Dtest=false.But that assumption fails with we run with -Dmaven.test.skip=true

The reason for this error is the .class file that the copy task trying to copy created after compiling the test sources.but when we use -Dmaven.test.skip=true to skip the tests it will execute the tesks that are listed in the test-compile phase .So it reports the Error.

to overcome that case i had to add the system variable check to the task.Now it will check for the maven.test.skip variable before executing the test.So if it is true it will not execute the tasks in the test-compile phase.Following this the modified pom which resolved the issue.



<plugin>
        <groupid>org.apache.maven.plugins</groupid>
        <artifactid>maven-antrun-plugin</artifactid>
        <executions>
            <execution>
                <id>build-repo</id>
                <phase>test-compile</phase>
                <configuration>
                    <tasks unless="maven.test.skip">
                        <mkdir dir="target/test-resources/samples/conf">
                        <mkdir dir="target/test-resources/samples/repository/modules">
                        <mkdir dir="target/test-resources/samples/repository/services">
                        <mkdir dir="target/test-resources/samples/repository/services/SampleService/org/apache/axis2/transport/sms">
                        <mkdir dir="target/test-resources/samples/repository/services/SampleService/META-INF">
                        <copy file="${settings.localRepository}/org/apache/axis2/addressing/${axis2.version}/addressing-${axis2.version}.mar" tofile="target/test-resources/samples/repository/modules/addressing.mar">
                        <copy file="target/test-classes/org/apache/axis2/transport/sms/SimpleInOutMessageReceiver.class" tofile="target/test-resources/samples/repository/services/SampleService/org/apache/axis2/transport/sms/SimpleInOutMessageReceiver.class">
                        <copy file="conf/axis2.xml" tofile="target/test-resources/samples/conf/axis2.xml">
                        <copy file="repository/services/SampleService/META-INF/MANIFEST.MF" tofile="target/test-resources/samples/repository/services/SampleService/META-INF/MANIFEST.MF">
                        <copy file="repository/services/SampleService/META-INF/services.xml" tofile="target/test-resources/samples/repository/services/SampleService/META-INF/services.xml">
                    </copy>
                </copy>
                <goals>
                    <goal>run</goal>
                </goals>
            </copy>
        </copy>
    </copy>

</mkdir></mkdir></mkdir></mkdir></mkdir></tasks></configuration></execution></executions></plugin>

As you see the only change is tasks unless="maven.test.skip" in the task element which check !(maven.test.skip)

the follwing xml segment is logically equal to

if(!(maven.test.skip)) {
//execute task
}


<tasks unless="maven.test.skip">

After this system variable check I was successful with running the tests with -Dtest=false , -Dmaven.test.skip=true.

Chandi jaisa rang hai tera- My favorite Gazal

2009-08-17T07:14:00.000-07:00

Gazal is a beautiful Hindustan music style which have lot of great songs.the most important thing about gazal style is most of the songs can be enjoyed even without having a classical music background.Most of the gazals are written about romance.It carries "Srungara Rasa" with it.

The Gazal song Chandi jaisa rang hai thera is a gazal that admire the beauty the girl that he loves.

Chandi jaisa rang hai tera, sone jaise baal
Ek tuhi dhanvaan hai gori, baaki sub kangaal
Chandi jaisa rang hai tera, sone jaise baal
Ek tuhi dhanvaan hai gori, baaki sub kangaal
Ek tuhi dhanvaan hai gori, baaki sub kangaal

Jis reste se tu gujre, voh phoolon se bhar jaye
Jis reste se tu gujre, voh phoolon se bhar jaye
Tere pair ki komal aahat sote bhaag jagaye
Jo patthar choo le gori tu voh heera ban jaye
Tu jisko mil jaye voh, tu jisko mil jaye
Vo ho jaye malamal
Ek tuhi dhanvaan hai gori, baaki sub kangaal
Chandi jaisa rang hai tera, sone jaise baal
Ek tuhi dhanvaan hai gori, baaki sub kangaal

Jo be-rang ho us par kya kya rang jamate log
Jo be-rang ho us par kya kya rang jamate log
Tu naadaan na jane kaise roop churate log
Nazaren bhar bhar dekhen tujhko aate jaate log
Chail chabeeli rani thoda, Chail chabeeli rani thoda
ghoonghat aur nikaal
Ek tuhi dhanvaan hai gori, baaki sub kangaal
Chandi jaisa rang hai tera, sone jaise baal
Ek tuhi dhanvaan hai gori, baaki sub kangaal

Dhanak ghata kaliyan aur tare sub hain tere roop
Dhanak ghata kaliyan aur tare sub hain tera roop
Ghazalen hon ya geet hon mere sub mein tera roop
Yunhi chamakti rahe hamesha tere husn ki dhoop
Tujhe nazar na lage kisi ki
Tujhe nazar na lage kisi ki
Jiye hazaron saal
Ek tuhi dhanvaan hai gori, baaki sub kangaal
Chandi jaisa rang hai tera, sone jaise baal
Ek tuhi dhanvaan hai gori, baaki sub kangaal
Chandi jaisa rang hai tera, sone jaise baal
Ek tuhi dhanvaan hai gori, baaki sub kangaal
Ek tuhi dhanvaan hai gori, baaki sub kangaal
Ek tuhi dhanvaan hai gori, baaki sub kangaal

Axis2 SMS Transport

2009-06-22T18:33:00.000-07:00

Apache Axis2 is an opensource framework for webservices which is widely used today ,and its implementation is available in both java and c. Axis2 is independent of the underlying transports which takes the Messages to it.Axis2 Engine is concentrating on the SOAP processing. Users can select transports to suite their requirement and that transports are responsible for injecting Axis2Messages to the Axis2Engine.So Axis2 Engine is dealing only with this Axis2MessageContex build from the underlying transport framework.

I' m writing SMS Transport as my Google Summer of Code 2009 project for Apache Axis2 which is a project focusing on implementing a SMPP support for Axis2java (And also it will able be used in Apache Synapse too Since Synapse uses the same axis2Transports ) by which Axis2 will be able to communicate with SMSCs (Short message service centers) or Any other Message centers that support SMPP . And also in this project it will make enable axis2 to communicate with Simple GSM modems.

At the beginning of the Project I considered the Word "SMS" as a generic one where there can be many implementations.Currently it support the SMPP protocol to send receive SMS via Message Centers.The SMS transport is designed and implimented in a such a way that it can be easyly extended to use any other implimentations or to use any SMS message formats.

SMPP - Short Message Peer to Peer protocal is an open, industry standard protocol
designed to provide a flexible data communications interface for transfer of short message data between a Message Center, such as a Short Message Service Centre (SMSC), GSM
Unstructured Supplementary Services Data (USSD) Server or other type of Message Center
and a SMS application system, such as a WAP Proxy Server, EMail Gateway or other
Messaging Gateway.The advantage of supporting SMPP protocol with the Axis2 SMS Transport is it can be use to send receive high volume of Short messages very fast.SMPP protocal is a Application layer protocal which can be used over TCP. There are many SMPP gateways avalilable in the world.and now almost all the Message centers support SMPP.Click is a good example of a SMPP sms gateway.
https://www.clickatell.com

SMS Transport will also support send receive SMSs using a Simple GSM modems attached to the Computer.This sms implementation can be used when the data Traffic is very low.A Typical GSM modem can only handdle about 6 messages per minute.If a user need to have a heiger data Traffic with the Axis2 the SMPP implimentation can be used.

following is an diagram of the overview of SMS Transport

Extending SMS Transport

SMS Transport was design to be a extensible one.where it provides proper interface to extend and reuse the current implementations.

If we focus on Axis2 SMS Transport the Axis2 dependent Transport senders , Transport listeners , Message Builders , Message Formatters are put in the generic SMS layer. That layer will be depending on the underlying implementation layer which only focus on the current SMS implementation which will have nothing to do with Axis2. So the advantage is that the Developers who need to write another implementation need not to worry about the Axis2.They just need to rely on the provided API and focus on their Implementation logic.

Other Extensible point of the SMS Transport is the Extending MessageFormatters and Message Builders.Users can write there own Message Builders and formatter to send receive any message formats they like by implementing the interfaces coming with the SMS Transport.

This blog is only a overview of the Axis2 SMS Transport and there will be documentation coming explaining the configuration , and extensibility of this Transport.

Spot Light to Service Component Architecture

2009-04-25T10:37:00.000-07:00

If we take a Normal Software application it will be consist of Many components.Where they may be developed using a same technology or different technologies.And also they may be deployed in a Same runtime ,machine or different ones and communicating with each other using a same technology or different technologies.

SCA (Service component Architecture) defines how these components are created and how they are assembled together to build composites.It is a programing model build based on the SOA.

According to the SCA specification SCA applications can be implemented using many technologies like Java ,Spring ,C++ etc ... SCA defines how these components built using any technology can be Assembled to built a application.

A Simple example of a Component assembled to build a Application would be a Simple Java Application with few classes communicating with each other in a Single JVM.Or in a More Complex case it will be set of Web Services working together to build up a Custom Service .

SCA Component is the atomic unit in a SCA application where they can be combine together in a preferable way
As the Diagram shows a Component can expose services that other components (or may be the out side applications )will be able to use.And also a Component may be relying on the Services provided by other components(or by out side systems).And also a Components can have properties that will be able to initialized at the component creation.In SCA a component can be properly configured by mentiong above mentioned properties ,services etc using SCDL (service component definition language)

Composites are Logical constructs that will consist of one or many components.but interestingly these components in side a Composite may be distributed in many runtimes. So it is impotent to understand that composite only define a logical construct using deferent components.It will have a logical meaning in the context of work done within the composite.But the components that the composite is build from may use different technologies.

As u see The composites can also have Services references , properties.

Following is a example of how a composite is configured using SCDL

sample.composite

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

<composite xmlns="http://www.osoa.org/xmlns/sca/1.0"
          xmlns:burlap="http://www.fabric3.org/binding/burlap/0.2"
          name="BurlapTestComposite">

   <!-- Hello Client -->
   <component name="HelloClient">

       <implementation.java class="org.fabric3.sample.hello.HelloClientImpl"/>
   <reference name="helloService" target="HelloService"/>
   </component>

   <!-- Hello Service -->
   <component name="HelloService">
       <implementation.java class="org.fabric3.sample.hello.HelloServiceImpl"/>
   </component>

</composite>

These fundamentals of SCA (components and composites) are contained with in a lager construct called SCA domain.Which is normally a Set of Systems with a common SCA runtime technology and common management(people).

Apache Tuscany , HydraSCA , Fabric3 are few examples of these SCA Runtimes.

SCA can be seen as a programming modal that will be very useful when developing and maintaining complex business applications.Which ensure the reuse by having low coupling and componentizing . The modal that SCA is trying to bring in is not a new concept to the domain. Even the Spring frame work has same concepts that shears with the SCA.These evelutions happening are showing some bright lights of the Pinnacle we are seeking in the Computer Science.

references : http://www.osoa.org/display/Main/Service+Component+Architecture+Home

Configuring Apache Synapse - Spring With IDE support

2009-03-29T19:38:00.000-07:00

Apache Synapse uses its own XML based DSL for Configuration.At the Synapse Initialising phase Synapse reads the XML file and Build the Synapse Configuration Object Structure.
It takes time to new users to be familiar with the Synapse Configuration language.Some times they may have to look in to the synapse configuration factories to know the all the configuration parameters.

Spring-DSL for synapse project enable users who are familiar with Spring syntax to configure synapse in Spring (both underlying Axis2 instence and Synapse)

One of the main advantages here is users being able to configure synapse using IDE support . Following are few Screen shots taken from the comming tutorial on Spring DSL for Synapse

Guardian-Mobile become handy when your mobile got stolen(personal experience)

2009-03-07T07:11:00.000-08:00

I lost my mobile yesterday night while i m on the way home in a train.Its about 10:30 pm when that happen.since its late night there were only few people in the train.This happen when the train stopped at the Bulugahagoda(between Gampaha and Ragama).
I was holding the phone because i got a phone call just before that happen.Suddenly one from the back grabbed my phone and run away and jump from the Train.I was fraction of a second late from catching him.
The reason i m blogging now is to explain how the Guardian-Mobile which is installed in my mobile helping me and the police to track the guy who is using it.

Guardian is an Advanced Antitheft Software for Mobile devices, it provides unique and powerful features:
- Sim Changed notification through Invisible sms
- Password Protection of messaging, gallery, contacts or every other application
- GPS Localization and Tracking through GoogleMaps
- optimized for Low Memory and Battery consumption
- and MUCH more...[1]

I have registered my sim as the user sim in that software.So when some one change the sim in my mobile , my mobile send a SMS from my mobile to a pre-configured no(In my case its my brothers no).

That SMS contains following details

phone NO: phone number of the currrent user
IMEI : International mobile euipment identity
IMSI : International Mobile Subscriber Identity
GSM CELL ID
GSM AREA ID
GSM COUNTRY ID

Now i'm getting updates from my mobile about the SIM changes containing above info.I have provided that information to the police So they can get the user information form the service provider.

IMEI can also used to track a user.

IMEI is a unique number for a given mobile device.when that device try to do any data transfer it sends it IMIE to the service provider (Which get logged) even a service provider can reject any data transfers from a given IMEI.So we can use this to track the device and also to make is useless to the user.

IMSI is a unique no for a given SIM

cell id and area id are GSM network specific details which can be used to track the mobile location.

I have already given up in finding my mobile but i hope at least police will be able to track the guy or the gang who did this which is finally good for the Country.

IMHO even the Gardian free edition is good for general use.

[1]http://www.guardian-mobile.com

Its time to Stop Forwarding junk mails

2009-01-22T03:22:00.001-08:00

With the fast growth of internet facilities and lot of free space given in mail accounts.Now People used to forward some mails that contain

Wishes , Beautiful Pictures ,etc....
They are using it as a good way of keeping touch with friends.

But if we see the size of those mails with attachments.and the way they are transfered between people its a great waste of resources.each and every mail we send use the processing power of every node in its path.Processing time of those nodes means power.

I think its time for us to sit back and think about the big process happening behind before we forward a another mail.

according to the Butterfly effect "Small variations of the initial condition of a dynamical system may produce large variations in the long term behavior of the system."

Lets make that Small variation for the betterment of the globe.
So lets try do minimize the unwanted data transfers through networks.And save some resources of the globe.

As a conclusion i remember a great saying "Earth has more than enough resources to fulfill mans needs but not his unlimited desires"

Apache Synapse Spring Mediator -(Feel the power of Apache Synapse)

2009-01-06T04:21:00.000-08:00

Apache Synapse is a Light weight ESB from Apache which supports XML webservies. And also it is a very extendible project[1].

Massage mediation is a core mode in Synapse. When in massage mediation mode Synapse act as a transparent proxy for clients. And also if Synapse receives a massage that does not belongs to any of the proxy services it will go through massage mediation[2] defined.

Synapse has Components named as Mediators witch can perform mediation action on the Message(MessageContext).Mediators get the full control over the message that is passing through it. Mediator can modify and inspect message or do something by looking at the message body. Since Synapse supports writing custom mediators the possibilities of usage of Mediators become unlimited.

Synapse Spring Mediator is a Mediator which enables Spring users to expose their Spring Beans as Mediators in Synapse.

Following is a example of how to use Spring Mediator

First thing we have to do is write a simple Bean that extends org.apache.synapse.mediators.AbstractMediator (AbstractMediator class can be found in Synapse core).

Eg:

package demo.hello;

import .....

public class HelloMediator extends AbstractMediator {

private String name;

public void setName(String name){

this.name=name;

}

public String getName(){

return name;

}

public boolean mediate(MessageContext synCtx) {

System.out.println(“Messsage Id: ”+ synCtx.getMessageID());

System.out.println(“Hello ”+name);

return true;

}

then put that class in to a Jar file and put it in the lib directory in Synapse installation directory(SYNAPSE_HOME).

Then we should write a xml file for that Spring Bean

ex: springsample.xml

and then we must write a SynapseConfiguration to use this. For that edit the Synapse.xml file in SYNAPSE_HOME/repository/conf/ as follows

put the springsample.xml in repository/conf/ directory of the Synapse installation directory.

Then Start the Synapse and try sending a message through synapse (you can use the client and server that is used in Synapse sample 0).

Above example shows how we can use the Synapse Spring Mediator to make Spring Bean a Mediator.

Now lets Look at the Power of this usage of Spring mediator. Since a mediator gives the total control over the message passing through it and the Spring supports Inject dependencies to the Spring bean using a XML configuration file,using a Spring Bean as a Mediator gives Spring users unlimited degree of freedom over the Message passing through the Spring bean.

One possibility came across my mind is Spring Users can use the Spring Mediator as a Bridge to pass a the Message to their own project.Using the inversion of control capability given by Spring .Spring users can make that very effective and flexible.

As image shows Spring Bean Mediator can be used as a bridge to pass the Messsage context to a project,And using the Spring XML file user can define appropriate dependencies that can be used to process the message without changing the code or changing Synapse Configuration. The main advantage here is Spring users do not have to have the knowledge on Synapse configuration. Once they have configure the synapse to use the the Spring Mediator they can use and change the Spring XML file to inject dependencies that can be used to use/change the message context.

And also I think Spring Mediator can be used to make a Wrapper Software project around synapse(As the same way synapse is wrapped around axis2) and Spring XML file can be used as a configuration file for that software.

[1] -http://synapse.apache.org/Synapse_Extending.html

[2]-http://synapse.apache.org/Synapse_Configuration_Language.html

Lenovo 3000 N200 sound card problem solved

2008-10-22T08:25:00.000-07:00

My Laptop is a lenovo 3000 N200.After i installed Ubuntu 8.04 my sound car was not detected by the system.
And also there were no software to test my finger print reader.

To fix the sound card problem in Lenovo 3000 N200 what i did was

1. open alsa-base file in the /etc/modprobe.d directory using a text editor

eg: $sudo vim /etc/modprobe.d/alsa-base

2 .then add following line to the end of that file

options snd-hda-intel model=lenovo
(and saved the file)

3.Open a empty text space and add the same line to that and save it as modprobe.conf in /etc/ directory and /etc/modutils/ directory

then i saved the files and restart the machine

finally i heard the sweeeeeeet Ubuntu starting sound........Cooooool
My next step is to find a fingerprint reader software for my fp reader....

Dialog HSPA modem in Linux /Ubantu

2008-10-18T09:18:00.000-07:00

Finally i managed to use my Dialog HSPA modem in Ubantu 8.04 .It is a Huawi e220 modem i used to connect.I didn't successful in using wvdial in this case.
So what i did is update the ubanu network manager by adding some src url to my update list file
this is the steps i followed

1. go to /etc/apt

2. open source.list file in a text editor (you must set the R/W active to the file before that)

3 Add following two lines to the end of the file

deb http://ppa.launchpad.net/network-manager/ubuntu hardy main
deb-src http://ppa.launchpad.net/network-manager/ubuntu hardy main

and save the file

4. type apt-get update in the terminal (Better do it as the root)

5.Then update manager will appier in the task bar( its a arrow directing down direction to indicate download)

6.DO the update and restart the machine with modem connected.

7.go to system->preferences -> network configuration to configure the connection

if you do not have a internet connection ,
use following url to download network manager
http://packages.ubuntu.com/gutsy/i386/network-manager-pptp/download

But what I did was i net worked my machine with windows machine and use my dialog modem to connect to the internet using that machine and share the net connection so that i can update Ubuntu online

have fun.......

Mobile Train TimeTable for Srilanka

2008-09-08T01:00:00.000-07:00

For my Level 3 programming project I did a train time table management system which enables the Users to view train details through mobile phone and a web interface.while the train staff is able to keep the train time table upto date by adding ,removing,editing ,posting delays ect..

This was a solution provided for a current Sri Lanken problem where no existing solutions are there.
It is a extendible system which was designed and implemented using MVC architecture.As a result of that the system is easily convertible to the new technologies.

you can read the Final Report of the project from
http://rapidshare.com/files/143558563/Final_Report.pdf.html

you can download mobile application source from
http://www.4shared.com/dir/9174953/943469c2/MeelangaDumriya.html

Enjoy
MOBILE MOBILE MOBILE MOBILE MOBILE MOBILE
CHARITH CHARITH CHARITH CHARITH CHARITH