<!--
 Licensed to the Apache Software Foundation (ASF) under one
 or more contributor license agreements. See the NOTICE file
 distributed with this work for additional information
 regarding copyright ownership. The ASF licenses this file
 to you under the Apache License, Version 2.0 (the
 "License"); you may not use this file except in compliance
 with the License. You may obtain a copy of the License at
 
 http://www.apache.org/licenses/LICENSE-2.0
 
 Unless required by applicable law or agreed to in writing,
 software distributed under the License is distributed on an
 "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 KIND, either express or implied. See the License for the
 specific language governing permissions and limitations
 under the License.
-->
<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
       "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
  <meta http-equiv="content-type" content="text/html; charset=iso-8859-1" />
  <title>Apache Sandesha2 - release notes</title>
  <meta name="generator" content="amaya 9.2.2, see http://www.w3.org/Amaya/"
  />
</head>

<body>
<h1>Apache Sandesha2 Release Notes</h1>

<p>This is the ${project.version} release of Apache Sandesha2.</p>

<p>Apache Sandesha2 1.6.2 is a maintenance release that provides compatibility with Axis2 1.6.2.
Please note that Sandesha2 1.6.2 will not work with Axis2 1.6.0 and that users of Axis2 1.6.2 are
required to update to Sandesha2 1.6.2, i.e. Sandesha2 1.6.0/1.6.1 doesn't work with Axis2 1.6.2.</p>

<h2>What is in this release</h2>

<p>Features available in this release of Sandesha2.</p>
<ol>
  <li>Support for WS-ReliableMessaging in both client side and server side of
    Axis2. (according the the WS-ReliableMessaging specification February
    2005).</li>
  <li>Support upto the CD4 of the WSRM 1.1 specification being developed under OASIS.</li>
  <li>Pluggable storage framework.</li>
  <li>Configurable delivery assurances. In-order exactly once delivery
    assurance is guaranteed. Users can also instruct the system to stop
    ordering (this will give a higher performance).</li>
  <li>Support for both SOAP 1.1 and 1.2.</li>
  <li>Mechanisms to support WS-ReliableMessaging policy assertions in both
    server side and the client side.</li>
  <li>Improved client API, which provides features for both general and
    advance users.</li>
  <li>Sandesha Report functionality to get status information on Sandesha2
    system and its sequences.</li>
  <li>SandeshaListner feature to get informed when specific events happen
    (for example when a fault is retrieved or when a sequence times out).</li>
  <li>Support for the WSRM specification being developed under OASIS WSRX
    technical committee.</li>
  <li>Support for SecureConversation+RM</li>
  <li>Test cases to test RM scenarios.</li>
  <li>Documentation</li>
</ol>

<p>Thank you for using Apache Sandesha2.</p>

<p></p>

<p>Apache Sandesha2 team</p>

</body>
</html>
