Bhakti Mehta's Blog

Working with Metro on Glassfish v3 TP2

Glassfish v3 will be the next major release of the GlassFish application server. The focus of the release is modularization, enablement of non Java EE containers
and embedability. GlassFish v3 builds on the strength of GlassFish v2 but takes a completely new approach, providing a highly modular, lightweight, extensible architecture.

GlassFish v3 Technology Preview 2 (TP2) is a milestone release of the GlassFish v3 Application Server. You can find the TP2 glassfish preview bundle here.
This page provides a brief description of TP2, and points to the information you need to get started. Here is the information on what is part of TP2

Metro will be available as an Update Center module in V3 as part of the TP2

This is a preliminary guide on how to work with Metro in the current development v3 builds.
Note: This can be subjected to change in future.

Steps to install and run v3.

1. Unzip gfv3-preview2.zip downloaded from  here.

This is the web distribution for v3 and does not have support for EJBs. For TP2 we will only support JAXWS deployment ie.webservices with webapps
whose versions are 2.3 or 2.4. Support for
JSR 109 based services is in progress and will be available after TP2.

2. Run glassfish-v3tp2/bin/updatetool.bat

You get a prompt like this

The software needed for this command (updatetool.bat) is not installed.
Press any key to install the necessary software, or Ctrl-C to quit.
After software installation is completed you may re-run this command.

Press any key to continue . . .

It downloads the necessary files

Platform: windows-i386
Software repository: http://pkg.glassfish.org/dev/windows/gf3000_2000/
Installing pkg packages...
Installing: python2.4-minimal@2.4.4,0-6.564:20080425T194712Z
python2.4-minimal@2.4.4,0-6.564:20080425T194712Z: manifest file doesn't exist ye
t, fetching from server
python2.4-minimal@2.4.4,0-6.564:20080425T194712Z: downloading files.............
................................................................................
..........................................................................
python2.4-minimal@2.4.4,0-6.564:20080425T194712Z: installing files...
Installing: pkg@0.1.4,0-6.564:20080425T194710Z
pkg@0.1.4,0-6.564:20080425T194710Z: manifest file doesn't exist yet, fetching fr
om server
pkg@0.1.4,0-6.564:20080425T194710Z: downloading files...........................
........................................
pkg@0.1.4,0-6.564:20080425T194710Z: installing files...
Installing updatetool packages...
Installing: wxpython2.8-minimal@2.8.7.1,0-6.564:20080425T194728Z
wxpython2.8-minimal@2.8.7.1,0-6.564:20080425T194728Z: manifest file doesn't exis
t yet, fetching from server
wxpython2.8-minimal@2.8.7.1,0-6.564:20080425T194728Z: downloading files.........
.............................................................
Installing: updatetool@2.0,0-6.564:20080425T194726Z
updatetool@2.0,0-6.564:20080425T194726Z: manifest file doesn't exist yet, fetch
ng from server
updatetool@2.0,0-6.564:20080425T194726Z: downloading files.....................
................................................................
updatetool@2.0,0-6.564:20080425T194726Z: installing files...
Update Center initialization complete.

This installs the UpdateCenter

3.Run glassfish-v3tp2/bin/updatetool.bat again 
and that brings up the gui like this
click on the Available Add-ons

4. Select Metro Web Services Stack and click install

This will copy webservices-rt.jar, webservices-tools.jar,webservices-api.jar and jsr109-impl.jar to
glassfishv3-tp2/glassfish/modules folder. Next you can start the GF using

glassfishv3-tp2/glassfish/bin/asadmin start-domain domain1

5. Deploy your war like this 
glassfishv3-tp2/glassfish/bin/asadmin deploy foo.war

You can try metro samples from https://metro.dev.java.net/
Please give us feedback if this works for you . You can file your bugs under https://glassfish.dev.java.net/issues/ category webservices and version v3.

Additional Information
Project Metro

V3 Engineers Guide

V3 Build Instructions

Techtip on using WebServiceRefs

A tip on Referencing Multiple Web Services from an application client is available as an Enterprise Java Techtip here

You can find more Enterprise Java Technical Tips that are posted every month at http://blogs.sun.com/enterprisetechtips/ .

In this tip, I talk about how you can build EJB and Servlet based webservices and use @WebServiceRefs to reference them in your application client.

