Arun Gupta, Miles to go ...

Sun Tech Days Hyderabad 2009

India has always had the largest number of attendees of all the Tech Days, and this time is certainly no exception. 10,000+ attendees, the passion for technology, the eagerness to share their work, and everything else makes it certainly one of the most exciting venues for Tech Days.

The Hyderabad International Airport is certainly very impressive - big, clean, and very 21st centurisque with a 8-lane freeway connecting to the main city.

See a short video as the attendees were allowed to enter the Hyderabad International Convention Center (the venue for Tech Days):


I got a chance to talk to the General Manager of the convention center and very happy to know that similar convention centers are planned for Pune (1/2 the size of existing one), Mumbai (4x), and Bangalore (2x) in the near future.

As part of the opening, there was an excellent performance by an 11-year old percussionist, enjoy the video here:


Absolutely stunning performance!

It was funny, I was standing right next to the boy's parents while recording the video. Apparently the boy was allotted 10 minutes and the parents were trying their best to distract the boy right at the beginning of 11th minute :)

I presented on:

• WSIT: Security, Reliability, Transactional, and .NET-interoperable Web services (slides). The screencast #ws7 is the demo shown during the talk.
• GlassFish & Future of Java EE (slides)

Posted by Arun Gupta in General  |  Comments[2]

Metro 1.0.1 and 1.1 are now available

Metro 1.0.1 (integrated in GlassFish v2 UR1) ad Metro 1.1 are now released. Metro contain stable releases of JAX-WS RI and WSIT. Read Vivek's blog for more details.

Even though Metro 1.1 is a stand-alone release, it can be easily installed on an existing GlassFish instance (for example override on v2ur1). A later release of Metro 1.1 will be integrated in GlassFish v2.1. Metro Roadmap provides all the details.

Please send us your feedback on users@metro or Forum. A pleasant change that happened earlier today was that cross-posting was enabled between user's list and forum. So all the questions posted on user's list are cross-posted to Forum and vice versa. This enables wider audience for your questions and more engineers to respond back :)

Technorati: webservices metro jax-ws wsit glassfish v2ur1

Posted by Arun Gupta in webservices  |  Comments[3]

Understanding Security Token Service - New Whitepaper

Jiandong announced a new whitepaper: Building Trust in Web Services with Security Token Service. This papers explains how Security Token Service (STS) enable exchange of interoperable security tokens. It also explains how multiple STSs can be chained across security domains to realize Brokered Trust pattern. And then it provides a high-level architecture and the major components of the framework in Metro Web services stack for building a STS.

In an earlier entry, Jiandong explained how NetBeans WSIT module (part of Metro) can be used to build a STS. In a related entry, Shyam explained the extension points to implement STS according to a specific business requirement.

And this 26-page article provides a complete overview of how Metro provides an implementation of key WS-* specifications.

Technorati: webservices metro wsit glassfish whitepaper

Posted by Arun Gupta in webservices  |  Comments[0]

wsHttpDualBinding - a non-interoperable binding

Based upon a user request, I'll explain why wsDualHttpBinding (a system-provided binding in WCF) is not an interoperable binding. This blog entry will explain the service endpoint code, client code, generated WSDL and the SOAP messages exchanged based upon the DualHttp Binding Sample that is bundled with the Windows SDK samples. This is also an update to an earlier attempt to explain wsDualHttpBinding.

In the sample, I replaced the default wsDualHttpBinding with an equivalent custom binding (after removing the security) as:

<bindings>
  <customBinding>
    <binding name="Binding1">
      <reliableSession />
      <compositeDuplex />
      <oneWay />
      <textMessageEncoding
                     messageVersion="Soap12WSAddressing10" 
                     writeEncoding="utf-8" />
      <httpTransport authenticationScheme="Anonymous"
                     bypassProxyOnLocal="false"
                     hostNameComparisonMode="StrongWildcard"
                     proxyAuthenticationScheme="Anonymous"
                     realm=""
                     useDefaultWebProxy="true" />
    </binding>
  </customBinding>
</bindings>

The wsDualHttpBinding, also known as Composite Duplex or Full Duplex Binding, provides a bi-directional communication between Client and Endpoint. In a single direction communication, the client can invoke a set of operations on a service and this interface is referred as primary interface in Duplex binding. The set of operations that a service can invoke on the client is called as callback interface.

The sample in Windows SDK is a trivial calculator service where primitive Math operations are performed in a running session on the "primary" interface and results are returned on the "callback" interface.

Service Endpoint Code

Let's understand the service endpoint code first. The "primary" service endpoint interface looks like:

[ServiceContract(Namespace = "http://Microsoft.ServiceModel.Samples", 
                 SessionMode=SessionMode.Required,
                 CallbackContract=typeof(ICalculatorDuplexCallback))]
public interface ICalculatorDuplex
{
  [OperationContract(IsOneWay=true)]
  void Clear();
  [OperationContract(IsOneWay = true)]
  void AddTo(double n);

