<!DOCTYPE html>
<html lang="en">
  <head>

    <meta charset="UTF-8">
      <title>Apache TomEE 1.5.1 Release Notes</title>
    <meta name="description" content="Apache TomEE">
    <meta name="author" content="Apache TomEE">
    <meta name="google-translate-customization" content="f36a520c08f4c9-0a04e86a9c075ce9-g265f3196f697cf8f-10">
    <meta http-equiv="Pragma" content="no-cache">
    <meta http-equiv="Expires" content="0">
    <meta http-equiv="Cache-Control" content="no-store, no-cache, must-revalidate, max-age=0">

    <!-- Le HTML5 shim, for IE6-8 support of HTML elements -->
    <!--[if lt IE 9]>
      <script src="http://html5shim.googlecode.com/svn/trunk/html5.js"></script>
    <![endif]-->

    <!-- Le styles -->
    <link href="./resources/css/bootstrap.css" rel="stylesheet">
    <link href="./resources/css/prettify.css" rel="stylesheet">
    <!--link href="./resources/css/bootstrap-mods.css" rel="stylesheet"-->
    <link href="./resources/css/main.css" rel="stylesheet">
    <link href="./resources/font-awesome-4.6.3/css/font-awesome.min.css" rel="stylesheet">

    <script type="text/javascript">
        var t = encodeURIComponent(document.title.replace(/^\s+|\s+$/g,""));
        var u = encodeURIComponent(""+document.URL);
    
      function fbshare () {
          window.open(
                  "http://www.facebook.com/sharer/sharer.php?u="+u,
                  'Share on Facebook',
                  'width=640,height=426');
      };
      function gpshare () {
          window.open(
                  "https://plus.google.com/share?url="+u,
                  'Share on Google+',
                  'width=584,height=385');
      };
      function twshare () {
          window.open(
                  "https://twitter.com/intent/tweet?url="+u+"&text="+t,
                  'Share on Twitter',
                  'width=800,height=526');
      };
      function pinshare () {
          window.open("//www.pinterest.com/pin/create/button/?url="+u+"&media=http%3A%2F%2Ftomee.apache.org%2Fresources%2Fimages%2Ffeather-logo.png&description="+t,
                  'Share on Pinterest',
                  'width=800,height=526');
      };
    </script>

    <!-- Le fav and touch icons -->
    <link rel="shortcut icon" href="./favicon.ico">
    <link rel="apple-touch-icon" href="./resources/images/apple-touch-icon.png">
    <link rel="apple-touch-icon" sizes="72x72" href="./resources/images/apple-touch-icon-72x72.png">
    <link rel="apple-touch-icon" sizes="114x114" href="./resources/images/apple-touch-icon-114x114.png">

    <script src="./resources/js/prettify.js" type="text/javascript"></script>
    <script src="./resources/js/jquery-latest.js"></script>
    <script src="http://platform.twitter.com/widgets.js" type="text/javascript"></script>
    <script src="./resources/js/common.js"></script>
    <script src="./resources/js/prettyprint.js"></script>
    <!--script src="//assets.pinterest.com/js/pinit.js" type="text/javascript" async></script//-->
    
    <script type="text/javascript">

      var _gaq = _gaq || [];
      _gaq.push(['_setAccount', 'UA-2717626-1']);
      _gaq.push(['_setDomainName', 'apache.org']);
      _gaq.push(['_trackPageview']);

      (function() {
        var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
        ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
        var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
      })();

    </script>
  </head>

  <body>

    <div class="topbar" data-dropdown="dropdown">
      <div class="fill">
        <div class="container">
          <a class="brand" href="./index.html">Apache TomEE</a>
          <ul class="nav">
              <li class="dropdown">
                  <a class="dropdown-toggle" data-toggle="dropdown" href="#">
                  Apache
                      <b class="caret"></b>
                  </a>
                  <ul class="dropdown-menu">
                     <!-- <li><a href="./misc/whoweare.html">Who we are?</a></li> -->
                     <!-- <li><a href="./misc/heritage.html">Heritage</a></li> -->
                     <li><a href="http://www.apache.org">Apache Home</a></li>
                     <!-- <li><a href="./misc/resources.html">Resources</a></li> -->
                     <li><a href="./misc/contact.html">Contact</a></li>
                     <li><a href="./misc/legal.html">Legal</a></li>
                     <li><a href="http://www.apache.org/foundation/sponsorship.html">Sponsorship</a></li>
                     <li><a href="http://www.apache.org/foundation/thanks.html">Thanks</a></li>
                     <li class="divider"/>
                     <li><a href="http://www.apache.org/security">Security</a></li>
                  </ul>
              </li>
              <li><a href="./index.html">Home</a></li>
              <li><a href="./downloads.html">Downloads</a></li>
              <li><a href="./documentation.html">Documentation</a></li>
              <li><a href="./examples-trunk/index.html">Examples</a></li>
              <li><a href="./support.html">Support</a></li>
              <li><a href="./contribute.html">Contribute</a></li>
              <li><a href="./security/index.html">Security</a></li>
          </ul>

            <!-- Google CSE Search Box Begins  -->
            <FORM class="pull-right" id="searchbox_010475492895890475512:_t4iqjrgx90" action="http://www.google.com/cse">
                <INPUT type="hidden" name="cx" value="010475492895890475512:_t4iqjrgx90">
                <INPUT type="hidden" name="cof" value="FORID:0">
                <INPUT size="18" width="130" style="width:130px" name="q" type="text" placeholder="Search">
            </FORM>
            <!--<SCRIPT type="text/javascript" src="http://www.google.com/coop/cse/brand?form=searchbox_010475492895890475512:_t4iqjrgx90"></SCRIPT>-->
            <!-- Google CSE Search Box Ends -->
        </div>
      </div>
    </div>

    <div class="container">
    

<div class="page-header">
    <small><a href="./index.html">Home</a></small><br>
    <h1>Apache TomEE 1.5.1 Release Notes

        <div style="float: right; position: relative; bottom: -10px; ">
            <a onclick="javascript:gpshare()" class="gp-share sprite" title="Share on Google+">share [gp]</a>
            <a onclick="javascript:fbshare()" class="fb-share sprite" title="Share on Facebook">share [fb]</a>
            <a onclick="javascript:twshare()" class="tw-share sprite" title="Share on Twitter">share [tw]</a>
            <a onclick="javascript:pinshare()" class="pin-share sprite" title="Share on Pinterest">share [pin]</a>
            <a data-toggle="modal" href="#edit" class="edit-page" title="Contribute to this Page">contribute</a>
        </div>
    </h1>
</div>

<h2>Upgrades</h2>