For more questions you can write to users@metro.dev.java.net

Developing Webservices from wsdl using Netbeans

The following blog shows how you can easily create a Webservices project in Glassfish v2 using Netbeans 6.0 from an existing wsdl.
Download Netbeans 6.0 from here
To Start
Select File->Create new Project->Web

Click on finish

Next Right Click on WebServiceFromWsdl project and select new WebService from wsdl
Here is the wsdl and its schema for this blog

Here is how the screen looks like

Click on finish

This is how the generated WebService Design tab looks like

You can implement the methods for the service by selecting the Source tab

Right Click on the WebServiceFromWsdl project and call Run
You will see the project deployed in GF

You can verify by clicking on http://localhost:8080/WebServiceFromWsdl/RMDemoService?wsdl
This is how the published wsdl will look like

Deploying SOAP 1.2 based webservice in Glassfish

The following blog shows how to create and deploy a SOAP 1.2 based webservice in Glassfish v2 using Netbeans 6.0

Download and install Netbeans 6.0 from here.

Click on File->New Project
Choose Web ->WebApplication

Next provide the name of the Web application
choose the Java EE version as Java EE 5

Click on Finish

Next in the Projects tab you will see EchoTest
Right Click on EchoTest and create New WebService

Click Finish

Next we add operations to the service

Click the source tab in the center pane you will see the Echo.java source code

Add the following operation to the source code (This can be done by right clicking Webservices->EchoService->AddOperation)

/**
     * Web service operation
     */
    @WebMethod(operationName = "echoString")
    public String echoString(
            @WebParam(name = "parameter") String parameter) {

        return "hello" + parameter;
    }

Add the following annotation
@javax.xml.ws.BindingType(value="http://java.sun.com/xml/ns/jaxws/2003/05/soap/bindings/HTTP/" )
The above is important because the default binding supported by JAXWS 2.0 is SOAP 1.1 over HTTP.

This is how the source code looks

Right Click on EchoTest project
Do Clean and Build
Do Undeploy and Deploy
You will see the service is deployed at
http://localhost:8080/EchoTest/EchoService?wsdl

Next step build a client

File -> New Project -> Web Application (Same as fig 1)

Name the project as EchoClient

Click Finish
Right click on EchoClientTest and click New Webservice Client

Specify the wsdllocation as shown

Click Finish

Next expand EchoClientTest->WebServiceReferences->EchoService->EchoService->EchoPort->echoString

Drag echoString and drop after line

This is how the jsp will look

Next Right click and call Run the EchoClientTest

This is what you see when you call http://localhost:8080/EchoClientTest/

Hello World!

Result = hello John Doe

Advanced Tip
If you want to see the soap messages add the following line
in
GF/domains/domain1/confiig/domain.xml in java-config element

-Dcom.sun.xml.ws.assembler.server=true

Then stop the GF server and restart it

Next call http://localhost:8080/EchoClientTest/
You can see the following messages in GF/domains/domain1/logs/server.log
Request



"http://www.w3.org/2003/05/soap-envelope">

  

    

       John
Doe

Response

"http://www.w3.org/2003/05/soap-envelope">


      hello John Doe


]

Rehash of WS Reliable Messaging (WS-RM) in Metro 1.0 and what's next

Project Metro is a new name for the JAX-WS + Project Tango combination. JAX-WS is the standardized web services stack
and Project Tango is the Sun's Java Web Services interoperability project with
Microsoft's Windows Communication Foundation (WCF).

Project Metro is released and so is the release of GlassFish V2 FCS (b58g).
GlassFish V2 Embeds the Metro 1.0 Stack within it thereby making WebServices functionality directly
usable from GlassFish (without the need for any extra downloads or installations).

WebServices Reliable Messaging (WS-RM) is one of the enterprise features in Project Metro.
Now we shall have a brief rehash of WS-RM in Metro 1.0 and what would be the new
features in upcoming releases

WS Reliable Messaging in Metro 1.0
WS-RM 1.0 is based on the following standards

The programming model when developing webservices applications with Metro is the same old JAXWS Programming Model and
nothing new is required to be learned.

