<!--
  ~ 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.
  -->

<html>
<head>
  <meta http-equiv="content-type" content="">
  <title>Apache Axis2 @axisVersion@ Release Notes</title>
</head>

<body lang="en">
<h1>Apache Axis2 @axisVersion@ Release Notes</h1>

<h2>About this version</h2>

1.5.1 is a maintenance release to fix several key problems in
the 1.5 release.

<h2>Changes since 1.5</h2>

<ul>
 <li>Fix for the dreaded "CLOSE_WAIT" problem (JIRA issues 935, 2883, etc).  We now share an instance of HTTPClient across each ConfigurationContext (i.e. each Axis2 server or ServiceClient) - connection reuse is now automatic.  This means <b>the REUSE_HTTP_CLIENT flag is no longer necessary or useful, nor is creating your own MultithreadedHttpConnectionManager</b>.</li>
 <li>Another important part of this fix involves automatically releasing the last OperationContext's resources each time ServiceClient.sendReceive() is called for blocking operations.  This behavior is controlled by setting the ServiceClient.AUTO_RELEASE_CONNECTION property in the Options class - the default is true, but if you want to turn it off you can call <code>options.setProperty(ServiceClient.AUTO_RELEASE_CONNECTION, false)</code> (note that if you do this you'll need to ensure that the transport connection is cleaned up some other way, such as by manually calling cleanupTransport() on your client or stub).</li>
 <li>Transport deployer is now actually functional, and getListenerManager() in ConfigurationContext now creates a new LM if there isn't one already.</li>
 <li>Fix for AXIS2-4034, module versions now support real versions like "1.5.1"</li>
 <li>NPE problem (see AXIS2-4114) fixed in MessageContext while retrieving policy.</li>
 <li>Fix a dependency problem with the JavaDocs build</li>
</ul>

<h4>Known Issues and Limitations in the @axisVersion@ Release:</h4>
<p><i>Please see JIRA</i></p>


<h2>About Axis2</h2>

<p>Apache Axis2 is a complete re-design and re-write of the widely used
Apache Axis engine and is a more efficient, more scalable, more modular
and more XML-oriented Web services framework. It is carefully designed to
support the easy addition of plug-in "modules" that extend its
functionality for features such as security and reliability.</p>

<p>Modules supporting WS-Security/Secure-Conversation (Apache Rampart),
WS-Trust (Apache Rahas), WS-Reliable Messaging (Apache Sandesha) and
WS-Eventing (Apache Savan) are available via the Apache Web Services
project. Please see the individual subproject sites for further information.</p>

<h2>Feedback</h2>

<p>We are striving for a simple and happy first time user experience as well as a
satisfying experienced user experience with this release. We welcome any
and all feedback at:</p>
<ul>
  <li><a href="mailto:axis-user@ws.apache.org">axis-user@ws.apache.org</a> (please include "[axis2]" in the subject)</li>
  <li><a href="mailto:axis-dev@ws.apache.org">axis-dev@ws.apache.org</a> (please include "[axis2]" in the subject)</li>
  <li><a href="http://issues.apache.org/jira/browse/AXIS2">http://issues.apache.org/jira/browse/AXIS2</a></li>
</ul>

<p>Thank you for your interest in Apache Axis2!</p>

<p><i>The Axis2 Development Team<br>
<a href="http://ws.apache.org/axis2/">http://ws.apache.org/axis2/</a></i></p>
</body>
</html>
