My weblog...

Into'ing Kubernetes (k8s)

2016-11-01T14:19:00.006+05:30

Kubernetes (k8s) is an open source platform for automating container operations such as deployment, scheduling and scalability across a cluster of nodes. If you are familiar with Docker container technology to deploy your containers, then consider Docker as a low level component used internally by Kubernetes to deploy containers.

- Managing application containers, using Kubernetes

- Manage deploying, scaling, and updating your applications

A Kubernetes cluster consists of two types of resources:

Master coordinates the cluster - scheduling applications, maintaining applications' desired state, scaling applications, and rolling out new updates.
Nodes are the workers that run applications - Each node has a Kubelet, which is an agent for managing the node and communicating with the Kubernetes master. The node should also have tools for handling container operations, such as Docker or rkt.

Masters manage the cluster and the nodes are used to host the running applications.

When you deploy applications on Kubernetes, you tell the master to start the application containers. The master schedules the containers to run on the cluster's nodes. The nodes communicate with the master using the Kubernetes API, which the master exposes. End users can also use the Kubernetes API directly to interact with the cluster.

A Kubernetes cluster can be deployed on either physical or virtual machines.

Try out kubernetes interactive tutorial :
http://kubernetes.io/docs/tutorials/kubernetes-basics/cluster-interactive/

Docker to run your applications

2016-10-27T11:00:00.000+05:30

Begin with a simple sample;
Sample 1 : Running a PHP application

src/index.php

<?php

Echo “Hello user”;

dockerfile

FROM php:7.0-apache

COPY src/ /var/www/html

EXPOSE 80

.
├── dockerfile
└── src

└── index.php

Build: docker build -t myhelloapp .

Run: docker run -v /home/thilini/Desktop/docker/src/:/var/www/html/ myhelloapp

docker run -p 80:80 -v /home/thilini/Desktop/docker/src/:/var/www/html/ myhelloapp

Output:

Sample 2 : Running a Java application

docker file

FROM java:7

COPY src/ /usr/src/myapp

WORKDIR /usr/src/myapp

RUN javac HelloWorld.java

CMD ["java", "HelloWorld"]

docker build -t my-java-app .

docker run -it --rm --name my-running-app my-java-app

More..

List containers : docker ps

Verify the image was built successfully : docker ps -a OR docker ps --all

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

List docker images : docker images
REPOSITORY TAG IMAGE ID CREATED SIZE

Remove unwanted docker containers : rm {container_ID}

Adding business rules to your enterprise applications

2016-06-09T13:30:00.003+05:30

Business rules help to determine the flow of your processes based on a group of rules you define.

Compared to traditional systems, the addition of business rules to you application has the following advantages.

Shortened development time
Changes can be made faster, with a lower risk
Rules are externalized and easily shareable among multiple applications
Lowers the cost for modifying the business logic
Increase the Line of Business (LOB) control over implemented decision logic for compliance and business management.
Reduce/remove the reliance on IT for changes in the production systems.
Improve process efficiency.

Business Rules capabilities in the WSO2 middleware platform brings the agility of business rules to your SOA toolkit. Based on a solid platform for hosting business rules, WSO2 business rules excel at extending the capabilities of your SOA.

It's used to define, deploy, execute, monitor and maintain the variety and complexity of decision logic that is used by operational systems within an enterprise.

SOA is the most prominent architectural pattern used to integrate heterogeneous systems. Therefore if the business decisions written as rules can be exposed as services then business rules can also be integrated to SOA systems.

Start a Process Instance using the BPMN REST API

2016-06-07T08:16:00.000+05:30

Request endpoint to start a BPMN process instance

https://<Host_Name>:<Port>/bpmn/runtime/process-instances

Request type:

POST

Request Body:

Request body (start by process definition Id):

{

"processDefinitionId":"sampleJavaServiceTask:1:27503",

"businessKey":"myBusinessKey",

"variables": [

{

"name":"myVar",

"value":"This is a variable"

}

]

}

Request body (start by process definition key):

{

"processDefinitionKey":"sampleJavaServiceTask",

"businessKey":"myBusinessKey",

"tenantId": "tenant1",

"variables": [

{

"name":"myVar",

"value":"This is a variable"

}

]

}

Starting the process instance via an ESB proxy service (with PayloadFactory Mediator)

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

<proxy xmlns="http://ws.apache.org/ns/synapse"
       name="OrderProxy"
       transports="https http"
       startOnLoad="true"
       trace="disable">

   <description/>
   <target>

//Calling the request endpoint
      <endpoint>
         <http method="POST"
               uri-template="https://localhost:9443/bpmn/runtime/process-instances"/>
      </endpoint>

//PayloadFactory Mediator transforms or replaces the contents of a message. Configuring 
the format of the request/response and mapping it to the arguments provided.

      <inSequence>
         <payloadFactory media-type="json">
            <format>{
   "processDefinitionId":"manualTaskProcess:1:2532",
   "businessKey":"myBusinessKey",
   "variables": [
      {
        "name":"myVar",
        "value":"This is a variable"
       
      }
   ]
}
            </format>
            <args/>
         </payloadFactory>

//Passing basic-auth credentials to invoke the secured service in BPS. Another way is to 
get these information from the secure vault.

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

         <property name="Content-Type"
                   value="application/json"
                   scope="transport"
                   type="STRING"/>
      </inSequence>
   </target>
</proxy>

BPM Use Cases

2016-04-28T21:32:00.000+05:30

Industry: Cross-Industry
Automating the investment decision and expenditure approval process

Business Problem:
    Replace the manual, e-mail based process with an automated process
    Provide managers with an insight to the ongoing and completed projects

Business Solution:
    WSO2 BPS is capable of creating business processes to automate the investment procedures and expenditure approval processes

This particular use case can very easily be leveraged for other investment approval processes, e.g. marketing spend requests, travel requests, equipment purchase requests, etc.

Business Benefits

Increase business efficiency and agility
Increase reliability
Increase accountability
Improve process visibility by providing real-time statistics, and analytics on investments through dashboards

Health-care industry : Managing patient cases

Business Problem

Manage patient cases
Patient care levels are degrading
Pressures to reduce cost of health
Unable to link treatments to outcomes

Business Solution

You can create processes that enables them to facilitate patient care and coordinate resources across multiple treatment centers to optimize health.

Business Benefit

Improve quality of health care
Streamline communication
Determine treatment automatically based on previous data in the system
Consistent and timely access to patient information during continuum of patient treatment is labor intensive and manual

Business Solution

You can create processes that enables them to facilitate patient care and coordinate resources across multiple treatment centers to optimize health