Adding WS-RM, Security and other Quality of Service features to the JAXWS webservice is enabled
via configuration files which can be handwritten or easily edited by Netbeans.
WS-RM is enabled in endpoints by the presence of RM policy assertions in the WSDL. Netbeans IDE will provide
configurable settings to easily enable RM in endpoints.

Here is a brief overview of WS-RM. The tutorial provides detailed instructions on how to work with Metro.
This is a screen cast which show how to easily enable WS-RM when working with Netbeans. For more information ,
instructions on how to use Netbeans with GF are also available here.

Future plans for WS Reliable Messaging 1.1

We have started working on these features on our trunk and you can get the latest nightly and try out and give us feedback at users@metro.dev.java.net .

Resolving Non RM Request or Missing wsa:Action header error

We have been getting bug reports where users run into the following error when interoperating with MS.

com.sun.xml.ws.rm.RMException: WSRM3018: Non RM Request or Missing
wsa:Action header

This is a case where we are trying MS client -> Sun endpoint which is written beginning from Java and which has WS Reliable Messaging
(WS RM) enabled. This is related to issue 487.
Here is how you can workaround this issue.

Consider you have a service like this

@WebService
 public class MyFooImpl {    
    @WebMethod(action="doFoo")
    public int doFoo(int bar, int zot) {
     .....       
    }
}

Make sure you specifiy the action in @WebMethod annotation. Without
the action in the @WebMethod annotation, empty Action appears in the
application messages..

For a complete running sample check the following sample in

wsit-enabled-fromjava
sample.

You need to set the AS_HOME to the installation of Glassfish v2.
Call the following targets

ant server
ant client run

This will show the demo with Sun client talking to Sun endpoint. Next if you want to try the C# client
Follow instuctions from here. This shows you how to generate the artifacts using svcutil, build the c# client and call Client.exe

WS-Reliable Messaging and Session Support (Part3)

This is the third part of tri series blogs where in Part 1 we showed one way of supporting sessions with
WS Reliable Messaging. Mike showed in his blog WS Reliable Messaging and Session Support Part 2
what are the problems with this approach and we now conclude with a third part where we have tried to fix some of these problems .

Sessions are unique ids used to identify a client. They would help maintain state for each client.
In this sample you will see how sessions can be supported with WS Reliable Messaging (WS RM) .
WS RM is one of the enterprise features in Project Tango which is Sun's Java Web Services
interoperability project with Microsoft's Windows Communication Foundation (WCF).

The following snippets of code show how the JAX-WS Endpoint implementation which is RM enabled
supports sessions .

This is the wsdl which shows RM is enabled in the endpoint by the presence of WS-RM Policy Assertions.
Here is endpoint implementation class

@WebService(endpointInterface="rmdemo.server.RMDemo")

public class RMDemoImpl {

....

}

As shown in part 1 JAX-WS uses annotations defined by Common Annotations for the Java Platform (JSR 250),
to inject the Web ServiceContext and declare lifecycle methods. Web ServiceContext holds the
context information pertaining to a request being served. With JAX-WS Web Service all you need to do is
mark a field or method with @Resource. From the WebServiceContext, MessageContext pertaining
to the the current request can be accessed.

  @Resource
  private javax.xml.ws.WebServiceContext context;

As mentioned above WebServiceContext exposes the MessageContext for the request being served when this method is called .
The session is obtained from the MessageContext using a jax-ws property "com.sun.xml.ws.session"

  private Hashtable getSession() {
      return (Hashtable)context.getMessageContext()
                .get("com.sun.xml.ws.session");

   }

The following getter method returns the String associated with each request .
Correspondingly the setter method stores the Strings for each session in the HashTable respectively.

 private String getSessionData() {
     Hashtable sess = getSession();
     String ret = (String)sess.get("request_record");
     return ret != null ? ret : "";
 }

  private void setSessionData(String data) {
      Hashtable session = getSession();
      session.put("request_record", data);
  }

These addString method and getResult method are exposed by our RM endpoint and are same as Part 1 .
The method addString takes a String as entered by a user and adds it to the Strings stored in the session data for that session.
The getResult will return all the strings entered by the user during that session.

  @WebMethod
  public void addString(String s )
      setSessionData(getSessionData() + " " + s);

  } 

  @WebMethod
  public String getResult() {
       return getSessionData();  

  }

Full source code for the RMDemoImpl.java is here.

