<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML Basic 1.1//EN" "http://www.w3.org/TR/xhtml-basic/xhtml-basic11.dtd">
<!--
  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.
  Architecture
-->
<html lang="en">
<head>
    <meta content="text/html; charset=utf-8" http-equiv="Content-Type"/>
    <meta content="ActiveMQ's next generation of messaging" name="description"/>
    <meta content="messaging,stomp,jms,activemq" name="keywords"/>
    <meta content="ActiveMQ" name="author"/>
    <link type="text/css" rel="stylesheet" href="styles/impact/css/pygmentize.css"/>
    <link type="text/css" rel="stylesheet" href="styles/impact/css/site.css"/>

    <style type='text/css'>
        /* <![CDATA[ */
        .download {
        font-size: 80%;
        }
        table.download { width: 100%;}
        table.download tr td {
        border: 1px solid #ccc;
        padding: .5em;
        }
        /* ]]> */
    </style>

    <title>ActiveMQ Artemis Release Notes 2.3.0</title>
</head>
<body>
<div id="navigation">
    <div class="wrapper">
        <ul>
            <li><a href="index.html">ActiveMQ Artemis</a></li>
            <li><a href="docs.html">Documentation</a></li>
            <li><a href="download.html">Download</a></li>
        </ul>
    </div>
</div>
<div id="overview">
    <div class="wrapper">
        <div class="logo">
            <img src="images/activemq-logo.png" alt="ActiveMQ logo"/>
        </div>
        <div class="message">
            <h1>ActiveMQ Artemis</h1>
        </div>
    </div>
</div>
<div id="content">
    <div class="wrapper">
        <h2 id="release-notes---apache-activemq-artemis-2.4.0">Release Notes - Apache ActiveMQ Artemis 2.4.0</h2>
    </div>
    <div class="wrapper">
        <p>A complete list of JIRAs for the 2.4.0 release can be found <a href=https://issues.apache.org/jira/secure/ReleaseNote.jspa?version=12341540&projectId=12315920>here.</a>
            </p>
                                
<h2>        Bug
</h2>
<ul>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-450'>ARTEMIS-450</a>] -         Deadlocked broker over addHead and Rollback with AMQP
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1218'>ARTEMIS-1218</a>] -         Add support for MQTT &quot;link stealing&quot; (MQTT-3.1.4-2)
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1227'>ARTEMIS-1227</a>] -         Internal properties not removed from messages
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1314'>ARTEMIS-1314</a>] -         Using the message filter with JMSCorrelationID seems not to work
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1352'>ARTEMIS-1352</a>] -         Artemis 2.2.0, createTopic create an anycast queue when there is no consumer created
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1366'>ARTEMIS-1366</a>] -         Openwire consumer is listed twice in hawtio console, consuming from Advisory &amp; requested queue/address
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1382'>ARTEMIS-1382</a>] -         Log messages without prefixed id code in artemis-server
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1391'>ARTEMIS-1391</a>] -         Embedding two instances of Artemis as MQTT broker doesn&#39;t work
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1393'>ARTEMIS-1393</a>] -         CriticalAnalyzer timeout uses System::currentTimeMillis
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1395'>ARTEMIS-1395</a>] -         FindBugs: Dubious method used: System.exit() in CoreMessage#toString()
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1397'>ARTEMIS-1397</a>] -         io.netty.buffer.UnpooledUnsafeDirectByteBufWrapper not found when running in an OSGI container
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1398'>ARTEMIS-1398</a>] -         MQTT client sending wrong password will hang indefinitely, broker logs Error disconnecting client: null
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1400'>ARTEMIS-1400</a>] -         FindBugs warnings
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1401'>ARTEMIS-1401</a>] -         Numerical overflow fix when using System::nanoTime
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1403'>ARTEMIS-1403</a>] -         Wildcard matching should always respect delimiters
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1405'>ARTEMIS-1405</a>] -         PurgeOnNoConsumer queue config is not persisted on restart
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1407'>ARTEMIS-1407</a>] -         FindBugs: Suspicious calls to generic collection methods in AMQPConnectionCallback.java
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1410'>ARTEMIS-1410</a>] -         Coverity: Identical code for different branches
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1413'>ARTEMIS-1413</a>] -         JMSDeliveryMode/Priority is lost when AMQP Producer and CORE Consumer
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1417'>ARTEMIS-1417</a>] -         Failback not working on NFSv4
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1418'>ARTEMIS-1418</a>] -         AIOSequentialFile does not throw Critical IO in several places
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1419'>ARTEMIS-1419</a>] -         OpenWire advisory message never deleted
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1421'>ARTEMIS-1421</a>] -         Duplicate queue in XML possible
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1422'>ARTEMIS-1422</a>] -         Support wildcard config for address matching
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1424'>ARTEMIS-1424</a>] -         Openwire not work with different tightEncoding options
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1425'>ARTEMIS-1425</a>] -         Unable to purge messages in queue (via hawtio)
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1431'>ARTEMIS-1431</a>] -         AMQ154003: Unable to reconnect org.apache.activemq.artemis.ra.inflow.ActiveMQActivationSpec
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1438'>ARTEMIS-1438</a>] -         Upgrade hawtio to 1.5.4
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1440'>ARTEMIS-1440</a>] -         Artemis broker.forceFailover not shutting down broker
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1441'>ARTEMIS-1441</a>] -         Critical Analyzer checkPeriod is not properly parsed
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1442'>ARTEMIS-1442</a>] -         Server should shut itself down if can&#39;t open new file
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1443'>ARTEMIS-1443</a>] -         When running Artemis in OSGI specifying CORE protocol causes it not to start
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1444'>ARTEMIS-1444</a>] -         Large messages are not working with OpenWire protocol
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1445'>ARTEMIS-1445</a>] -         Auto-created addresses and queues are not being auto-deleted for AMQP and OpenWire clients
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1448'>ARTEMIS-1448</a>] -         Core to JMS message fails to convert priority
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1450'>ARTEMIS-1450</a>] -         InitialMessagePacketSize property can not be set on ConnectionFactoryConfiguration
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1455'>ARTEMIS-1455</a>] -         HQ222142: Error on resetting large message deliver - null: java.lang.NullPointerException
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1456'>ARTEMIS-1456</a>] -         createQueue(null, ...) is failing, even though documentation says this is valid call
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1457'>ARTEMIS-1457</a>] -         Diverts are not working with Openwire protocol
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1461'>ARTEMIS-1461</a>] -         Allow Property changes on AMQP message and reencode
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1464'>ARTEMIS-1464</a>] -         Core to AMQP conversion BytesMessage corrupts bytes
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1468'>ARTEMIS-1468</a>] -         Address can&#39;t be deleted via management console
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1470'>ARTEMIS-1470</a>] -         Console move message broken
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1473'>ARTEMIS-1473</a>] -         System property BROKER_BIND_URL with parameters will not work if AMQ_USER and AMQ_PASSWORD also set
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1475'>ARTEMIS-1475</a>] -         NPE when deploying 2 MDBs with same clientID/subscriptionName
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1479'>ARTEMIS-1479</a>] -         Set validated user in all messages
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1480'>ARTEMIS-1480</a>] -         Console purge Queue is broken
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1482'>ARTEMIS-1482</a>] -         Catch malformed simple string
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1483'>ARTEMIS-1483</a>] -         Upgrade beanutils
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1484'>ARTEMIS-1484</a>] -         Live&#39;s topology update may be ignored
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1490'>ARTEMIS-1490</a>] -         Race on deleteAddress when autocreated
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1491'>ARTEMIS-1491</a>] -         multiple Jolokia instances shipped
</li>
</ul>
                                    
