10-99

Ready Set Go Openstack!

2015-07-14T12:06:00.002-07:00

	LAYER	Example Technology	Workaround (ignore)
5	Customer VMs	Virtual machines
4	Openstack Services (Proxy to Virtualization)	nova-api, nova-compute, nova-scheduler….cinder-api, cinder-volume….neutron...swift..	http://docs.openstack.org/juno/install-guide devstack
3	Virtualization Software (Hypervisor- Type B)	KVM, QEMU, XEN, LXC, Docker, Ironic, Hyper-V
2	Operating System (Virtualization Software (Hypervisor- Type A))	Ubuntu, Redhat, Vmware ESXi	Only because we have a laptop with windows: VirtualBox -> Create a Ubuntu VM and assume that is our Baremetal server with ubuntu. Vagrant (script to spin a VM and install stuff)
1	Hardware (baremetal)	Laptop, HP Servers, Dell Racks, blade servers

[study material]

Read the following in order. Read a topic such as Openstack Identity first in the admin guide then in config guide and then in install guide. Then repeat the same order for Openstack Image, compute etc.

Admin guide: http://docs.openstack.org/admin-guide-cloud/content/
Configuration Guide: http://docs.openstack.org/kilo/config-reference/content/
Install Guide: http://docs.openstack.org/juno/install-guide/install/apt/content/index.html

[Hands on]

In order to install openstack (which needs multiple nodes - at least one controller node, one compute node) we need to spin multiple nodes in personal laptop and hence we need to use a virtualization software

VirtualBox (is the virtualization software)
Vagrant ( we can write a script to spin a VM instead of using VirtualBox UI)

Devstack is a all in one box openstack install. It is a bunch of shell scripts that install openstack as described in the install guide. These scripts deploy openstack components all in one box and hence not supposed to be used for production installs. It is intended for development and test purpose installs only.

Installing Openstack in Laptop using VirtualBox, Vagrant and Devstack

Install VirtualBox by downloading from, choose all defaults. https://www.virtualbox.org/wiki/Downloads
Install Vagrant by downloading from, choose all defaults http://www.vagrantup.com/downloads.html
Now we are ready to write a vagrant script and create a ubuntu VM in windows laptop.

create a folder in your laptop, say c:\devstack
open command prompt and cd c:\devstack and run following commands
download a 64 bit ubuntu image

vagrant box add precise64 http://files.vagrantup.com/precise64.box

spin a ubuntu VM using Vagrant and VirtualBox inside windows laptop

create a file : c:\devstack\Vagrantfile with following contents

https://gist.github.com/sheenaa24/c92a600dae0f0c4cef38
boot the VM using vagrant up and at following location as follows

c:\devstack > vagrant up

above will output a successful VM creation stating ssh port as 2222
ssh to the new VM using following command

c:\devstack > vagrant ssh

At the end of above steps you should have successfully spun a ubuntu VM inside windows and presented a ssh shell into the new VM

download devstack scripts to install openstack - all in one box

on the ssh shell session for the ubuntu VM download devstack scripts using following commands

sudo apt-get update
sudo apt-get -y install git
git clone git://git.openstack.org/openstack-dev/devstack
cd devstack

install openstack

cd /home/vagrant/devstack
vi local.conf

paste the following into this file and save https://gist.github.com/sheenaa24/a87d70ad95be5a755ee1

./stack.sh

Access openstack

dashboard:

http://localhost:8080
user/pass : admin/letm3in

command line tools

cd /home/vagrant/devstack
source openrc admin admin
any command line tool example. such as:

list VMs: nova list
list images: glance image-list

keystone tenants: keystone tenant-list

Autoscaling Example Using Openstack Heat and Ceilometer on a Devstack install

2015-02-22T11:43:00.000-08:00

Heat : Openstack's orchestration service.
Ceilometer: Openstack's usage collection service.
Nova: Openstack's compute service
Devstack: All in one machine install of openstack services. Meets development purposes.
Vagrant: Scripting to spin a VM for development purposes

Real Business usecase

Real business use case:

spin 2 VMs to serve standard load
scale up to 3 VMs when CPU load on existing VMs rises above a threshold
scale down to 1 VMs when CPU loads are below a threshold.

Outline Steps during this exercise

Setup a new linux install. Create a VM using Vagrant and VirtualBox
Download devstack and install Openstack services
Create a Heat HOT template describing our use case
Verify that on launch Heat, Ceilometer and Nova work in tandem to achieve our use case.
Analyze the glue that ties heat, ceilometer and nova together.

Step 1: Setup a new linux install. Create a VM using Vagrant and VirtualBox

install VirtualBox https://www.virtualbox.org/wiki/Downloads
install Vagrant http://www.vagrantup.com/downloads.html
open a terminal and import a vagrant box

vagrant box add trusty64 https://cloud-images.ubuntu.com/vagrant/trusty/current/trusty-server-cloudimg-amd64-vagrant-disk1.box

Create a working folder and a new file named Vagrantfile with following contents

bring up the VM

vagrant up

ssh on to the newly created vm

vagrant ssh

update and install git

sudo apt-get update && sudo apt-get -y install git

Step 2: Download devstack and install Openstack services

git clone git://git.openstack.org/openstack-dev/devstack
cd devstack
git checkout stable/icehouse
create a local.conf file as follows . I have substituted a password: letm3in across the board as this is just a example demonstration and nothing serious.
./stack.sh
After the above script completes you should be able to perform following to test out a successful install

Open horizon dashboard using your browser at http://localhost:8080/ and login using admin/letm3in
Access keystone API to generate a auth token. Assuming the port forwarding is same as in the Vagrantfile above
Access ceilometer API at http://localhost:8082/v2 assuming the port forwarding is same as in the Vagrantfile above

Step 3: Create a Heat HOT template describing our use case

Assumptions that you might need to stick to:

ceilometer collects metrics every 10 minutes (this is the default on a devstack install)
cpu_util in my deployment ranged around 0.65% by observation and hence my ceilometer alarm thresholds in my template are listed at 0.65%

Now the template (explanation below the template)

Explanation:

The template is broadly divided into two sections - parameters and resources
Parameters provide a means to provide values into the template when it is loaded into Heat using either command line or horizon dashboard. I have pasted some snapshots as to how these parameters play out when you use horizon dashboard to load it.
Resources section is a listing of following resources
A resource called "asg" - named to abbreviate auto scaling group. Please feel free to name as it suits you. This resource list that it deals in a list of resources that form this group. In this case just one resource - a instance or VM that we will use heat to launch or tear down during our upscale or downscale operations
A resource called "scale_up_policy" and a resource called "scale_down_policy" which define our policy around up scale operation where we increase the count of our resource in asg group (nova instance) by either +1 or -1
A resource called "cpu_alarm_high" and a resource called "cpu_alarm_low" which define the ceilometer alarms that heat will provision to be called back upon for up scale or down scale operations when thresholds are satisfied. I have used a threshold definition using cpu_util meter to be computed over 600 seconds (equivalent to ceilometer collection intervals) and the alarm evaluation over 1 period of 600 seconds. Please check the output of the ceilometer call to retrieve alarms that explain further on call back urls and query criteria.

Launch the above template using horizon dashboard:

Login to dashboard at http://localhost:8080/ using admin/letm3in
Change the tenant on the top of the page to admin
click on Project -> Orchestration -> stacks
Click Launch Stack button and select file and browse to the HOT template above and say ok.
The next page that shows up is a page to provide values you specified in properties section of the template. You might need to collect a image id from Project -> Compute -> images page. Provide password letm3in and hit Next.

Next page shows a in progress template launch. Please wait for status to show complete.
At this point the stack is at the desired capacity of resources under "asg" section. We will have to wait for at lease 20 more minutes for cpu_util metric to show up and raise alarms either cpu_util higher than 0.65% or lower than 0.65% to drive auto scaling.

Step 4: Verify that on launch Heat, Ceilometer and Nova work in tandem to achieve our use case.

Upon waiting for around 20 minutes (600 seconds x 2 intervals) ceilometer would have collected cpu meters and computed cpu_util metric to raise either a cpu_alarm_high or cpu_alarm_low. Please browse to Project -> Orchestration -> stacks -> click on the template -> select events tab to show something as follows that I experienced. Notice that it specifies the cpu_util value and the policy that got triggered. In my case it triggered a scale_up_policy as cpu_util was 5.8% followed by a scale_down_policy because cpu_util was at 0.59% followed by a scale_up_policy as cpu_util was at 0.66%

Step 4: Analyze the glue that ties heat, ceilometer and nova together.

Heat template definition of metadata drives metadata flow over to nova and ceilometer alarms. Following sections of the above depicted heat template. Upon launch heat creates resources to the desired capacity. In our example 2 VMs. Following metadata definition in the HOT template drives this:

Nova API call to retrieve instance detail shows the above defined metadata in action. Mark lines 71, 72 and 73 with metadata that was defined by HOT template:
Ceilometer Alarm definition that queries for cpu_util on resources with metadata defined by HOT template. Mark lines for metadata based query on ceilometer alarms. Mark lines 23 - 28 and 58 - 63 in the gist below that was created by HOT template

Passing PMP in 21 days

2014-08-11T14:41:00.003-07:00

Everyone,

If you have worked in a project which followed SDM processes, then it is easy to pass PMP exam. I am listing below the steps taken by me to get my PMP in 3 weeks.

Step 1 : Register for 35 hours of PM education from ProXalt for $35

Step 2 : Read Head first PMP to understand the concepts. It is really easy and fun to learn. I encourage everyone to read this before reading any other PMP book.

Step 3 : Take short sample tests. You will find it is difficult to get a passing score, because scenario based questions are not covered in Head First PMP.

Step 4 : Read Rita Mulcahy’s PMP Exam prep 8th Edition. This has in-depth explanations for scenario based questions. Has tons of exercises, flow charts and what-next, what-before kinda questions which will help you map the processes and knowledge areas. Glance through it once again.

Step 5 : Read notes and ITTOs like Abhishek's Version - Rajesh Nair PMP Notes

Step 6 : Take as many PMP free tests as possible. Register for free sets of questions from various sites. It is okay to retake tests twice. Take Oliver Lehmann's test which is the most difficult.

Step 7 : Reference PMBOK guide when you check answers for the test.

Step 8 : Once you score 70% or above in tests, book your test with prometric.

Step 9 : Go and write the exam!

Thank you all for reading this!

OpenStack Monitoring with Nagios

2014-05-16T09:22:00.001-07:00

Monitoring OpenStack can be placed widely into two buckets.

1. Monitor OpenStack infrastructure

2. Monitor OpenStack services grouped by tenants/projects

#1 above can be performed using Nagios. Monitoring aspects such as CPU, RAM, Disk Space, Network, installed OpenStack processes (e.g. nova-conductor, nova-scheduler, swift-proxy etc. )

#2 above can be performed using Ceilometer API.

There are a lot of good articles on the web depicting Nagios usage. This particular model depicted as part of the diagram below uses nagios with NRDP and NRDS to monitor an OpenStack ecosystem.

Responding to an RFP(Request For Proposal)

2014-05-13T13:57:00.001-07:00

What is RFP?

A request for proposal (RFP) is a document that an organization posts to elicit bids from potential vendors for a product or service.This usually is done to have several companies bid on the work, thus producing more competitive prices. However, if it is not done correctly, it can produce no bids or bids that are a waste of your time.

RFP is usually developed by Sourcing team with the help of sponsors, business users and sourcing/strategy team. There are sourcing and procurement tools available in the industry from various organizations like Ariba, SourceOne, Enporion, etc.

Sourcing Team

Sends RFP to Vendors, respond to questions from vendors, setup meeting with vendors to present the proposal. They pass the information back and forth between the vendors and business users who requested the RFP. Sourcing team make sure all processes are followed

RFP Review team

This team reviews the responses for the RFP and score the vendors for their proposals. Score card is given to every reviewer in the RFP team. Reviewers consists of Business users, IT partners, Business and IT architecture team, strategy team, Managers, Directors, etc.

Selection Criteria