Advantages
Here the Session is created every time a new CreateSequence request is received and gets terminated everytime there is a
TerminateSequence request. This way the resource management issue as mentioned by Mike is addressed.

Client Code
Here is the source code for the client. The client enters various input Strings and finally hits carriage
return to terminate the client application and all the Strings received so far for that client will be returned by the server.

Sample will be bundled in the wsit workspace and this is the README to run the samples.

Additional sources of information

WSIT website
Check this website for latest source code, samples,documentation

WS-ReliableMessaging specification

Maintaining Session With JAX-WS

Woodstox in Glassfish v2

Starting with GF v2 b49, Woodstox is now integrated as part of Glassfish along with sjsxp so that users have the benefit of additional performance improvements which woodstox provides.
sjsxp is the default parser in glassfish. This is a preliminary integration with Woodstox and testing is still in progress so let us know if you run into issues.
Here is some more information from Santiago regarding Woodstox in his blog Woodstox rocks Glassfish v2

To enable Woodstox we need to use the following

Client side

These three system properties will need to be added on client side when you want to enable Woodstox.
-Djavax.xml.stream.XMLInputFactory=com.ctc.wstx.stax.WstxInputFactory
-Djavax.xml.stream.XMLOutputFactory=com.ctc.wstx.stax.WstxOutputFactory
-Djavax.xml.stream.XMLEventFactory=com.ctc.wstx.stax.WstxEventFactory

Server side

Similarly on server side we can use standard JAXP API's system properties to turn Woodstox on for entire GF. So GF process needs to be execed with the following system properties:

-Djavax.xml.stream.XMLInputFactory=com.ctc.wstx.stax.WstxInputFactory
-Djavax.xml.stream.XMLOutputFactory=com.ctc.wstx.stax.WstxOutputFactory
-Djavax.xml.stream.XMLEventFactory=com.ctc.wstx.stax.WstxEventFactory

In glassfish, the admin console provides easy way to set system properties as show in Fig 1 (you can do the same by editing domain.xml)

Fig 1 Modifying system properties using admin console http://localhost:4848

You can try it out and give us feedback at
dev@wsit.dev.java.net
dev@glassfish.dev.java.net

Obtaining and analyzing thread dumps

Most of us run into bugs where tests "hang". Here are some nice tools and tips I found to obtain and analyze thread dumps. I am sure there may be other tools so if you know of some good ones feel free to add.

Jstack
jstack prints Java stack traces of Java threads for a given Java process or core file or a remote debug server. However jstack is not available for Windows platforms or on the Linux platform.

Stacktrace
Stacktrace has great features which include
1. Thread dump for Java processes running as a Windows service (like Tomcat, for example), started with javaw.exe or embedded inside another process.
2. Thread dump for any applet running inside any browser (Apple, IBM and Sun JDKs for Windows and Mac OS X). StackTrace is known to work with IE, Firefox, Safari and Mozilla.
and many other features..

I usually get the java process id using jps

Control Break/ kill options

On UNIX platforms you can send a signal to a program by using the kill command. This is the quit signal, which is handled by the JVM. For example, on Solaris you can use the command kill -QUIT process_id,
where process_id is the process number of your Java program.

Alternatively you can enter the key sequence \ in the window where the Java program was started. Sending this signal instructs a signal handler in the JVM, to recursively print out all the information on the threads
and monitors inside the JVM.
To generate a stack trace on Windows platforms, enter the key sequence in the window where the Java program is running, or click the Close button on the window.

Byron Nevins has also pointed in his blog how to obtain thread dumps in Glassfish.

TDA
This is a great utility I found for analyzing thread dumps.

I especially liked the ability to filter the threads display to be able to ignore e.g. idle threads.. Also as you can see in Fig 1 The three pane view is really helpful

Fig 1 : Using TDA to analyze thread dumps

Update to Developing Webservices using Glassfish AS 9.1 and JDK 6

In the previous blog we tried running glassfish-samples using Glassfish v2 using JDK 6.
We walked through what was different when trying with JDK 6 and I mentioned to use a temporary
work-around of putting javaee.jar in $AS_HOME/lib/endorsed..
However this bug is now fixed since Glassfish v2 b31 .