Furthermore, Streamlining Order Management in the Telecommunication industry, Streamlining procurement process, Managing purchases for promotions, Managing claims and returns, etc in the Retails, Claim management in the Financial sector are some of the real-world examples.

[NEW] OData support in WSO2 Data Services Server

2016-03-30T12:08:00.000+05:30

OData (Open Data Protocol) is an OASIS standard that defines the best practice for building and consuming RESTful APIs. OData helps to build RESTful APIs and it provides facility for extension to fulfill any custom needs of your RESTful APIs.

OData RESTful APIs are easy to consume. The OData metadata, a machine-readable description of the data model of the APIs, enables the creation of powerful generic client proxies and tools. Some of them can help you interact with OData even without knowing anything about the protocol.

WSO2 DSS 3.5.0 onwards we have come up with the support for OASIS OData protocol version 4.0.0. So that now you can easily expose your databases as an OData service.

Choosing BPMN or BPEL to model your processes

2016-01-15T12:17:00.000+05:30

BPEL and BPMN are both ‘languages’ or ‘notations’ for describing and executing business processes. BPEL is well suited to model some kinds of processes and BPMN is well suited to model other kinds of processes. Of course there is a pretty significant overlap where either will do a great job.

WSO2 has decided to support them both and treat equally when modeling business processes.

BPEL

XML-based language used to define enterprise business processes within Web services.
IT experts translate them to BPEL in order to make them executable.
Best suited for service orchestration.

Fault handling capabilities are indeed richer in BPELwith compensation etc (fault management framework in BPEL).
For WS-* environments
Well suited for SOAP based service invocations --> tied concept of SOA/web services (Apache ODE, WSO2 BPS-BPEL)
WS-BPEL, WS-HumanTask and BPEL4People together can do human based workflows (human tasks).

BPMN

Standard set of diagramming conventions for describing business processes.
Business experts create BPMN models.
Well suited for REST based service invocations (Activiti BPMN, WSO2 BPS-BPMN).

A graphical notation that defines the steps in a business process.

BPMN Business Process Diagram has been designed to be easy to use and understand, but also provides the ability to model complex business processes.
Native support for human tasks.

Mapping BPMN to BPEL is not straight forward due to following reasons.
- strict semantics
- lack of technical details in BPMN models
- loops/blocks

Importing Swagger API definitions to Create APIs in WSO2 API-M 1.8.0

2015-04-24T20:45:00.002+05:30

Now you have the facility to add/edit the Swagger definition (1.2 version) of an API in the API design time with API-M 1.8.0

A sample swagger API definition URI: http://petstore.swagger.io/api/api-docs

Using Import option;

Designer API UI after importing the Swagger API definition;

Upcoming API-M version (1.9.0) has the support for Swagger 2.0 API definitions.

How to write a SaaS app on Stratos

2014-03-25T12:06:00.003+05:30

Wikipedia defines software as a service (SaaS) as; "On-demand software provided by an application service provider." "A software delivery model in which software associated data are centrally hosted in the cloud."

Gartner defines SaaS as; "Software that is owned, delivered and managed remotely by one or more providers. The provider delivers software based on one set of common code and data definitions that is consumed in a one-to-many model by all contracted customers at anytime on a pay-for-use basis or as a subscription based on use metrics."

Typical Application Vs SaaS

SaaS Technical Requirements

1. Elastic

Scales up and down as needed.

Works with the underlying IaaS.

2. Self-service

De-centralized creation and management of tenants.

Automated Governance across tenants.

3. Multi-tenant

Virtual isolated instances with near zero incremental cost.

Implies you have a proper identity model.

4. Granularly Billed and Metered

Allocate costs to exactly who uses them.

5. Distributed/Dynamically Wired

Supports deploying in a dynamically sized cluster.

Finds services across applications even when they move.

6. Incrementally Deployed and Tested

Supports continuous update, side-by-side operation, in-place testing and

incremental production.

A cloud platform offers,

Automated Provisioning.
Versioning.
Lifecycle management.
Infrastructure as a Service.
Virtualization.
Federated Identity Management.
Clustering.
Caching.
Billing and Metering.

WSO2 Stratos

WSO2 Stratos is WSO2’s Cloud Middleware Platform(CMP).
A complete SOA platform.
In private cloud or public cloud.
100% Open Source under Apache licence.
Can run on top of any Cloud IaaS.
WSO2 StratosLive is the PaaS offering by WSO2.
Significantly ahead of the competition.
Stratos is the only 100% Open Source, Open Standards option.
Based on OSGi - modular, componentized, standard.

Cloud Native features supported in Stratos

Elasticity.
Multi-tenancy.
Billing and Metering.
Self Provisioning.
Incremental Testing.

Super Tenant SaaS Applications Vs Tenant SaaS Applications

Tenant SaaS application do not have certain permissions and will not be able to access or modify other tenant's data where the super tenant applications have full controllability and permissions.

Tenant SaaS Web Applications

Configure security in web.xml

Super Tenant SaaS Application can access tenant's user level information. It uses org.wso2.carbon.context.PrivulegedCarbonContext to access tenant's information such as registry, cache, tenant manager, queue, etc.

Resources

[1]A sample is available at https://svn.wso2.org/repos/wso2/scratch/thilini/SaasTest/
[2]Creating a SaaS App with the Multi-Tenant Carbon Framework: http://blog.cobia.net/cobiacomm/2013/09/10/creating-a-saas-app-with-the-multi-tenant-carbon-framework-step-1/
[3]Webinar on Building and Deploying SaaS Applications: https://www.youtube.com/watch?v=_lEwm6VzAmo

Approval based user registration process for WSO2 AppFactory

2012-12-12T18:06:00.000+05:30

Human-in-the-Loop

1. User enters information to register in the Appfactory

2. User gets a notification 'Registration request has been submitted and it's under approval'

3. Admin logins to the system

4. Checking the available tasks

5. User registration request is available in the Claimable Task list (Task is in READY state)

6. Admin progressing the task (Task moves from READY to IN_PROGRESS state)

7. Admin performs 'Approve' or 'Reject' to complete the task

8. Task moves from IN_PROGRESS to COMPLETED state

Now the task is no longer in Claimable or MyTasks categories. Earlier performed tasks can only be found in AllTasks list.

If the approval is done by the administrator, new user gets an email with login instructions.

In the next post, I'll discuss how this has been implemented using bpel, humantasks and jaggery(jaggery UI).

How to secure a BPEL Process

2012-10-22T22:34:00.001+05:30

Here we will learn how to secure a BPEL process, so that it can only be accessed by authenticated users.

In a nutshell, we will,

Create and protect a BPEL process by user authentication, the process is exposed as a service which requires providing a username and password inside the UsernameToken of the WS-Security specification.