The proposals you get back in response to your RFP will differ. Each organization that responds to an RFP will have different strengths. Selection criteria can be lowest cost, best quality, most complete feature set, etc. You should decide up front whether you are looking for the lowest cost, the fastest delivery, or some combination. Various comparative approach like Cost Benefit Ratio, Present Value, Net Present Value, Internal Rate of Return(IRR), Payback Period or more mathematical approach like linear, Nonlinear, Dynamic, Integer, Multi-Objective algorithms, etc. can be used.

Time Restriction

When an RFP is published, there is a time limit set to respond to with your proposal.

RFP is send out via mail or email to selected Vendors by the sourcing team. Participating vendors are selected based on industry experience, features provided, clientele, etc. Sourcing team can either pre-select few vendors or post it to all eligible parties.

Proposal submission process usually consist of Responding to RFP questionnaire, Presenting the proposal followed by the Demonstration of the solution/product/service.

During the proposal review vendors are scored on the RFP responses, Proposal presentation and Cost.

How to Respond to an RFP?

First and foremost thing to do is form a RFP response team. Team should consists of presenters, marketing staff, SMEs, technical writer, multimedia/stylist, management staffs, etc.

The team can analyse the RFP and create a proposal to respond to the RFP. Usually the questionnaire consists of a list of inquiries to check if the product/service can handle the client demands.

The questions could be categorized based on major business/client needs. There could be additional sections for Non-Disclosure Agreement(NDA), Financial Profile, Company Profile, Minority/Women-owned Business, Current Customer Status/Industry Experience, References, Supplier Governance and Cost.

For an IT project, it may also have additional questions regarding Project Managements, Architecture, etc.

Questionnaire will have Response Submission Instructions, Introduction about the Client/Need and options to attach additional documents. Additional instructions may be provided on how to attach response documents like Financial Matrix table, Professional Services Pricing Sheet, glossary, etc. A Sample Response Submission Instruction is shown below.

Introduction will describe the project objectives, product requirements, scope and need by date.

Financial Profile will have questions related to your company's financial situation like 'Has your organization been involved in material merger/Acquisition/Divestiture activity in the last three years', 'Please provide a copy of your organization’s Comprehensive Dun & Bradstreet Report', 'How does your organization ensure compliance with state/federal regulatory requirements', etc.

Sample Financial Profile related questions are shown below.

Company Profile will contain questions regarding your organization like total number of customers, employees,, repeat client ratio, industry awards, etc.

Sample Company Profile related questions are shown below.

Minority/Women-Owned Business will have to answer additional questions like supplier diversity program, MWBE certification, etc.

Additional questions related to current relationship with the organization could be present. If you have done business in the past with this client, then it is a good idea to highlight all the achievements with proof.

Reference section requests multiple contacts, brief descriptions of services/products provided with time frame.

Supplier Governance questions talks about supplier support model, if there are resources working outside of present country, typical SLAs, etc. Sample is provided below.

Architecture related questions can request for high -level logical view of your architecture, server environments, process flows, etc. IT related RFP can ask for Platform, Availability & Scalability, Infrastructure & Reliability, Disaster Recovery and Information Security related questions.

Cost related questions have pricing details for the product, licenses, warranty period, Escrow account, Service Level Agreements, etc.

Sample Cost related questions are as shown below.

Provide detailed answers for questions related to the product/service being requested. Final selection of the vendor will be based on the services/product features that accurately fit the requested needs in RFP. Sample questions from a company for Life Insurance Industry is shown below.

Additional documents can be attached to support any of the answers provided for questions.

By answering the RFP questionnaire, you are actually shaping your proposal. Proposal is prepared based on the needs listed in RFP. Proposal, cost estimates, glossary, brochures, etc. are send to RFP contact.

How to Present a Proposal?

Based on the responses, sourcing team will invite vendors to present the proposal. Usually the presentation can be anywhere from 2 - 6 hours including the demo of the product or service offered.

Presentation deck can be printed out along with product brochures and distributed to the group before the presentation.

Presentation and Demo ends with a Question & Answer session. Reviewers regroup and calculate the scores. Based on score the appropriate vendor for the product/service is selected.

Additional details are requested from selected vendor and the procurement process begins. There could be scenarios in which multiple vendors are selected and additional deep dive-ins are conducted. 1 more vendors can be asked to produce a POC (Proof Of Concept) before the contract is signed.

Saying this, I end this blog on how to respond to an RFP. Thank you for reading!

Endeca Presentation API class diagram

2014-03-04T14:01:00.001-08:00

Endeca presentation API is a huge object graph with multitudes of navigation paths and objects. I managed to compile the following class diagram while I used Endeca presentation API for Record Search and Dimension search. I will try to update more as I compile more.

Note: This is not a complete class diagram and is just a means to figure out retrieving record search and dimension search responses from Endeca.

Following maven project is a endeca client POC project that I created to test endeca connection. https://bitbucket.org/rpatnaik_lsi/endeca-client-poc

Parallel Processing in Mule ESB

2014-02-11T09:47:00.000-08:00

Following is an example of parallel processing in Mule ESB. I tried a couple of other posts out there that suggested parallel processing but when I picked the threading model in them they seemed single threaded. Most of the documentation out there on this topic is a bit confusing. router is a good candidate to spin a parallel asynchronous router and process jobs that are resource intensive. But lacks the ability to queue a list of objects to process asynchronously. Mule transport in a exchange-pattern=one-way can queue a list of tasks and in combination with router can achieve parallel processing a list of objects. Additionally the and routers are required to perform splitting of a list of tasks and aggregation respectively. In all following is the list of mule constructs required to perform the task of parallel processing a list of objects/tasks.

input: A list of objects
output: A list of processed objects

Mule constructs:

collection-splitter router: To split the list of input objects
vm transport: To queue the objects for parallel processing
async router: To process a object asynchronously and in a mult-threaded model
collection-aggregator router: To aggregate the split and processed objects back to a list for output

Project Code - Mule Studio Project as zip http://sites.google.com/site/rockycodes/mule_parallel_process_capitalcase.zip

Mule flow: parallel-processing-flow.xml



<?xml version="1.0" encoding="UTF-8"?>
<mule xmlns:https="http://www.mulesoft.org/schema/mule/https" xmlns:cxf="http://www.mulesoft.org/schema/mule/cxf" xmlns:tracking="http://www.mulesoft.org/schema/mule/ee/tracking" xmlns:http="http://www.mulesoft.org/schema/mule/http"
 xmlns:vm="http://www.mulesoft.org/schema/mule/vm" xmlns="http://www.mulesoft.org/schema/mule/core" xmlns:json="http://www.mulesoft.org/schema/mule/json" xmlns:doc="http://www.mulesoft.org/schema/mule/documentation"
 xmlns:spring="http://www.springframework.org/schema/beans" version="EE-3.4.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.mulesoft.org/schema/mule/cxf http://www.mulesoft.org/schema/mule/cxf/current/mule-cxf.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-current.xsd
http://www.mulesoft.org/schema/mule/core http://www.mulesoft.org/schema/mule/core/current/mule.xsd
http://www.mulesoft.org/schema/mule/vm http://www.mulesoft.org/schema/mule/vm/current/mule-vm.xsd
http://www.mulesoft.org/schema/mule/http http://www.mulesoft.org/schema/mule/http/current/mule-http.xsd
http://www.mulesoft.org/schema/mule/ee/tracking http://www.mulesoft.org/schema/mule/ee/tracking/current/mule-tracking-ee.xsd
http://www.mulesoft.org/schema/mule/https http://www.mulesoft.org/schema/mule/https/current/mule-https.xsd
http://www.mulesoft.org/schema/mule/json http://www.mulesoft.org/schema/mule/json/3.1/mule-json.xsd">

 <flow name="ParallelProcessFlow" doc:name="ParallelProcessFlow">
  <http:inbound-endpoint exchange-pattern="request-response" address="http://localhost:8081/capitalize" doc:name="HTTP" method="POST" />
  <json:json-to-object-transformer returnClass="java.util.List" />
  <request-reply timeout="180000"> <!-- timeout in 3 minutes -->
   <vm:outbound-endpoint path="one-string-for-processing-vm" doc:name="send-one-string-for-processing-vm">
    <message-properties-transformer scope="outbound">
     <delete-message-property key="MULE_REPLYTO" />
    </message-properties-transformer>
    <collection-splitter enableCorrelation="ALWAYS" />
   </vm:outbound-endpoint>
   <vm:inbound-endpoint path="aggregate-processed-strings-vm" doc:name="aggregate-processed-strings-vm">
    <collection-aggregator timeout="120000" /> <!-- timeout in 2 minutes -->
   </vm:inbound-endpoint>
  </request-reply>
  <json:object-to-json-transformer />
 </flow>

 <flow name="capitalcase-one-string-flow" doc:name="capitalcase-one-string-flow">
  <vm:inbound-endpoint path="one-string-for-processing-vm" doc:name="receive-one-string-to-convert-to-capital-case-vm" />
  <async>
   <logger message="***CapitalCase #[payload] at #[System.currentTimeMillis()] using #[Thread.currentThread().getName()]" level="INFO" />
   <expression-transformer expression="#[payload.toUpperCase()]" doc:name="Change to Uppercase" />
   <logger message="***CapitalCased #[payload] at #[System.currentTimeMillis()]" level="INFO" />
   <vm:outbound-endpoint path="aggregate-processed-strings-vm" doc:name="send-back-capitalcase-string-for-aggregation-vm" />
  </async>
 </flow>

</mule>

XML External Entity(XXE) Vulnerability and Prevention

2013-02-20T22:10:00.002-08:00

Definition

Xml External Entity(XXE) is an XML entity construct as defined in the XML 1.0 Standard which can access local or remote content via a declared system identifier. More about XXE can be found in the XML 1.0 standard specification at the following location:
http://www.w3.org/TR/REC-xml/#sec-external-ent

Example XML that references a URL to retrieve EURO to USD currency conversion:



<?xml version="1.0" encoding="ISO-8859-1"?>
 <!DOCTYPE foo [  
   <!ELEMENT foo ANY >
   <!ENTITY euroToUSDRate SYSTEM "http://rate-exchange.appspot.com/currency?from=USD&to=EUR" >]>
<foo>&euroToUSDRate;</foo>

When a parser parses the above XML a reference to "euroToUSDRate" is replaced by the JSON response from the URL and the resultant XML is as follows:



<?xml version="1.0" encoding="ISO-8859-1"?>
 <!DOCTYPE foo [  
   <!ELEMENT foo ANY >
   <!ENTITY euroToUSDRate SYSTEM "http://rate-exchange.appspot.com/currency?from=USD&to=EUR" >]>
<foo>{"to": "EUR", "rate": 0.75278530600000004, "from": "USD"}</foo>

Vulnerability

Since all external entity references are resolved when the parser parses the XML and the fact that an external entity could either be a file on the local file system or a URL to a file on an external site this could lead to some of the following:

If the reference is to a file on the local file system the parser might reveal the file contents. Check the examples below where a history file on my local drive is revealed.
If the reference is resolved to a file whose size exceed allocated memory to the parser it might lead to a system crash.
A webserver serving display content by utilizing the de-referenced entity reference might lead to injection attacks.

Protection

Most XML Parsers are configurable inorder to disable this feature. By configuring appropriate properties we can protect against the XXE vulnerability. Below is an example of how this can be achieved in Groovy and in Java.

Groovy

XmlSlurper parser in Groovy in its default configuration allows de-referencing external entities and hence is vulnerable. The following Groovy script demonstrates how a file in the local file system (a mysql history file in my local system) can be revealed.

Vulnerable Parser Example:



rake0702@MHKTQWDV13:~/servers/groovy-2.0.5/scripts$ cat xxeDemo.groovy 

def xmlWithXXEVulnerability = '<?xml version="1.0"?><!DOCTYPE customer[<!ENTITY name SYSTEM "/Users/rake0702/.mysql_history">]><customer><name>&name;</name></customer>'
def xxeVulnerableParser = new XmlSlurper();
def parsedObjWithMySqlHistory = xxeVulnerableParser.parseText(xmlWithXXEVulnerability)
println parsedObjWithMySqlHistory

rake0702@MHKTQWDV13:~/servers/groovy-2.0.5/scripts$ groovy xxeDemo.groovy 

show tables;
select * from strategy;
update strategy set auto_activate=true where family='BASE';
select * from strategy;
select * from strategy where auto_activate=true;
select * from strategy;