The latest Glassfish v2 installs webservices-api.jar in $AS_HOME/lib/endorsed. and hence we do not need to put javaee.jar there.

So here is the updated blog.

Steps to run the sample with JDK 6

Install JDK 6 from http://download.java.net/jdk6/binaries/

Install GlassFish v2

You can install the latest nightly or the latest promoted v2 build from https://glassfish.dev.java.net/public/downloadsindex.html
Follow these instructions to unbundle and configure glassfish .

Check the version of JDK used by Glassfish to be JDK 6.0

For those users who have already installed GlassFish and wish to change the JDK version. That's equally simple. The JDK path is stored in one location :

Check the following file where AS_HOME is the location where Glassfish is installed
```
<$AS_HOME>/config/asenv.conf for AS_JAVA
```
Modify $AS_JAVA to point to JDK 6 if that is not already set
```
AS_JAVA="location of JDK 6" 
```

Download the glassfish-samples from the following site https://glassfish-samples.dev.java.net/

Run :

 java -jar javaee5-samples-installer-1.0-b09.jar

Edit : /bp-project/build.properties to point to $AS_HOME for e.g

      javaee.home="location of Glassfish"

Check the java version on the client side

      /usr/glassfish-samples/javaee5/webservices %java -version
      java version "1.6.0-rc"
      Java(TM) SE Runtime Environment (build 1.6.0-rc-b104)
      Java HotSpot(TM) Client VM (build 1.6.0-rc-b104, mixed mode, sharing)

Start Appserver

/usr/glassfish/bin %$AS_HOME/bin/asadmin* start-domain domain1

Run the Sample

/usr/glassfish-samples/javaee5/webservices/hello-jaxws %ant

/usr/glassfish-samples/javaee5/webservices/hello-jaxws %ant

Buildfile: build.xml


init:


compile-deploy-service:

     [echo] /usr/glassfish


get-artifacts-unix:

     [exec] parsing WSDL...




     [exec] generating code...


get-artifacts-windows:


get-artifacts:


compile-client:

    [javac] Compiling 1 source file to /usr/glassfish-samples/javaee5/webservices

hello-jaxws/build


run-client-unix:

     [exec] Hello result = Hello Administrator!


run-client-windows:


run-client:


all:


BUILD SUCCESSFUL

Total time: 13 seconds

Please note:
As seen in the following sample.
Clients should set the fololowing property to run with JDK 6

Also for ant tasks like wsimport,xjc :

The solution is to copy $AS_HOME/lib/endorsed/webservices-api.jar to $JAVA_HOME/jre/lib/endorsed.

Neither jvmargs nor sysproperty will work in this case
because by the time ant loads this class it would have already loaded the 2.0 classes
and we did not get the chance to override the 2.0 classes with 2.1 classes.

Developing Webservices using Glassfish AS 9.1 and JDK 6

This blog will show how to develop, run and deploy JAX-WS based webservices with Glassfish v2 Milestone 3 build using JDK 6.
It will demonstrate step by step instructions using the hello-jaxws sample from the following glassfish-samples.

What is different when trying with JDK 6?

JDK 6.0 has JAXB/JAX-WS 2.0 versions of the apis.
In the latest Glassfish v2 we are integrating the implementation classes compliant with JAXB/JAX-WS 2.1 versions
of the apis which are present in javaee.jar .

So when we run with Glassfish and JDK 6.0 (without putting anything in the /lib/endorsed directory),
the APIs/Annotation classes for JAX-WS 2.0 and JAXB 2.0 will be picked up instead of JAX-WS 2.1 and JAXB 2.1.

To avoid this we need to use the endorsed standards to override the 2.0 apis by putting javaee.jar in $AS_HOME/lib/endorsed.
This is a temporary workaround for now and this issue will be fixed soon.

Steps to run the sample with JDK 6

Install JDK 6 from http://download.java.net/jdk6/binaries/

Install GlassFish v2 Milestone 3

Install from https://glassfish.dev.java.net/public/downloadsindex.html
Follow these instructions to unbundle and configure glassfish .

Check the following file where AS_HOME is the location where Glassfish is installed
```
<$AS_HOME>/config/asenv.conf for AS_JAVA
```
Modify $AS_JAVA to point to JDK 6 if that is not already set
```
AS_JAVA="location of JDK 6" 
```