<h2>        Improvement
</h2>
<ul>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1318'>ARTEMIS-1318</a>] -         Uses unbuffered MAPPED Journal if no data-sync is required
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1390'>ARTEMIS-1390</a>] -         2 minute delay in hawtio startup on host with no internet access
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1420'>ARTEMIS-1420</a>] -         enforce timeout on network client handshake
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1423'>ARTEMIS-1423</a>] -         [ActiveMQServerControl.listQueues(), filtering ] add numeric filtering for ActiveMQServerControl.listQueues() 
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1433'>ARTEMIS-1433</a>] -         expose total Address memory usage in JMX
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1435'>ARTEMIS-1435</a>] -         Expose the Jolokia security configuration for the web console
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1436'>ARTEMIS-1436</a>] -         update CLI StatQueue to allow greater_than/less_than operations
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1439'>ARTEMIS-1439</a>] -         Upgrade to Netty 4.1.16.Final
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1446'>ARTEMIS-1446</a>] -         Support passing in properties to Transformers for configuration
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1451'>ARTEMIS-1451</a>] -         Remove synchronization on ActiveMQThreadPoolExecutor
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1452'>ARTEMIS-1452</a>] -         Journal Configuration Improvements
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1454'>ARTEMIS-1454</a>] -         Support SASL in outgoing AMQP connections
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1465'>ARTEMIS-1465</a>] -         Improve MQTT protocol logging
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1469'>ARTEMIS-1469</a>] -         Support trusting any SSL client certificate for testing purposes
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1474'>ARTEMIS-1474</a>] -         TimedBuffer improved doc and refactored dead brenches on methods
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1476'>ARTEMIS-1476</a>] -         HdrHistogram support on verbose SyncCalculation
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1477'>ARTEMIS-1477</a>] -         Remove netty-all dependency from clients
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1481'>ARTEMIS-1481</a>] -         Update to hawtio 1.5.5
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1485'>ARTEMIS-1485</a>] -         ActiveMQTestBase.threadDump should print information about locks and deadlocks
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1489'>ARTEMIS-1489</a>] -         Add TimedBuffer to Critical Analyzer
</li>
</ul>
            
<h2>        New Feature
</h2>
<ul>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-534'>ARTEMIS-534</a>] -         Allow JMX configuration from broker.xml
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1428'>ARTEMIS-1428</a>] -         Allow configuration of max frame payload length for STOMP web-socket
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1447'>ARTEMIS-1447</a>] -         JDBC NodeManager to support JDBC HA Shared Store
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1463'>ARTEMIS-1463</a>] -         Implement rbac of management objects
</li>
</ul>
                                                                    
<h2>        Task
</h2>
<ul>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1426'>ARTEMIS-1426</a>] -         Update stomp.js in chat example
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1432'>ARTEMIS-1432</a>] -         update to qpid-jms 0.25.0 and proton-j 0.22.0
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1434'>ARTEMIS-1434</a>] -         handle edge cases when driving transport#tick(now) with nanoTime derived values
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1453'>ARTEMIS-1453</a>] -         AMQP: Update Qpid JMS to latest 0.26.0 release
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1462'>ARTEMIS-1462</a>] -         Allow ActiveMQScheduledComponent initial delay configuration
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1466'>ARTEMIS-1466</a>] -         Upgrade Node.js version to comply with GitBook 3.2.3
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1467'>ARTEMIS-1467</a>] -         Create example for bridging messages from the 5.x broker to Artemis
</li>
<li>[<a href='https://issues.apache.org/jira/browse/ARTEMIS-1488'>ARTEMIS-1488</a>] -         Add &quot;all&quot; client jar to distribution
</li>
</ul>
                


    </div>
</div>
</body>
</html>