Non-Vulnerable Parser Example:



rake0702@MHKTQWDV13:~/servers/groovy-2.0.5/scripts$ cat xxeSafeDemo.groovy 

def xmlWithXXEVulnerability = '<?xml version="1.0"?><!DOCTYPE customer[<!ENTITY name SYSTEM "/Users/rake0702/.mysql_history">]><customer><name>&name;</name></customer>'
def nonXXEVulnerableParser = new XmlSlurper();
nonXXEVulnerableParser.setFeature("http://xml.org/sax/features/external-general-entities", false)
def parsedObj = nonXXEVulnerableParser.parseText(xmlWithXXEVulnerability)
println parsedObj

rake0702@MHKTQWDV13:~/servers/groovy-2.0.5/scripts$ groovy xxeSafeDemo.groovy 

rake0702@MHKTQWDV13:~/servers/groovy-2.0.5/scripts$

Java

You can prevent the Xml eXternal Entity (XXE) attack by unmarshalling from an XMLStreamReader that has the IS_SUPPORTING_EXTERNAL_ENTITIES and/or XMLInputFactory.SUPPORT_DTD properties set to false.



JAXBContext jc = JAXBContext.newInstance(Customer.class);

XMLInputFactory xif = XMLInputFactory.newFactory();
xif.setProperty(XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, false);
xif.setProperty(XMLInputFactory.SUPPORT_DTD, false);
XMLStreamReader xsr = xif.createXMLStreamReader(new StreamSource("/Users/rake0702/servers/xml/xxeVulnerable.xml"));

Unmarshaller unmarshaller = jc.createUnmarshaller();
Customer customer = (Customer) unmarshaller.unmarshal(xsr);

References

https://www.owasp.org/index.php/XML_External_Entity_(XXE)_Processing

Java development environment best practices

2012-03-09T20:15:00.001-08:00

following are the standards/best practices for Java Development I have seen in projects. Please feel free to correct/add with your own experience.

1. Java Code: All developers could use a common editor formatting standard. I have attached a code style formatting for eclipse that can be imported using project->preferences-> Java -> Code Style -> Formatter

also use project->preferences->java->editor->Save Actions and make sure the above formatting is executed on save actions

2. Java Code: Usual java coding styles are standardized and an exhaustive listing is available at http://www.sourceformat.com/coding-standard-java.htm

3. Source Control: Each code change could be performed in a separate code branch(named after the related jira/ticket) as in case of GIT version control system or should be tagged with a jira/ticket number in case of SVN or similar version control systems. Source control is picking pace as a service and is being provided as a SAAS. bitbucket.org is a very popular provider that provides free unlimited private repositories.

4. Build Mangement: If maven is used for build management tasks. Each project should have a scm url pointing to the company wide maven repository. This ensures dependencies and maven releases are faster/secure and not exposed to the outside. All dependent projects should depend on RELEASE versions.

5. Test Driven Development (TDD) is preferred development methodology. As of recent efforts a more improvised means devised on top of TTD is Behavior Driven Development(BDD). BDD takes a step further in building more robust and agile software. It glues business scenarios in a better way around software development process. Scenarios and steps are provided in BDD that can be expressed in a language called Gherkin. Java and Ruby communities have provided JBehave and Cucumber that is programmatic expression to software behavior.