In tutorial part 1 and 2, we learnt how to create a WS-BPEL process. Now we are going to enable security in that process.

[1] Enable security after the deployment

Add a security scenario (for eg: scenario 1, that is UsernameToken) using the Management Console.

[2] Enable security at the deployment time
This is vital when it comes to securing BPELs. Here we are following a service.xml based approach. The BPEL package contains an additional configuration(xml) file to keep the security policy. A sample BPEL process can be found here.

ServicePasswordCallbackHandler is the default password callbackhandler in Carbon, it resides in the org.wso2.carbon.security package. If you prefer, you can create your own password callback handler and refer it in the policy configuration, so that it will overwrite the default handler;
<rampart:passwordCallbackClass>org.wso2.carbon.appfactory.pwcb.PWCBHandler</rampart:passwordCallbackClass>

Copy password callback handler jar to BPS_HOME/repository/components/lib directory and restart the server.

Invoking WSO2 Carbon Admin Services using BPEL

2012-10-22T21:15:00.002+05:30

(1) UEP Approach [Relevant to: BPS 3.0.0]

Add basic auth credentials (username and password) as http headers in unified endpoint configuration.

A sample configuration (.epr) is shown below.

<wsa:EndpointReference
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.w3schools.com uep_schema.xsd"
xmlns:wsa="http://www.w3.org/2005/08/addressing"
xmlns:wsdl11="http://schemas.xmlsoap.org/wsdl/">
<wsa:Address>https://localhost:9443/services/UserRegistrationService</wsa:Address>
<wsa:Metadata>
<id>SInvokeEPR</id>
<transport type="http">
<authorization-username>admin</authorization-username>
<authorization-password>admin</authorization-password>
</transport>
</wsa:Metadata>
</wsa:EndpointReference>

A Sample is available at [1].

(2) Using a proxy service [Relevant to: BPS 3.0.0 and older (carbon 3.2.* ) versions]

First login to AuthenticationAdmin service and get a authenticated cookie, that cookie value can be used for all subsequent invocations.

BPEL process invokes the login method in the AuthenticationAdminProxy service which in turn invokes the backend servers' AuthenticationAdmin service. On the return path, this proxy service retrieves the authenticated cookie and sends to BPEL as value in the SOAP message, so the BPEL can keep this value in a variable.
For all the subsequent requests from the BPEL process, it sends this cookie to the corresponding proxy services. These proxy services set the cookie as a HTTP header and invoke the backend service.

[1] https://svn.wso2.org/repos/wso2/carbon/platform/branches/4.0.0/products/bps/3.0.1/modules/samples/product/src/main/resources/bpel/2.0/AdminServiceInvokeSample

Part 2: Developing a WS-BPEL Process using WSO2 Developer Studio

2012-10-15T03:20:00.001+05:30

Tutorial 1 is a step by step instruction to implement a bpel process using WSO2 Developer Studio and deploy on WSO2 Business Process Server.