Download the glassfish-samples from the following site https://glassfish-samples.dev.java.net/

Run :

 java -jar javaee5-samples-installer-1.0-b08.jar

Edit :
/bp-project/build.properties to point to $AS_HOME for e.g
```
 javaee.home="location of Glassfish"
```

Check the java version on the client side

 /usr/glassfish-samples/javaee5/webservices %java -version
       java version "1.6.0-rc"
       Java(TM) SE Runtime Environment (build 1.6.0-rc-b104)
       Java HotSpot(TM) Client VM (build 1.6.0-rc-b104, mixed mode,   sharing)

Add javaee.jar to $AS_HOME/lib/endorsed

As mentioned earlier this extra step will be required for running with JDK 6.0

```
mkdir -p $AS_HOME/lib/endorsed
```

mv $AS_HOME/lib/javaee.jar $AS_HOME/lib/endorsed

Start Appserver

/usr/glassfish/bin %$AS_HOME/bin/asadmin* start-domain domain1

Run the Sample

Modify /javaee5/webservices/hello-jaxws/build.xml to point to
$AS_HOME/lib/endorsed/javaee.jar in classpath. Currently the samples point to j2ee.jar in the build.xml


    
    


and
 
     
     
              srcdir="./src"
         includes="endpoint/**"
         destdir="${autodeploydir}"
         classpath="${javaee.home}/lib/endorsed/javaee.jar"
     />
...

Run:

/usr/glassfish-samples/javaee5/webservices/hello-jaxws %ant

This is how the output looks like on the client side

/usr/glassfish-samples/javaee5/webservices/hello-jaxws %ant

Buildfile: build.xml


init:


compile-deploy-service:

     [echo] /usr/glassfish


get-artifacts-unix:

     [exec] parsing WSDL...




     [exec] generating code...


get-artifacts-windows:


get-artifacts:


compile-client:

    [javac] Compiling 1 source file to /usr/glassfish-samples/javaee5/webservices

hello-jaxws/build


run-client-unix:

     [exec] Hello result = Hello Administrator!


run-client-windows:


run-client:


all:


BUILD SUCCESSFUL

Total time: 13 seconds

WS-Reliable Messaging and Session Support (Part2)

This is Part 2 in a series of articles on supporting sessions using WS-ReliableMessaging. In this blog Mike Grogan compares HttpSessions and ReliableSessions and demonstrates the problems with the approach taken in Part 1

Technorati:WSIT Tango

WS Reliable Messaging and Session Support (Part1)

WS Reliable Messaging and Session Support This sample was shown as a demo in the session "Reliable and Transacted Web Services between
Java™ Technology-Based Project Tango and Microsoft Indigo" TS-1603 at Javaone 2006.

This is a part of tri series blogs where in Part 1 we will show one way of supporting sessions with
WS Reliable Messaging. Then Mike will show in his blog what are the problems with this approach and we will
conclude with a third part where we have tried to fix some of these problems .

Sessions are unique ids used to identify a client. They would help maintain state for each client.
In this sample you will see how sessions can be supported with WS Reliable Messaging (WS RM) .
WS RM is one of the enterprise features in Project Tango which is Sun's Java Web Services
interoperability project with Microsoft's Windows Communication Foundation (WCF).

The following snippets of code show how the JAX-WS Endpoint implementation which is RM enabled
supports sessions .

This is the wsdl which shows RM is enabled in the endpoint by the presence of WS-RM Policy Assertions.
Here is endpoint implementation class

@WebService(endpointInterface="rmdemo.server.RMDemo")

public class RMDemoImpl {

....

}

We create a HashTable of SessionIds as the keys and Strings which are entered by the clients as the values.

private final HashTable sessionTable = 

    new HashTable();

JAX-WS uses annotations defined by Common Annotations for the Java Platform (JSR 250),
to inject the Web ServiceContext and declare lifecycle methods. Web ServiceContext holds the
context information pertaining to a request being served. With JAX-WS Web Service all you need to do is
mark a field or method with @Resource. From the WebServiceContext, MessageContext pertaining
to the the current request can be accessed. More information on how MessageContext can be used to
share metadata is explained in this article.

  @Resource
  private javax.xml.ws.WebServiceContext context;