6. Tools like EMMA (http://emma.sourceforge.net/) for code coverage can be useful to figure out how much of production code is tested in the Unit tests. Code quality can be plugged into build management and continuous integration via tools like sonar.

7. If JUnit(http://www.junit.org/) is used for unit test code, mocking frameworks like Mockito (http://code.google.com/p/mockito/) should be used for mocking external resources instead of using real external resources. Data access object tests should use DBUnit (http://www.dbunit.org/) to mock database data rather than using hard coded values from the database.

8. Code review could be performed before committing code. Some code review tools that can be used are:

Crucible: http://www.atlassian.com/software/crucible/overview

CodeCollaborator: http://smartbear.com/products/software-development/code-review/code-review-tool-1

Open Source tools: http://ostatic.com/blog/open-source-code-review-tools

9. Continuous integration servers can be used to ensure that code is intact at all times. Several CI tools are available that can be configured to listen to Source control systems and email reports.

TeamCity: http://www.jetbrains.com/teamcity/

Hudson: http://hudson-ci.org/
Jenkins: http://jenkins-ci.org/

Continuous Integration is picking pace as a service as well. Popular SAAS for build management and continuous integration is cloudbees.

several good rules can be configured into CI servers to ensure project quality. Code coverage, complexity, duplication etc are few. Project release can be centrally performed from CI servers so rules are not broken or would require special exceptions being made.

10. Project management and issues management can be performed using tools like:

JIRA: http://www.atlassian.com/software/jira/overview

TRAC: http://trac.edgewall.org/

many more can be found at http://www.smashingmagazine.com/2008/11/13/15-useful-project-management-tools/

all the above listed tools can be integrated to a PM tool for better record keeping.

11. Code Quality/analysis/reporting is a good but optional feature. Each code commit can be followed by an automatic analysis by such tools. It performs algorithmic analysis on a specific set of rules to report issues like code complexity, too long java methods, insufficient code coverage, possible use of better standards like code patterns instead of clumsy decision blocks( eg strategy pattern instead of if-else or switch blocks), too long java classes, redundant code/unused code, orphan variables and just a trillion more things.

tools available:

http://www.sonarsource.org/

http://en.wikipedia.org/wiki/List_of_tools_for_static_code_analysis#Java

Other java development tools that could be of good use are:
- Goolgle CodePro Analytix
- JRebel

Automated test for Dozer transformations

2011-09-27T00:14:00.000-07:00

Source for this topic can be downloaded from:
http://sites.google.com/site/rockycodes/dozer-automated-test.zip

Dozer is an api to perform object transformations. A significant use case in a project is the transformations from Domain Objects(or ORM entitiy objects) to DTOs(Data transfer objects). More about dozer....
A simple example would be:


public class ValueObject{
  private int attr1;
  .... other attributes....
}

public class DTO{
  private int attr1;
  ...other attributes...
}

private DozerBeanMapper beanMapper

ValueObject valueObjectinstance = getValueObjectInstance();AutomatedDozerTestReport testReport =  new AutomatedDozerTester().testClasses(ValueObject.class, DTO.class)
assertTrue(testReport.getMappingFailures().isEmpty());


//map ValueObject to DTO using dozer
DTO dtoInstance = beanMapper.map( valueObjectinstance, DTO.class);

In one of the use cases I came across several hundreds of such transformations to and from Domain to DTO objects. Unit testing so many objects by instantiating each Domain object with attributes and verifying the transformed DTO would involve sever thousands of lines of code. Instead an automated class that would cerate a new instance of a given Domain class , perform transformation and assert the transformed DTO instance would be of great help. This is exactly what the following project is meant to perform. The automated tester in the attached source would perform a test in the following fashion:

Usage:


AutomatedDozerTestReport<ValueObject,DTO> testReport =  new AutomatedDozerTester().testClasses(ValueObject.class, DTO.class)
assertTrue(testReport.getMappingFailures().isEmpty());

testClasses() method in AutomatedDozerTester: (see attached source)




public <T, P> AutomatedDozerTestReport<T, P> testClasses(Class<T> sourceClass, Class<P> destinationClass, DozerBeanMapper beanMapper) throws Exception {
	AutomatedDozerTestReport<T, P> testReport = new AutomatedDozerTestReport<T, P>(sourceClass, destinationClass);

	T newSrcInstance = getInstanceWithValues(sourceClass);

	P destMappedInstance = beanMapper.map(newSrcInstance, destinationClass);

	testReport.setSourceInstance(newSrcInstance);
	testReport.setDestInstance(destMappedInstance);
	matchAndGenerateReport(testReport, newSrcInstance, destMappedInstance, "", "");

	return testReport;

}

There are certain limitations to testing using AutomatedDozerTester as of now:
1. Does not support custom converters at field level.
2. Need to add to AutomatedDozerTester.getValueFromFactory() in case a new data type is used in the objects
3. The report object sometimes fails to report proper unmappedSourceAttributes.

configuring log4j using configuration servlet

2011-07-11T14:23:00.000-07:00

Logging levels on log4j are varied and range low to high from:

ALL, TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF

In a normal production deployed app we would set the logging levels to WARN or for that case to ERROR. Some performance maniac deployer would even turn off logs and cripple a developers life :(

In some cases when we can run the same error path for an app deployed to prod to recreate the error the Log4j configuration servlet comes to rescue.
We can set logging to the desired level at runtime and perform the error path and capture the logs.
We need not change the log4j.xml, rebuild the ear and deploy the app. Configuration servlet configures log4j at runtime.

Log4j v1.3 http://wiki.apache.org/logging-log4j/Log4jv13Features has this capability. Unfortunately this version has been abandoned and users requested to fall back to 1.2. A sourceforge open source project called "openutils-log4j" mirrors the same functionality and can be used. More info can be found at http://openutils.sourceforge.net/openutils-log4j/servlet.html

Adding this functionality to the web app is as follows:

web.xml


 <servlet>
  <servlet-name>log4j</servlet-name>
  <display-name>Log4j configuration Servlet</display-name>
  <servlet-class>it.openutils.log4j.Log4jConfigurationServlet</servlet-class>
 </servlet>

 <servlet-mapping>
  <servlet-name>log4j</servlet-name>
  <url-pattern>/log4j</url-pattern>
 </servlet-mapping>

dependency in pom.xml


    <dependency>
     <groupId>net.sourceforge.openutils</groupId>
     <artifactId>openutils-log4j</artifactId>
     <version>2.0.5</version>
 </dependency>

The log4j configuration servlet would appear at a url as follows:

http://localhost:9090//log4j

and the page would appear something like this:

ErrorWrap: An Error handling Spring aspect, logs and sends email notification

2011-06-01T00:40:00.000-07:00

Error handling - Logging the error and notifying the error(via email or other means) is a cross-cutting concern. Top level web service methods and API methods are candidates that might need such handling.
Following article is about a spring aspect that captures the error, logs the method signature and arguments where the error occurred and emails the error notification to a pre-configured email destination. This aspect is annotation driven hence is easily pluggable to any existing method that is part of a spring bean.

Code(eclipse project) can be downloaded from the following location:
http://sites.google.com/site/rockycodes/ErrorWrapper.zip

Following is an example usage of the aspect annotation on few webservice methods:



@ErrorWrap(logException = true, sendEmail = false)
public String bar(String fooPasscode) {
....
}

@ErrorWrap //by default log the error and also send an email
public String foo(String barPasscode) {
....
}

The ErrorWrap annotation that is used as a pointcut definition for this aspect is as follows:

ErrorWrap.java



package com.blog10_99.error;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface ErrorWrap {
 boolean sendEmail() default  true;
 boolean logException() default true;
 boolean ignoreDeclaredExceptions() default true;
 String appender() default "";
}

The aspect that is defined for achieving this purpose is as follows. It defines a pointcut using the ErrorWrap annotation as defined above.

ErrorHandlerAspect.java



package com.blog10_99.error;

import java.util.Arrays;

import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.exception.ExceptionUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.mail.MailSender;
import org.springframework.mail.SimpleMailMessage;

@Aspect
public class ErrorHandlerAspect {

 private static final String METHOD_INFO_MSG = "Error encountered while invocation of n Method: %s n Arguments: [%s]";

 private static final Logger logger = LoggerFactory.getLogger(ErrorHandlerAspect.class);

 private MailSender mailSender;

 private SimpleMailMessage messageTemplate;

 @AfterThrowing(pointcut="@annotation(errorWrap)",
     throwing="exception")
 public void handleException(JoinPoint joinPoint,
    Throwable exception,
    ErrorWrap errorWrap){

  if (errorWrap.ignoreDeclaredExceptions() &&
 isExceptionDeclaredType(exceptionThrown, joinPoint)) {
    return;
  }

  String appender = errorWrap.appender();
  if (StringUtils.isNotEmpty(errorWrap.appender())) {
   appender += ": ";
  }

  String methodInfo = String.format(METHOD_INFO_MSG, joinPoint.getSignature(), Arrays.asList(joinPoint.getArgs()));

  logger.error(appender + methodInfo);

  if(errorWrap.logException()){
   logger.error(appender + "Exception trace:n", exception);
  }

  if(errorWrap.sendEmail()){
   logger.debug(appender + "Sending email.");
   sendEmail(exception, methodInfo);
  }
 }

 private void sendEmail(Throwable exception, String methodInfo) {
  SimpleMailMessage message = getMessageTemplate();
  StringBuilder messageBody = new StringBuilder();
  messageBody.append(methodInfo);
  messageBody.append("n");
  messageBody.append("Exception Trace: n" + ExceptionUtils.getStackTrace(exception));
  message.setText(messageBody.toString());
  getMailSender().send(message);
 }

 private boolean isExceptionDeclaredType(Throwable exceptionThrown, JoinPoint joinPoint) {
  MethodSignature signature = (MethodSignature) joinPoint.getSignature();
  boolean exceptionOfDeclaredType = false;
  @SuppressWarnings("unchecked")
  Class[] declaredExceptions = signature.getExceptionTypes();
  if (ArrayUtils.isNotEmpty(declaredExceptions)) {
   for (Class declaredExClass : declaredExceptions) {
    if (declaredExClass.isAssignableFrom(exceptionThrown.getClass())) {
     exceptionOfDeclaredType = true;
 break;
    }
   }
  }
  return exceptionOfDeclaredType;
 }

 public MailSender getMailSender() {
  return mailSender;
 }

 public void setMailSender(MailSender mailSender) {
  this.mailSender = mailSender;
 }

 public SimpleMailMessage getMessageTemplate() {
  return messageTemplate;
 }

 public void setMessageTemplate(SimpleMailMessage messageTemplate) {
  this.messageTemplate = messageTemplate;
 }
}

Rest of the configuration for email and sample web services with execution unit tests can be found in the attached code link above.
The test com.blog10_99.error.ExecuteAndTestErrorWrap is what I used to test the error handling when the FooBarService methods are invoked.

B.o.B hip hop feat on The Foundations

2011-05-05T10:10:00.000-07:00

I was listening to B.o.B and stumbled across this song:

remembered a song that this is based off The Foundations.

Foundations were a British Music band active from 1967 - 1970. I will not copy paste any more :) If u want to read more go to wikipedia link to Foundations

one more song that hit the charts:

asta la vista ....

Camel and Cxf integration use cases

2011-03-16T02:45:00.000-07:00

Apache Camel is a very powerful java api to implement workflow based implementations in an enterprise application. Cxf services are an essential part of enterprise as well. Hence, integration of Camel and Cxf services could be thumbs up to the architecture of an enterprise java application.

Code for this project can be downloaded from the following location:

http://sites.google.com/site/rockycodes/CamelCxfDemo.zip

Following use cases are part of this demo application:

Make the entry point of a Camel workflow as a Cxf webservice. A http soap xml call on the the service could invoke the Camel workflow and return the response soap xml back as a response.
Invoke a Cxf web service in one of the workflow steps of the Camel route.

Components of the application are as follows:

A Cxf webservice "KeyService"
A Camel entry point exposed as webservice "RouteEntryPointService"
A Camel route

flow: A webservice request invokes "RouteEntryPointService" that triggers the Camel workflow. As part of the workflow another webservice "KeyService" is invoked and the response is processed before returning a response to the initial call that invoked the workflow or camel route.

Spring Application Context file applicationContext.xml



<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:camel="http://camel.apache.org/schema/spring"
 xmlns:util="http://www.springframework.org/schema/util" xmlns:tx="http://www.springframework.org/schema/tx"
 xmlns:amq="http://activemq.apache.org/schema/core" xmlns:cxf="http://camel.apache.org/schema/cxf"
 xmlns:jaxws="http://cxf.apache.org/jaxws"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
 http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring-2.1.0.xsd
 http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-2.5.xsd
 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
 http://activemq.apache.org/schema/core http://activemq.apache.org/schema/core/activemq-core.xsd
 http://camel.apache.org/schema/cxf http://activemq.apache.org/camel/schema/cxf/camel-cxf.xsd
 http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">

 <import resource="classpath:META-INF/cxf/cxf.xml" />
 <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />
 <import resource="classpath:META-INF/cxf/cxf-servlet.xml" />

 <jaxws:endpoint id="keyServiceImplEndPoint"
  xmlns:blog10_99="http://www.10_99.blogspot.com/com/blog10_99/ws/common"
  implementor="#keyServiceImpl" address="/services/KeyService"
  serviceName="KeyService" />

 <bean id="keyServiceImpl" class="com.blog10_99.ws.impl.KeyServiceImpl" />

 <cxf:cxfEndpoint id="routeEntryPointService"
  address="/services/RouteEntryPointService"
  serviceClass="com.blog10_99.ws.common.RouteEntryService" 
  xmlns:blog10_99="http://www.10_99.blogspot.com/com/blog10_99/ws/common">
  <cxf:properties>
   <entry key="dataFormat" value="POJO" />
   <entry key="setDefaultBus" value="true" />
  </cxf:properties>
 </cxf:cxfEndpoint>

    <bean id="keyServiceClient" class="com.blog10_99.ws.common.KeyService"
        factory-bean="keyServiceClientProxyFactory" factory-method="create" lazy-init="true"/>

    <bean id="keyServiceClientProxyFactory" class="org.apache.cxf.jaxws.JaxWsProxyFactoryBean" lazy-init="true">
        <property name="serviceClass" value="com.blog10_99.ws.common.KeyService" />
        <property name="address" value="http://localhost:9666/CamelCxfDemo/services/KeyServiceImpl?wsdl" />
    </bean>

 <camel:camelContext trace="true">
  <camel:route>
   <camel:from
    uri="cxf:bean:routeEntryPointService" />
   <camel:to uri="bean:routeEntryRequestProcessor"/>
   <camel:to uri="bean:keyServiceClient?method=getKey"/>
   <camel:to uri="bean:routeExitResponseProcessor"/>
  </camel:route>
 </camel:camelContext>
 
 <bean id="routeEntryRequestProcessor" class="com.blog10_99.handlers.RouteEntryRequestProcessor"/>
 
 <bean id="routeExitResponseProcessor" class="com.blog10_99.handlers.RouteExitResponseProcessor"/>
 
</beans>

rest of the files can be found in the source code at:

http://sites.google.com/site/rockycodes/CamelCxfDemo.zip

steps to execute the demo:

at the source root execute "mvn jetty:run"
from a SOAP UI create a project with wsdl at :

http://localhost:9666/CamelCxfDemo/services/RouteEntryPointService?wsdl

populate the default request with a requestor string attribute and execute it.

Multi Transaction Manager Spring Configuration - A Mix of Declarative and XML Configuration

2010-11-28T00:13:00.000-08:00

Spring transaction management involves specifying transaction boundaries and transaction Propagation using either annotations or configuring it in XML.

What this post is about:

The annotation(declarative) approach is limited to creating and configuring boundary for a single transaction manager but fails to address the scenario of multiple transaction managers. XML configuration approach is the only means to achieve this. Multiple transactions could be required either around a single point cut Or weave one transaction around a point cut and another around a different point cut but in the same work flow path.

The best way to find out Transactions begin and end in Spring is to watch the log using log4j. Following scenarios are few that might be of interest. The attached code has the complete maven project with Unit tests that can be run to watch the transaction log show.

Code for this project can be downloaded from the following location:

http://sites.google.com/site/rockycodes/SpringMultiDatasrc.zip

A Single point cut, Single transaction manager configuration using

XML configuration
Declarative Annotations

A Single Point cut, Multiple Transaction managers using

XML configuration
Annotations cannot be used for more than one txn manager. Annotation driven approach limits binding a single transaction manager to transaction annotations.
A Mix of XML Configuration and Annotations.One of the txn managers can be configured using XML config and the other using annotations. This is not advised as it seriously effects maintainability of the application.

The code below depicts a project with Two DataSources, Two Transaction Managers, Two Advices and a set of PointCut definitions that weave the transaction boundaries for the two transaction managers.

All the transaction configurations are depicted in the following Spring ApplicationContext file applicationContext.xml



<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
 xmlns:tx="http://www.springframework.org/schema/tx"
 xsi:schemaLocation="
     http://www.springframework.org/schema/beans 
     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
     http://www.springframework.org/schema/tx
     http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
     http://www.springframework.org/schema/aop 
     http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

 <bean id="dataSourceOne" class="org.apache.commons.dbcp.BasicDataSource"
  destroy-method="close">
  <property name="driverClassName" value="org.hsqldb.jdbcDriver" />
  <property name="url" value="jdbc:hsqldb:memone:dbone" />
  <property name="username" value="sa" />
  <property name="password" value="" />
 </bean>

 <bean id="dataSourceTwo" class="org.apache.commons.dbcp.BasicDataSource"
  destroy-method="close">
  <property name="driverClassName" value="org.hsqldb.jdbcDriver" />
  <property name="url" value="jdbc:hsqldb:memtwo:dbtwo" />
  <property name="username" value="sa" />
  <property name="password" value="" />
 </bean>

 <bean id="transactionManagerOne"
  class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSourceOne" />
 </bean>

 <bean id="transactionManagerTwo"
  class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSourceTwo" />
 </bean>

 <tx:advice id="txAdviceOne" transaction-manager="transactionManagerOne">
  <tx:attributes>
   <tx:method name="*" />
  </tx:attributes>
 </tx:advice>

 <tx:advice id="txAdviceTwo" transaction-manager="transactionManagerTwo">
  <tx:attributes>
   <tx:method name="*" />
  </tx:attributes>
 </tx:advice>

 <aop:config>
  <aop:pointcut id="pcForMethod_singlePC_SingleTxnMgr_XMLConfig"
   expression="execution(* com.blog10_99.business.BusinessHandler.singlePC_SingleTxnMgr_XMLConfig())" />
  <aop:advisor advice-ref="txAdviceOne" pointcut-ref="pcForMethod_singlePC_SingleTxnMgr_XMLConfig" />
 </aop:config>

 <aop:config>
  <aop:pointcut id="pcForMethod_singlePC_TwoTxnMgr_XMLConfig_TxnMgrOne"
   expression="execution(* com.blog10_99.business.BusinessHandler.singlePC_TwoTxnMgr_XMLConfig())" />
  <aop:advisor advice-ref="txAdviceOne" pointcut-ref="pcForMethod_singlePC_TwoTxnMgr_XMLConfig_TxnMgrOne" />
 </aop:config>

 <aop:config>
  <aop:pointcut id="pcForMethod_singlePC_TwoTxnMgr_XMLConfig_TxnMgrTwo"
   expression="execution(* com.blog10_99.business.BusinessHandler.singlePC_TwoTxnMgr_XMLConfig())" />
  <aop:advisor advice-ref="txAdviceTwo" pointcut-ref="pcForMethod_singlePC_TwoTxnMgr_XMLConfig_TxnMgrTwo" />
 </aop:config>

 <aop:config>
  <aop:pointcut id="pcForMethod_singlePC_TwoTxnMgr_OneXMLConfigOneAnnotation_TxnMgrTwo"
   expression="execution(* com.blog10_99.business.BusinessHandler.singlePC_TwoTxnMgr_OneXMLConfigOneAnnotation())" />
  <aop:advisor advice-ref="txAdviceTwo" pointcut-ref="pcForMethod_singlePC_TwoTxnMgr_OneXMLConfigOneAnnotation_TxnMgrTwo" />
 </aop:config>

 <!-- annotation driven can co-exist with other XML Configs. The transaction-manager
  attribute specified is used to run transaction boundaries wherever annotations
  are specified. If this attribute is not specified transaction manager with id "transactionManager"
  is used. There is none with that name specified in this context. 
  -->
    <tx:annotation-driven transaction-manager="transactionManagerOne"/>

 <bean id="handler" class="com.blog10_99.business.BusinessHandlerImpl"/>
 
</beans>

The BusinessHandler interface file BusinessHandler.java


package com.blog10_99.business;

import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

public interface BusinessHandler {

 public abstract void singlePC_SingleTxnMgr_XMLConfig();

 @Transactional(propagation = Propagation.REQUIRED)
 public abstract void singlePC_SingleTxnMgr_Annotations();

 public abstract void singlePC_TwoTxnMgr_XMLConfig();

 @Transactional(propagation = Propagation.REQUIRED)
 public abstract void singlePC_TwoTxnMgr_OneXMLConfigOneAnnotation();

}

The BusinessHandler Implementation file BusinessHandlerImpl.java


package com.blog10_99.business;

import org.apache.log4j.Logger;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

public class BusinessHandlerImpl implements BusinessHandler {

 private static final Logger LOGGER = Logger.getLogger( BusinessHandlerImpl.class );

 @Override
 public void singlePC_SingleTxnMgr_XMLConfig(){
 }

 @Override
 @Transactional(propagation=Propagation.REQUIRED)
 public void singlePC_SingleTxnMgr_Annotations(){
 }

 @Override
 public void singlePC_TwoTxnMgr_XMLConfig(){
 }

 @Override
 @Transactional(propagation = Propagation.REQUIRED)
 public void singlePC_TwoTxnMgr_OneXMLConfigOneAnnotation(){
 }
}

Unit Test to execute and run the methods BusinessHandler_UT.java


package com.blog10_99.business;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"/applicationContext.xml"})
public class BusinessHandler_UT {