<ul>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-571">TOMEE-571</a> Update to OWB 1.1.7</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-629">TOMEE-629</a> myfaces 2.1.10</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-472">TOMEE-472</a> XBean 3.12</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-516">TOMEE-516</a> ShrinkWrap 1.1.1-alpha-1</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-513">TOMEE-513</a> arquillian 1.0.3.Final</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-512">TOMEE-512</a> Shrinkwrap Descriptors 2.0.0.alpha-4</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-511">TOMEE-511</a> Arquilliant Transaction 1.0.0.Alpha2</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-494">TOMEE-494</a> Slf4j 1.7.2</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-453">TOMEE-453</a> Tomcat 7.0.34</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-457">TOMEE-457</a> cxf 2.6.3</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-455">TOMEE-455</a> Was not able to use CXF SOAP client with SalesForce until JAXB upgraded to 2.2.6</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-454">TOMEE-454</a> ActiveMQ 5.7.0</li>
    <li><a href="https://issues.apache.org/jira/browse/OPENEJB-1927">OPENEJB-1927</a> Hibernate 4.1.8.Final</li>
</ul>

<h2>New Features</h2>

<ul>

    <li><a href="https://issues.apache.org/jira/browse/TOMEE-630">TOMEE-630</a> add a maven archetype to start a project with tomee</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-440">TOMEE-440</a> add a tomee test enricher for arquillian tomee adapters</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-600">TOMEE-600</a> ability to inject remote initial context in tomee clients</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-473">TOMEE-473</a> ability to customize a bit more the classloaders</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-460">TOMEE-460</a> allow tomee maven plugin to reload application (war)</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-566">TOMEE-566</a> ability to let openejb/tomee scan entities instead of letting the jpa provider doing it</li>
    <li><a href="https://issues.apache.org/jira/browse/OPENEJB-1902">OPENEJB-1902</a> support shrinkwrap archive as library in openejb arquillian embedded adapter</li>
    <li><a href="https://issues.apache.org/jira/browse/OPENEJB-1906">OPENEJB-1906</a> active by default karaf webconsole in KarafEE</li>
    <li><a href="https://issues.apache.org/jira/browse/OPENEJB-1929">OPENEJB-1929</a> add an openejb lightweight web module to be able to write web tests more easily in embedded mode</li>
    <li><a href="https://issues.apache.org/jira/browse/OPENEJB-1931">OPENEJB-1931</a> support servlet deployment in embedded mode</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4005">AMQ-4005</a> Implement pluggable broker lockers</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3787">AMQ-3787</a> useCompression on server side specially on network of brokers</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3880">AMQ-3880</a> WSS transport</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3298">AMQ-3298</a> Cannot create bridge to WebSphere queue using default messaging provider</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3894">AMQ-3894</a> Add support for Broker based redelivery</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-2106">AMQ-2106</a> Allow broker to evenly distribute message groups among consumers</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3917">AMQ-3917</a> ActiveMQ should support multiple durable subscriptions per Stomp client</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3924">AMQ-3924</a> Allow REST API to connect to the secured broker</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4065">AMQ-4065</a> Add optional destination suffix for the IndividualDeadLetterStrategy</li>
    <li><a href="https://issues.apache.org/jira/browse/CXF-4460">CXF-4460</a> Support static claims globally and per endpoint</li>
    <li><a href="https://issues.apache.org/jira/browse/MYFACES-3612">MYFACES-3612</a> [perf] compress/remove spaces for facelets html markup</li>
    <li><a href="https://issues.apache.org/jira/browse/MYFACES-3636">MYFACES-3636</a> Add new Web Context Parameter to set Resource Buffer Size</li>
</ul>

<h2>Improvements</h2>