Today with tutorial 2, I am going to develop a BPEL process (let's call it as FunctionProcess) which has multiple service invocations. This is also going to be a synchronous process as it does not involve any long-lasting operations. If you have already followed-up tutorial 1, then follow up of tutorial 2 is real easy.

The following flowchart illustrates the bpel process that we are going to develop in this tutorial.

Figure 1

This can simply be shown using an equation as follows.

f(x) = [(a * b) - (a + b) ]^2

Now we are going to design it using WSO2 Developer Studio, BPEL editor.

Here, we have four service invocations, meaning that four Invoke activities such as InvokeMultiplyService, InvokeAdderService, InvokeSubtractService and InvokeSquareService.

Multiply and Adder activities are not depending on each other, or in other words, these activities can be invoked concurrently. So that they will be defined inside a flow activity (<flow/>) as shown in Figure 2.

Figure2

Open the FunctionProcessArtifacts.wsdl and click on the arrow next to FunctionProcessRequest. Add two integer elements as shown in Figure 3.

Figure 3

Open the FunctionProcessArtifacts.wsdl and click on the arrow next to FunctionProcessResponse. Add resulting integer element.

Figure4

Let's configure four Assign activities. The source is given for each assign activity below, if you need to know how to do this with Developer Studio Graphical Editor, please follow-up tutorial 1.

AssignActivityInputParams Configuration

<bpel:assign validate="no" name="AssignInputParams">
            <bpel:copy>
                <bpel:from>
                    <bpel:literal>
                        <ns:add xmlns:ns="http://demo.carbon.wso2.org" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
                            <ns:a>0</ns:a>
                              <ns:b>0</ns:b>
                        </ns:add>
                    </bpel:literal>
                </bpel:from>
                <bpel:to variable="adderPLRequest" part="parameters"></bpel:to>
            </bpel:copy>
            <bpel:copy>
                <bpel:from>
                    <bpel:literal>
                        <ns:multiply xmlns:ns="http://demo.carbon.wso2.org" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
                            <ns:a>0</ns:a>
                              <ns:b>0</ns:b>
                        </ns:multiply>
                    </bpel:literal>
                </bpel:from>                
                <bpel:to variable="multiplyPLRequest" part="parameters"></bpel:to>
            </bpel:copy>            
            <bpel:copy>
                <bpel:from part="payload" variable="input">
                    <bpel:query queryLanguage="urn:oasis:names:tc:wsbpel:2.0:sublang:xpath1.0"><![CDATA[tns:a]]></bpel:query>
                </bpel:from>
                <bpel:to part="parameters" variable="multiplyPLRequest">
                    <bpel:query queryLanguage="urn:oasis:names:tc:wsbpel:2.0:sublang:xpath1.0"><![CDATA[ns:a]]></bpel:query>
                </bpel:to>
            </bpel:copy>          
            <bpel:copy>
                <bpel:from part="payload" variable="input">
                    <bpel:query queryLanguage="urn:oasis:names:tc:wsbpel:2.0:sublang:xpath1.0"><![CDATA[tns:b]]></bpel:query>
                </bpel:from>
                <bpel:to part="parameters" variable="multiplyPLRequest">
                    <bpel:query queryLanguage="urn:oasis:names:tc:wsbpel:2.0:sublang:xpath1.0"><![CDATA[ns:b]]></bpel:query>
                </bpel:to>
            </bpel:copy>
            <bpel:copy>
                <bpel:from part="payload" variable="input">
                    <bpel:query queryLanguage="urn:oasis:names:tc:wsbpel:2.0:sublang:xpath1.0"><![CDATA[tns:a]]></bpel:query>
                </bpel:from>
                <bpel:to part="parameters" variable="adderPLRequest">
                    <bpel:query queryLanguage="urn:oasis:names:tc:wsbpel:2.0:sublang:xpath1.0"><![CDATA[ns:a]]></bpel:query>
                </bpel:to>
            </bpel:copy>
            <bpel:copy>
                <bpel:from part="payload" variable="input">
                    <bpel:query queryLanguage="urn:oasis:names:tc:wsbpel:2.0:sublang:xpath1.0"><![CDATA[tns:b]]></bpel:query>
                </bpel:from>
                <bpel:to part="parameters" variable="adderPLRequest">
                    <bpel:query queryLanguage="urn:oasis:names:tc:wsbpel:2.0:sublang:xpath1.0"><![CDATA[ns:b]]></bpel:query>
                </bpel:to>
            </bpel:copy>
        </bpel:assign>

AssignActivity2 Configuration

<bpel:assign validate="no" name="AssignActivity2">
            <bpel:copy>
                <bpel:from>
                    <bpel:literal>
                        <ns:substract xmlns:ns="http://demo.carbon.wso2.org" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
                            <ns:a>0</ns:a>
                            <ns:b>0</ns:b>
                        </ns:substract>
                    </bpel:literal>
                </bpel:from>
                <bpel:to variable="subtractPLRequest" part="parameters"></bpel:to>
            </bpel:copy>            
            <bpel:copy><bpel:from part="parameters" variable="multiplyPLResponse">
                    <bpel:query queryLanguage="urn:oasis:names:tc:wsbpel:2.0:sublang:xpath1.0"><![CDATA[ns:return]]></bpel:query>
                </bpel:from>
                <bpel:to part="parameters" variable="subtractPLRequest">
                    <bpel:query queryLanguage="urn:oasis:names:tc:wsbpel:2.0:sublang:xpath1.0">
                        <![CDATA[ns:a]]>
                    </bpel:query>
                </bpel:to>            
            </bpel:copy>
            <bpel:copy><bpel:from part="parameters" variable="adderPLResponse">
                    <bpel:query queryLanguage="urn:oasis:names:tc:wsbpel:2.0:sublang:xpath1.0">
                        <![CDATA[ns:return]]>
                    </bpel:query>
                </bpel:from>
                <bpel:to part="parameters" variable="subtractPLRequest">
                    <bpel:query queryLanguage="urn:oasis:names:tc:wsbpel:2.0:sublang:xpath1.0">
                        <![CDATA[ns:b]]>
                    </bpel:query>
                </bpel:to>            
            </bpel:copy> </bpel:assign>

AssignActivity3 Configuration

             <bpel:assign validate="no" name="AssignActivity3">

              <bpel:copy>
                <bpel:from>
                    <bpel:literal>
                        <ns:square xmlns:ns="http://demo.carbon.wso2.org" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
                            <ns:a>0</ns:a>
                        </ns:square>
                    </bpel:literal>
                </bpel:from>
                <bpel:to variable="squarePLRequest" part="parameters"></bpel:to>
            </bpel:copy>
            <bpel:copy>
                <bpel:from part="parameters" variable="subtractPLResponse">
                    <bpel:query queryLanguage="urn:oasis:names:tc:wsbpel:2.0:sublang:xpath1.0"><![CDATA[ns:return]]></bpel:query>
                </bpel:from>
                <bpel:to part="parameters" variable="squarePLRequest">
                    <bpel:query queryLanguage="urn:oasis:names:tc:wsbpel:2.0:sublang:xpath1.0"><![CDATA[ns:a]]></bpel:query>
                </bpel:to>
            </bpel:copy>            
        </bpel:assign>

AssignOutputParams Configuration

      <bpel:assign validate="no" name="AssignOutputParams">

            <bpel:copy>
                <bpel:from>
                    <bpel:literal>
                        <tns:FunctionProcessResponse xmlns:tns="http://wso2.org/bps/sample" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
                            <tns:result>0</tns:result>
                        </tns:FunctionProcessResponse>
                    </bpel:literal>
                </bpel:from>
                <bpel:to variable="output" part="payload"></bpel:to>
            </bpel:copy>
            <bpel:copy>
                <bpel:from part="parameters" variable="squarePLResponse">
                    <bpel:query queryLanguage="urn:oasis:names:tc:wsbpel:2.0:sublang:xpath1.0"><![CDATA[ns:return]]></bpel:query>
                </bpel:from>
                <bpel:to part="payload" variable="output">
                    <bpel:query queryLanguage="urn:oasis:names:tc:wsbpel:2.0:sublang:xpath1.0"><![CDATA[tns:result]]></bpel:query>
                </bpel:to>
            </bpel:copy>
        </bpel:assign>

Now we have completed, implementation of the business logic of our work flow.

Figure 5

Configuring deployment descriptor(deploy.xml)

This process has 4 service invocations, therefore there should have four partnerlinks in the outbound interface section.

Figure 6

Now we have completed the bpel process development. Let's deploy it on WSO2 BPS and test the flow.
Make sure to deploy four external(partner) services on a AppServer.

Testing the bpel process with TryIt (or with any other testing tool) gives the answer as;

eg: f(x) = [(4*9) - (4+9)]^2 = 529

Figure 7

Part 1: Developing a WS-BPEL Process using WSO2 Developer Studio

2012-10-11T15:19:00.002+05:30

In this post I am going to discuss following list of items.

Installing WSO2 Developer Studio
BPEL Editor
WSO2 Business Process Server
Creating a WS-BPEL process using WSO2 Developer Studio and deploy it on WSO2 BPS.

What's a BPEL Process?

A BPEL Process is a container where you can declare relationships to external partners, declarations for process data, handlers for various purposes and most importantly, the activities to be executed.

Let's start with designing a simple workflow.

Create a BPEL process that returns addition of two integer numbers. For the number addition operation the BPEL process invokes an existing service and gets the result from the web service. This web service takes two integers and returns addition of the two integer values. The web service will be hosted on WSO2 AppServer (or else you can use any other appserver).

Figure 1, shows the axis2 service that we are going to invoke via the BPEL process.
Create the axis2 archive (.aar) [Right click on the AdderService Project --> Export Project as a deployable archive and save it].

Now Start WSO2 AppServer (Goto AppServer_HOME/bin --> sh wso2server.sh)

Deploy AdderService.aar on AppServer.
1. Copy aar file to AppServer_HOME/repository/deployment/server/axis2services directory

2. Using the AppServer Management Console (Add --> AAR Service --> upload the service archive)

We need to keep the wsdl file for the AdderService as, that is required later when developing the BPEL process.

wget http://localhost:9763/services/AdderService?wsdl
Save the AdderService.wsdl to your local file system.

Figure 1

Let's start with designing the BPEL workflow.

Open eclipse which has WSO2 Developer Studio installed.

Goto Dashboard (Developer Studio --> Open Dashboard menu and click on BPEL Workflow under Business Process Server category)

Figure 2: Create New BPEL Project

Give a project Name, Namespace and select the Template type. As we are going to create a short running bpel process, select the template type as Synchronous.

Synchronous interaction - Suppose a BPEL process invokes a partner service. The BPEL process then waits for the partner service's operation to be completed, and responded. After receiving this completion response from the partner service, the BPEL process will continue to carry on its execution flow. This transmission does not apply for the In-Only operations defined in the WSDL of the partner service.

Usually we'll use asynchronous services for long-lasting operations and synchronous services for operations that return a result in a relatively short time.

Figure 3

Figure 4

Here you can see the template for our business process. The BPEL editor automatically generates receiveInput and replyOutput activities(Figure 5). Also it will generate partnerLink and variables used in these two activities.

Note: It will automatically generate AdderProcessArtifacts.wsdl and AdderProcess.bpel. If we look at the folder structure of the BPEL process, we can easily figure out these two files.

Figure 5

In our BPEL process we need to invoke an external service which is AdderService. To invoke this service we need to assign the input variables into external service’s input and again the reply from the external service to our BPEL process output. So that, here we need two assign activities and one invoke activity.

Let’s add an assign activity in between receiveInput and replyOutput activities. To add assign activity drag it from the Action section of the Palette.

Figure 6 : AdderProcess workflow

Before filling the invoke activity, you need to import the AdderService.wsdl to you workflow project.

Figure 7

Now start implementing the business logic.
Goto Properties of invoke activity.
Goto 'Details' tab and from the 'Operation' drop down list, select 'Create Global Partner Link'

Figure 8

Give a Partner Link Name and click OK.

Figure 9

Now you'll prompt to the window shown in Figure 10. Click on 'Add WSDL'

Figure 10

Select the WSDL file which you have already imported to the workflow project. Click OK.

Figure 11

In the Partner Link Type window, you should select the correct PortType. then click OK.

Figure 12

Give a name to the Partner Link Type and click Next.

Figure 13

Give a name to the partner role and then select the correct PortType. Now click Finish. We have only one role for this invoke activity. If we have multiple roles (partner roles and my roles, we need to click on Next and create the next role).

Figure 14

Now you need to pick the 'add' operation from the Quick Pick box. For that 'Double' click on it.

Figure 15

Now you are done with implementing invoke activity. Next step is to implement two assign activities. Before doing that, you need to identify what are the inputs and outputs of your process. We have two integer values as the request parameters and a resulting integer as the response.

Open the AdderProcessArtifacts.wsdl and find the Service, PortType and the binding there. Click on the arrow next to AdderProcessRequest.

Figure 16

Add two integer elements as shown in Figure 17. [To add a element, RightClick --> Add Element] Select the element type as int from the drop down list.

Figure 17

Configure AdderProcessResponse part similarly the above step.
There you need to click on the arrow next to AdderProcessResponse.

Figure 18

For the request, you have only one integer element as the output.
Now save the wsdl file and close it.

Figure 19

Go back to the bpel file and start implementing the first assign activity, that is 'AssignInputVars'.

Goto 'Details' tab and click on 'New'.

Do the mapping as shown in Figure 20.

Figure 20

It will automatically prompt for the initialization. Click on 'Yes'.

Figure 21

Figure 22

Now you are done with configuring the First Assign Activity.

Figure 23

Configure the second assign activity, that is 'AssignoutputVars'.

Figure 24

Allow for the automatic variable initialization for response.

Figure 25

Now you are done with the bpel process flow design. Now open the deploy.xml (Deployment Descriptor).

Here you can specify the process state (whether it activated, deactivated or retired) after the deployment, set the process executed only in memory, Inbound Interfaces (Service) and Outbound Interfaces (Invokes) etc.

Figure 26

Now make the BPEL process as a deployable archive (Right click on the AdderProcess workflow --> Export Project as a deployable archive).

Start WSO2 Business Process Server (BPS_HOME/bin --> sh wso2server.sh)

Make the port offset to 1 (Change offset to 1 in BPS_HOME/repository/conf/carbon.xml)

Deploy AdderProcess.zip on WSO2 BPS.
1. Copy zip file to BPS_HOME/repository/deployment/server/bpel directory

2. Using the BPS Management Console (Processes --> Add --> BPEL Archive(zip) --> upload)

Figure 27

To test the process use TryIt wizard or any other tool(eg: SOAP UI).

Figure 28 : Click on TryIt

Figure 29 : SOAP Request

Figure 30 : SOAP Request/Response

Here, we get integer (a+b) as the response in the xml output.

Part 2: Generating Build Reports with Jenkins [Code Quality]

2012-09-24T17:25:00.000+05:30

Configure Sonar on Jenkins

sonar plugin can be downloaded from here. Copy this plugin to .jenkins/plugins directory and restart the server.

Name	Mandatory	Description
Name	yes	The logical name of the server
Disable	no	Check it if you want to disable this server
Server URL	yes	The URL to access your Sonar server (default to http://localhost:9000). This is the URL used when the analysis will be launched by Jenkins
Server public URL	yes	This is the URL which the user should use to connect to Sonar. If it's not specified the Server URL will be used.
Database URL	yes	The JDBC URL to connect to the database hosting the Sonar database
Database login	yes	The login to connect to the database hosting the Sonar database
Database password	yes	The password to connect to the database hosting the Sonar database the password will be encrypted on the configuration file.
Database driver	yes	The Java driver classname to be used to connect to the database
Version of sonar-maven-plugin	no	If you want to force the use of a specific sonar-maven-plugin, you can set it here.
Additional properties	no	The properties you want to pass to Sonar, you must use the format : -Dsome.property=some.value -Danother.property=another.value
Skip if triggered by SCM Changes	no	If you want to skip Sonar analysis when the Jenkins build is launched by a change in the SCM, check it
Skip if triggered by the build of a dependency	no	If you want to skip Sonar analysis when the Jenkins build is launched by the build of a dependency, check it
Skip if environment variable is defined	no	If the variable set is defined, Sonar analysis will be skipped

Activate Sonar analysis on Maven jobs

Activate Sonar analysis on non-maven jobs

The parameters are;

Paramater	Explanation
Path to project properties	Relative path of the properties file.
Project properties	Here you can set the properties without the need of the properties file. The values here will will take precedence over the ones defined eventually in the project properties file
JVM_OPTIONS	Allow to set the JVM parameters used the Sonar Runner when it will be executed

Part 1: Generating Build Reports with Jenkins [Test Coverage]

2012-09-22T10:00:00.000+05:30

Configure Access Controls

Security Realm and Authorization Settings

Activating Role-based Authorization

Role Strategy plugin adds a new role-based strategy to ease and fasten users management. It gives a Jenkins administrator the ability to define various security roles that will apply to the system they administer.

Creating global roles, such as admin, job creator, anonymous, etc., allowing to set Overall, Slave, Job, Run, View and SCM permissions on a global basis. Creating project roles, allowing to set only Job and Run permissions on a project basis.

Assigning previously created roles to users.

User Home Page : that will list out jobs belong to that particular user.

Creating a new Job : Adding a new build to the system.

Add the repository URL where you have checked-in the application source.

Add emma plugin to .jenkins/plugins directory. Now you will see "Record Emma coverage report" option under post-build steps.

Trigger the build. It will first checkout the source to the job's workspace in .jenkins directory.

Starting the goal [clean emma:emma]

Test coverage reports generated by the Jenkins build using emma.

A sample can be checked-out from here.

References:

[1] Role Strategy Plugin https://wiki.jenkins-ci.org/display/JENKINS/Role+Strategy+Plugin
[2] Emma Plugin https://wiki.jenkins-ci.org/display/JENKINS/Emma+Plugin

How to install BPEL features via Feature Manager

2012-03-05T15:56:00.001+05:30

You can install feature to any Carbon server using;

Equinox OSGi console or using
Carbon management console.

1. Using Equinox OSGi console.

Start the Carbon server with osgiConsole.

thilini@thilini:~/home/thilini/wso2greg-4.1.1/bin$ ./wso2server.sh -DosgiConsole

Now specify the artifact and metadata repositories in the OSGi console.
osgi>provaddrepo https://svn.wso2.com/repo/p2repo/carbon/releases/3.2.0/

osgi>provaddartifactrepo https://svn.wso2.com/repo/p2repo/carbon/releases/3.2.0/

Check the installable features included in the above artifact repository via;
osgi>provlg

Now install the BPEL feature as follows.

osgi>provinstall org.wso2.carbon.bpel.feature.group 3.2.0

If the installation is successful, you will get the "Installation complete" message.
Then restart the carbon server to apply the changes. To shutdown the server;
osgi>shutdownCarbon
Then start the server again to see the Business Process Server functionality.
thilini@thilini:~/home/thilini/wso2greg-4.1.1/bin$ ./wso2server.sh

2. Using Carbon Management Console

Figure1: Add p2 repository location.

If the required repository is not in the list, add the new p2 repository location.

Figure2: Filter 'BPEL' Feature via Find Features option

This allows you to search for available features in repositories. You can select the exact repository or all available repositories. Some repositories contains multiple versions of features. If you are only interested in latest versions, you can use the "Show only the latest versions" option.

If the selected repository contains features which are already installed in the system, they will not be shown under the available features list and also the previous versions of installed features will not be shown.

Figure3: Available feature list.

Select 'BPEL' and click install to proceed to the next step. 'BPEL' feature contains the bundles required for BPEL functionality.

Figure4: Installation..

Figure5: Accept the terms of the license agreement.

Figure6: Installation..

Then you will get the 'Installation Complete' message. Now restart the server and check whether the features are correctly installed.

Figure7: Business Processes capabilities are available via the Carbon server Management Console.

P2 features come as a hosted solution as well as a zip archive. You can use either the hosted solution [1] or the packaged solution [2], but if you are behind a proxy you will face a problem when using hosted solution. In that case use the zip archive.

[1] https://svn.wso2.com/repo/p2repo/carbon/releases/3.2.0/

[2] http://dist.wso2.org/p2-zip/carbon/releases/3.2.0/20-06-2011/p2-repo.zip

Refer more details on Provisioning WSO2 Carbon based SOA Products with Equinox P2 and find p2repository locations from [3].

[3] http://wso2.org/projects/carbon/provisioning-wso2-carbon-with-equinox-p2

A Cluster of Carbon Products

2012-01-10T01:44:00.000+05:30

[Ref: stackoverflow]

Case: Having a central G-Reg which shares registry space across other G-Regs. This G-Reg shares its' registry with the individual Carbon products. Consider such an deployment with 5 clusters:

Cluster of DSSs with a G-Reg (Sharing Registry)
Cluster of DSSs with a G-Reg (Sharing Registry)
Cluster of ESBs with a G-Reg (Sharing Registry)
Cluster of ESBs with a G-Reg (Sharing Registry)
Cluster of ASs with a G-Reg (Sharing Registry)

How is it possible to connect all G-Regs above to a central G-Reg, and control all configuration from there.

Solution: G-Reg has a separation of registries..

Local registry: Holds the resources specific to a given node.
Config registry: Holds the resources related to all the nodes in a given cluster/
Governance registry: Holds the resources shared across multiple clusters.

In the above deployment you can have 5 config registries for 5 different clusters, mounted on the same central Registry and have a single Governance Registry for shared resources between clusters.

Java Client to send/receive JMS requests/responses with WSO2 Business Process Server

2011-11-03T17:55:00.001+05:30

Step1: Apache ActiveMQ 5.2.0 is used as the message broker. Start the ActiveMQ Server.

$apache-activemq-5.2.0/bin$ ./activemq

Figure 1: ActiveMQ Server is started, tcp conn URL can be found from the console log.

Step2: Then you need to enable JMS transport support in WSO2 Business Process Server.

Uncomment transport receiver configurations in axis2.xml;

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

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

        <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">QueueConnectionFactory</parameter>
        </parameter>
</transportReceiver>

Enable out transport configurations in axis2.xml and axis2_client.xml.
As we invoke BPEL process using a client program, we need to enable this particular configuration in axis2_client.xml file also.

Step3: Copy following ActiveMQ jar files to BPS_HOME/repository/components/lib

activeio-core-3.1.0.jar (ActiveMQ_HOME\lib\optional)

activemq-core-5.0.0.jar (ActiveMQ_HOME\lib\)

geronimo-j2ee-management_1.0_spec-1.0.jar (ActiveMQ_HOME\lib\)

geronimo-jms_1.1_spec-1.0.jar (ActiveMQ_HOME\lib\)

Step4: Start Business Process Server.
$wso2bps_HOME/bin$ ./wso2server.sh

Step5: Download, extract and copy AdderService.aar, MultiplierService.aar and SquareService.aar to BPS_HOME/repository/deployment/server/axis2services directory. Deploy FunctionProcess sample and goto Service Dashboard. You will find, now the FunctionProcessService is exposed over JMS.

Figure2: Service Dashboard: JMS endpoint is created and the URL is listed on the UI as;

jms:/FunctionProcessServiceService?transport.jms.DestinationType=queue&transport.jms.ContentTypeProperty=Content-Type&java.naming.provider.url=tcp://localhost:61616&java.naming.factory.initial=org.apache.activemq.jndi.ActiveMQInitialContextFactory&transport.jms.ConnectionFactoryJNDIName=QueueConnectionFactory

Step6: Let's see how we can send a JMS request to the BPS Server and receive response over JMS.

Generate the stub from the FunctionProcessServiceService.wsdl using wsdl2java tool .

$AXIS2HOME/bin$ sh wsdl2java.sh -uri http://<IP>:<PORT>/services/FunctionProcessServiceService?wsdl -o out -uw and you will get the generated java code at a directory called out.

I have created a Java client to invoke, FunctionProcessServiceServiceStub#functionProcessServiceOperation and is given below.

import org.apache.axis2.AxisFault;
import org.apache.axis2.context.ConfigurationContext;
import org.apache.axis2.context.ConfigurationContextFactory;
import wsdl.functionprocessservice.FunctionProcessServiceServiceStub;

import java.rmi.RemoteException;

public class Client {

    public static void main(String[] args) throws AxisFault {
        ConfigurationContext cc = ConfigurationContextFactory.createConfigurationContextFromFileSystem("/home/thilini/wso2bps-2.1.2/repository/deployment/client", "/home/thilini/wso2bps-2.1.2/repository/conf/axis2_client.xml");
        String url = "jms:/FunctionProcessServiceService?transport.jms.DestinationType=queue&transport.jms.ContentTypeProperty=Content-Type&java.naming.provider.url=tcp://localhost:61616&java.naming.factory.initial=org.apache.activemq.jndi.ActiveMQInitialContextFactory&transport.jms.ConnectionFactoryJNDIName=QueueConnectionFactory";

        FunctionProcessServiceServiceStub stub = new FunctionProcessServiceServiceStub(cc, url);

        try {
            System.out.println("******* Response: " + stub.functionProcessServiceOperation(2, 4));
        } catch (RemoteException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

You need to add following set of jars to the classpath.

activemq-core-5.2.0.jar (ActiveMQ_HOME\lib)
geronimo-jms_1.1_spec-1.1.1.jar (ActiveMQ_HOME\lib)
geronimo-j2ee-management_1.0_spec-1.0.jar (ActiveMQ_HOME\lib)
axis2-transport-jms-1.1.0-wso2v5.jar (WSO2BPS_HOME/repository/components/plugins)
commons-io-2.0.0.wso2v1.jar (WSO2BPS_HOME/repository/components/plugins)
jettison-1.1.wso2v1.jar (WSO2BPS_HOME/repository/components/plugins)

When you run the client, it sends a JMS request to the BPS Server and creates an instance of the FunctionProcess. You will see that the total instance count of the FunctionProcess is incrementing.

Figure3: Total Instance Count at Process Information

And the server sends the response back to the client and you will see the response on the console as follows.

Figure4: Response Message

SOAP over JMS messaging with WSO2 Business Process Server

Figure 5: SOAP over JMS messaging

Here, I have deployed BPEL process at the Business process Server which has a http endpoint. And I have hosted partner services (i.e: Adder Service, Square Service and Multiple Service) at WSO2 Application Server which has JMS endpoints.

The deployment and the communication architecture diagram is shown in Figure 5.

JMS sender (i.e: Apache Active MQ) delivers the SOAP request message coming through the Business Process Server to the destination queue and receives the SOAP response message.

To talk to JMS sender by the SOAP engine (BPS server), you need to enable transport sender configurations for JMS in axis2.xml

To talk to WSO2 AS by the JMS sender, you need to enable transport receiver configurations for JMS in axis2.xml

Configuring JMS transport with Qpid in WSO2 BPS 2.1.*

2011-09-23T12:33:00.001+05:30

This is a continuation for my previous blog post on 'how to communicate via JMS with Active MQ in WSO2 BPS Server'.

Here I'll be using Qpid as the JMS provider.

The following JNDI property configurations need to be added/uncomment to the jndi.properties file inside $WSO2_BPS_HOME/repository/conf

connectionfactory.TopicConnectionFactory = amqp://admin:admin@carbon/carbon?brokerlist='tcp://localhost:5672'
connectionfactory.QueueConnectionFactory = amqp://admin:admin@carbon/carbon?brokerlist='tcp://localhost:5672'
queue.MyQueue = example.MyQueue
topic.MyTopic=example.MyTopic

The following configurations need to be added to axis2.xml file inside $WSO2_BPS_HOME/repository/conf in order to enable JMS transport support with Qpid.

<transportReceiver name="jms" class="org.apache.axis2.transport.jms.JMSListener">
         <parameter name="myTopicConnectionFactory" locked="false">
             <parameter name="java.naming.factory.initial" locked="false">org.apache.qpid.jndi.PropertiesFileInitialContextFactory</parameter>
             <parameter name="java.naming.provider.url" locked="false">repository/conf/jndi.properties</parameter>
             <parameter name="transport.jms.ConnectionFactoryJNDIName" locked="false">TopicConnectionFactory</parameter>
             <parameter name="transport.jms.ConnectionFactoryType" locked="false">topic</parameter>
         </parameter>
         <parameter name="myQueueConnectionFactory" locked="false">
             <parameter name="java.naming.factory.initial" locked="false">org.apache.qpid.jndi.PropertiesFileInitialContextFactory</parameter>
             <parameter name="java.naming.provider.url" locked="false">repository/conf/jndi.properties</parameter>
             <parameter name="transport.jms.ConnectionFactoryJNDIName" locked="false">QueueConnectionFactory</parameter>
             <parameter name="transport.jms.ConnectionFactoryType" locked="false">queue</parameter>
         </parameter>
     </transportReceiver>

Note:

We had to manually copy following jars to $CARBON_HOME/lib/core/WEB-INF/lib in earlier carbon releases.

Carbon 3.2.* (BPS 2.1.*) does not require to do this step as qpid-client-0.11.0.wso2v1.jar already packed with the product and it does this functionality.

If you are using an older release other than Carbon 3.2.* (BPS 2.1.*) you have to manually copy these files to above mentioned location.

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

Now you are done with enabling JMS transport with Qpid as the JMS provider.

Communicate via JMS with Active MQ using WSO2 Business Process Server (BPS)

2011-09-20T14:06:00.000+05:30

Download the latest version of WSO2 BPS server.

Step 1. Enable JMS in WSO2 BPS server.

For that:

Enable/uncomment following section (transport sender and receiver) in axis2.xml inside BPS_HOME/repository/conf/ and configure appropriately for JMS transport support.

<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://thilini:61616</parameter>
            <parameter name="transport.jms.ConnectionFactoryJNDIName">TopicConnectionFactory</parameter>
        </parameter>

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

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

And enable/uncomment following section in axis2_client.xml inside BPS_HOME/repository/conf/.

WSO2 BPS provides a simple and easily configurable UI to enable transports.

We can achieve the same via Management API as shown below. But the above way is more appropriate than using the below approach.

Enabling JMS through Management API.

Step 2. Copy ActiveMQ jars toBPS_HOME/repository/components/lib

activeio-core-3.1-SNAPSHOT.jar (ActiveMQ_HOME\lib\optional)

activemq-core-5.0.0.jar (ActiveMQ_HOME\lib\)

geronimo-j2ee-management_1.0_spec-1.0.jar (ActiveMQ_HOME\lib\)

geronimo-jms_1.1_spec-1.0.jar (ActiveMQ_HOME\lib\)

Step 3. Start ActiveMQ server.

I have used Apache ActiveMQ-5.2.0 as the JMS provider.

Start the activeMQ server sh activemq

Step 4

Download, extract and copy 3 partner services,
such as AdderService.aar, MultiplierService.aar and SquareService.aar to BPS_HOME/repository/deployment/server/axis2services directory.

Step 5. Start WSO2 BPS Server
sh wso2server.sh

You can check whether the connection via JMS is successful or not through the Service Dashboard as follows.

Step 6. Deploy FunctionProcess at BPS server.
You need to change endpoint references inside each wsdl of previously downloded BPEL package. Endpoint URIs are listed at the Service dashboard as well as it can be found from the console logs.
Deploy the BPEL package.
Then create an instance.

This post will help you to communicate via JMS using WSO2 Business Process Server.

WSO2Con 2011.... less than a week!!!

2011-09-08T11:48:00.003+05:30

WSO2Con 2011 will be taking place from 12th to 16th September in Waters Edge, Sri Lanka for the second consecutive time.

It's for you!!
The Developers, Architects, IT managers and technology enthusiasts, covering from building lean enterprise middleware solutions to cloud computing and many more!!!

WSO2Con 2011 at a glance....

After a successful conference in 2010, it is back in 2011!!!

Customer Experience describing how WSO2 products are being used to build enterprise and SaaS applications in financial services, government, mobile and telecommunication and other various industries.

Best practices for leading enterprise architecture initiatives, managing SOA projects and moving beyond SOA and open source.

Tutorials on a board range of middleware technologies by WSO2 developers and apache committers with real world experience working with customers around the world.

Looking for more info? visit http://wso2con.com

How to get Governance Functionality inside WSO2 Enterprise Service Bus (ESB)

2011-09-01T22:10:00.000+05:30

Carbon Feature Management facility will help you to get the Governance functionality inside WSO2 ESB or any other WSO2 product. It will install new features or upgrade existing features.

You simply need to install Governance feature from the P2 repository. P2 repository locations for the latest carbon release can be found at [1] and [2].

[1]URL: https://svn.wso2.com/repo/p2repo/carbon/releases/3.2.0/
[2]Local: http://dist.wso2.org/p2-zip/carbon/releases/3.2.0/20-06-2011/p2-repo.zip

Please follow the steps specified in the following user guide [3] to get it work.
[3] http://wso2.org/project/carbon/3.2.0/docs/component-mgt/docs/userguide.html

Search for 'governance' and 'dashboard' features and select them to install.

Further you need to follow below three steps.

1. Goto ESB_HOME/repository/conf/registry.xml and uncomment all the handlers. (enable <handler></handler> section).
2. Copy services-config.xml to ESB_HOME/repository/conf.
This config file is packed with the WSO2 Governance Registry Product (wso2greg_HOME/repository/conf/services-config.xml).
3. Copy dashboard folder to ESB_HOME/repository/resources
This also packed with WSO2 Governance Registry Product and you can find it at wso2greg_HOME/repository/resources/dashboard

Further, you can find configuration files mentioned in above 2nd and 3rd steps at WSO2 G-Reg available at [4] http://wso2.org/downloads/governance-registry

[5] describes how to package components in a single server via P2 feature Management in WSO2 Carbon. [5] http://wso2-carbon.blogspot.com/2011/08/packaging-components-in-single-server.html

WSO2 Business Process Server (BPS)

2011-08-23T10:39:00.000+05:30

WSO2 Business Process Server (BPS) is an open source product which enables developers to easily deploy business processes written using the WS-BPEL standard, and serves as the business process management and hosting environment for a Service-Oriented Architecture (SOA).

It is based on WSO2 Carbon, the industry’s first fully componentized SOA framework and powered by Apache ODE,which provides developers with a level of flexibility and ease of integration unmatched by any other business process management (BPM) solution on the market.
Use WSO2 BPS to make it easy to compose and ochestrate BPEL Business Processes.

Getting started with Apache ODE

2011-08-09T11:12:00.029+05:30

I played a bit around Apache-ODE during last couple of days, ODE is a BPEL engine. WSO2 Business Process Server is powered by Apache ODE.

ODE executes business processes written following the WS-BPEL standard. It talks to web services, sending and receiving messages, handling data manipulation and error recovery as described by your process definition.

Getting the source : take a checkout from the ode-trunk.

svn checkout http://svn.apache.org/repos/asf/ode/trunk ode-trunk

Setting Maven option for Permanent Generation Space.

MAVEN_OPTS=" -Xms512m -Xmx1024m -XX:MaxPermSize=1024m"

export MAVEN_OPTS

Build the source: do a maven build (tests skipped)

mvn clean install -Dmaven.test.skip=true

This is not the only way you can build it. To use the Buildr [1].

Locate ../ode-trunk/axis2-war/target/ode-axis2-war-1.4-SNAPSHOT.war and deploy it on apache-tomcat.
Access through the browser.

Apache ODE executes business processes written following the WS-BPEL standard.
Let's deploy the simple HelloWorld process sample which comes with the ODE distribution.

To deploy a process at the ODE engine;
You need to copy its whole directory to the WEB-INF/processes directory of your deployed exploded webapp.
OR
You can use the ODE web interface.

HelloWorld Sample
Demonstrates a simple service invocation that synchronously replies to a message. It is developed using WS-BPEL 2.0 standard.

Invoking the HelloWorld process

Putting the bin directory or Ode's distribution in your path:

Linux

export PATH=$PATH:PATH_TO_ODE/bin

Windows

set PATH=%PATH%;PATH_TO_ODE\bin
Execute the following command from the example directory in the ODE distribution.

sendsoap http://localhost:8080/ode/processes/helloWorld testRequest.soap

The response is a SOAP message containing the 'Hello World' string.

Now you have successfully deployed and invoked your first BPEL process in Apache ODE.

[1] http://ode.apache.org/building-ode.html