As mentioned above WebServiceContext exposes the MessageContext for the request being served when this method is called .
The session id is obtained from the MessageContext using a jax-ws property "com.sun.xml.ws.sessionid"

  private String getSessionId() {
       return (String)context.getMessageContext()
      .get("com.sun.xml.ws.sessionid");
  }

The following getter method returns the String associated with each request . Correspondingly the setter method
stores the Strings for each session in the HashTable respectively.

 private String getSessionData() {
      String id = getSessionId();
      String ret = sessionTable.get(id);
      return ret!= null ? ret : "";
  }

  private void setSessionData(String data) {
       sessionTable.put(getSessionId(), data);
  }

These addString method and getResult method are exposed by our RM endpoint. The method addString takes a
String as entered by a user and adds it to the Strings stored in the session data for that session.
The getResult will return all the strings entered by the user during that session.

  @WebMethod
  public void addString(String s )
      setSessionData(getSessionData() + " " + s);

  } 

  @WebMethod
  public String getResult() {
       return getSessionData();  

  }

This example is a good demonstration of how InOrder delivery assurance (i.e messages are delivered in
the order that they are sent) in WS Reliable Messaging works. If the ordered delivery would not work
right then the strings stored in the session would not have been in the right order.
Full source code for the RMDemoImpl.java is here.

Client Code
Here is the source code for the client. The client enters various input Strings and finally hits carriage
return to terminate the client application and all the Strings received so far for that client will be returned by the
server.

Sample will be bundled in the samples folder.

Instructions to run the sample

Please follow the Readme to setup and run the sample.

For any questions or feedback on the sample please write to users@wsit.dev.java.net

Additional sources of information

WSIT website
Check this website for latest source code, samples,documentation

Project GlassFish Open Source App Server
All WSIT technologies can be installed on this FREE app server

Netbeans IDE Module:
All WSIT technologies available today can be configured visuall using this Netbeans module.

Slides for TS 1603
Reliable and Transacted Web Services between Java™ Technology-Based Project Tango and Microsoft Indigo
at Javaone 2006

WS-ReliableMessaging specification

Maintaining Session With JAX-WS

Overview of Web Services Reliable Messaging

WS-Reliable Messaging In the real world, challenges are encountered in delivering messages. There can be network/connection problems.
Consequently, messages can be lost or delivered out of order. Web Services Reliable Messaging (WS RM) provides
a mechanism to ensure a layer of reliability between potentially unreliable or intermittently connected networks.
It provides an interoperable protocol that a RM (Reliable Messaging) Source and RM Destination use to provide
Application Source and Destination a guarantee that the message that is sent will be delivered.
This guarantee is known as delivery assurance.

There are four basic delivery assurances that endpoints can provide

AtMostOnce:
Messages will be delivered at most once without duplication . It is possible some messages in a sequence may not be
delivered.
AtLeastOnce:
Every message sent will be delivered. Some messages may be delivered more than once.
ExactlyOnce :
Every message sent will be delivered without duplication.
InOrder:
Messages will be delivered in the order that they were sent.

WS RM is one of the enterprise features in Project Tango which is Sun's Java Web Services interoperability project with Microsoft's Windows Communication Foundation (WCF).

In Project Tango, RM is enabled in endpoints by the presence of RM policy assertions in the WSDL. Netbeans IDE
will provide configurable settings to easily enable RM in endpoints as shown in the screen shot below.

Fig 1 Screenshot of how to configure WS RM for an endpoint using Netbeans

Programming Model for Tango

Developer writes Producers/Consumers using JAX-WS 2.0 apis.
Developer/Deployer supplies config files which would be wsdls containing Policy assertions to enable/control Tango components.
Config file can be written by hand or easily produced by Tango Netbeans Module as shown in Fig 1.

Message exchanges when RM is enabled

Fig 2 Message exchange when RM is enabled using WS RM implementation

The above figure shows how the Client or Application Source sends a message for reliable delivery.
When RM is enabled, Project Tango's RM Source module is plugged into the JAX-WS remoting system.
The RM Source module keeps copies of messages until their receipt is acknowledged (via the exchange of protocol
messages). Similarly, an RM Destination module acknowledges messages (and may buffer them for order guarantees).
After guaranteeing order (if ordering enabled), the RM Destination allows the message to proceed through the
JAX-WS dispatch for delivery to the Endpoint or Application Destination.