<ul>

    <li><a href="https://issues.apache.org/jira/browse/TOMEE-633">TOMEE-633</a> More understandable 'tomee.autoconfig' property to control automatic creation of resources</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-488">TOMEE-488</a> Js JNDI Panel</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-486">TOMEE-486</a> ability to override properties values (system.properties + services) by environment</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-481">TOMEE-481</a> RemoteServer should stop tomcat with Bootstrap stop and not with only the socket</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-482">TOMEE-482</a> Split the "dangerous" parts of the tomee webapp into a secure subdir</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-480">TOMEE-480</a> deploy SOAP webservices using the classloader of the app/webapp containing it</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-500">TOMEE-500</a> tomee-jdbc doesn't handle passwordcipher</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-447">TOMEE-447</a> Using Handlebars</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-627">TOMEE-627</a> when an @Resource injection can't be statisfied the error message is not always explicit</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-476">TOMEE-476</a> Update Bootstrap</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-477">TOMEE-477</a> In Arquillian TomEE ensure test class is useable when using our custom enricher (not only load it)</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-478">TOMEE-478</a> JS should load WebServiceHelperImpl info</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-474">TOMEE-474</a> not persistent amq brokers shouldnt need to specify an empty Datasource parameter in AMQ RA</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-470">TOMEE-470</a> Use less.js</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-559">TOMEE-559</a> TomEE should be able to support the tomee. prefix for properties</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-617">TOMEE-617</a> Have a look if warning due to load webapp classes from tempclassloader couldnt be avoided</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-514">TOMEE-514</a> JSONProvider - default setting of serializeAsArray is true, leading to marshaling error in out-of-the-box CXF configuration</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-510">TOMEE-510</a> shade javax.management.* from mbean annotation api to openejb-api to be able to use it even in OSGi and show it is not (yet) standard</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-596">TOMEE-596</a> provide a way to limit package took into account when using openejb to scan jpa entities</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-462">TOMEE-462</a> avoid to reload classes from appclassloader in tempclassloader</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-464">TOMEE-464</a> lazystopclassloader should call stop after destroyapplication to allow reload without memory leak</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-468">TOMEE-468</a> skip sub folders properly when synchronizing conf/lib/bin in arquillian adapter</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-467">TOMEE-467</a> ability to specify CATALINA_OPTS in arquillian.xml</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-498">TOMEE-498</a> tomee maven plugin can't use removeDefaultWebapps if adding a custom webapp</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-569">TOMEE-569</a> cdi resolution in ear are not complete from webapp</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-499">TOMEE-499</a> OpenEJBContextConfig doesn't handle correctly ROOT webapp</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-565">TOMEE-565</a> set tomee serverinfo</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-567">TOMEE-567</a> Check for invalid attributes in tomee.xml file</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-560">TOMEE-560</a> allow to use a custom bean validation impl in webapps</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-525">TOMEE-525</a> set openejb.jmx.active to false by default</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-490">TOMEE-490</a> Use regular xmlhttp requests is the browser does not support websockets</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-561">TOMEE-561</a> Rethink arquillian-tomee-webapp-remote adapter to reflect user experience with installer</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-563">TOMEE-563</a> better mapping of openejb bootstrap in tomee.sh (to get cipher command...)</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-495">TOMEE-495</a> if a bean is @Local and @LocalBean local business interface are ignored in CDI resolution</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-496">TOMEE-496</a> expose a Single Line Formatter useable with arquillian tomee remote adapter</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-497">TOMEE-497</a> arquillian tomee remote should expose a simpleLog attribute to get more readable log (embedded mode like)</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-452">TOMEE-452</a> resource in context.xml not available</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-612">TOMEE-612</a> use javax.persistence.validation.mode is validationMode is not set in persistence.xml</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-615">TOMEE-615</a> ear cdi and specializations/alternatives</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-611">TOMEE-611</a> if validation mode of jpa is none we shouldn't pass the validation factory to the emf</li>
    <li><a href="https://issues.apache.org/jira/browse/OPENEJB-1924">OPENEJB-1924</a> in arquillian-openejb-embedded release creational context of test class</li>
    <li><a href="https://issues.apache.org/jira/browse/OPENEJB-1925">OPENEJB-1925</a> don't suppose openejb (embedded) is started from app classloader for JULI classes</li>
    <li><a href="https://issues.apache.org/jira/browse/OPENEJB-1926">OPENEJB-1926</a> ignore org.scalatest interfaces</li>
    <li><a href="https://issues.apache.org/jira/browse/OPENEJB-1920">OPENEJB-1920</a> [KARAFEE] imported services in cdi should only be the service on the deployed bundle</li>
    <li><a href="https://issues.apache.org/jira/browse/OPENEJB-1903">OPENEJB-1903</a> managing ShrinkWrap resources in embedded openejb adapter</li>
    <li><a href="https://issues.apache.org/jira/browse/OPENEJB-1921">OPENEJB-1921</a> [KARAFEE] getResources should aggregate instead of returning the first value</li>
    <li><a href="https://issues.apache.org/jira/browse/OPENEJB-1908">OPENEJB-1908</a> [KarafEE] use a transaction manager from OSGi registry</li>
    <li><a href="https://issues.apache.org/jira/browse/OPENEJB-1909">OPENEJB-1909</a> try etc folder if conf folder is not available</li>
    <li><a href="https://issues.apache.org/jira/browse/OPENEJB-1911">OPENEJB-1911</a> ProxyEJB shouldnt add IvmProxy and Serializable interface for all localbean proxies</li>
    <li><a href="https://issues.apache.org/jira/browse/OPENEJB-1912">OPENEJB-1912</a> KarafEE logs</li>
    <li><a href="https://issues.apache.org/jira/browse/OPENEJB-1933">OPENEJB-1933</a> When implicitely creating a non jta or jta datasource for a persistence unit the max initial size should be 5 and not the same than the model to avoid too much netweork bandwith usage</li>
    <li><a href="https://issues.apache.org/jira/browse/OPENEJB-1915">OPENEJB-1915</a> ignore net.sourceforge.cobertura.coveragedata.HasBeenInstrumented for ejb interfaces</li>
    <li><a href="https://issues.apache.org/jira/browse/OPENEJB-1916">OPENEJB-1916</a> KarafEE distribution should come with its bundle in system repo</li>
    <li><a href="https://issues.apache.org/jira/browse/OPENEJB-1913">OPENEJB-1913</a> avoid NPE in OSGi Deployer</li>
    <li><a href="https://issues.apache.org/jira/browse/OPENEJB-1932">OPENEJB-1932</a> basic filter + servletcontextinitializer support for applicationcomposer</li>
    <li><a href="https://issues.apache.org/jira/browse/OPENEJB-1914">OPENEJB-1914</a> revisit slightly the way bundle are retrieved in felix (karafee)</li>
    <li><a href="https://issues.apache.org/jira/browse/OPENEJB-1956">OPENEJB-1956</a> try to get rootUrl for persistence units even with ApplicationComposer</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4003">AMQ-4003</a> Add option to PooledConnectionFactory to control if connection should be created on startup or not</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4004">AMQ-4004</a> activemq-pool - Rename maximumActive option maximumActiveSessionPerConnection</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4008">AMQ-4008</a> Tomcat WARN on shutdown about ThreadLocal not cleared from log4j</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3986">AMQ-3986</a> Allow optimizeDurableTopicPrefetch to be set using resource adapter properties</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3983">AMQ-3983</a> Fix osgi dependency</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3980">AMQ-3980</a> Websocket transport: support increasing the max size of websocket messages</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3696">AMQ-3696</a> Slave broker cannot be stopped in a JDBC Master/Slave configuration within OSGi</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3890">AMQ-3890</a> Turn dependency on fusemq-leveldb optional</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3893">AMQ-3893</a> Adjust topic policy entry in default configuration</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3991">AMQ-3991</a> Output version number in started log line to be consistent</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4027">AMQ-4027</a> Add support for java 7 in AbstractJmxCommand</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4026">AMQ-4026</a> Refactor logic to shutdown thread pools using a single API to ensure better shutdown and offer logging et all</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4029">AMQ-4029</a> Unregistering mbean should handle null mbean names</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4028">AMQ-4028</a> Add support for testing secured web sockets</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3861">AMQ-3861</a> Offer a way to not set a transaction manager in activemq-camel</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4012">AMQ-4012</a> Use english locale for introspection support when discovering setter/getter method names</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4011">AMQ-4011</a> Refactor IntrospectionSupport to avoid using java bean property editors</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4010">AMQ-4010</a> Use pre compiled patterns for JMX ObjectName encoder</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4019">AMQ-4019</a> Make better use of commons-pool in activemq-pool</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4016">AMQ-4016</a> org.apache.activemq.ActiveMQConnectionFactory - Seems like static thread pool is not used</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4015">AMQ-4015</a> Add uptime to broker mbean and when stopping broker to report its uptime</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3877">AMQ-3877</a> Add ability to set a timeout for the calls made to Broker MBeans</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3878">AMQ-3878</a> Reset stats automatically without dependancy on JMX / Java APIs</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3224">AMQ-3224</a> Redelivery per destination</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3770">AMQ-3770</a> Generalize LDAP group processing / LDAP group expansion</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3534">AMQ-3534</a> Fixes to poms to allow eclipse indigo and m2eclipse to not show errors.</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3902">AMQ-3902</a> Documentation for JMS Bridge With Oracle AQ </li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3813">AMQ-3813</a> limit the number of producers and consumers created by a Connection</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3815">AMQ-3815</a> Hybrid Master Slave Architecture</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3918">AMQ-3918</a> Expose transport connector URIs in uniform fashion</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3913">AMQ-3913</a> Stomp Spec allows for stomp headers to have spaces in key or value we currently trim.</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3914">AMQ-3914</a> Add support for MS SQL JDBC driver 4.0</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3940">AMQ-3940</a> REST API - support application/json response type</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4049">AMQ-4049</a> Polish the AMQ start|stop logging</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3847">AMQ-3847</a> Optional import for org.apache.activemq.pool in activemq-camel should be required</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3060">AMQ-3060</a> java.lang.ClassCastException: org.apache.activemq.broker.region.QueueSubscription cannot be cast to org.apache.activemq.broker.region.DurableTopicSubscription</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3950">AMQ-3950</a> Blueprint version should be [0.3,2)</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3859">AMQ-3859</a> To tight version range in activemq features file</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3822">AMQ-3822</a> The current sslContext element does not provide the ability to define the keystore key password key.</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3960">AMQ-3960</a> Update 5.7 to use Apache Camel 2.10.x</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4069">AMQ-4069</a> Upgrade Maven Plugins</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4066">AMQ-4066</a> Cleanup of old deprecated methods and classes from the code base.</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4067">AMQ-4067</a> Prefix Thread names with ActiveMQ</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3554">AMQ-3554</a> activemq:create command should use name as argument in place of option</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4063">AMQ-4063</a> Trim RAR to not included Derby JAR</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4060">AMQ-4060</a> activemq-optional - Upgrade Spring OXM to Spring 3 version</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3972">AMQ-3972</a> Add an 'isDisposed' check before calling 'propagateFailureToExceptionListener' in FailoverTransport</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3444">AMQ-3444</a> Fail Fast or Warn on using fileCursors/fileQueueCursors when <broker persistent="false"></li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4057">AMQ-4057</a> activemq-option - Upgrade to http client 4.2</li>
    <li><a href="https://issues.apache.org/jira/browse/CXF-4488">CXF-4488</a> Making importing com.sun.tools* packages by cxf-rf-databinding-jaxb optional in CXF 2.6</li>
    <li><a href="https://issues.apache.org/jira/browse/CXF-4485">CXF-4485</a> Provide optional support for inheriting WADL resource parameters</li>
    <li><a href="https://issues.apache.org/jira/browse/CXF-4501">CXF-4501</a> AtomPojoProvider should be able to get the entry content directly from POJO</li>
    <li><a href="https://issues.apache.org/jira/browse/CXF-4497">CXF-4497</a> Configure WSDL generation to ignore jaxb.index and ObjectFactory</li>
    <li><a href="https://issues.apache.org/jira/browse/CXF-4495">CXF-4495</a> Extend SimpleAuthorizingInterceptor to check only configured roles</li>
    <li><a href="https://issues.apache.org/jira/browse/CXF-4490">CXF-4490</a> cxf-codegen-plugin does not detect changes in WSDL loaded from classpath</li>
    <li><a href="https://issues.apache.org/jira/browse/CXF-4506">CXF-4506</a> support to set the username and password on the wsn service configuration</li>
    <li><a href="https://issues.apache.org/jira/browse/CXF-4521">CXF-4521</a> Optimization for other stax implementations</li>
    <li><a href="https://issues.apache.org/jira/browse/CXF-4519">CXF-4519</a> Make it possible to specify schemas specific to individual types</li>
    <li><a href="https://issues.apache.org/jira/browse/CXF-3813">CXF-3813</a> Possibiblity to only validate requests and/or responses</li>
    <li><a href="https://issues.apache.org/jira/browse/CXF-4515">CXF-4515</a> maven java2ws plugin address configuration</li>
    <li><a href="https://issues.apache.org/jira/browse/CXF-4479">CXF-4479</a> Improve "No namespace on "{0}" element" error message.</li>
    <li><a href="https://issues.apache.org/jira/browse/CXF-4532">CXF-4532</a> Java First @Policy support bean references</li>
    <li><a href="https://issues.apache.org/jira/browse/CXF-4431">CXF-4431</a> Add support for OAuth2 'mac' token type</li>
    <li><a href="https://issues.apache.org/jira/browse/MYFACES-3623">MYFACES-3623</a> [perf] avoid use HashSet for check empty html elements in HtmlResponseWriterImpl</li>
    <li><a href="https://issues.apache.org/jira/browse/MYFACES-3635">MYFACES-3635</a> [perf] Improvements over #{cc} and #{cc.attrs} evaluation</li>
    <li><a href="https://issues.apache.org/jira/browse/MYFACES-3619">MYFACES-3619</a> Define a special property to specify when a component is created by facelets  ( oam.vf.addedByHandler )</li>
    <li><a href="https://issues.apache.org/jira/browse/MYFACES-3628">MYFACES-3628</a> [perf] do not calculate facelets view mappings and context suffixes if not necessary</li>
    <li><a href="https://issues.apache.org/jira/browse/MYFACES-3645">MYFACES-3645</a> review/refactor/document ViewState handling</li>