 @Resource(name="handler")
 private BusinessHandler handler;
 
 @Test
 public void watchLogOn_singlePC_SingleTxnMgr_XMLConfig() throws Exception{
  handler.singlePC_SingleTxnMgr_XMLConfig();
 }
 
 @Test
 public void watchLogOn_singlePC_SingleTxnMgr_Annotations() throws Exception{
  handler.singlePC_SingleTxnMgr_Annotations();
 }

 
 @Test
 public void watchLogOn_singlePC_TwoTxnMgr_XMLConfig() throws Exception{
  handler.singlePC_TwoTxnMgr_XMLConfig();
 }

 
 @Test
 public void watchLogOn_singlePC_TwoTxnMgr_OneXMLConfigOneAnnotation() throws Exception{
  handler.singlePC_TwoTxnMgr_OneXMLConfigOneAnnotation();
 }

}

Log4J config to enable logging for spring framework log4j.xml


<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/"
 debug="false">

 <!-- logs to system console -->
 <appender name="CONSOLE" class="org.apache.log4j.ConsoleAppender">
  <param name="Target" value="System.out" />
  <param name="Threshold" value="ALL" />
  <layout class="org.apache.log4j.PatternLayout">
   <param name="ConversionPattern" value="%d{ABSOLUTE} %-5p [%c{1}] %m%n" />
  </layout>
 </appender>

 <logger name="org.springframework" additivity="false">
  <level value="TRACE" />
  <appender-ref ref="CONSOLE" />
 </logger>

 <root>
  <level value="ALL" />
  
  <appender-ref ref="CONSOLE" />
 </root>

</log4j:configuration>

A callback Java Collection

2010-09-24T23:38:00.000-07:00

A collection is meant to store or group together objects. In most cases the purpose is to retrieve it later after collecting and process/modify the objects within. Almost always this retrieval or traversal of the collection is after all the objects have been collected. There could be a use case where in the retrieval/processing of these objects is triggered on events such as:
- The number of objects collected within, a particular threshold reached
- The time elapsed

Following implementation depicts a callback collection that would perform a callback on such events. Additionally events could be decorated such that a logical OR of such events could be performed.

source at :
https://sites.google.com/site/rockycodes/CallbackCollection.zip

Usage of the collection as shown below in CallbackCollectionUsage.java


package com.blog10_99.usage;

import java.util.ArrayList;
import java.util.Collection;

import com.blog10_99.callbackcoll.CallbackCollection;
import com.blog10_99.callbackcoll.CallbackCollectionHandler;
import com.blog10_99.callbackcoll.MaxSizeCallbackCollection;

public class CallbackCollectionUsage implements CallbackCollectionHandler<String>{

 public static void main(String args[]){
  new CallbackCollectionUsage().performTest();
 }
 
 private void performTest(){
  Long MAX_SIZE = 5L;
  CallbackCollection<String> callbackCollection = new MaxSizeCallbackCollection<String>(new ArrayList<String>(), MAX_SIZE);
  callbackCollection.addCallbackHandler(this);
  for(int i=0;i<10;i++){
   callbackCollection.add("String:" + i);
  }  
 }
 
 @Override
 public void callbackCollectionNotification(Collection<String> collection) {
  System.out.println("Callback performed:");
  for(String obj : collection){
   System.out.println(obj);
  }
  collection.clear();
 }
}

The CallbackCollection interface


package com.blog10_99.callbackcoll;

import java.util.Collection;

public interface CallbackCollection<T>{
 public Collection<T> getCollection();
    public void addCallbackHandler(CallbackCollectionHandler<T> handler);
    public Collection<CallbackCollectionHandler<T>> getCallbackHandlers();
    public void initiateNotification();
    public boolean isReady();
    public boolean add(T object);
}

The MaxSizeCallbackCollection implementation


package com.blog10_99.callbackcoll;

import java.util.Collection;

public class MaxSizeCallbackCollection<T> extends AbstractCallbackCollection<T>{
    private Long maxSize = Long.MAX_VALUE;
    private AbstractCallbackCollection<T> decoration;

    public MaxSizeCallbackCollection(Collection<T> collection,Long maxSize){
     super(collection);
        this.maxSize = maxSize;
        this.decoration = new DefaultCallbackCollection<T>(collection,true);
    }

    public MaxSizeCallbackCollection(Collection<T> collection,Long maxSize, AbstractCallbackCollection<T> decoration){
        this(collection,maxSize);
        if (decoration != null) {
            this.decoration = decoration;
        }
    }

    @Override
    public boolean add(T element) {
        boolean result = super.add(element);
        if(isReady()){
            initiateNotification();
        }
        return result;
    }

    @Override
    public boolean isReady() {
        if((super.getCollection().size() == maxSize) && decoration.isReady()){
            return true;
        }
        return false;
    }
}

Rest of the code including AbstractCallbackCollection.java, CallbackCollectionHandler.java, TimeOutCallbackCollection.java can be found in the source at the following location:

https://sites.google.com/site/rockycodes/CallbackCollection.zip

Additionally synchronization issues might crop up when TimeOutCallbackCollection type is used. I ended up dumping this kind and using Spring3.0 timer constructs like Scheduler.

JSF2.0 Navigation Use Cases

2010-09-19T23:04:00.000-07:00

Navigation to and from workflow steps and pages in a web application is central to its design and usability. JSF2.0 brings smiles to developers because of its easy to use navigation features. JSF1.2 made developers do all the navigation as a configuration in xml configuration but JSF2.0 comes with new implicit navigation, button like UI component control navigation, EL driven navigation outcomes. All these cool new additions almost make JSF1.2 apps look like they were from the stone age.

In the following code example that has "pageOne.xhtml", "pageTwo.xhtml" and "pageThree.xhtml" h:commandButton can be used for navigation in the following ways:

Implicit Navigation using h:commandButton's action attribute


<h:commandButton action="pageTwo" value="Go To pageTwo" />

<h:button outcome="pageTwo" value="Go To pageTwo" />

Implicit Navigation using action method binding


<h:commandButton action="#{pageOneController.navigateToPageTwo}" value="Go To pageTwo" />


package com.blog10_99.jsfnavigation;

import javax.faces.bean.ManagedBean;
import javax.faces.bean.RequestScoped;
import javax.faces.event.ActionEvent;

@ManagedBean
@RequestScoped
public class PageOneController {
 
 private boolean readyToGoToPageTwo;
 
 public String navigateToPageTwo(){
  return "pageTwo";
 }
 
 public void decideApplicationState(ActionEvent ae){
  if(Math.random() < 0.5){
   readyToGoToPageTwo = true;
  }else{
   readyToGoToPageTwo = false;
  }
 }

 public boolean isReadyToGoToPageTwo() {
  return readyToGoToPageTwo;
 }

 public void setReadyToGoToPageTwo(boolean readyToGoToPageTwo) {
  this.readyToGoToPageTwo = readyToGoToPageTwo;
 }
}

Conditional Navigation using faces-config.xml EL


<h:commandButton actionListener="#{pageOneController.decideApplicationState}" value="Go To pageTwo or pageThree" />


<?xml version="1.0"?>
<faces-config xmlns="http://java.sun.com/xml/ns/javaee"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-facesconfig_2_0.xsd"
 version="2.0">
 <application>
  <resource-bundle>
   <base-name>com.blog10_99.jsfnavigation.messages.messages</base-name>
   <var>msgs</var>
  </resource-bundle>
 </application>

 <navigation-rule>
  <from-view-id>/ui/pageOne.xhtml</from-view-id>
  <navigation-case>
   <if>#{pageOneController.readyToGoToPageTwo}</if>
   <to-view-id>/ui/pageTwo.xhtml</to-view-id>
  </navigation-case>
  <navigation-case>
   <if>#{!pageOneController.readyToGoToPageTwo}</if>
   <to-view-id>/ui/pageThree.xhtml</to-view-id>
  </navigation-case>
 </navigation-rule>
</faces-config>

Source code with maven project for the above JSF2.0 navigation demo can be downloaded from the following location: https://sites.google.com/site/rockycodes/jsfnavigation.zip

MP3 ID3V2 tag modifier tool to have a directory structure grouping in your iPod just like in your hard-drive

2010-08-07T22:18:00.000-07:00

IPOD/IPhone does a good job grouping music over some tags but fails badly on some. For example grouping like IPOD --> more.. --> Albums takes you to songs grouped by a unique combination of Artist and Album name. This grouping leaves you with a scattered list of songs from an album whose songs have been sung by different artists. For me this resulted in having 5 listings of the same album name in the Albums view because each song in it was sung by a separate artist. I had to manually change to play songs from the same album and it was one of my favorites !

I almost wish I had a folder structure listed out in my IPOD that was just like the one on my hard-drive!

I granted myself this wish and found the following workaround:

IPOD --> more.. --> Composers is a group that I never use. I created a tool that given a root folder name on the hard-drive(I had all my songs in c:\songs) recursively browses each folder and sets the composer attribute of the ID3V2 tag of a MP3 file to the name of its folder. Hence if I had songs in folder C:\songs\metallica\Death Magnetic, all songs in this folder would be updated to have a composer value of Death Magnetic. After having run the tool I cleared out my itunes and dragged all my modified files back again and got my iphone sync'd. Wo...hooo!! now the exact same directory structure grouping shows up when I browse to IPOD --> more.. --> Composers

My songs folder was c:\songs hence I used the following command:

java -jar SeekNChange.jar "C:\songs"

Download the SeekNChange.jar file from the following location:
https://sites.google.com/site/rockycodes/SeekNChange.jar

External Libraries and Tools used

Source Code:


package com.blog10_99.music;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class MP3SeekNModifier {
 private FileWriter logFile;

 public void modifyComposerForMP3sInFolderToParentFolderName(
   String folderPath) throws IOException {
  System.out.println("modifying composer names in folder: " + folderPath);
  File inputFolder = new File(folderPath);
  logFile = new FileWriter(new File(folderPath, "SeekNChangeErrors.txt"));
  modifyComposer(inputFolder);
  logFile.close();
 }

 private void modifyComposer(File parentFolder) throws IOException {
  System.out.println("modifying composer names in folder: "
    + parentFolder.getAbsolutePath());
  File[] children = parentFolder.listFiles();
  if (children == null) {
   return;
  }
  for (File childFile : children) {
   if (childFile.isDirectory()) {
    modifyComposer(childFile);
    logFile.flush();
   } else {
    changeComposer(parentFolder, childFile);
   }
  }
 }

 private void changeComposer(File parentFolder, File childFile)
   throws IOException {
  if (childFile.canWrite()
    && childFile.getAbsolutePath().matches(
      ".*\\.{1}?[(mp)(MP)(mP)(Mp)]+3")) {
   try {
    new MP3FileID3Modifier().modifyId3V2Composer(childFile,
      parentFolder.getName());
   } catch (Exception e) {
    String logMessage = "Could not modify composer for file: "
      + childFile.getAbsolutePath();
    System.out.println(logMessage);
    e.printStackTrace();
    logFile.write(logMessage + "\n");
   }
  }
 }

 public static void main(String args[]) throws IOException {
    if (args == null || args.length != 1) {
  System.out.println("USAGE: java -jar SeekNChange.jar ");
  return;
    }
    new MP3SeekNModifier()
    .modifyComposerForMP3sInFolderToParentFolderName(args[0]);
 }
}