Protocol Messages

Fig 3 Possible application and protocol message exchanges between RM endpoints

The above figure shows how the message exchange takes place between two reliable messaging endpoints
once the initial preconditions are established such as resolving endpoint references, policy exchange and establishing trust.

The RM Source requests creation of a new Sequence by initiating a
CreateSequence/CreateSequenceResponse handshake.
The RM Destination creates the Sequence by returning a CreateSequenceResponse
with globally unique identifier.This sequence id would be used to identify
the sequence and will be sent in all the following messages.
The RM Sources begins sending messages with MessageNumber 1 .
After 3 messages it sends LastMessage token.
The 2nd message is lost in transit
The RM Destination acknowledges receipt of message numbers 1 and 3 in response to LastMessage.
The RM Source retransmits 2nd message which has the same sequence identifier
and message number so that the RM Destination can recognize it as equivalent of earlier message.
The RM Source also includes an AckRequested so RM Destination can expedite the acknowledgement.
RM Destination receives the second transmission and acknowledges the receipt of messages 1,2 ,3.
The RM Source receives the acknowledgement and sends Terminate Sequence to RM Destination.
The RM Destination receives TerminateSequence and reclaims resources associated with the Sequence

Availability
The implementation will be available by JavaOne on Java.net with support for Glassfish and Netbeans IDE.

Plugfest Status
We tested our WS RM implementation with Microsofts WCF at the Plugfest on March 7-9 at Redmond.
We successfully interoperated in the ReliableOneWay and ReliableRoundrip scenarios both as clients and endpoints.

JavaOne 2006
For more information be sure to check out the session on
Reliable and Transacted Web Services between Java™ Technology-Based Project Tango and Microsoft Indigo TS-1603.

Other information
WS-ReliableMessaging specification
WS-RM Policy Assertion

JAXB 2.0 and JAX-WS 2.0 are a part of Mustang (JDK 6.0)

Delivering Web Services is one of the primary themes for Mustang (Java SE 6). Our goal is that JSE will provide reasonable support for ease of development for the web services stack. This will primarily be client-side focused with a lightweight server to support callbacks. The main specifications are the Java Architecture for XML-Web Services (JAX-WS) 2.0 (formerly known as JAX-RPC) and Java Architecture for XML Binding (JAXB) 2.0.

JSR 224 is defining JAX-WS 2.0. This is a major update since the JAX-RPC 1.0 specification incorporating new specifications and updates to existing standards. JAX-WS 2.0 now delegates the databinding related tasks to JAXB 2.0.

JSR 222 is defining JAXB 2.0. It adds significantly to JAXB 1.0, including 100% XML schema support, the binding of Java classes to XML schema, the meeting of data binding requirements for JAX-WS 2.0, and schema evolution support. A flexible binding allows an application to bind only parts of an XML document (relevant to the application) to Java.

Mustang has the webservices features integrated as of b40. You can try the latest snapshot from https://mustang.dev.java.net/

We are fixing and integrating bugs on a regular basis. Please let us know about your bugs, you can file them at
http://bugs.sun.com/bugdatabase/index.jsp

There are 4 new scripts added in the jdk6.0/bin which are as follows xjc, schemagen , wsimport and wsgen
To run the JAXB schema compiler you can invoke the xjc as

/path/to/jdk6.0/bin/xjc foo.xsd -p test.foo

Similarly to invoke the schema generator to generate schemas from Java sources

/path/to/jdk6.0/bin/schemagen Foo.java

To generate portable artifacts from wsdls and external jaxws or jaxb binding files you can use wsimport

/path/to/jdk6.0/bin/wsimport stock.wsdl -b stock.xml -b stock.xjb

To generate portable artifacts from Java sources you can use wsgen

/path/to/jdk6.0/bin/wsgen example.Stock

Javadocs for jdk6.0
The javadocs are located at
http://www.java.net/download/jdk6/doc/api/

Forums
http://forums.java.net/jive/forum.jspa?forumID=25

List of Committed bugs in the latest snapshot release
https://mustang.dev.java.net/MustangCommittedBugs.html

More information on JAXB and JAXWS

* JAXB
* JAXWS