</ul>

<h2>Bugs</h2>

<ul>

<li><a href="https://issues.apache.org/jira/browse/TOMEE-578">TOMEE-578</a> Tomee Drop-in WARs installer "install" button points to a bad path </li>
<li><a href="https://issues.apache.org/jira/browse/TOMEE-487">TOMEE-487</a> deployerejb uses home to create unique file, it should be base if temp dir is not writable</li>
<li><a href="https://issues.apache.org/jira/browse/TOMEE-483">TOMEE-483</a> plus and jaxrs webapp doesn't have classes in web-inf/classes</li>
<li><a href="https://issues.apache.org/jira/browse/TOMEE-441">TOMEE-441</a> TomEE doesn't stop with arquillian adapter (remote) under windows</li>
<li><a href="https://issues.apache.org/jira/browse/TOMEE-444">TOMEE-444</a> tomee webapp enricher suppose tomee libs are in <tomee>/lib folder (not the case when using tomcat+tomee webapp)</li>
<li><a href="https://issues.apache.org/jira/browse/TOMEE-443">TOMEE-443</a> MyFaces does not integrate with OWB EL resolver</li>
<li><a href="https://issues.apache.org/jira/browse/TOMEE-446">TOMEE-446</a> Failed to service TomEE as a service on Windows</li>
<li><a href="https://issues.apache.org/jira/browse/TOMEE-445">TOMEE-445</a> @RequestScoped @Stateful EJB beans are not destroyed after request completes</li>
<li><a href="https://issues.apache.org/jira/browse/TOMEE-479">TOMEE-479</a> Can't use custom typed resource references and factories</li>
<li><a href="https://issues.apache.org/jira/browse/TOMEE-475">TOMEE-475</a> tomcat request.isCallerInRole doesn't work</li>
<li><a href="https://issues.apache.org/jira/browse/TOMEE-436">TOMEE-436</a> Getting SEVERE: OpenEJBContextConfig.processAnnotationsFile: failed. on Windows</li>
<li><a href="https://issues.apache.org/jira/browse/TOMEE-515">TOMEE-515</a> NoClassDefFoundError Exception while marshaling data in CXF RS to JSON </li>
<li><a href="https://issues.apache.org/jira/browse/TOMEE-508">TOMEE-508</a> EntityManager dependency considered not passivation capable (CDI spec violation)</li>
<li><a href="https://issues.apache.org/jira/browse/TOMEE-461">TOMEE-461</a> faces-config.xml can't be empty</li>
<li><a href="https://issues.apache.org/jira/browse/TOMEE-466">TOMEE-466</a> "Activation failed" messages for @ConversationScoped @Stateful bean</li>
<li><a href="https://issues.apache.org/jira/browse/TOMEE-624">TOMEE-624</a> ?hen webapp is ROOT rest services can't find the webapp</li>
<li><a href="https://issues.apache.org/jira/browse/TOMEE-598">TOMEE-598</a> (cdi) appscope and singleton are not well destroyed</li>
<li><a href="https://issues.apache.org/jira/browse/TOMEE-469">TOMEE-469</a> Hotkeys listener</li>
<li><a href="https://issues.apache.org/jira/browse/TOMEE-568">TOMEE-568</a> TomEE doesn't support WARDirContext</li>
<li><a href="https://issues.apache.org/jira/browse/TOMEE-564">TOMEE-564</a> Installation page for drop war does not work (old style web ui)</li>
<li><a href="https://issues.apache.org/jira/browse/TOMEE-524">TOMEE-524</a> EARs not re-unpacked on startup when changed</li>
<li><a href="https://issues.apache.org/jira/browse/TOMEE-493">TOMEE-493</a> Regression on TomEE vs Tomcat 7 on Windows native library loading</li>
<li><a href="https://issues.apache.org/jira/browse/TOMEE-521">TOMEE-521</a> EAR modules' default name should not contain the .jar or .war extension</li>
<li><a href="https://issues.apache.org/jira/browse/TOMEE-523">TOMEE-523</a> EAR war file context path should default to /<ear-name>/<module-name>/<servlets>*</li>
<li><a href="https://issues.apache.org/jira/browse/TOMEE-522">TOMEE-522</a> EAR modules' <module-name> ignored</li>
<li><a href="https://issues.apache.org/jira/browse/TOMEE-451">TOMEE-451</a> CDI injection in servlet of a webapp included in an ear doesn't work</li>
<li><a href="https://issues.apache.org/jira/browse/TOMEE-456">TOMEE-456</a> some jndi names are not unbound</li>
<li><a href="https://issues.apache.org/jira/browse/TOMEE-459">TOMEE-459</a> exclusions.list not working properly</li>
<li><a href="https://issues.apache.org/jira/browse/TOMEE-610">TOMEE-610</a> when using <Deployment ...> TomcatJndiBinder doesn't find webcontext in general</li>
<li><a href="https://issues.apache.org/jira/browse/OPENEJB-1905">OPENEJB-1905</a> karafee version is not well filtered in rebranding module</li>
<li><a href="https://issues.apache.org/jira/browse/OPENEJB-1923">OPENEJB-1923</a> openejb main doesn't support parameter with -D inside (A-D for instance)</li>
<li><a href="https://issues.apache.org/jira/browse/OPENEJB-1907">OPENEJB-1907</a> revisit KarafEE import package and shade</li>
<li><a href="https://issues.apache.org/jira/browse/OPENEJB-1928">OPENEJB-1928</a> avoid to load openejb classes with multiple classloader in karafee</li>
<li><a href="https://issues.apache.org/jira/browse/OPENEJB-1930">OPENEJB-1930</a> serialization of timerdata is too strict for manual timers</li>
<li><a href="https://issues.apache.org/jira/browse/OPENEJB-1938">OPENEJB-1938</a> Embedded ActiveMQ broker startup and shutdown fails to observe configured timeout</li>
<li><a href="https://issues.apache.org/jira/browse/OPENEJB-1910">OPENEJB-1910</a> IvmProxy shouldnt be used when creating ejb as OSGi services in KarafEE</li>
<li><a href="https://issues.apache.org/jira/browse/OPENEJB-1934">OPENEJB-1934</a> arquillian-openejb-embedded-4 doesn't manage properly war libraries regarding cdi</li>
<li><a href="https://issues.apache.org/jira/browse/OPENEJB-1954">OPENEJB-1954</a> Arquillian tests don't fail immediately if Test cannot be enriched</li>
<li><a href="https://issues.apache.org/jira/browse/OPENEJB-1959">OPENEJB-1959</a> DeploymentListenerObserver should be public</li>
<li><a href="https://issues.apache.org/jira/browse/OPENEJB-1961">OPENEJB-1961</a> Classloader memory leak by Threads which is started by org.apache.openejb.loader.Files</li>
<li><a href="https://issues.apache.org/jira/browse/OWB-719">OWB-719</a> @Named qualifier is not adhering to CDI spec default naming conventions</li>
<li><a href="https://issues.apache.org/jira/browse/OWB-718">OWB-718</a> Decorator can't call two methods of the delegate object in the same method</li>
<li><a href="https://issues.apache.org/jira/browse/OWB-711">OWB-711</a> Specialization does not deactivate Observer methods in parent class</li>
<li><a href="https://issues.apache.org/jira/browse/OWB-720">OWB-720</a> injections using generic not well managed</li>
<li><a href="https://issues.apache.org/jira/browse/OWB-732">OWB-732</a> ClassLoader leak in WebBeansUtil.isScopeTypeNormalCache</li>
<li><a href="https://issues.apache.org/jira/browse/OWB-713">OWB-713</a> Static observer methods of superclasses are not called when a method with the same name and parameters exists in the subclass</li>
<li><a href="https://issues.apache.org/jira/browse/OWB-725">OWB-725</a> Beans containing a producerMethod are using the wrong CreationalContext</li>
<li><a href="https://issues.apache.org/jira/browse/OWB-734">OWB-734</a> CLONE - AbstractProducer stores CreationalContext</li>
<li><a href="https://issues.apache.org/jira/browse/OWB-724">OWB-724</a> Ambiguous producer methods and fields are not detected due to bug in AbstractProducerBean equals and hashCode</li>
<li><a href="https://issues.apache.org/jira/browse/OWB-722">OWB-722</a> @Typed not respected for beans using generics</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-4001">AMQ-4001</a> activemq karaf feature uses different commons-lang than pom</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-4002">AMQ-4002</a> Instance of BlobTransferPolicy and its URL are being shared among multiple messages</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-4007">AMQ-4007</a> BrokerService TempUsage and StoreUsage Default Values Are Incorrect</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3785">AMQ-3785</a> ActiveMQSslConnectionFactory does not detect ssl request in failover URIs when creating transports</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3989">AMQ-3989</a> ActiveMQSslConnectionFactory.setKeyAndTrustManagers does not work with failover enabled using 5.7 snapshot Jars</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3988">AMQ-3988</a> PooledSession throw Exception at closing</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3987">AMQ-3987</a> For JMSUsecaseTest, incompatible types found   : javax.jms.Message required: org.apache.activemq.Message </li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3985">AMQ-3985</a> ActiveMQConnection temp advisory consumer should use asyncDispatch - can cause deadlock with slow consumers</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3882">AMQ-3882</a> Broker should not send advisories for slow consumers or fast producers if the destination in question is an advisory destination already.</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3881">AMQ-3881</a>  Handy diagnostic script for troubleshooting ActiveMQ problems</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3982">AMQ-3982</a> Overlapping PList iterators can read wrong data or throw exceptions about chunk streams not existing.</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3981">AMQ-3981</a> ActiveMQSslConnectionFactory.java now has apache commons dependency</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3885">AMQ-3885</a> ActiveMQ java client doesn't scale to thousands of queues</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3889">AMQ-3889</a> Body Preview of BytesMessages change when browsed multiple times from QueueViewMbean</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3887">AMQ-3887</a> Occasional Null Pointer Exception during NetworkConnector connection</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3791">AMQ-3791</a> Flexibility, concurrency, security, and compatibility issues in CachedLDAPAuthorizationMap</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3797">AMQ-3797</a> org.apache.activemq.util.StringArrayEditor causes classloader leaks</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3998">AMQ-3998</a> Incorrect reporting of pendingQueueSize of durable subs after reconnect with unacked</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3997">AMQ-3997</a> Memory leak in activemq-pool</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3999">AMQ-3999</a> Unsubscribing durable subs can be blocked on calls to determine store size, contending with active subs</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3994">AMQ-3994</a> DefaultDatabaseLocker will leak pooled connections on link failure</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3891">AMQ-3891</a> Durable subscribers receiving duplicate messages</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3995">AMQ-3995</a> PListTest.testSerialAddIterate runs for over 30 minutes on Hudson nodes</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3895">AMQ-3895</a> Broker sends a STOMP RECEIPT frame although the subscription fails</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3992">AMQ-3992</a> Zero Prefetch consumers increment the Enqueue Counter when the pull times out</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3897">AMQ-3897</a> Stomp 1.1 keep alive does not work with stomp+nio</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3896">AMQ-3896</a> AMQ3622Test throws NumberFormatException on ec2/ubuntu 10.04</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3669">AMQ-3669</a> Pending producer with qMirror, messages are not spooled to disk</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3664">AMQ-3664</a> Not all messages will be acknowledged when optimizeAcknowledge is true</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3860">AMQ-3860</a> doAddMessageReference missing setting priority into prepared statement therefore using wrong index for message itself </li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3868">AMQ-3868</a> ActiveMQ 5.6 - RAR deployment is not working on JBoss6</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3867">AMQ-3867</a> Unable to delete messages whose original destination is virtual topic from web console</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3865">AMQ-3865</a> AjaxTest fails all tests due to line ending differences</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3863">AMQ-3863</a> XA session is returned twice to the pool</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-4017">AMQ-4017</a> Demand Forwarding Bridge uses value of asyncDispatch for advisory consumers</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3871">AMQ-3871</a> Problem in OrderPendingList can lead to message not being deliver after durable sub reconnect.</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3870">AMQ-3870</a> ArrayIndexOutOfBoundsException when using Multi kahaDB (mKahaDB) adapter, per-destination adapters and Topics</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3879">AMQ-3879</a> Temporary queues may be deleted by the wrong connection</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3873">AMQ-3873</a> Occasional deadlock during startup</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3872">AMQ-3872</a> Implement "exactly once" delivery with JDBC and XA in the event of a failure post prepare</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-2521">AMQ-2521</a> Some JMX operations fail with SecurityException with secured broker</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3654">AMQ-3654</a> JDBC Master/Slave : Slave cannot acquire lock when the master loose database connection.</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3633">AMQ-3633</a> [OSGi] activemq-web-console: exception after restart container</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-2453">AMQ-2453</a> start/control-script is not suitable for professional environments</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-4090">AMQ-4090</a> Missing svn:ignores</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-4084">AMQ-4084</a> Linux/Unix Files Have Incorrect EOL When Packaged</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3807">AMQ-3807</a> MBeans are not unregistered under WebSphere</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3908">AMQ-3908</a> StompSslAuthTest.testSubscribeWithReceiptNotAuthorized() fails</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-2656">AMQ-2656</a> ActiveMQInitialConnectionFactory cannot return an XAConnectionFactory</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3909">AMQ-3909</a> Messages sometimes not received by active topic subscriptions</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3903">AMQ-3903</a> Failed to fire fast producer advisory, reason: java.lang.NullPointerException</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3905">AMQ-3905</a> Karaf: activemq:create-broker results in only locally visible broker</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3912">AMQ-3912</a> Durable subs store messages in error with broker attribute persistent="false"</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-4081">AMQ-4081</a> favicon should be handled as binary file in assembly</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-4083">AMQ-4083</a> Consumers in Client Ack sessions can fail to ack expired messages in some cases</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-4076">AMQ-4076</a> sizePrefixDisabled and/or maxFrameSize change in AcriveMq 5.6 broke FilePendingMessageCursor for big messages</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3919">AMQ-3919</a> getDestinationMap does not return temp destinations</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3915">AMQ-3915</a> JMX connector does not bind to a specific host when a connectHost is specified on the managementContext</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-2665">AMQ-2665</a> Durable subscription re-activation failed when keepDurableSubsActive=true.</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3727">AMQ-3727</a> activemq-web-console: AjaxServlet not working in OSGi container</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3921">AMQ-3921</a> Duplicated durable subscriptions after broker retart with option keepDurableSubsActive=true</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3920">AMQ-3920</a> Performance issue with delay policy in DestinationBridge.onMessage</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3923">AMQ-3923</a> Webconsole should import javax.servlet.* too</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3925">AMQ-3925</a> Advisory messages/topics not generated for ActiveMQ.Advisory.FULL or ActiveMQ.Advisory.FastProducer.Queue</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3927">AMQ-3927</a> can't connect to stomp protocol 1.1 using telnet</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3929">AMQ-3929</a> STOMP multiple header handling incorrect per the 1.1 spec</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-2488">AMQ-2488</a> Unable to access Serializable class when receiving ObjectMessage in OSGi environment</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3934">AMQ-3934</a> QueueViewMBean.getMessage throws NullPointerException when message not found</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3932">AMQ-3932</a> receiveNoWait hangs when broker is down, using failover and prefetch=0</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3931">AMQ-3931</a> Memory problems with large transactions</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3935">AMQ-3935</a> JConsole browse() function does not work if useCache=false</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3936">AMQ-3936</a> activemq status return codes should be LSB compliant </li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3939">AMQ-3939</a> FailoverTransport never closes backup connections</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3841">AMQ-3841</a> mKahaDB causes ArrayIndexOutOfBoundsException on restart after deleting existing queues</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3845">AMQ-3845</a> CachedLDAPAuthorizationMap doesn't handle the ldap connectino dying</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3846">AMQ-3846</a> The JMX message move, copy and remove operation do not take messages in FIFO order</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3943">AMQ-3943</a> Connect to ActiveMQ server's jmx feature,but failed.</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-4042">AMQ-4042</a> Rest MessageServlet on osgi failes to start</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3848">AMQ-3848</a> Messages Are Not Read With Multiple Consumers</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-4043">AMQ-4043</a> Web demo - Receive a message page renders an error page</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3849">AMQ-3849</a> Typos in protobuf specs + generated Java code for KahaDB</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-4047">AMQ-4047</a> activemq-optional - Should include the JARs it needs</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-4044">AMQ-4044</a> Shutting down AcitveMQ broker started in foreground logs 2 times</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3852">AMQ-3852</a> Stomp transport allows durable topic subscriber to subscribe to a queue</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3853">AMQ-3853</a> Missing import in activemq-web-console</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3856">AMQ-3856</a> MessageServlet assumes TextMessages contain Text</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3857">AMQ-3857</a> MessageServlet get messages does not return JMS Message Properties</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3854">AMQ-3854</a> Referencing old spring xsd in configuration files</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3855">AMQ-3855</a> MQTT doesn't translate wildcards to ActiveMQ wildcards</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3955">AMQ-3955</a> WebSocket Transport - Race condition starting transport</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3956">AMQ-3956</a> KahaDB pagefile (db.data) steady growth - BTreeIndex page leak</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3953">AMQ-3953</a> org.apache.activemq.util.URISupport.isCompositeURI doesn't work properly.</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3954">AMQ-3954</a> Intended delivery mode for JMSUsecaseTest is not tested</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3951">AMQ-3951</a> LDAP Connection Timeouts in CachedLDAPAuthorizationMap</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3958">AMQ-3958</a> META-INF/spring.schemas does not contain a reference to 5.6.0 schema</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-4030">AMQ-4030</a> Tomcat7 with ActiveMQ-5.6 or ActiveMQ-5.7 starts with error</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-4031">AMQ-4031</a> BrokerFactoryBean logs error when starting a non persistent broker</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3858">AMQ-3858</a> Failure to resolve local jmx url for sunJvm can result in npe</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-4033">AMQ-4033</a> AMQ Broker - Uses custom RMIServerSocketFactory class which cannot be unloaded due socket reuse</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-4035">AMQ-4035</a> Null pointer in class KahaDBStore programmed</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-4070">AMQ-4070</a> catstomp.rb does not work anymore</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3961">AMQ-3961</a> Durable subscriber only receives part of the persisted messages on re-connect</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3962">AMQ-3962</a> Memory leak bacause of InactivityMonitor thread</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-2170">AMQ-2170</a> Incoherent documentation / strange property names for advisory messages</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3965">AMQ-3965</a> Expired msgs not getting acked to broker causing consumer to fill up its prefetch and not getting more msgs.</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3594">AMQ-3594</a> Stuck messages in topic after restart of ActiveMQ</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3557">AMQ-3557</a> Performance of consumption with JDBC persistance and Microsoft SQL Server</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-4062">AMQ-4062</a> durableTopicPrefetch attribute in policyEntry in activemq.xml dont take effect</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3828">AMQ-3828</a> URISupport incorrectly handles parenthesis</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3451">AMQ-3451</a> Tomcat 6.0.32 complains that ActiveMQ 5.5 doesn't shutdown a thread</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3827">AMQ-3827</a> The SslContext definition is not used by the https transport protocol.</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3832">AMQ-3832</a> Upgrade maven-bundle-plugin</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3831">AMQ-3831</a> Exit code is not properly returned when using RUN_AS_USER</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3973">AMQ-3973</a> data.db size is not included in calculation to monitor systemUsage settings</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3976">AMQ-3976</a> ActiveMQMessageProducer::send uses == instead of equals to compare destinations</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3979">AMQ-3979</a> AjaxServlet preventing Tomcat Container from shutting down.  </li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-4058">AMQ-4058</a> http transport should remove options in uri</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-4052">AMQ-4052</a> When consumers was killed and restarted frequently, some messages could not be consumed by consumer but they were still in pending messages.</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3837">AMQ-3837</a> BrokerFacade returns more connections than expect when call  getConnections by connector name</li>
<li><a href="https://issues.apache.org/jira/browse/AMQ-3836">AMQ-3836</a> STOMP 1.0 protocol (SUBSCRIBE destination) broken on ActiveMQ 5.6.0</li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4541">CXF-4541</a> idl2wsdl not finding properly scoped structure elements</li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4542">CXF-4542</a> @XmlJavaTypeAdapter ignored on exception classes </li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4540">CXF-4540</a> Colon character in the password is not hanled properly in AbstractHTTPDestination class</li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4545">CXF-4545</a> ut_sign + sign_enc samples broken in last releases</li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4484">CXF-4484</a> Claims to SAML attribute encoding wrong</li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4487">CXF-4487</a> cxf-codegen-plugin: Error resolving component warnings for imported types</li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4481">CXF-4481</a> unable to generate WADL to java </li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4500">CXF-4500</a> Evaluate jaxrs:schemaLocations after jaxrs:providers</li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4539">CXF-4539</a> WS-Security inbound performance regression</li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4537">CXF-4537</a> XmlAdapter Not Being Used</li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4552">CXF-4552</a> typical HTML form payload does not seem to work when HTML form is used</li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4499">CXF-4499</a> wrong charset encoding in FormEncodingProvider </li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4496">CXF-4496</a> find of ResponseExceptionMapper do not handle runtime exceptions</li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4494">CXF-4494</a> JMSDestination need set binary mode if server send MTOM message back</li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4493">CXF-4493</a> If javax.jws.Oneway annotation is specified for a SOAP interface method a NPE occurs</li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4511">CXF-4511</a> WS-RM Sequence header should have mustUnderstand attribute</li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4503">CXF-4503</a> TransformOutInterceptor may lose namespace declarations in some elements</li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4505">CXF-4505</a> Invalid WS-RM messages may not be correctly rejected by WS-RM destination</li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4507">CXF-4507</a> bug in SchemaJavascriptBuilder while deserializing an Array</li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4508">CXF-4508</a> @Context fails to inject SearchContext into JAX-RS resource bean</li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4523">CXF-4523</a> Unclosed XMLStreamReader/Writer causes leaking</li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4522">CXF-4522</a> The logicalHandler could not modify the soap:body content if provider uses the SOAPMessage</li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4520">CXF-4520</a> XMLStreamException about namespace has not been bound to a prefix with other stax implemenation</li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4518">CXF-4518</a> CXF bundle jax-ws-catalog.xml doesn't include mapping of "http://www.w3.org/2006/03/addressing" </li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4517">CXF-4517</a> ClassCastException in WS-RM when RMP 200702  assertions are used</li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4514">CXF-4514</a> JAXRS client ignores enum properties when populating request URI from beans</li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4476">CXF-4476</a> Content-Disposition header may be incorrectly set in MTOM under windows </li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4475">CXF-4475</a> LoggingInInterceptor throws when pretty printing MTOM messages</li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4477">CXF-4477</a> [WADL2JAVA] Generate incorrect primitive parameter type </li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4533">CXF-4533</a> Encoding error in CachedOutputStream when double-byte char is on 1024 byte boundary</li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4535">CXF-4535</a> SOAP fault XML is invalid when a details element exists</li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4534">CXF-4534</a> SortedMap is returned as HashMap</li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4526">CXF-4526</a> PolicyAnnotationListener throws NPE in jar</li>
<li><a href="https://issues.apache.org/jira/browse/CXF-4528">CXF-4528</a> WebApplicationExceptionMapper is too shy</li>
<li><a href="https://issues.apache.org/jira/browse/MYFACES-3620">MYFACES-3620</a> jsf.js: @this results in a javascript error</li>
<li><a href="https://issues.apache.org/jira/browse/MYFACES-3638">MYFACES-3638</a> NPE in ServerSideStateCacheImpl</li>
<li><a href="https://issues.apache.org/jira/browse/MYFACES-3646">MYFACES-3646</a> remove unused src/main/old from core-impl</li>
<li><a href="https://issues.apache.org/jira/browse/MYFACES-3637">MYFACES-3637</a> jsf.js: All Script Tags are Evaluated (wrong behavior)</li>
<li><a href="https://issues.apache.org/jira/browse/MYFACES-3649">MYFACES-3649</a> myfaces-shaded-impl always unpacks myfaces-2.1.1</li>
<li><a href="https://issues.apache.org/jira/browse/MYFACES-3630">MYFACES-3630</a> PartialViewContextImpl.findHeadComponent and findBodyComponent does not take into account h:head or h:body inside child of UIViewRoot</li>
<li><a href="https://issues.apache.org/jira/browse/MYFACES-3617">MYFACES-3617</a> NullPointerException occurs when using an EL Expression in f:viewParam name attribute</li>
<li><a href="https://issues.apache.org/jira/browse/MYFACES-3641">MYFACES-3641</a> ViewDeclarationLanguageFactoryImpl.getViewDeclarationLanguage(String viewId) should not throw exception if no associate VDL can be found</li>
<li><a href="https://issues.apache.org/jira/browse/MYFACES-3618">MYFACES-3618</a> jsf.js: ajax response is missing a param in the error handing of replaceHtmlItem</li>
<li><a href="https://issues.apache.org/jira/browse/MYFACES-3616">MYFACES-3616</a> Javascript: Method call with wrong argument size after error in AJAX request/response</li>
<li><a href="https://issues.apache.org/jira/browse/MYFACES-3613">MYFACES-3613</a> NPE in composite component when ActionListener is missing in the source</li>
<li><a href="https://issues.apache.org/jira/browse/MYFACES-3626">MYFACES-3626</a> f:ajax execute '@none' submitted as explicit request param, firing source listeners</li>
<li><a href="https://issues.apache.org/jira/browse/MYFACES-3632">MYFACES-3632</a> resource bundle name with bean property collition when trying to set value</li>
<li><a href="https://issues.apache.org/jira/browse/MYFACES-3631">MYFACES-3631</a> Malformed Ajax XML Response with duplicated IDs</li>
<li><a href="https://issues.apache.org/jira/browse/MYFACES-3627">MYFACES-3627</a> jsf.js: DomExperimental.js isMultipartCandidate fails on older IE Versions</li>
</ul>