  ...
}

Three points to note in this code:

• A duplex contract requires a session, because a context must be established to correlate the set of messages being sent between client and service. Even though this is specified using SessionMode=SessionMode.Required attribute but the default value of SessionMode=SessionMode.Allowed (equivalent of not specifying) will be sufficient as well. This is because all Duplex bindings in .NET maintain a transport session.

• Callback interface is specified using CallbackContract attribute.

• All the methods are declared as One-way operations otherwise the response can be returned on the transport back channel itself. The documentation on this particular binding is limited.

The "callback" interface is defined as:

public interface ICalculatorDuplexCallback
{
  [OperationContract(IsOneWay = true)]
  void Result(double result);

  ...
}

In order for a service endpoint to establish a connection with the "callback" interface on client, a CallbackChannel is obtained from the OperationContext in the implementation of the "primary" interface as:

public class CalculatorService : ICalculatorDuplex
{
  double result;
  ICalculatorDuplexCallback callback = null;

  public CalculatorService()
  {
    result = 0.0D;
    callback = OperationContext.Current.GetCallbackChannel<ICalculatorDuplexCallback>();
  }

Another variable is initialized to return the running result. The implementation of each method in the "primary" interface then invokes a method on the "callback" interface to return the running result as:

public void AddTo(double n)
{
  result += n;
  callback.Result(result);
}

Generated WSDL

Now let's look at the generated WSDL fragments. The policy assertion elements are:

<wsp:All>
  <wsrm:RMAssertion xmlns:wsrm="http://schemas.xmlsoap.org/ws/2005/02/rm/policy">
    <wsrm:InactivityTimeout Milliseconds="600000" /> 
    <wsrm:AcknowledgementInterval Milliseconds="200" /> 
  </wsrm:RMAssertion>
  <cdp:CompositeDuplex xmlns:cdp="http://schemas.microsoft.com/net/2006/06/duplex" /> 
  <ow:OneWay xmlns:ow="http://schemas.microsoft.com/ws/2005/05/routing/policy" /> 
  <wsaw:UsingAddressing /> 
</wsp:All>

The wsrm:RMAssertion and wsaw:UsingAddressing elements are bound to a known namespace and their behavior is clearly documented. However the specification of cdp:CompositeDuplex and ow:OneWay elements are unclear at this time. This does not allow any WSDL-based interoperability whenever these elements are included.

All methods from the "primary" and the "callback" interface are generated in one wsdl:portType. The methods from the "primary" interface are generated as One-way operations. But methods from the "callback" interface are generated as Notification operation. For example, one of the methods from "callback" interface looks like:

<wsdl:operation msc:isInitiating="true" msc:isTerminating="false" name="Result">
  <wsdl:output
      wsaw:Action="http://Microsoft.ServiceModel.Samples/ICalculatorDuplex/Result"
      message="tns:ICalculatorDuplex_Result_OutputCallbackMessage"/>
</wsdl:operation>

JAX-WS, the core of Metro, supports only Request-Response and One-way operations. This is the second place where WSDL-based interoperability will not work with any JAX-WS-based WSDL import tool, such as wsimport. Moreover, the WSDL-to-Java mapping defined by the JAX-WS specification requires each wsdl:portType map to a single Java interface. This WSDL design pattern requires two interfaces to be generated from a single wsdl:portType.

There are some other elements in namespace prefix bound to "http://schemas.microsoft.com/ws/2005/12/wsdl/contract" and their purpose is also unclear. Rest of the WSDL is pretty straight-forward.

Client side code

On the client side, svcutil (WSDL importing tool for .NET 3.0) generates the "primary" and "callback" interface from the WSDL. The "callback" is implemented as:

public class CallbackHandler : ICalculatorDuplexCallback
{
  public void Result(double result)
  {
    Console.WriteLine("Result({0})", result);
  }