package com.blog10_99.music;

import java.io.File;

import org.jaudiotagger.audio.AudioFile;
import org.jaudiotagger.audio.AudioFileIO;
import org.jaudiotagger.tag.FieldKey;
import org.jaudiotagger.tag.Tag;

public class MP3FileID3Modifier {
 public void modifyId3V2Composer(File mp3File, String composerName)
   throws Exception {
  System.out.println("processing... " + mp3File.getAbsolutePath());
  AudioFile f = AudioFileIO.read(mp3File);
  Tag tag = f.getTagOrCreateAndSetDefault();
  tag.setField(FieldKey.COMPOSER, composerName);
  f.commit();
  System.out.println("changed composer for: " + mp3File.getName()
    + " to " + composerName);
 }
}

Creating a CXF client using spring

2010-06-23T16:45:00.000-07:00

This post demonstrates creating a JAXWS client to a webservice using CXF. You could create a CXF client in plain java code or you could configure the same in spring and inject it into your business objects for use.

Following simple webservice interface could be taken as an example service:


package com.blog10_99.svc;
@javax.jws.WebService
public interface AddService{
    public int add(int number1, int number2);
}

Supposing the above service is deployed and accessible at the following url:
http://localhost/myservices/AddService

WSDL URL:
http://localhost/myservices/AddService?wsdl

A simple CXF Client using plain java code:


org.apache.cxf.jaxws.JaxWsProxyFactoryBean factory = new org.apache.cxf.jaxws.JaxWsProxyFactoryBean();
factory.setServiceClass(com.blog10_99.svc.AddService.class);
factory.setAddress("http://localhost/myservices/AddService");
com.blog10_99.svc.AddService client = (com.blog10_99.svc.AddService) factory.create();
System.out.println(client.add(1, 2));

A simple CXF Client configured using spring:


<bean id="proxyFactory" class="org.apache.cxf.jaxws.JaxWsProxyFactoryBean">
  <property name="serviceClass" value="com.blog10_99.svc.AddService" />
  <property name="address" value="http://localhost/myservices/AddService" />
</bean>

<bean id="client" class="com.blog10_99.svc.AddService"
  factory-bean="proxyFactory" factory-method="create" />

The bean with id "client" can now be injected into any business bean and used to invoke the service.

Custom Paginated JSF Table Component using Hibernate

2010-03-06T13:33:00.000-08:00

It is a custom component that takes in a reference to Hibernate Session Factory, a desired page size and a Hibernate entity class name. Yikes!!! it takes in a "Session Factory"... A UI component !!! Yes this one plays a Rambo!
usage:

<blog10_99:ptable pageSize="5"
            entityClass="com.blog10_99.entities.Person"
            sessionFactory="#{sessionFactoryProvider.sessionFactory}"/>

looks like:

- "sessionFactory" attribute in the tag is used to take in a managed bean EL that evaluates to a configured Session Factory instance.
- "entityClass" attribute reffers to a fully qualified Entity Class name that has been mapped in Hibernate and is part of the session factory configuration.
- "pageSize" refers to the number of rows to fetch in one go.

This component uses hibernate's ability to fetch paginated data as follows:

Criteria criteria = session.createCriteria(getEntityClass());
        criteria.setFirstResult(startIndex);
        criteria.setMaxResults(pageSize);        
        List entities = criteria.list();

There was this great tutorial that I mined out from the web and that tought me to pacakage a custom component.
Download link to the packaged component:
http://sites.google.com/site/rockycodes/ptable.jar
This jar also contains the source code for the Component Class, Tag Class, Renderer class, TLD file used to build the component. Directory structure looks like this:

the faces-config.xml file in the distributable jar file for the component is just for reference and I could not make out a plugable way to use it. Component and Renderer declaration has to go in manually in to whichever project a JSF component needs to be used.

Following is a link to a demo project that uses this component:
http://sites.google.com/site/rockycodes/DemoPTable.zip
this project also contains sql scripts CreatePersonTable.sql and PopulatePersonTableProc.sql under the resources dir that can be used to populate the database for this demo. You might need to configure "hibernate.cfg.xml" to use the correct URL and username/password for your database instance. I tried this on a Oracle Express Edition database that is free for download fro Oracle's Website.

Component Code Follows:

com.blog10_99.jsf.component.UIPaginatedTable

package com.blog10_99.jsf.component;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;

import javax.faces.component.UIComponentBase;
import javax.faces.context.FacesContext;

import org.hibernate.Criteria;
import org.hibernate.SessionFactory;
import org.hibernate.classic.Session;

import com.blog10_99.jsf.renderer.PaginatedTableHtmlRenderer;

public class UIPaginatedTable extends UIComponentBase {
    public static final String COMPONENT_FAMILY_TYPE = "blog10_99.paginatedtable";
    private Class entityClass;
    private int pageSize;
    private int currentPageNumber;
    
    @Override
    public String getFamily() {
        return COMPONENT_FAMILY_TYPE;
    }

    @Override
    public String getRendererType() {
        return PaginatedTableHtmlRenderer.RENDERER_TYPE;
    }

    public List<List<String>> getEntityData() {
        List<List<String>> entityAttrValuesInStrings = new ArrayList<List<String>>();
        List entities = getEntitiesFromSource(getCurrentPageNumber()
                * getPageSize(), getPageSize(), getEntityClass());
        for (Object entity : entities) {
            List<String> attrValues = new ArrayList<String>();
            Field[] fields = getEntityClass().getDeclaredFields();
            for (Field field : fields) {
                String fieldValue = "";
                try {
                    field.setAccessible(true);
                    fieldValue = field.get(entity).toString();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                attrValues.add(fieldValue);
            }
            entityAttrValuesInStrings.add(attrValues);
        }
        return entityAttrValuesInStrings;
    }

    private List getEntitiesFromSource(int startIndex, int pageSize,
            Class entityClass) {
        SessionFactory sessionFactory =(SessionFactory)getAttributes().get("sessionFactory");
        Session session = sessionFactory.openSession();
        session.beginTransaction();
        Criteria criteria = session.createCriteria(getEntityClass());
        criteria.setFirstResult(startIndex);
        criteria.setMaxResults(pageSize);        
        List entities = criteria.list();
        return entities;
    }

    public Class getEntityClass() {
        return entityClass;
    }

    public void setEntityClass(Class entityClass) {
        this.entityClass = entityClass;
    }

    public int getPageSize() {
        return pageSize;
    }

    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }

    public int getCurrentPageNumber() {
        return currentPageNumber;
    }

    public void setCurrentPageNumber(int currentPageNumber) {
        this.currentPageNumber = currentPageNumber;
    }
    
    @Override
    public Object saveState(FacesContext context) {
        Object values[] = new Object[2];
        values[0] = super.saveState(context);
        values[1] = collectCustomTableComponentAttributeValues();
        return ((Object) (values));
    }

    @Override
    public void restoreState(FacesContext context, Object state) {
        Object values[] = (Object[]) state;
        super.restoreState(context, values[0]);
        restoreCustomTableComponentAttributeValues((Object[]) values[1]);
    }

    private Object[] collectCustomTableComponentAttributeValues(){
        Object customTableComponentValues[] = new Object[3];
        customTableComponentValues[0] = getEntityClass();
        customTableComponentValues[1] = getPageSize();
        customTableComponentValues[2] = getCurrentPageNumber();
        return customTableComponentValues;
    }
    
    private void restoreCustomTableComponentAttributeValues(Object[] customTableComponentValues){
        setEntityClass((Class) customTableComponentValues[0]);
        setPageSize((Integer)customTableComponentValues[1]);
        setCurrentPageNumber((Integer) customTableComponentValues[2]);        
    }
}

com.blog10_99.jsf.renderer.PaginatedTableHtmlRenderer

package com.blog10_99.jsf.renderer;

import java.io.IOException;
import java.lang.reflect.Field;
import java.util.List;

import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.context.ResponseWriter;
import javax.faces.render.Renderer;

import com.blog10_99.jsf.component.UIPaginatedTable;

public class PaginatedTableHtmlRenderer extends Renderer {
    public static final String RENDERER_TYPE = "blog10_99.paginatedtable";

    @Override
    public void decode(FacesContext context, UIComponent component) {
        super.decode(context, component);
        if ((context == null) || (component == null)) {
            throw new NullPointerException();
        }
        UIPaginatedTable paginatedTableComponent = (UIPaginatedTable) component;
        String key = "currentPageNumber";
        String value = (String) context.getExternalContext()
                .getRequestParameterMap().get(key);
        if (value != null) {
            paginatedTableComponent.setCurrentPageNumber(new Integer(value));
        }else{
            paginatedTableComponent.setCurrentPageNumber(paginatedTableComponent.getCurrentPageNumber() + 1);
        }
    }

    @Override
    public void encodeEnd(FacesContext context, UIComponent component)
            throws IOException {
        ResponseWriter writer = context.getResponseWriter();
        UIPaginatedTable paginatedTableComponent = (UIPaginatedTable) component;
        writer.startElement("table", component);
        writer.writeAttribute("width", "80%", "width");
        writer.writeAttribute("border", "1", "border");
        writer.startElement("caption", component);
        writer.write("Hibernate Entity: "+ paginatedTableComponent.getEntityClass().getCanonicalName());
        writer.endElement("caption");
        writer.startElement("thead", component);
        writer.startElement("tr", component);
        for (Field entityField : paginatedTableComponent.getEntityClass()
                .getDeclaredFields()) {
            writer.startElement("th", component);
            writer.write(entityField.getName().toUpperCase());
            writer.endElement("th");
        }
        writer.endElement("tr");
        writer.endElement("thead");
        writer.startElement("tbody", component);
        List<List<String>> entityAttrValuesList = paginatedTableComponent
                .getEntityData();
        if (entityAttrValuesList != null) {

            for (List<String> entityAttrValues : entityAttrValuesList) {
                writer.startElement("tr", component);
                for (String attrValue : entityAttrValues) {
                    writer.startElement("td", component);
                    writer.write(attrValue);
                    writer.endElement("td");
                }
                writer.endElement("tr");
            }
        }
        writer.endElement("tbody");
        writer.startElement("tfoot", component);
        writer.startElement("th", component);
        writer.startElement("input", component);
        writer.writeAttribute("id", "currentPageNumber", "id");
        writer.writeAttribute("type", "hidden", "type");
        writer.writeAttribute("value",paginatedTableComponent.getCurrentPageNumber() , "value");
        writer.endElement("input");
        int startRowIndex = paginatedTableComponent.getCurrentPageNumber() * paginatedTableComponent.getPageSize();
        int endRowIndex = startRowIndex + paginatedTableComponent.getPageSize();
        writer.startElement("label", component);
        writer.write("Currently displaying rows " + (startRowIndex + 1) + " - " + endRowIndex + "     ");
        writer.endElement("label");
        writer.endElement("th");
        writer.startElement("tr", component);
        writer.writeAttribute("colspan", "3", "colspan");
        writer.startElement("input", component);
        writer.writeAttribute("id", "nextButton", "id");
        writer.writeAttribute("type", "submit", "type");        
        writer.writeAttribute("value","Next > " , "value");
        writer.endElement("input");
        writer.endElement("tr");
        writer.endElement("tfoot");
        writer.endElement("table");
        writer.flush();
    }
}

com.blog10_99.jsf.tag.PaginatedTableHtmlTag

package com.blog10_99.jsf.tag;

import javax.faces.component.UIComponent;
import javax.faces.el.ValueBinding;
import javax.faces.webapp.UIComponentTag;

import com.blog10_99.jsf.component.UIPaginatedTable;
import com.blog10_99.jsf.renderer.PaginatedTableHtmlRenderer;

public class PaginatedTableHtmlTag extends UIComponentTag {

    private String sessionFactory;
    private String entityClass;
    private String pageSize;
    