<h2>Tasks & Sub-Tasks</h2>

<ul>



    <li><a href="https://issues.apache.org/jira/browse/TOMEE-442">TOMEE-442</a> valid using hostname in webapp id is fine</li>
    <li><a href="https://issues.apache.org/jira/browse/TOMEE-439">TOMEE-439</a> refactor DeployerEjb to be able to deploy war as Tomcat</li>
    <li><a href="https://issues.apache.org/jira/browse/OPENEJB-1922">OPENEJB-1922</a> [KARAFEE] see how to take into account cdi dependencies</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4006">AMQ-4006</a> activemq-pool - Upgrade to commons-pool 1.6.0</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3784">AMQ-3784</a> Download page lists lots of releases; they are not in order and most of the pages point to the wrong location</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4013">AMQ-4013</a> Upgrade to xbean 3.11</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4041">AMQ-4041</a> Upgrade ActiveMQ karaf feature</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4045">AMQ-4045</a> Unit test shows NPE in BrokerService</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4038">AMQ-4038</a> Favor using JARs from Maven central</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4039">AMQ-4039</a> Upgrade 3rd party dependency JARs and align with SMX/Camel</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4056">AMQ-4056</a> Remove activemq-jmdns module</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-4053">AMQ-4053</a> Cleanup duplicate JARs in ActiveMQ distro</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3945">AMQ-3945</a> QueueBrowser missing messages on first browse.</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3947">AMQ-3947</a> ActiveMQConnectionFactory doesn't set the nestedMapAndListEnabled property on new Connections</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3967">AMQ-3967</a> ActiveMQJmsHeaderRouteTest doesn't work with Apache Camel 2.10</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3969">AMQ-3969</a> ActiveMQJmsHeaderRouteTest doesn't work with Apache Camel 2.10</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3968">AMQ-3968</a> ActiveMQJmsHeaderRouteTest doesn't work with Apache Camel 2.10</li>
    <li><a href="https://issues.apache.org/jira/browse/AMQ-3970">AMQ-3970</a> ActiveMQJmsHeaderRouteTest doesn't work with Apache Camel 2.10</li>