  public void Equation(string eqn)
  {
    Console.WriteLine("Equation({0})", eqn);
  }
}

This client instance is initialized with the callback implementation as:

class Client
{
  static void Main()
  {
    // Construct InstanceContext to handle messages on callback interface
    InstanceContext instanceContext = new InstanceContext(new CallbackHandler());

    // Create a client with given client endpoint configuration
    CalculatorDuplexClient client = new CalculatorDuplexClient(instanceContext);

And then the client invokes the service endpoint normally as shown below:

// Call the AddTo service operation.
double value = 100.00D;
client.AddTo(value);

...

SOAP messages

Lets look at the SOAP messages exchanged between client and endpoint now. The first call from the client to an endpoint triggers a protocol handshake for establishing a session. The CreateSequence protocol message looks like:

<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope" xmlns:a="http://www.w3.org/2005/08/addressing">
  <s:Header>
    <a:Action s:mustUnderstand="1">http://schemas.xmlsoap.org/ws/2005/02/rm/CreateSequence</a:Action>
    <a:ReplyTo>
      <a:Address>http://iamfine.sfbay.sun.com/Temporary_Listen_Addresses/bfd8c103-b0f9-4c65-9cb6-fbebb7d1517b/4e0cdb31-2451-4fb6-84b8-dc286e5f26c8</a:Address>
    </a:ReplyTo>
    <a:MessageID>urn:uuid:51918652-9a78-4ba3-82f5-e68ecd664d42</a:MessageID>
    <a:To s:mustUnderstand="1">http://localhost:8888/</a:To>
  </s:Header>
  <s:Body>
    <CreateSequence xmlns="http://schemas.xmlsoap.org/ws/2005/02/rm">
      <AcksTo>
        <a:Address>http://iamfine.sfbay.sun.com/Temporary_Listen_Addresses/bfd8c103-b0f9-4c65-9cb6-fbebb7d1517b/4e0cdb31-2451-4fb6-84b8-dc286e5f26c8</a:Address>
      </AcksTo>
      <Offer>
        <Identifier>urn:uuid:b1116e69-f1dd-45b0-8495-129645038160</Identifier>
      </Offer>
    </CreateSequence>
  </s:Body>
</s:Envelope>

The WCF runtime uses the Windows HTTP.SYS library to host an endpoint at the address specified in a:ReplyTo. This address is used for all subsequent messages sent on the callback channel. This message is used to create a session for the "primary" interface. The message also carries an offer, in the SOAP Body, to create a "callback" interface session.

The CreateSequenceResponse protocol message returns "primary" interface session identifier and also accepts the offered "callback" session. The message looks like:

<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope" xmlns:a="http://www.w3.org/2005/08/addressing">
  <s:Header>
    <a:Action s:mustUnderstand="1">http://schemas.xmlsoap.org/ws/2005/02/rm/CreateSequenceResponse</a:Action>
    <a:RelatesTo>urn:uuid:51918652-9a78-4ba3-82f5-e68ecd664d42</a:RelatesTo>
    <a:To s:mustUnderstand="1">http://iamfine.sfbay.sun.com/Temporary_Listen_Addresses/bfd8c103-b0f9-4c65-9cb6-fbebb7d1517b/4e0cdb31-2451-4fb6-84b8-dc286e5f26c8</a:To>
  </s:Header>
  <s:Body>
    <CreateSequenceResponse xmlns="http://schemas.xmlsoap.org/ws/2005/02/rm">
      <Identifier>urn:uuid:d483898c-4bd3-4077-ba04-07a9010ab27f</Identifier>
      <Accept>
        <AcksTo>
          <a:Address>http://localhost:8888/</a:Address>
        </AcksTo>
      </Accept>
    </CreateSequenceResponse>
  </s:Body>
</s:Envelope>

Now, because of the way each method is implemented (invoking callback.Result(result) method at the end of each "primary" operation), a response to a request received by an endpoint is returned over the callback channel. This happens under-the-cover even though all messages in the "primary" interface are defined as One-way operations.

The behavior is quite analogous to a Request-Response operation primitive. I wonder what are the usecases of wsDualHttpBinding ?

Summary

Finally, I summarize the reasons that makes wsDualHttpBinding a non-interoperable binding:

1. The specifications of cdp:CompositeDuplex and ow:OneWay are not available and these elements will thus be ignored by the Metro WSDL importing tool.

2. The operations from "callback" interface are mapped as Notification operation in the WSDL. This operation primitive is not supported by Metro.

3. On the service endpoint, all the operations from "primary" and "callback" interface are mapped to a single wsdl:portType. On the client side, wsdl:portType is mapped to separate "primary" and "callback" interfaces. The Java-to-WSDL mapping defined by the JAX-WS specification allows one-to-one mapping between Java interface and wsdl:portType.

Technorati: webservices interoperability wcf metro jax-ws wsit

Posted by Arun Gupta in webservices  |  Comments[8]

SOAP Message Logging in Metro and WCF

Metro provides Secure, Reliable, Transactional and .NET 3.0 interoperable Web services stack in GlassFish. This entry explains how to enable SOAP message logging in Metro and .NET 3.0.

The SOAP message logging in Metro is explained here.

In WCF (the Web services stack in .NET), the Configuration Editor Tool is the preferred way to enable SOAP message logging. But sometimes you may want to directly edit your configuration file, for example, if you do not want to re-generate the file again. In such cases you can include the XML fragments from the template configuration file given below into your application specific configuration and this will enable only SOAP message logging:

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <system.diagnostics>
    <sources>
      <source name="System.ServiceModel.MessageLogging" switchValue="Warning, ActivityTracing">
        <listeners>
          <add type="System.Diagnostics.DefaultTraceListener" name="Default">
            <filter type="" />
          </add>
          <add name="ServiceModelMessageLoggingListener">
            <filter type="" />
          </add>
        </listeners>
      </source>
    </sources>
    <sharedListeners>
      <add initializeData="LOG_DIRECTORY\messages.svclog"
           type="System.Diagnostics.XmlWriterTraceListener, System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"
           name="ServiceModelMessageLoggingListener" traceOutputOptions="Timestamp">
        <filter type="" />
      </add>
    </sharedListeners>
  </system.diagnostics>
  <system.serviceModel>
    <diagnostics>
      <messageLogging logEntireMessage="true" logMalformedMessages="true" logMessagesAtTransportLevel="true" />
    </diagnostics>
  </system.serviceModel>
</configuration>

After the client application is invoked, all SOAP messages will be logged to LOG_DIRECTORY\messages.svclog file. The message log can be viewed using svctraceviewer.

Technorati: wcf webservices wsit metro glassfish

Posted by Arun Gupta in webservices  |  Comments[0]

Transcript of Sun and Microsoft Interoperability Exchange Forum

A complete transcript of the Sun/Microsoft Expert Exchange Forum is now available. And if you still have questions, feel free to post them to users@metro or Metro Forum.

Try 3 things today:

1. Download GlassFish V2.
2. Develop and Deploy a Reliable Web service using NetBeans IDE following this screencast (complete list).
3. Read more details about Project Tango in this 26-page article.

Technorati: wsit metro webservices glassfish netbeans sun microsoft interoperability

Posted by Arun Gupta in webservices  |  Comments[1]

Metro on Tomcat 6.x

Rama described how to run JAX-WS samples with Tomcat 6.x. JAX-WS is part of Metro - the Web services stack in GlassFish. Another key component of Metro is WSIT (aka Project Tango) that provides Secure, Reliable, Transactional and Interoperable Web service. Read more about Project Tango in this 26-page article.

A stable version of Metro is integrated in GlassFish V2 and the latest nightlies of stand-alone bundle are also available. The stand-alone bundle comes with an install scipt (wsit-on-tomcat.xml) that allows it install on Tomcat 5.x. I followed the steps in Rama's blog to install Metro on Tomcat 6.x. But first, a little bit of explanation and then the actual code fragments.

Tomcat's classloading mechanism has changed slightly between 5.x and 6.x. The first change is that Tomcat 5.x used to have shared/lib directory to share classes across all web applications. This directory in turn used to be specified as value of shared.loader property in  conf/catalina.properties. In Tomcat 6.x, the property still exists but it's value is set to nothing and shared/lib directory no longer exists in the default installation. I see the motivation behind this change as it keeps the Tomcat installation directory clean and any shared resources can still be specified in conf/catalina.properties. But this means that wsit-on-tomcat.xml script, that copies the files in shared/lib directory, will work on Tomcat 5.x only. In order for this script to work on Tomcat 6.x, the value of shared.loader property need to be changed to include Metro jars.

Now, the code fragments! The value of shared.loader property in Tomcat 5.x is:

shared.loader=${catalina.base}/shared/classes,${catalina.base}/shared/lib/*.jar

And in Tomcat 6.x is the value of this property is:

shared.loader=

If Metro is installed in c:\metro then changing its value to:

shared.loader=file:///c:/metro/lib/*.jar

will enable Tomcat 6.x to host Secure, Reliable, Transactional and .NET 3.0-Interoperable Web services. And this mechanism will work for Tomcat 5.x too, so changing the value of this property in Tomcat 5.x installation to:

shared.loader=${catalina.base}/shared/classes,${catalina.base}/shared/lib/*.jar,file:///c:/metro/lib/*.jar

instead of copying the files in shared/lib will be sufficient as well.

The second change in Tomcat's classloading mechanism is required if you are using Java SE 6. Tomcat 5.x used to have common/endorsed directory which no longer exists in Tomcat 6.x. Java SE 6 is bundled with JAX-WS 2.0 and Metro needs JAX-WS 2.1. So if you are using Java SE 6 then copy webservices-api.jar in c:/jdk6/jre/lib/endorsed directory. Read Endorsed Directory Mechanism for more details.

Several screencasts are available that show how to develop Secure, Reliable and Transactional and Interoperable Web service. All the screencasts use NetBeans IDE but if you are more of a command-line user then follow this entry that shows how to develop a reliable endpoint and invoke it from WCF and vice versa.

Technorati: metro webservices wsit jax-ws glassfish tomcat

Posted by Arun Gupta in webservices  |  Comments[34]

users@metro = users@wsit + users@jax-ws

Metro - the Web services stack in GlassFish - was announced recently. It was basically creating a single entity for two related projects - JAX-WS RI and Project Tango. The next logical step is to create a single place where users can ask questions and search for already existing answers. Here are some of the changes Koshuke made in that direction:

• Subscribers of users-AT-wsit and users-AT-jax-ws (normal as well as digests) are all subscribed to users@metro.
• users@metro archive is populated with the combined archive of users@wsit and users@jax-ws.
• Nabble archive is set up http://www.nabble.com/Metro---Users-f24522.html. Any new posts to users@metro will be archived there.
• Sending e-mails to users@wsit and users@jax-ws will trigger the auto responder and show the following message:
  
  'users@wsit.dev.java.net' has moved to 'users@metro.dev.java.net',
so please resubmit your message to the new alias.

We apologize for the inconvenience.

  users@metro is going to be the alias for asking all Web services related questions.

We are working on consolidating the JAX-WS and JAXB and WSIT forums as well.

Technorati: metro webservices wsit jax-ws glassfish

Posted by Arun Gupta in webservices  |  Comments[2]

Sun Expert Exchange FREE Forum - Sun and Microsoft Interoperability

Whether you watched Tango in Sun Net Talk or not, you can still participate in Sun Expert Exchange Forum, a FREE forum, asking questions about Sun and Microsoft interoperability. I'll be there, along with Harold Carr, to field all questions on Project Tango. And then there are experts on other topics from Sun as well.

You can read all about Project Tango in this 26-page article.

Technorati: webservices wsit sun microsoft interoperability

Posted by Arun Gupta in webservices  |  Comments[7]

Project Tango: An Overview - New Article

TheServerSide announced the availability of Project Tango: An Overview article. This 26-page article provides a comprehensive overview of Project Tango explaining topics such as:

• What is Project Tango ?
• What features does it provide ?
• How is it related to Metro and GlassFish ?
• How NetBeans IDE provide a simple and intuitive Tango programming model ?
• How Project Tango can be used to solve real-life scenarios ?

And lots of other details.

Project Tango (Web Services Interoperability Technology or WSIT) is an open source implementation from Sun Microsystems of the key enterprise Web services specifications, commonly known as WS-*, that provides interoperability with .NET 3.0 framework. This article is a good starting place if you don't know anything about Project Tango. If you are already familiar then it serves as a good reference with all different aspects of Project Tango.

Please leave a comment on this blog for feedback.

Technorati: tango wsit webservices glassfish netbeans theserverside whitepaper

Posted by Arun Gupta in webservices  |  Comments[4]

GlassFish V2 Beta3 and Vista - Interoperable out-of-the-box

GlassFish V2 beta3 is now available. I take this opportune moment for a follow up entry showing how a Reliable WSIT endpoint can be invoked from WCF client and vice versa. WSIT is already integrated in GlassFish V2.

The first part where a WSIT endpoint is invoked by a WCF client is now already available in this entry by Jesus Rodriguez. Couple of points in the entry:

• The Web Service configuration (a.k.a. WSIT configuration file) is not hand edited. Instead it is conveniently generated by NetBeans IDE as shown in screencast #ws3. The user experience really is to just check mark a box and all the relevant XML fragments are generated by NetBeans.
• Even though entry requires to rely on SOAP 1.1 (mistyped as WS-Addressing 1.1) , it workes with SOAP 1.2 very well. In fact, I've used SOAP 1.2 in the code below.

This entry provides the code to deploy a Reliable WCF endpoint and invoke it using a WSIT client.

1. Create a service endpoint service.svc as:
   
   <%@ServiceHost language=c# Debug="true" Service="WCFReliableEndpoint.Hello" %>

using System.ServiceModel;

namespace WCFReliableEndpoint
{
  [ServiceContract]
   public interface IHello
   {
     [OperationContract]
     string sayHello(string name);
   }

   public class Hello : IHello
   {
     public string sayHello(string name)
     {
       return "Hello " + name;
     }
   }
}
2. In the same directory, create Web.config as:
   
   <?xml version="1.0" encoding="utf-8"?>
<configuration>
  <system.serviceModel>
    <services>
      <service name="WCFReliableEndpoint.Hello" behaviorConfiguration="MetadataBehavior">
        <endpoint address=""
                  binding="customBinding"
                  bindingConfiguration="Binding1"
                  contract="WCFReliableEndpoint.IHello" />
      </service>
    </services>

    <bindings>
      <customBinding>
        <binding name="Binding1">
          <reliableSession />
            <textMessageEncoding messageVersion="Soap12WSAddressing10" writeEncoding="utf-8" />
            <httpTransport authenticationScheme="Anonymous" bypassProxyOnLocal="false"
              hostNameComparisonMode="StrongWildcard"
              proxyAuthenticationScheme="Anonymous" realm=""
              useDefaultWebProxy="true" />
        </binding>
      </customBinding>
    </bindings>

    <behaviors>
      <serviceBehaviors>
        <behavior name="MetadataBehavior">
          <serviceMetadata httpGetEnabled="true" />
        </behavior>
      </serviceBehaviors>
    </behaviors>

  </system.serviceModel>
</configuration>
3. If IIS was installed after Vista installation was complete, then you'll have to explicitly register WCF components with IIS following these instructions and as shown below:
   
   
4. Create a virtual directory, say wsit-reliable, in IIS mapping to the directory where service.svc and Web.config are present. You should now see the default WCF/IIS page as below:
   
   
   
   The service endpoint is now hosted at http://localhost/wsit-reliable/service.svc and the WSDL of the endpoint looks like:
   
   
5. Create a WSIT client, using NetBeans IDE, following the instructions in screencast #ws2. Enable WSIT message logging by adding the following property to domains/domain1/config/domain.xml:
   
   <jvm-options>-Dcom.sun.xml.ws.assembler.client=true</jvm-options>

6. The SOAP messages exchanged between the WSIT client and the WCF endpoint are given below:
   
   ====[com.sun.xml.ws.assembler.client:request]====
<?xml version="1.0" ?>
<S:Envelope xmlns:S="http://www.w3.org/2003/05/soap-envelope">
  <S:Header>
    <To xmlns="http://www.w3.org/2005/08/addressing">http://iamfine/wsit-reliable/service.svc</To>
    <Action xmlns="http://www.w3.org/2005/08/addressing">http://schemas.xmlsoap.org/ws/2005/02/rm/CreateSequence</Action>
    <ReplyTo xmlns="http://www.w3.org/2005/08/addressing">
      <Address>http://www.w3.org/2005/08/addressing/anonymous</Address>
    </ReplyTo>
    <MessageID xmlns="http://www.w3.org/2005/08/addressing">uuid:fcaef2ab-bccf-4a08-a1d1-b10f7819f7ea</MessageID>
  </S:Header>
  <S:Body>
    <ns2:CreateSequence
        xmlns:ns6="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"
        xmlns:ns5="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"
        xmlns:ns4="http://www.w3.org/2005/08/addressing" xmlns:ns3="http://schemas.microsoft.com/ws/2006/05/rm"
        xmlns:ns2="http://schemas.xmlsoap.org/ws/2005/02/rm">
      <ns2:AcksTo>
        <ns4:Address>http://www.w3.org/2005/08/addressing/anonymous</ns4:Address>
      </ns2:AcksTo>
      <ns2:Offer>
        <ns2:Identifier>uuid:4953079f-3726-40b5-b6b4-255eb46c0fda</ns2:Identifier>
      </ns2:Offer>
    </ns2:CreateSequence>
  </S:Body>
</S:Envelope>
============
====[com.sun.xml.ws.assembler.client:response]====
<?xml version="1.0" ?>
<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope" xmlns:a="http://www.w3.org/2005/08/addressing">
  <s:Header>
    <a:Action s:mustUnderstand="1">http://schemas.xmlsoap.org/ws/2005/02/rm/CreateSequenceResponse</a:Action>
    <a:RelatesTo>uuid:fcaef2ab-bccf-4a08-a1d1-b10f7819f7ea</a:RelatesTo>
  </s:Header>
  <s:Body>
    <CreateSequenceResponse xmlns="http://schemas.xmlsoap.org/ws/2005/02/rm">
      <Identifier>urn:uuid:8ebe44c6-494c-4a43-8ade-dab90800d7f5</Identifier>
      <Accept>
        <AcksTo>
          <a:Address>http://iamfine/wsit-reliable/service.svc</a:Address>
        </AcksTo>
      </Accept>
    </CreateSequenceResponse>
  </s:Body>
</s:Envelope>
============
====[com.sun.xml.ws.assembler.client:request]====
<?xml version="1.0" ?>
<S:Envelope xmlns:S="http://www.w3.org/2003/05/soap-envelope">
  <S:Header>
    <To xmlns="http://www.w3.org/2005/08/addressing">http://iamfine/wsit-reliable/service.svc</To>
    <Action xmlns="http://www.w3.org/2005/08/addressing">http://tempuri.org/IHello/sayHello</Action>
    <ReplyTo xmlns="http://www.w3.org/2005/08/addressing">
      <Address>http://www.w3.org/2005/08/addressing/anonymous</Address>
    </ReplyTo>
    <MessageID xmlns="http://www.w3.org/2005/08/addressing">uuid:5ac7c151-8049-444e-8dd0-1e053b26895d</MessageID>
    <ns2:Sequence
      xmlns:ns4="http://www.w3.org/2005/08/addressing"
      xmlns:ns3="http://schemas.microsoft.com/ws/2006/05/rm"
      xmlns:ns2="http://schemas.xmlsoap.org/ws/2005/02/rm">
      <ns2:Identifier>urn:uuid:8ebe44c6-494c-4a43-8ade-dab90800d7f5</ns2:Identifier>
      <ns2:MessageNumber>1</ns2:MessageNumber>
    </ns2:Sequence>
    <ns2:AckRequested
      xmlns:ns4="http://www.w3.org/2005/08/addressing"
      xmlns:ns3="http://schemas.microsoft.com/ws/2006/05/rm"
      xmlns:ns2="http://schemas.xmlsoap.org/ws/2005/02/rm">
      <ns2:Identifier>urn:uuid:8ebe44c6-494c-4a43-8ade-dab90800d7f5</ns2:Identifier>
    </ns2:AckRequested>
  </S:Header>
  <S:Body>
    <sayHello xmlns:ns2="http://schemas.microsoft.com/2003/10/Serialization/" xmlns="http://tempuri.org/">
      <name>Duke</name>
    </sayHello>
  </S:Body>
</S:Envelope>
============
====[com.sun.xml.ws.assembler.client:response]====
<?xml version="1.0" ?>
<s:Envelope
    xmlns:s="http://www.w3.org/2003/05/soap-envelope"
    xmlns:r="http://schemas.xmlsoap.org/ws/2005/02/rm"
    xmlns:a="http://www.w3.org/2005/08/addressing">
  <s:Header>
    <r:Sequence s:mustUnderstand="1">
      <r:Identifier>uuid:4953079f-3726-40b5-b6b4-255eb46c0fda</r:Identifier>
      <r:MessageNumber>1</r:MessageNumber>
    </r:Sequence>
    <r:SequenceAcknowledgement>
    <r:Identifier>urn:uuid:8ebe44c6-494c-4a43-8ade-dab90800d7f5</r:Identifier>
    <r:AcknowledgementRange Lower="1" Upper="1"></r:AcknowledgementRange>
      <netrm:BufferRemaining xmlns:netrm="http://schemas.microsoft.com/ws/2006/05/rm">8</netrm:BufferRemaining>
    </r:SequenceAcknowledgement>
    <a:Action s:mustUnderstand="1">http://tempuri.org/IHello/sayHelloResponse</a:Action>
    <a:RelatesTo>uuid:5ac7c151-8049-444e-8dd0-1e053b26895d</a:RelatesTo>
  </s:Header>
  <s:Body>
    <sayHelloResponse xmlns="http://tempuri.org/">
      <sayHelloResult>Hello Duke</sayHelloResult>
    </sayHelloResponse>
  </s:Body>
</s:Envelope>
============

There were no custom settings or configurations required to make the WSIT client This shows, once again, that GlassFish V2 and .NET 3.0 (pre-bundled in Vista) are interoperable out of the box.

Technorati: webservices wsit glassfish reliablemessaging wcf interoperability

Posted by Arun Gupta in webservices  |  Comments[3]

NetBeans 6 M10 and Web Service Designer

NetBeans 6 Milestone 10 is now available. One of the new and noteworthy features is better Web services support. This entry is a follow up to an earlier post where Web services designer was tried on Milestone 9.

1. Uninstall NetBeans 6 M9 build from the machine.
2. Download either the Full or Standard version. Full version provides UML, SOA and Ruby support as well. I downloaded Full version and did a custom install as shown here:
   
   
3. The build number is 200706281431 as shown here:
   
   
   
   Click through Next buttons and finish installing taking defaults all the way through.
4. After the install is completed, it requires to start NetBeans IDE from the Start Menu or desktop icon as shown here:
   
   
   
   An option to start NetBeans IDE after finishing the install would be nice (issue #108809).
5. The first visible difference from NetBeans M9 and NetBeans 5.5.1 is that "Runtime" tab is now renamed to "Services". Even the content within Services tab is cleaned up and re-ordered. Here is a snapshot from NetBeans 5.5.1 and NetBeans 6 M10:
    
6. Adding Server instance is a better experience and shows GlassFish V2 as the default. Here is a snapshot from NetBeans 5.5.1 and NetBeans 6 M10:
   
    
7. A new addition to M10 is that it allows to choose a GlassFish profile as shown here:
   
   
8. I used GlassFish V2 b53 and added the server instance by taking all defaults.
9. Following the instructions #2 and #3 from here, add a new Web service to a Web project. The Web Service Designer color scheme is now much more in-lined with the existing IDE as shown here:
   
   
   
   The earlier version always used to remind of three colors in the Indian national flag :) Notice the small icons right next to "Design" button, they allow you to fit the diagram in current window size. But there is a small gotcha. Any hints ? Notice the missing letter "n" in "Policy Configuration" and "g" in "Reliable Messaging" (issue #108807).
10. Click on "Add Operation" and it allows you to add an operation by specifying the operation name and parameters. And the new thing is, it allows you to add Exceptions as well as shown here:
    
    
    
    Couple of issues here. First the parameter name specified in designer is ignored and the source code still uses the default parameter name "parameter". However little bit more investigation revealed that tabbing out of the parameter box did accept the parameter name. This is a usability issue and so I filed #108794. Secondly, the faults are still not correctly displayed in the designer as shown here:
    
    
    
    The source view of the Web service shows:
    
    public String operation(@WebParam(name = "parameter")
String parameter) throws {
//TODO write your implementation code here:
return null;
}
    
    Notice, an empty throws clause (issue #108798). An expanded view looks like:
    
    
11. Because of #108798, I had to remove the operation and add it again and this time without any faults. So I right-clicked on the project and the deploy sub-menu is changed as shown here:
    
    
    
    For the first time deployment, this menu item is confusing. I think the thought process behind this might have been that "Deploy" by itself (which was in NetBeans 5.5.1) does not give the feeling that it undeploys the previous project. But why does the user need to know it ? Another option is to change the menu item label if the project is already deployed. But this label is certainly confusing. (issue #108801).
12. Once the project was deployed, I tried "Test Web Service" contextual menu and it worked like a charm.
13. Selecting one of the boxes in "Policy Configuration" generated the appropriate WSIT configuration file. And it was also found to be in-sync with the "WSIT Configuration" tab that is reached by clicking "Edit Web Service Attributes" in the contextual menu.
14. To verify WSIT functionality, I selected "Reliable Messaging" in Policy Configuration, deployed the project again and invoked the endpoint. As expected, several WS-Addressing and WS-Reliable Messaging headers were shown in the browser window confirming that Reliable Messaging was correctly enabled.

Here is a summary of the issues filed:

1. An option to start NetBeans IDE after install is completed (#108809)
2. Parameter name specified in Designer is not propagated to the source code (#108794)
3. Faults are broken in Designer (#108798)
4. Incomplete words if Window is resized (#108807)
5. "Undeploy and Deploy" menu label is confusing (#108801)

Technorati: wsit webservices glassfish netbeans

Posted by Arun Gupta in webservices  |  Comments[2]

WS-I Interop Event Report at Burton Catalyst

As mentioned earlier, Sun Microsystems participated in an interoperability demo showcasing  the WS-I Sample Application that supports the Basic Security Profile 1.0 (BSP1.0) at Burton Group's Catalyst Conference 2007 last week. Jiandong reported that the event went smoothly as expected. Microsoft, IBM, Novell and SAP also participated in the event and there were no glitches.

This version of Sample Application is built using WSIT integrated in GlassFish V2 and we tested interoperability with all the participating vendors. Here is a matrix from Sample Application Security Architecture Document that shows a summary of port-level security requirements for some of the operations:

This matrix shows Different key sizes (128 & 256), Profiles (X.509 and UsernameToken), Custom headers signing, Encrypting the signature and other features used for securing the sample app. Even though WSIT provides a much richer set of Security Profiles, these features represent a good mix of the commonly used options. And all of these are indeed supported by WSIT as well.

The Sample Apps Deliverables page shows the following list of platforms used by each vendor for their version of Secure Sample App:

And Sun's version of Secure Sample App, using WSIT in GlassFish V2, is interoperable with these.

Thanks to Harsha for porting the JAX-RPC-based Sample Application.

Technorati: burtongroup burtoncatalyst ws-i conf wsit glassfish webservices

Posted by Arun Gupta in webservices  |  Comments[0]

Tango in Sun Net Talk

Hear Sun's Executive Vice President and CTO Greg Papadopoulos and Harold Carr talk about Project Tango in this edition of Sun Net Talk. The talk provides a progress report on Sun and Microsoft legendary partnership announced 3 years ago and is appropriately titled "Sun Delivers Microsoft Interoperability Year 3".

Project Tango provides an implementation of key enterprise Web services specifications, commonly known as WS-*, and integrated in GlassFish V2.

Greg talks about Project Tango on slide 5 starting at 4 min, 38 seconds (4:38). And then Harold provides a detailed overview from slide 13 through 19. Greg calls Project Tango as "the biggest object of our affection" and it truly is :)

After you provide your email, you can download slides as well.

Technorati: sun wsit webservices

Posted by Arun Gupta in webservices  |  Comments[2]

WS-I and WSIT - What's the difference ?

Before I explain the differences between WS-I and WSIT, let me point out the similarities:

• They both are working to achieve interoperability of Web services
• The first three letters in their short name stand for the exact same words "Web Services Interoperability"

And that's where the similarity ends, now the differences.

As is evident from the table even though both WS-I and WSIT working towards Web services interoperability, there are clear differences between them.

Sun is a current Board Member of WS-I and has actively participated in the production of Basic Profile 1.0, 1.1 and 1.2, Simple SOAP Binding Profile 1.0, Attachments Profile 1.0, Basic Security Profile 1.0, Sample Applications Use Cases, Architecture, Scenarios and Implementation 1.0, Attachment Profile Usage Scenario 1.0, SAML Token Profile 1.0, REL Token Profile 1.0, Kerberos Token Profile 1.0. As the specifications supported by WSIT are endorsed by standards bodies in future, WS-I may decide to profile them as well.

The WSIT bits are integrated in GlassFish V2 and comes with a seamless integration with NetBeans IDE. WSIT is built as an extension to JAX-WS RI that provides a Core web services implementation compliant with several of the profiles mentioned above.

WSIT and JAX-WS are the two key components of Metro - the Web services stack in GlassFish. That gives you the best of both world - a product-quality implementation of WS-* specifications and compliance with industry-standard profiles.

Technorati: wsit ws-i metro webservices glassfish

Posted by Arun Gupta in webservices  |  Comments[2]