    @Override
    public String getComponentType() {
        return UIPaginatedTable.COMPONENT_FAMILY_TYPE;
    }

    @Override
    public String getRendererType() {
        return PaginatedTableHtmlRenderer.RENDERER_TYPE;
    }

    @Override
    protected void setProperties(UIComponent component) {
        super.setProperties(component);
        UIPaginatedTable paginatedTableComponent = (UIPaginatedTable) component; 
        evaluateAndSetSessionFactory(getPageSize(), "pageSize", component);        
        paginatedTableComponent.setPageSize(new Integer(getPageSize()));        
        evaluateAndSetSessionFactory(getSessionFactory(),"sessionFactory",component);
        try {
            paginatedTableComponent.setEntityClass(Class.forName(getEntityClass()));
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }        
    }

    private void evaluateAndSetSessionFactory(String tagAttributeValue,
            final String componentAttributeKey, UIComponent component) {
        if (tagAttributeValue != null) {
                ValueBinding vb = getFacesContext().getApplication()
                        .createValueBinding(tagAttributeValue);
                component.setValueBinding(componentAttributeKey, vb);
        }
    }

    @Override
    public void release() {
        super.release();
        setEntityClass(null);
        setSessionFactory(null);
        setPageSize(null);
    }

    public String getSessionFactory() {
        return sessionFactory;
    }

    public void setSessionFactory(String sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

    public String getEntityClass() {
        return entityClass;
    }

    public void setEntityClass(String entityClass) {
        this.entityClass = entityClass;
    }

    public String getPageSize() {
        return pageSize;
    }

    public void setPageSize(String pageSize) {
        this.pageSize = pageSize;
    }
}

faces-config.xml

<?xml version='1.0' encoding='UTF-8'?>
<faces-config xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-facesconfig_1_2.xsd"
    version="1.2">

    <component>
        <component-type>blog10_99.paginatedtable</component-type>
        <component-class>com.blog10_99.jsf.component.UIPaginatedTable</component-class>
    </component>

    <render-kit>
        <renderer>
            <component-family>blog10_99.paginatedtable</component-family>
            <renderer-type>blog10_99.paginatedtable</renderer-type>
            <renderer-class>com.blog10_99.jsf.renderer.PaginatedTableHtmlRenderer</renderer-class>
        </renderer>
    </render-kit>

</faces-config>

paginatedTable.tld

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
"http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
<taglib>
    <tlib-version>1.0</tlib-version>
    <jsp-version>1.2</jsp-version>
    <short-name>blog10_99</short-name>
    <uri>http://10-99.blogspot.com/</uri>
    <tag>
        <name>ptable</name>
        <tag-class>com.blog10_99.jsf.tag.PaginatedTableHtmlTag</tag-class>
        <attribute>
            <name>pageSize</name>
            <description>Number of rows per page</description>
        </attribute>
        <attribute>
            <name>sessionFactory</name>
            <description>sessionFactoryProvider</description>
        </attribute>
        <attribute>
            <name>entityClass</name>
            <description>Canonical name of the Entity Class</description>
        </attribute>
    </tag>
</taglib>

JAXB: Marshalling and Unmarshalling a non-trivial java.util.Map

2010-02-25T20:00:00.000-08:00

JAXB can marshall or unmarshall a trivial java.util.Map such as Map, Map, Map etc. or Map where KeyType and ValueType have primitive types, Wrapper types or types that inturn again are made up of primitive types or warpper types. To be particular the KeyType or ValueType objects should not have a List kind of attribute. The XML generated out on Marshalling a Map object has the following format:

<mapattributexmltypename>
  <entry>
    <key>
      <keytypeattribute1>...</keytypeattribute1>
      <keytypeattribute2>...</keytypeattribute2>
    </key>
    <value>
      <valuetypeattribute1>...</valuetypeattribute1>
      <valuetypeattribute2>...</valuetypeattribute2>
    </value>
  </entry>
</mapattributexmltypename>

Note that in the above generated XML there is no <KeyType> and <ValueType> elements that embed their attributes. Hence if either the KeyType or the ValuType objects have a List kind of attribute then marshalling would result in something like the following:

<mapattributexmltypename>
   <entry>
       <key>
      <keytypeattribute1>...</keytypeattribute1>
      <keytypeattribute2>...</keytypeattribute2>
      <listattributename>entry1</listattributename>
      <listattributename>entry2</listattributename>
    </key>
    <value>
      <valuetypeattribute1>...</valuetypeattribute1>
      <valuetypeattribute2>...</valuetypeattribute2>
      <listattributename>entry1</listattributename>
      <listattributename>entry2</listattributename>
    </value>
   </entry>
</mapattributexmltypename>

Unmarshalling of which would be ambiguois logic.

Hence marshalling of such non-trivial Maps can make use of XmlJavaTypeAdapter annotation and implement a XmlAdapter to overcome this problem. The key is to take the Map from the object and create a List of Wrapper objects that holds the KeyType and ValueType as its attributes and marshall. Upon unmarshalling we take the list of Wrapper type objects and rebuild the Map and set it back on on the object. The annotation XmlJavaTypeAdapter on top of the Map attribute on the object signals the Marshaller to use a specific Adapter to transform this Map object into another type( in this case a list of wrappers ). Upon Unmarshall the Unmarshaller again invokes a certian method in the Adapter to transform the List of Wrappers into the Map type before setting it on to the object.
Following example demonstrates the use of an Adapter:

Download link for full Source: http://sites.google.com/site/rockycodes/JAXBNonTrivialMap.zip

Object to Marshall & Unmarshall : PoolOfDreams.java

package com.blog10_99;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;

@XmlAccessorType(XmlAccessType.FIELD)
@XmlRootElement(name = "PoolOfDreams")
public class PoolOfDreams {
    private List<Dream> plainListOfDreams  = new ArrayList<Dream>();

    @XmlJavaTypeAdapter(DateVsDreamListXmlAdapter.class)
    private Map<Date, ArrayList<Dream>> dateVsListOfdreamsMap = new HashMap<Date,ArrayList<Dream>>();

    public PoolOfDreams() {

    }

    public List<Dream> getPlainListOfDreams() {
        return plainListOfDreams;
    }

    public void setPlainListOfDreams(List<Dream> plainListOfDreams) {
        this.plainListOfDreams = plainListOfDreams;
    }

    public Map<Date, ArrayList<Dream>> getDateVsListOfdreamsMap() {
        return dateVsListOfdreamsMap;
    }

    public void setDateVsListOfdreamsMap(
            Map<Date, ArrayList<Dream>> dateVsListOfdreamsMap) {
        this.dateVsListOfdreamsMap = dateVsListOfdreamsMap;
    }
}

Main Method Class: TestDream.java

import java.io.File;
import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.Date;
import java.util.Set;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;

import com.blog10_99.Dream;
import com.blog10_99.PoolOfDreams;

public class TestDream {

    public static void main(String args[]) throws Exception {
        PoolOfDreams poolOfDreams = new PoolOfDreams();

        // data for PoolOfDreams :: List<Dream> plainListOfDreams
        Dream plainListDream1 = new Dream("Dream1 of plain List<Dream> kind");
        Dream plainListDream2 = new Dream("Dream2 of plain List<Dream> kind");
        poolOfDreams.getPlainListOfDreams().add(plainListDream1);
        poolOfDreams.getPlainListOfDreams().add(plainListDream2);

        // data for PoolOfDreams :: Map<Date, ArrayList<Dream>>
        // dateVsListOfdreamsMap
        Dream dateVsDreamListMapDream1 = new Dream(
                "Dream-1 of Date Vs ArrayList<Dream> kind");
        Dream dateVsDreamListMapDream2 = new Dream(
                "Dream-2 of Date Vs ArrayList<Dream> kind");
        ArrayList<Dream> dreamListForMap = new ArrayList<Dream>();
        dreamListForMap.add(dateVsDreamListMapDream1);
        dreamListForMap.add(dateVsDreamListMapDream2);
        poolOfDreams.getDateVsListOfdreamsMap().put(new Date(1),
                dreamListForMap);
        Dream dateVsDreamListMapDream3 = new Dream(
                "Dream-3 of Date Vs ArrayList<Dream> kind");
        Dream dateVsDreamListMapDream4 = new Dream(
                "Dream-4 of Date Vs ArrayList<Dream> kind");
        dreamListForMap = new ArrayList<Dream>();
        dreamListForMap.add(dateVsDreamListMapDream3);
        dreamListForMap.add(dateVsDreamListMapDream4);
        poolOfDreams.getDateVsListOfdreamsMap().put(new Date(2),
                dreamListForMap);

        JAXBContext jaxbContext = JAXBContext
                .newInstance(com.blog10_99.PoolOfDreams.class);
        Marshaller marshaller = jaxbContext.createMarshaller();
        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
        marshaller.marshal(poolOfDreams, new FileOutputStream("MyDream.xml"));

        Unmarshaller unMarshaller = jaxbContext.createUnmarshaller();
        PoolOfDreams unMarshalledPoolOfDreams = (PoolOfDreams) unMarshaller
                .unmarshal(new File("MyDream.xml"));

        System.out
                .println("------------------**********----------------------");

        System.out.println("Printing from List<Dream> plainListOfDreams");
        for (Dream dream : unMarshalledPoolOfDreams.getPlainListOfDreams()) {
            System.out.println(dream.getSubject());
        }

        System.out
                .println("------------------**********----------------------");

        System.out
                .println("Printing from Map<Date, ArrayList<Dream>> dateVsListOfdreamsMap");
        Set<Date> dreamDateKeySet = unMarshalledPoolOfDreams
                .getDateVsListOfdreamsMap().keySet();
        for (Date dreamDate : dreamDateKeySet) {
            System.out.println("----Dreams for Date: " + dreamDate);
            for (Dream dream : unMarshalledPoolOfDreams
                    .getDateVsListOfdreamsMap().get(dreamDate)) {
                System.out.println(dream.getSubject());
            }
        }

    }

}

Other Classes:
DateVsDreamListXmlAdapter.java

package com.blog10_99;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import javax.xml.bind.annotation.adapters.XmlAdapter;

public class DateVsDreamListXmlAdapter
        extends
        XmlAdapter<DateKeyAndDreamsListValueHolderListWrapper, Map<Date, ArrayList<Dream>>> {

    @Override
    public DateKeyAndDreamsListValueHolderListWrapper marshal(
            Map<Date, ArrayList<Dream>> dateVsListOfdreamsMap) throws Exception {
        ArrayList<DateKeyAndDreamsListValueHolder> dateKeyAndDreamsListValueHolders = new ArrayList<DateKeyAndDreamsListValueHolder>();
        if (dateVsListOfdreamsMap != null) {
            Set<Date> dreamDatekeySet = dateVsListOfdreamsMap.keySet();
            for (Date dreamDate : dreamDatekeySet) {
                dateKeyAndDreamsListValueHolders
                        .add(new DateKeyAndDreamsListValueHolder(dreamDate,
                                dateVsListOfdreamsMap.get(dreamDate)));
            }
        }
        DateKeyAndDreamsListValueHolderListWrapper listWrapper = new DateKeyAndDreamsListValueHolderListWrapper();
        listWrapper
                .setDateKeyAndDreamsListValueHolders(dateKeyAndDreamsListValueHolders);
        return listWrapper;
    }

    @Override
    public Map<Date, ArrayList<Dream>> unmarshal(
            DateKeyAndDreamsListValueHolderListWrapper dateKeyAndDreamsListValueHolderList)
            throws Exception {
        Map<Date, ArrayList<Dream>> dateVsListOfdreamsMap = new HashMap<Date, ArrayList<Dream>>();
        if (dateKeyAndDreamsListValueHolderList != null) {
            for (DateKeyAndDreamsListValueHolder holder : dateKeyAndDreamsListValueHolderList
                    .getDateKeyAndDreamsListValueHolders()) {
                dateVsListOfdreamsMap.put(holder.getDate(), holder
                        .getDreamsList());
            }
        }
        return dateVsListOfdreamsMap;
    }
}

Dream.java

package com.blog10_99;

public class Dream {
    private String subject;

    public Dream() {

    }

    public Dream(String subject) {
        setSubject(subject);
    }

    public String getSubject() {
        return subject;
    }