</ul>




        <div id="edit" class="modal hide fade in" style="display: none; ">
            <div class="modal-header">
                <a class="close" data-dismiss="modal">x</a>

                <h3>Thank you for contributing to the documentation!</h3>
            </div>
            <div class="modal-body">
                <h4>Any help with the documentation is greatly appreciated.</h4>
                <p>All edits are reviewed before going live, so feel free to do much more than fix typos or links.  If you see a page that could benefit from an entire rewrite, we'd be thrilled to review it.  Don't be surprised if we like it so much we ask you for help with other pages :)</p>
                <small>NOTICE: unless indicated otherwise on the pages in question, all editable content available from apache.org is presumed to be licensed under the Apache License (AL) version 2.0 and hence all submissions to apache.org treated as formal Contributions under the license terms.</small>
                <!--[if gt IE 6]>
                <h4>Internet Explorer Users</h4>
                <p>If you are not an Apache committer, click the Yes link and enter a <i>anonymous</i> for the username and leave the password empty</p>
                <![endif]-->

            </div>
            <div class="modal-footer">
                Do you have an Apache ID?
                <a href="javascript:void(location.href='https://cms.apache.org/redirect?uri='+escape(location.href))" class="btn">Yes</a>
                <a href="javascript:void(location.href='https://anonymous:@cms.apache.org/redirect?uri='+escape(location.href))" class="btn">No</a>
            </div>
        </div>
        <script src="./resources/js/bootstrap-modal.js"></script>

        <footer>
            <p>Copyright &copy; 1999-2016 The Apache Software Foundation, Licensed under the Apache License, Version 2.0.
                Apache TomEE, TomEE, Apache, the Apache feather logo, and the Apache TomEE project logo are trademarks of The Apache Software Foundation.
                All other marks mentioned may be trademarks or registered trademarks of their respective owners.</p>
        </footer>

    </div> <!-- /container -->

    <!-- Javascript
    ================================================== -->
    <!-- Placed at the end of the document so the pages load faster -->
    <script src="./resources/js/bootstrap-dropdown.js"></script>

  </body>
</html>