    public void setSubject(String subject) {
        this.subject = subject;
    }

    public String toString(){
        return getSubject();
    }
}

DateKeyAndDreamsListValueHolder.java

package com.blog10_99;

import java.util.ArrayList;
import java.util.Date;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;

@XmlAccessorType(XmlAccessType.FIELD)
public class DateKeyAndDreamsListValueHolder {
    private Date date;
    private ArrayList<Dream> dreamsList = new ArrayList<Dream>();

    public DateKeyAndDreamsListValueHolder() {

    }

    public DateKeyAndDreamsListValueHolder(Date date,
            ArrayList<Dream> dreamsList) {
        this.date = date;
        this.dreamsList = dreamsList;
    }

    public Date getDate() {
        return date;
    }

    public void setDate(Date date) {
        this.date = date;
    }

    public ArrayList<Dream> getDreamsList() {
        return dreamsList;
    }

    public void setDreamsList(ArrayList<Dream> dreamsList) {
        this.dreamsList = dreamsList;
    }

}

DateKeyAndDreamsListValueHolderListWrapper.java

package com.blog10_99;

import java.util.ArrayList;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;

@XmlAccessorType(XmlAccessType.FIELD)
public class DateKeyAndDreamsListValueHolderListWrapper {
    private ArrayList<DateKeyAndDreamsListValueHolder> dateKeyAndDreamsListValueHolders =
        new ArrayList<DateKeyAndDreamsListValueHolder>();

    public DateKeyAndDreamsListValueHolderListWrapper() {
    }

    public ArrayList<DateKeyAndDreamsListValueHolder> getDateKeyAndDreamsListValueHolders() {
        return dateKeyAndDreamsListValueHolders;
    }

    public void setDateKeyAndDreamsListValueHolders(
            ArrayList<DateKeyAndDreamsListValueHolder> dateKeyAndDreamsListValueHolders) {
        this.dateKeyAndDreamsListValueHolders = dateKeyAndDreamsListValueHolders;
    }
}

Generated File:
MyDream.xml

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<poolofdreams>
    <plainlistofdreams>
        <subject>Dream1 of plain List&lt;Dream&gt; kind</subject>
    </plainListOfDreams>
    <plainlistofdreams>
        <subject>Dream2 of plain List&lt;Dream&gt; kind</subject>
    </plainListOfDreams>
    <datevslistofdreamsmap>
        <datekeyanddreamslistvalueholders>
            <date>1969-12-31T18:00:00.001-06:00</date>
            <dreamslist>
                <subject>Dream-1 of Date Vs ArrayList&lt;Dream&gt; kind</subject>
            </dreamsList>
            <dreamslist>
                <subject>Dream-2 of Date Vs ArrayList&lt;Dream&gt; kind</subject>
            </dreamsList>
        </dateKeyAndDreamsListValueHolders>
        <datekeyanddreamslistvalueholders>
            <date>1969-12-31T18:00:00.002-06:00</date>
            <dreamslist>
                <subject>Dream-3 of Date Vs ArrayList&lt;Dream&gt; kind</subject>
            </dreamsList>
            <dreamslist>
                <subject>Dream-4 of Date Vs ArrayList&lt;Dream&gt; kind</subject>
            </dreamsList>
        </dateKeyAndDreamsListValueHolders>
    </dateVsListOfdreamsMap>
</PoolOfDreams>

Output from the main program:


Dream1 of plain List kind
Dream2 of plain List kind
------------------**********----------------------
Printing from Map> dateVsListOfdreamsMap
----Dreams for Date: Wed Dec 31 18:00:00 CST 1969
Dream-1 of Date Vs ArrayList kind
Dream-2 of Date Vs ArrayList kind
----Dreams for Date: Wed Dec 31 18:00:00 CST 1969
Dream-3 of Date Vs ArrayList kind
Dream-4 of Date Vs ArrayList kind

Using soapUI to test a webservice

2009-06-17T21:24:00.000-07:00

soapUI is a very handy tool to test or talk to a webservice. It is based on the "contract first" webservice client approach. It needs a wsdl contract in order to generate required artifacts(jaxb beans and service stubs) to talk to the service.

I will discuss how to use soapUI to test a service developed in the blog http://10-99.blogspot.com/2009/05/java-webservice-using-jaxws-ri-and.html
assuming that this service is deployed locally at "http://localhost:8080/SunRIService/GameService"

Download soapUI from http://www.soapui.org/ and install and launch it.
File -> "New soapUI Project" will launch a dialog asking for inputs to create the client.

Enter:
Project Name: GameServiceClient
Initial WSDL/WADL : http://localhost:8080/SunRIService/GameService?wsdl
Keep the defaults for other inputs and press "Ok" . Thats all !! you are ready to call the service.
This will look something like the picture below. Ofcourse I have clicked "Request1" on "GetCricketGameOperation" and pressed the little green button to the top right of the JInternal Pane.

What about service calls that require parameters? well everything on a service call is plain old SOAP XML. Hence you just have to enter text values in the sample requests and call the service by pressing the little green button.

The second web method in GameService - "GetGameWithTeamsOp" takes in two teams and returns back a Game object. Expand this tree node and you can see a "Request1" which is a sample request created for you by soapUI. Just fill in with some text for '?' in the xml and press the little green button to see the response in xml on the right hand side JInternal pane. This looks something like the following pic:

In summary all you need to test call a web service is its wsdl. You could get this wsdl by calling ?wsdl using your web browser. Using this wsdl you can generate a soapUI project and make calls to any web service.

Java Web Service using JAXWS-RI and Tomcat 6 (no editors and no funky tools)

2009-05-30T20:42:00.000-07:00

war file for this service can be downloaded from http://rockycodes.googlepages.com/SunRIService.war
Files involved in this Service:

POJOs in this service are: Game.java, Team.java and Player.java
Service interface is GameService.java
Service implementation is GameServiceImpl.java

GameService has two web methods-

@WebMethod(operationName="GetCricketGameOperation")
Game getCricketGame();

This method has not input parameters but returns back a Game instance.

@WebMethod(operationName="GetGameWithTeamsOp")
Game getGameWithTeams(@WebParam(name="gameName")String name,@WebParam(name="homeTeam")Team homeTeam, @WebParam(name="visitorsTeam") Team visitors);

This method takes in two Team instances and composes them into a Game instance with gameName.

create the following directory structure with source listings at the end of this blog

JaxwsRiSvc\
JaxwsRiSvc\build
JaxwsRiSvc\src
JaxwsRiSvc\src\blog10_99\game\Game.java
JaxwsRiSvc\src\blog10_99\game\Team.java
JaxwsRiSvc\src\blog10_99\game\Player.java
JaxwsRiSvc\src\blog10_99\sunri\service\GameService.java
JaxwsRiSvc\src\blog10_99\sunri\service\GameServiceImpl.java
JaxwsRiSvc\build\WEB-INF\
JaxwsRiSvc\build\WEB-INF\sun-jaxws.xml
JaxwsRiSvc\build\WEB-INF\web.xml
JaxwsRiSvc\build\WEB-INF\classes
JaxwsRiSvc\build\WEB-INF\lib

download JAXWS-RI 2.1.7 from jax-ws.dev.java.net

https://jax-ws.dev.java.net/2.1.7/JAXWS2.1.7-20090419.jar

run the following on the downloaded jar to extract the files:

java -jar JAXWS2.1.7-20090419.jar

copy the files from the extracted folder "jaxws-ri\lib" to project folder "JaxwsRiSvc\build\WEB-INF\lib"

compile the project files:

JaxwsRiSvc\src > javac -d "..\build\WEB-INF\classes" -cp .;../ blog10_99/game/*.java
JaxwsRiSvc\src > javac -d "..\build\WEB-INF\classes" -cp .;../ blog10_99/sunri/service/*.java

create sun-jaxws.xml to define the service endpoints for the webapp

sun-jaxws.xml

<?xml version="1.0" encoding="UTF-8"?>
<endpoints xmlns="http://java.sun.com/xml/ns/jax-ws/ri/runtime" version='2.0'>
<endpoint
name="GameService"
implementation="blog10_99.sunri.service.GameServiceImpl"
url-pattern="/GameService"/>
</endpoints>

define deployment descriptor web.xml

web.xml defines a WS Listener that configures services at deployment. It also defines a WSServlet for a url pattern that points to our service. All requests to a webservice is routed through this JAX WS Servlet.

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4"
   xmlns="http://java.sun.com/xml/ns/j2ee"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
   <listener>
      <listener-class>
        com.sun.xml.ws.transport.http.servlet.WSServletContextListener
      </listener-class>
   </listener>
   <servlet>
      <servlet-name>GameService</servlet-name>
      <servlet-class>
        com.sun.xml.ws.transport.http.servlet.WSServlet
      </servlet-class>
      <load-on-startup>1</load-on-startup>
   </servlet>
   <servlet-mapping>
      <servlet-name>GameService</servlet-name>
      <url-pattern>/GameService</url-pattern>
   </servlet-mapping>
   <session-config>
      <session-timeout>
         30
      </session-timeout>
   </session-config>
   <welcome-file-list>
      <welcome-file>
      index.jsp
      </welcome-file>
   </welcome-file-list>
</web-app>

package the files into a war file

JaxwsRiSvc\build > jar -cvf ../SunRIService.war *

download tomcat6.0 and copy SunRIService.war to the webapps folder.

start tomcat and at stratup you can see that WSServletContextListener defined in web.xml loads up and does some initialization.
The service is now up and running and the following url should get you the service wsdl

http://localhost:8080/SunRIService/GameService?wsdl

Sources for the above service:

Service Interface definition GameService.java:

package blog10_99.sunri.service;

import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebService;

import blog10_99.game.Game;
import blog10_99.game.Team;

@WebService(name = "GameService")
public interface GameService {
    @WebMethod(operationName = "GetCricketGameOperation")
    Game getCricketGame();

    @WebMethod(operationName = "GetGameWithTeamsOp")
    Game getGameWithTeams(@WebParam(name = "gameName") String name,
            @WebParam(name = "homeTeam") Team homeTeam,
            @WebParam(name = "visitorsTeam") Team visitors);
}

Service implementation GameServiceImpl.java

package blog10_99.sunri.service;

import java.util.Arrays;

import javax.jws.WebService;

import blog10_99.game.Game;
import blog10_99.game.Player;
import blog10_99.game.Team;

@WebService(endpointInterface = "blog10_99.sunri.service.GameService")
public class GameServiceImpl implements GameService{

    public Game getCricketGame() {
        Game game = new Game();
        game.setTeams(Arrays.asList(getTeamIndia(), getTeamAustralia()));
        game.setName("Cricket");
        return game;
    }

    public Game getGameWithTeams(String name, Team homeTeam, Team visitors) {
        Game game = new Game();
        game.setName(name);
        game.setTeams(Arrays.asList(homeTeam, visitors));
        return game;
    }

    private Team getTeamIndia() {
        Player sehwag = getPlayer("Sehwag", 25);
        Player yuvi = getPlayer("Yuvraj", 24);
        Team team1 = new Team();
        team1.setPlayers(Arrays.asList(sehwag, yuvi));
        team1.setName("India");
        return team1;
    }

    private Team getTeamAustralia() {
        Player ponting = getPlayer("Ricky Ponting", 25);
        Player lee = getPlayer("Bret Lee", 24);
        Team team1 = new Team();
        team1.setPlayers(Arrays.asList(ponting, lee));
        team1.setName("Australia");
        return team1;
    }

    private Player getPlayer(String name, int age) {
        Player player = new Player();
        player.setName(name);
        player.setAge(age);
        return player;
    }
}

POJOs

Game.java

package blog10_99.game;

import java.util.List;
public class Game {
    private List<Team> teams;
    private String name;

    public void setTeams(List<Team> teams) {
        this.teams = teams;
    }

    public List<Team> getTeams() {
        return teams;
    }

    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Team.java

package blog10_99.game;

import java.util.List;

public class Team {
    private String name;
    private List<Player> players;

    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<Player> getPlayers() {
        return this.players;
    }

    public void setPlayers(List<Player> players) {
        this.players = players;
    }
}

Player.java

package blog10_99.game;

public class Player {
    private String name;
    private Integer age;

    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return this.age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}