
<!DOCTYPE HTML>
<html lang="" >
    <head>
        <meta charset="UTF-8">
        <meta content="text/html; charset=utf-8" http-equiv="Content-Type">
        <title>Configuration Reload · ActiveMQ Artemis Documentation</title>
        <meta http-equiv="X-UA-Compatible" content="IE=edge" />
        <meta name="description" content="">
        <meta name="generator" content="GitBook 3.2.3">
        
        
        
    
    <link rel="stylesheet" href="gitbook/style.css">

    
            
                
                <link rel="stylesheet" href="gitbook/gitbook-plugin-highlight/website.css">
                
            
                
                <link rel="stylesheet" href="gitbook/gitbook-plugin-search/search.css">
                
            
                
                <link rel="stylesheet" href="gitbook/gitbook-plugin-fontsettings/website.css">
                
            
        

    

    
        
    
        
    
        
    
        
    
        
    
        
    

        
    
    
    <meta name="HandheldFriendly" content="true"/>
    <meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no">
    <meta name="apple-mobile-web-app-capable" content="yes">
    <meta name="apple-mobile-web-app-status-bar-style" content="black">
    <link rel="apple-touch-icon-precomposed" sizes="152x152" href="gitbook/images/apple-touch-icon-precomposed-152.png">
    <link rel="shortcut icon" href="gitbook/images/favicon.ico" type="image/x-icon">

    
    <link rel="next" href="connection-ttl.html" />
    
    
    <link rel="prev" href="configuring-transports.html" />
    

    </head>
    <body>
        
<div class="book">
    <div class="book-summary">
        
            
<div id="book-search-input" role="search">
    <input type="text" placeholder="Type to search" />
</div>

            
                <nav role="navigation">
                


<ul class="summary">
    
    

    

    
        
        
    
        <li class="chapter " data-level="1.1" data-path="./">
            
                <a href="./">
            
                    
                    Introduction
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.2" data-path="notice.html">
            
                <a href="notice.html">
            
                    
                    Legal Notice
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.3" data-path="preface.html">
            
                <a href="preface.html">
            
                    
                    Preface
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.4" data-path="project-info.html">
            
                <a href="project-info.html">
            
                    
                    Project Info
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.5" data-path="versions.html">
            
                <a href="versions.html">
            
                    
                    Versions
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.6" data-path="messaging-concepts.html">
            
                <a href="messaging-concepts.html">
            
                    
                    Messaging Concepts
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.7" data-path="architecture.html">
            
                <a href="architecture.html">
            
                    
                    Architecture
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.8" data-path="using-server.html">
            
                <a href="using-server.html">
            
                    
                    Using the Server
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.9" data-path="upgrading.html">
            
                <a href="upgrading.html">
            
                    
                    Upgrading
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.10" data-path="address-model.html">
            
                <a href="address-model.html">
            
                    
                    Address Model
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.11" data-path="protocols-interoperability.html">
            
                <a href="protocols-interoperability.html">
            
                    
                    Protocols and Interoperability
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.12" data-path="amqp.html">
            
                <a href="amqp.html">
            
                    
                    AMQP
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.13" data-path="mqtt.html">
            
                <a href="mqtt.html">
            
                    
                    MQTT
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.14" data-path="stomp.html">
            
                <a href="stomp.html">
            
                    
                    STOMP
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.15" data-path="openwire.html">
            
                <a href="openwire.html">
            
                    
                    OpenWire
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.16" data-path="core.html">
            
                <a href="core.html">
            
                    
                    Core
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.17" data-path="jms-core-mapping.html">
            
                <a href="jms-core-mapping.html">
            
                    
                    Mapping JMS Concepts to the Core API
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.18" data-path="using-jms.html">
            
                <a href="using-jms.html">
            
                    
                    Using JMS
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.19" data-path="client-classpath.html">
            
                <a href="client-classpath.html">
            
                    
                    The Client Classpath
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.20" data-path="examples.html">
            
                <a href="examples.html">
            
                    
                    Examples
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.21" data-path="wildcard-routing.html">
            
                <a href="wildcard-routing.html">
            
                    
                    Routing Messages With Wild Cards
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.22" data-path="wildcard-syntax.html">
            
                <a href="wildcard-syntax.html">
            
                    
                    Wildcard Syntax
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.23" data-path="filter-expressions.html">
            
                <a href="filter-expressions.html">
            
                    
                    Filter Expressions
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.24" data-path="persistence.html">
            
                <a href="persistence.html">
            
                    
                    Persistence
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.25" data-path="configuring-transports.html">
            
                <a href="configuring-transports.html">
            
                    
                    Configuring Transports
            
                </a>
            

            
        </li>
    
        <li class="chapter active" data-level="1.26" data-path="config-reload.html">
            
                <a href="config-reload.html">
            
                    
                    Configuration Reload
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.27" data-path="connection-ttl.html">
            
                <a href="connection-ttl.html">
            
                    
                    Detecting Dead Connections
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.28" data-path="slow-consumers.html">
            
                <a href="slow-consumers.html">
            
                    
                    Detecting Slow Consumers
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.29" data-path="network-isolation.html">
            
                <a href="network-isolation.html">
            
                    
                    Avoiding Network Isolation
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.30" data-path="critical-analysis.html">
            
                <a href="critical-analysis.html">
            
                    
                    Detecting Broker Issues (Critical Analysis)
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.31" data-path="transaction-config.html">
            
                <a href="transaction-config.html">
            
                    
                    Resource Manager Configuration
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.32" data-path="flow-control.html">
            
                <a href="flow-control.html">
            
                    
                    Flow Control
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.33" data-path="send-guarantees.html">
            
                <a href="send-guarantees.html">
            
                    
                    Guarantees of sends and commits
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.34" data-path="undelivered-messages.html">
            
                <a href="undelivered-messages.html">
            
                    
                    Message Redelivery and Undelivered Messages
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.35" data-path="message-expiry.html">
            
                <a href="message-expiry.html">
            
                    
                    Message Expiry
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.36" data-path="large-messages.html">
            
                <a href="large-messages.html">
            
                    
                    Large Messages
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.37" data-path="paging.html">
            
                <a href="paging.html">
            
                    
                    Paging
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.38" data-path="scheduled-messages.html">
            
                <a href="scheduled-messages.html">
            
                    
                    Scheduled Messages
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.39" data-path="last-value-queues.html">
            
                <a href="last-value-queues.html">
            
                    
                    Last-Value Queues
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.40" data-path="ring-queues.html">
            
                <a href="ring-queues.html">
            
                    
                    Ring Queues
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.41" data-path="retroactive-addresses.html">
            
                <a href="retroactive-addresses.html">
            
                    
                    Retroactive Addresses
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.42" data-path="exclusive-queues.html">
            
                <a href="exclusive-queues.html">
            
                    
                    Exclusive Queues
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.43" data-path="message-grouping.html">
            
                <a href="message-grouping.html">
            
                    
                    Message Grouping
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.44" data-path="consumer-priority.html">
            
                <a href="consumer-priority.html">
            
                    
                    Consumer Priority
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.45" data-path="pre-acknowledge.html">
            
                <a href="pre-acknowledge.html">
            
                    
                    Extra Acknowledge Modes
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.46" data-path="management.html">
            
                <a href="management.html">
            
                    
                    Management
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.47" data-path="management-console.html">
            
                <a href="management-console.html">
            
                    
                    Management Console
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.48" data-path="metrics.html">
            
                <a href="metrics.html">
            
                    
                    Metrics
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.49" data-path="security.html">
            
                <a href="security.html">
            
                    
                    Security
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.50" data-path="masking-passwords.html">
            
                <a href="masking-passwords.html">
            
                    
                    Masking Passwords
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.51" data-path="broker-plugins.html">
            
                <a href="broker-plugins.html">
            
                    
                    Broker Plugins
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.52" data-path="resource-limits.html">
            
                <a href="resource-limits.html">
            
                    
                    Resource Limits
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.53" data-path="jms-bridge.html">
            
                <a href="jms-bridge.html">
            
                    
                    The JMS Bridge
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.54" data-path="client-reconnection.html">
            
                <a href="client-reconnection.html">
            
                    
                    Client Reconnection and Session Reattachment
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.55" data-path="diverts.html">
            
                <a href="diverts.html">
            
                    
                    Diverting and Splitting Message Flows
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.56" data-path="core-bridges.html">
            
                <a href="core-bridges.html">
            
                    
                    Core Bridges
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.57" data-path="transformers.html">
            
                <a href="transformers.html">
            
                    
                    Transformers
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.58" data-path="duplicate-detection.html">
            
                <a href="duplicate-detection.html">
            
                    
                    Duplicate Message Detection
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.59" data-path="clusters.html">
            
                <a href="clusters.html">
            
                    
                    Clusters
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.60" data-path="federation.html">
            
                <a href="federation.html">
            
                    
                    Federation
            
                </a>
            

            
            <ul class="articles">
                
    
        <li class="chapter " data-level="1.60.1" data-path="federation-address.html">
            
                <a href="federation-address.html">
            
                    
                    Address Federation
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.60.2" data-path="federation-queue.html">
            
                <a href="federation-queue.html">
            
                    
                    Queue Federation
            
                </a>
            

            
        </li>
    

            </ul>
            
        </li>
    
        <li class="chapter " data-level="1.61" data-path="ha.html">
            
                <a href="ha.html">
            
                    
                    High Availability and Failover
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.62" data-path="graceful-shutdown.html">
            
                <a href="graceful-shutdown.html">
            
                    
                    Graceful Server Shutdown
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.63" data-path="libaio.html">
            
                <a href="libaio.html">
            
                    
                    Libaio Native Libraries
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.64" data-path="thread-pooling.html">
            
                <a href="thread-pooling.html">
            
                    
                    Thread management
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.65" data-path="web-server.html">
            
                <a href="web-server.html">
            
                    
                    Embedded Web Server
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.66" data-path="logging.html">
            
                <a href="logging.html">
            
                    
                    Logging
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.67" data-path="rest.html">
            
                <a href="rest.html">
            
                    
                    REST Interface
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.68" data-path="embedding-activemq.html">
            
                <a href="embedding-activemq.html">
            
                    
                    Embedding the Broker
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.69" data-path="karaf.html">
            
                <a href="karaf.html">
            
                    
                    Apache Karaf
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.70" data-path="tomcat.html">
            
                <a href="tomcat.html">
            
                    
                    Apache Tomcat
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.71" data-path="spring-integration.html">
            
                <a href="spring-integration.html">
            
                    
                    Spring Integration
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.72" data-path="cdi-integration.html">
            
                <a href="cdi-integration.html">
            
                    
                    CDI Integration
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.73" data-path="intercepting-operations.html">
            
                <a href="intercepting-operations.html">
            
                    
                    Intercepting Operations
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.74" data-path="data-tools.html">
            
                <a href="data-tools.html">
            
                    
                    Data Tools
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.75" data-path="maven-plugin.html">
            
                <a href="maven-plugin.html">
            
                    
                    Maven Plugin
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.76" data-path="unit-testing.html">
            
                <a href="unit-testing.html">
            
                    
                    Unit Testing
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.77" data-path="perf-tuning.html">
            
                <a href="perf-tuning.html">
            
                    
                    Troubleshooting and Performance Tuning
            
                </a>
            

            
        </li>
    
        <li class="chapter " data-level="1.78" data-path="configuration-index.html">
            
                <a href="configuration-index.html">
            
                    
                    Configuration Reference
            
                </a>
            

            
        </li>
    

    

    <li class="divider"></li>

    <li>
        <a href="https://www.gitbook.com" target="blank" class="gitbook-link">
            Published with GitBook
        </a>
    </li>
</ul>


                </nav>
            
        
    </div>

    <div class="book-body">
        
            <div class="body-inner">
                
                    

<div class="book-header" role="navigation">
    

    <!-- Title -->
    <h1>
        <i class="fa fa-circle-o-notch fa-spin"></i>
        <a href="." >Configuration Reload</a>
    </h1>
</div>




                    <div class="page-wrapper" tabindex="-1" role="main">
                        <div class="page-inner">
                            
<div id="book-search-results">
    <div class="search-noresults">
    
                                <section class="normal markdown-section">
                                
                                <h1 id="configuration-reload">Configuration Reload</h1>
<p>The system will perform a periodic check on the configuration files, configured
by <code>configuration-file-refresh-period</code>, with the default at 5000, in
milliseconds.</p>
<p>Once the configuration file is changed (broker.xml) the following modules will
be reloaded automatically:</p>
<ul>
<li>Address Settings</li>
<li>Security Settings</li>
<li>Diverts</li>
<li>Addresses &amp; queues</li>
</ul>
<p>If using <a href="configuration-index.html#modularising-broker.xml">modulised broker.xml</a> ensure you also read <a href="configuration-index.html#reloading-modular-configuration-files">Reloading modular configuration files</a></p>
<p><strong>Note:</strong></p>
<p>Deletion of Address&apos;s and Queue&apos;s, not auto created is controlled by Address Settings</p>
<ul>
<li><p>config-delete-addresses</p>
<ul>
<li>OFF (DEFAULT) - will not remove upon config reload.</li>
<li>FORCE - will remove the address and its queues upon config reload, even if messages remains, losing the messages in the address &amp; queues.</li>
</ul>
</li>
<li><p>config-delete-queues</p>
<ul>
<li>OFF (DEFAULT) - will not remove upon config reload.</li>
<li>FORCE - will remove the queue upon config reload, even if messages remains, losing the messages in the queue.</li>
</ul>
</li>
</ul>
<p>By default both settings are OFF as such address &amp; queues won&apos;t be removed upon
reload, given the risk of losing messages.</p>
<p>When OFF You may execute explicit CLI or Management operations to remove
address &amp; queues.</p>
<h2 id="reloadable-parameters">Reloadable Parameters</h2>
<p>The broker configuration file has 2 main parts, <code>&lt;core&gt;</code> and <code>&lt;jms&gt;</code>. Some of
the parameters in the 2 parts are monitored and, if modified, reloaded into the
broker at runtime.</p>
<p><strong>Note:</strong> Elements under <code>&lt;jms&gt;</code> are <strong>deprecated</strong>. Users are encouraged to
use <code>&lt;core&gt;</code> configuration entities.</p>
<blockquote>
<p><strong>Note:</strong></p>
<p>Most parameters reloaded take effect immediately after reloading. However
there are some that won&#x2019;t take any effect unless you restarting the broker.
Such parameters are specifically indicated in the following text.</p>
</blockquote>
<h3 id="core"><code>&lt;core&gt;</code></h3>
<h4 id="security-settings"><code>&lt;security-settings&gt;</code></h4>
<ul>
<li><code>&lt;security-setting&gt;</code> element</li>
</ul>
<p>Changes to any <code>&lt;security-setting&gt;</code> elements will be reloaded. Each
<code>&lt;security-setting&gt;</code> defines security roles for a matched address.</p>
<ul>
<li><p>The <code>match</code> attribute</p>
<p>This attribute defines the address for which the security-setting is
defined. It can take wildcards such as &#x2018;#&#x2019; and &#x2018;*&#x2019;.</p>
</li>
<li><p>The <code>&lt;permission&gt;</code> sub-elements</p>
</li>
</ul>
<p>Each <code>&lt;security-setting&gt;</code> can have a list of <code>&lt;permission&gt;</code> elements, each
of which defines a specific permission-roles mapping.  Each permission has 2
attributes &#x2018;type&#x2019; and &#x2018;roles&#x2019;. The &#x2018;type&#x2019; attribute defines the type of
operation allowed, the &#x2018;roles&#x2019; defines which roles are allowed to perform such
operation. Refer to the user&#x2019;s manual for a list of operations that can be
defined.</p>
<blockquote>
<p><strong>Note:</strong></p>
<p>Once loaded the security-settings will take effect immediately. Any new
clients will subject to the new security settings. Any existing clients will
subject to the new settings as well, as soon as they performs a new
security-sensitive operation.</p>
</blockquote>
<p>Below lists the effects of adding, deleting and updating of an
element/attribute within the <code>&lt;security-settings&gt;</code> element, whether a change
can be done or can&#x2019;t be done.</p>
<table>
<thead>
<tr>
<th>Operation</th>
<th>Add</th>
<th>Delete</th>
<th>Update</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>&lt;security-settings&gt;</code></td>
<td>X* (at most one element is allowed)</td>
<td>Deleting it means delete the whole security settings from the running broker.</td>
<td>N/A*</td>
</tr>
<tr>
<td><code>&lt;security-setting&gt;</code></td>
<td>Adding one element means adding a new set of security roles for an address in the running broker</td>
<td>Deleting one element means removing a set of security roles for an address in the running broker</td>
<td>Updating one element means updating the security roles for an address (if match attribute is not changed), or means removing the old match address settings and adding a new one (if match attribute is changed)</td>
</tr>
<tr>
<td>attribute <code>match</code></td>
<td>N/A*</td>
<td>X*</td>
<td>Changing this value is same as deleting the whole <security-setting> with the old match value and adding</security-setting></td>
</tr>
<tr>
<td><code>&lt;permission&gt;</code></td>
<td>Adding one means adding  a new permission definition to runtime broker</td>
<td>Deleting a permission from the runtime broker</td>
<td>Updating a permission-roles in the runtime broker</td>
</tr>
<tr>
<td>attribute <code>type</code></td>
<td>N/A*</td>
<td>X*</td>
<td>Changing the type value means remove the permission of the old one and add the permission of this type to the running broker.</td>
</tr>
<tr>
<td>attribute <code>roles</code></td>
<td>N/A*</td>
<td>X*</td>
<td>Changing the &#x2018;roles&#x2019; value means updating the permission&#x2019;s allowed roles to the running broker</td>
</tr>
</tbody>
</table>
<blockquote>
<ul>
<li><code>N/A</code> means this operation is not applicable.</li>
<li><code>X</code> means this operation is not allowed.</li>
</ul>
</blockquote>
<h4 id="address-settings"><code>&lt;address-settings&gt;</code></h4>
<ul>
<li><code>&lt;address-settings&gt;</code> element</li>
</ul>
<p>Changes to elements under <code>&lt;address-settings&gt;</code> will be reloaded into runtime
broker. It contains a list of <code>&lt;address-setting&gt;</code> elements.</p>
<ul>
<li><p><code>&lt;address-setting&gt;</code> element</p>
<p>Each address-setting element has a &#x2018;match&#x2019; attribute that defines an address
pattern for which this address-setting is defined. It also has a list of
sub-elements used to define the properties of a matching address.</p>
<blockquote>
<p><strong>Note:</strong> </p>
<p>Parameters reloaded in this category will take effect immediately
after reloading. The effect of deletion of Address&apos;s and Queue&apos;s, not auto
created is controlled by parameter <code>config-delete-addresses</code> and
<code>config-delete-queues</code> as described in the doc.</p>
</blockquote>
</li>
</ul>
<p>Below lists the effects of adding, deleting and updating of an
element/attribute within the address-settings element, whether a change can be
done or can&#x2019;t be done.</p>
<table>
<thead>
<tr>
<th>Operation</th>
<th>Add</th>
<th>Delete</th>
<th>Update</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>&lt;address-settings&gt;</code></td>
<td>X(at most one element is allowed)</td>
<td>Deleting it means delete the whole address settings from the running broker</td>
<td>N/A</td>
</tr>
<tr>
<td><code>&lt;address-setting&gt;</code></td>
<td>Adding one element means adding a set of address-setting for a new address in the running broker</td>
<td>Deleting one  means removing a set of address-setting for an address in the running broker</td>
<td>Updating one element means updating the address setting for an address (if match attribute is not changed), or means removing the old match address settings and adding a new one (if match attribute is changed)</td>
</tr>
<tr>
<td>attribute <code>match</code></td>
<td>N/A</td>
<td>X</td>
<td>Changing this value is same as deleting the whole <address-setting> with the old match value and adding a new one with the new match value.</address-setting></td>
</tr>
<tr>
<td><code>&lt;dead-letter-address&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>Removing the configured dead-letter-address address from running broker.</td>
<td>The dead letter address of the matching address will be updated after reloading</td>
</tr>
<tr>
<td><code>&lt;expiry-address&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>Removing the configured expiry address from running broker.</td>
<td>The expiry address of the matching address will be updated after reloading</td>
</tr>
<tr>
<td><code>&lt;expiry-delay&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>The configured expiry-delay will be removed from running broker.</td>
<td>The expiry-delay for the matching address will be updated after reloading.</td>
</tr>
<tr>
<td><code>&lt;redelivery-delay&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>The configured redelivery-delay will be removed from running broker after reloading</td>
<td>The redelivery-delay for the matchin address will be updated after reloading.</td>
</tr>
<tr>
<td><code>&lt;redelivery-delay-multiplier&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>The configured redelivery-delay-multiplier will be removed from running broker after reloading.</td>
<td>The redelivery-delay-multiplier will be updated after reloading.</td>
</tr>
<tr>
<td><code>&lt;max-redelivery-delay&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>The configured max-redelivery-delay will be removed from running broker after reloading.</td>
<td>The max-redelivery-delay will be updated after reloading.</td>
</tr>
<tr>
<td><code>&lt;max-delivery-attempts&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>The configured max-delivery-attempts will be removed from running broker after reloading.</td>
<td>The max-delivery-attempts will be updated after reloading.</td>
</tr>
<tr>
<td><code>&lt;max-size-bytes&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>The configured max-size-bytes will be removed from running broker after reloading.</td>
<td>The max-size-bytes will be updated after reloading.</td>
</tr>
<tr>
<td><code>&lt;page-size-bytes&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>The configured page-size-bytes will be removed from running broker after reloading.</td>
<td>The page-size-bytes will be updated after reloading.</td>
</tr>
<tr>
<td><code>&lt;page-max-cache-size&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>The configured page-max-cache-size will be removed from running broker after reloading.</td>
<td>The page-max-cache-size will be updated after reloading.</td>
</tr>
<tr>
<td><code>&lt;address-full-policy&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>The configured address-full-policy will be removed from running broker after reloading.</td>
<td>The address-full-policy will be updated after reloading.</td>
</tr>
<tr>
<td><code>&lt;message-counter-history-day-limit&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>The configured message-counter-history-day-limit will be removed from running broker after reloading.</td>
<td>The message-counter-history-day-limit will be updated after reloading.</td>
</tr>
<tr>
<td><code>&lt;last-value-queue&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>The configured last-value-queue will be removed from running broker after reloading (no longer a last value queue).</td>
<td>The last-value-queue will be updated after reloading.</td>
</tr>
<tr>
<td><code>&lt;redistribution-delay&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>The configured redistribution-delay will be removed from running broker after reloading.</td>
<td>The redistribution-delay will be updated after reloading.</td>
</tr>
<tr>
<td><code>&lt;send-to-dla-on-no-route&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>The configured send-to-dla-on-no-route will be removed from running broker after reloading.</td>
<td>The send-to-dla-on-no-route will be updated after reloading.</td>
</tr>
<tr>
<td><code>&lt;slow-consumer-threshold&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>The configured slow-consumer-threshold will be removed from running broker after reloading.</td>
<td>The slow-consumer-threshold will be updated after reloading.</td>
</tr>
<tr>
<td><code>&lt;slow-consumer-policy&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>The configured slow-consumer-policy will be removed from running broker after reloading.</td>
<td>The slow-consumer-policy will be updated after reloading.</td>
</tr>
<tr>
<td><code>&lt;slow-consumer-check-period&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>The configured slow-consumer-check-period will be removed from running broker after reloading. (meaning the slow consumer checker thread will be cancelled)</td>
<td>The slow-consumer-check-period will be updated after reloading.</td>
</tr>
<tr>
<td><code>&lt;auto-create-queues&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>The configured auto-create-queues will be removed from running broker after reloading.</td>
<td>The auto-create-queues will be updated after reloading.</td>
</tr>
<tr>
<td><code>&lt;auto-delete-queues&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>The configured auto-delete-queues will be removed from running broker after reloading.</td>
<td>The auto-delete-queues will be updated after reloading.</td>
</tr>
<tr>
<td><code>&lt;config-delete-queues&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>The configured config-delete-queues will be removed from running broker after reloading.</td>
<td>The config-delete-queues will be updated after reloading.</td>
</tr>
<tr>
<td><code>&lt;auto-create-addresses&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>The configured auto-create-addresses will be removed from running broker after reloading.</td>
<td>The auto-create-addresses will be updated after reloading.</td>
</tr>
<tr>
<td><code>&lt;auto-delete-addresses&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>The configured auto-delete-addresses will be removed from running broker after reloading.</td>
<td>The auto-delete-addresses will be updated after reloading.</td>
</tr>
<tr>
<td><code>&lt;config-delete-addresses&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>The configured config-delete-addresses will be removed from running broker after reloading.</td>
<td>The config-delete-addresses will be updated after reloading.</td>
</tr>
<tr>
<td><code>&lt;management-browse-page-size&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>The configured management-browse-page-size will be removed from running broker after reloading.</td>
<td>The management-browse-page-size will be updated after reloading.</td>
</tr>
<tr>
<td><code>&lt;default-purge-on-no-consumers&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>The configured default-purge-on-no-consumers will be removed from running broker after reloading.</td>
<td>The default-purge-on-no-consumers will be updated after reloading.</td>
</tr>
<tr>
<td><code>&lt;default-max-consumers&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>The configured default-max-consumers will be removed from running broker after reloading.</td>
<td>The default-max-consumers will be updated after reloading.</td>
</tr>
<tr>
<td><code>&lt;default-queue-routing-type&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>The configured default-queue-routing-type will be removed from running broker after reloading.</td>
<td>The default-queue-routing-type will be updated after reloading.</td>
</tr>
<tr>
<td><code>&lt;default-address-routing-type&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>The configured default-address-routing-type will be removed from running broker after reloading.</td>
<td>The default-address-routing-type will be updated after reloading.</td>
</tr>
</tbody>
</table>
<h4 id="diverts"><code>&lt;diverts&gt;</code></h4>
<p>All <code>&lt;divert&gt;</code> elements will be reloaded. Each <code>&lt;divert&gt;</code> element has a &#x2018;name&#x2019;
and several sub-elements that defines the properties of a divert.</p>
<blockquote>
<p><strong>Note:</strong></p>
<p>Existing diverts get undeployed if you delete their <code>&lt;divert&gt;</code> element.</p>
</blockquote>
<p>Below lists the effects of adding, deleting and updating of an
element/attribute within the diverts element, whether a change can be done or
can&#x2019;t be done.</p>
<table>
<thead>
<tr>
<th>Operation</th>
<th>Add</th>
<th>Delete</th>
<th>Update</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>&lt;diverts&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>Deleting it means delete (undeploy) all diverts in running broker.</td>
<td>N/A</td>
</tr>
<tr>
<td><code>&lt;divert&gt;</code></td>
<td>Adding a new divert. It will be deployed after reloading</td>
<td>Deleting it means the divert will be undeployed after reloading</td>
<td>No effect on the deployed divert (unless restarting broker, in which case the divert will be redeployed)</td>
</tr>
<tr>
<td>attribute <code>name</code></td>
<td>N/A</td>
<td>X</td>
<td>A new divert with the name will be deployed. (if it is not already there in broker). Otherwise no effect.</td>
</tr>
<tr>
<td><code>&lt;transformer-class-name&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>No effect on the deployed divert.(unless restarting broker, in which case the divert will be deployed without the transformer class)</td>
<td>No effect on the deployed divert.(unless restarting broker, in which case the divert has the transformer class)</td>
</tr>
<tr>
<td><code>&lt;exclusive&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>No effect on the deployed divert.(unless restarting broker)</td>
<td>No effect on the deployed divert.(unless restarting broker)</td>
</tr>
<tr>
<td><code>&lt;routing-name&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>No effect on the deployed divert.(unless restarting broker)</td>
<td>No effect on the deployed divert.(unless restarting broker)</td>
</tr>
<tr>
<td><code>&lt;address&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>No effect on the deployed divert.(unless restarting broker)</td>
<td>No effect on the deployed divert.(unless restarting broker)</td>
</tr>
<tr>
<td><code>&lt;forwarding-address&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>No effect on the deployed divert.(unless restarting broker)</td>
<td>No effect on the deployed divert.(unless restarting broker)</td>
</tr>
<tr>
<td><code>&lt;filter&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>No effect on the deployed divert.(unless restarting broker)</td>
<td>No effect on the deployed divert.(unless restarting broker)</td>
</tr>
<tr>
<td><code>&lt;routing-type&gt;</code></td>
<td>X (no more than one can be present)</td>
<td>No effect on the deployed divert.(unless restarting broker)</td>
<td>No effect on the deployed divert.(unless restarting broker)</td>
</tr>
</tbody>
</table>
<h4 id="addresses"><code>&lt;addresses&gt;</code></h4>
<p>The <code>&lt;addresses&gt;</code> element contains a list <code>&lt;address&gt;</code> elements. Once changed,
all <code>&lt;address&gt;</code> elements in <code>&lt;addresses&gt;</code> will be reloaded.</p>
<blockquote>
<p><strong>Note:</strong></p>
<p>Once reloaded, all new addresses (as well as the pre-configured queues) will
be deployed to the running broker and all those that are missing from the
configuration will be undeployed.</p>
<p><strong>Note:</strong></p>
<p>Parameters reloaded in this category will take effect immediately after
reloading.  The effect of deletion of Address&apos;s and Queue&apos;s, not auto created
is controlled by parameter <code>config-delete-addresses</code> and
<code>config-delete-queues</code> as described in this doc.</p>
</blockquote>
<p>Below lists the effects of adding, deleting and updating of an
element/attribute within the <code>&lt;addresses&gt;</code> element, whether a change can be
done or can&#x2019;t be done.</p>
<table>
<thead>
<tr>
<th>Operation</th>
<th>Add</th>
<th>Delete</th>
<th>Update</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>&lt;addresses&gt;</code></td>
<td>X(no more than one is present)</td>
<td>Deleting it means delete  (undeploy) all diverts in running broker.</td>
<td>N/A</td>
</tr>
<tr>
<td><code>&lt;address&gt;</code></td>
<td>A new address will be deployed in the running broker</td>
<td>The corresponding address will be undeployed.</td>
<td>N/A</td>
</tr>
<tr>
<td>attribute <code>name</code></td>
<td>N/A</td>
<td>X</td>
<td>After reloading the address of the old name will be undeployed and the new will be deployed.</td>
</tr>
<tr>
<td><code>&lt;anycast&gt;</code></td>
<td>X(no more than one is present)</td>
<td>The anycast routing type will be undeployed from this address, as well as its containing queues after reloading</td>
<td>N/A</td>
</tr>
<tr>
<td><code>&lt;queue&gt;</code>(under <code>&lt;anycast&gt;</code>)</td>
<td>An anycast queue will be deployed after reloading</td>
<td>The anycast queue will be undeployed</td>
<td>For updating queues please see next section <code>&lt;queues&gt;</code></td>
</tr>
<tr>
<td><code>&lt;multicast&gt;</code></td>
<td>X(no more than one is present)</td>
<td>The multicast routing type will be undeployed from this address, as well as its containing queues after reloading</td>
<td>N/A</td>
</tr>
<tr>
<td><code>&lt;queue&gt;</code>(under <code>&lt;multicast&gt;</code>)</td>
<td>A multicast queue will be deployed after reloading</td>
<td>The multicast queue will be undeployed</td>
<td>For updating queues please see next section <code>&lt;queues&gt;</code></td>
</tr>
</tbody>
</table>
<h4 id="queues"><code>&lt;queues&gt;</code></h4>
<p>The <code>&lt;queues&gt;</code> element contains a list <code>&lt;queue&gt;</code> elements. Once changed, all
<code>&lt;queue&gt;</code> elements in <code>&lt;queues&gt;</code> will be reloaded.</p>
<blockquote>
<p><strong>Note:</strong></p>
<p>Once reloaded, all new queues will be deployed to the running broker and all
queues that are missing from the configuration will be undeployed.</p>
<p><strong>Note:</strong></p>
<p>Parameters reloaded in this category will take effect immediately after
reloading.  The effect of deletion of Address&apos;s and Queue&apos;s, not auto created
is controlled by parameter <code>config-delete-addresses</code> and
<code>config-delete-queues</code> as described in this doc.</p>
</blockquote>
<p>Below lists the effects of adding, deleting and updating of an
element/attribute within the <code>&lt;queues&gt;</code> element, and whether a change can be
done or can&#x2019;t be done.</p>
<table>
<thead>
<tr>
<th>Operation</th>
<th>Add</th>
<th>Delete</th>
<th>Update</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>&lt;queues&gt;</code></td>
<td>X(no more than one is present)</td>
<td>Deleting it means delete  (undeploy) all queues from running broker.</td>
<td>N/A</td>
</tr>
<tr>
<td><code>&lt;queue&gt;</code></td>
<td>A new queue is deployed after reloading</td>
<td>The queue will be undeployed after reloading.</td>
<td>N/A</td>
</tr>
<tr>
<td>attribute <code>name</code></td>
<td>N/A</td>
<td>X</td>
<td>A queue with new name will be deployed and the queue with old name will be updeployed after reloading (see Note above).</td>
</tr>
<tr>
<td>attribute <code>max-consumers</code></td>
<td>If max-consumers &gt; current consumers max-consumers will update on reload</td>
<td>max-consumers will be set back to the default <code>-1</code></td>
<td>If max-consumers &gt; current consumers max-consumers will update on reload</td>
</tr>
<tr>
<td>attribute <code>purge-on-no-consumers</code></td>
<td>On reload purge-on-no-consumers will be updated</td>
<td>Will be set back to the default <code>false</code></td>
<td>On reload purge-on-no-consumers will be updated</td>
</tr>
<tr>
<td>attribute <code>address</code></td>
<td>N/A</td>
<td>No effect unless starting broker</td>
<td>No effect unless starting broker</td>
</tr>
<tr>
<td>attribute <code>filter</code></td>
<td>The filter will be added after reloading</td>
<td>The filter will be removed after reloading</td>
<td>The filter will be updated after reloading</td>
</tr>
<tr>
<td>attribute <code>durable</code></td>
<td>The queue durability will be set to the given value after reloading</td>
<td>The queue durability will be set to the default <code>true</code> after reloading</td>
<td>The queue durability will be set to the new value after reloading</td>
</tr>
</tbody>
</table>
<h3 id="jms-deprecated"><code>&lt;jms&gt;</code> <em>(Deprecated)</em></h3>
<h4 id="queue"><code>&lt;queue&gt;</code></h4>
<p>Changes to any <code>&lt;queue&gt;</code> elements will be reloaded to the running broker.</p>
<blockquote>
<p><strong>Note:</strong></p>
<p>Once reloaded, new queues defined in the new changes will be deployed to the
running broker. However existing queues won&#x2019;t get undeployed even if the
matching element is deleted/missing. Also new queue elements matching
existing queues won&#x2019;t get re-created &#x2013; they remain unchanged.</p>
</blockquote>
<table>
<thead>
<tr>
<th>Operation</th>
<th>Add</th>
<th>Delete</th>
<th>Update</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>&lt;queue&gt;</code></td>
<td>A new jms queue will be deployed after reloading</td>
<td>No effect unless starting broker</td>
<td>No effect unless starting broker</td>
</tr>
<tr>
<td>attribute <code>&lt;name&gt;</code></td>
<td>N/A</td>
<td>X</td>
<td>A jms queue of the new name will be deployed after reloading</td>
</tr>
<tr>
<td><code>&lt;selector&gt;</code></td>
<td>X(no more than one is present)</td>
<td>No effect unless starting broker</td>
<td>No effect unless starting broker</td>
</tr>
<tr>
<td><code>&lt;durable&gt;</code></td>
<td>X(no more than one is present)</td>
<td>No effect unless starting broker</td>
<td>No effect unless starting broker</td>
</tr>
</tbody>
</table>
<h4 id="topic"><code>&lt;topic&gt;</code></h4>
<p>Changes to any <code>&lt;topic&gt;</code> elements will be reloaded to the running broker.</p>
<blockquote>
<p><strong>Note:</strong></p>
<p>Once reloaded, new topics defined in the new changes will be deployed to the
running broker. However existing topics won&#x2019;t get undeployed even if the
matching element is deleted/missing. Also any <code>&lt;topic&gt;</code> elements matching
existing topics won&#x2019;t get re-deployed &#x2013; they remain unchanged.</p>
</blockquote>
<table>
<thead>
<tr>
<th>Operation</th>
<th>Add</th>
<th>Delete</th>
<th>Update</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>&lt;topic&gt;</code></td>
<td>A new jms topic will be deployed after reloading</td>
<td>No effect unless starting broker</td>
<td>No effect unless starting broker</td>
</tr>
<tr>
<td>attribute <code>name</code></td>
<td>N/A</td>
<td>X</td>
<td>A jms topic of the new name will be deployed after reloading</td>
</tr>
</tbody>
</table>

                                
                                </section>
                            
    </div>
    <div class="search-results">
        <div class="has-results">
            
            <h1 class="search-results-title"><span class='search-results-count'></span> results matching "<span class='search-query'></span>"</h1>
            <ul class="search-results-list"></ul>
            
        </div>
        <div class="no-results">
            
            <h1 class="search-results-title">No results matching "<span class='search-query'></span>"</h1>
            
        </div>
    </div>
</div>

                        </div>
                    </div>
                
            </div>

            
                
                <a href="configuring-transports.html" class="navigation navigation-prev " aria-label="Previous page: Configuring Transports">
                    <i class="fa fa-angle-left"></i>
                </a>
                
                
                <a href="connection-ttl.html" class="navigation navigation-next " aria-label="Next page: Detecting Dead Connections">
                    <i class="fa fa-angle-right"></i>
                </a>
                
            
        
    </div>

    <script>
        var gitbook = gitbook || [];
        gitbook.push(function() {
            gitbook.page.hasChanged({"page":{"title":"Configuration Reload","level":"1.26","depth":1,"next":{"title":"Detecting Dead Connections","level":"1.27","depth":1,"path":"connection-ttl.md","ref":"connection-ttl.md","articles":[]},"previous":{"title":"Configuring Transports","level":"1.25","depth":1,"path":"configuring-transports.md","ref":"configuring-transports.md","articles":[]},"dir":"ltr"},"config":{"plugins":[],"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"github":"apache/activemq-artemis","theme":"default","githubHost":"https://github.com/","pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"variables":{},"title":"ActiveMQ Artemis Documentation","links":{"home":"http://activemq.apache.org/artemis","issues":"https://issues.apache.org/jira/browse/ARTEMIS","contribute":"http://activemq.apache.org/contributing.html"},"gitbook":"3.x.x","description":"ActiveMQ Artemis User Guide and Reference Documentation"},"file":{"path":"config-reload.md","mtime":"2020-07-08T19:06:56.000Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-07-20T14:05:25.043Z"},"basePath":".","book":{"language":""}});
        });
    </script>
</div>

        
    <script src="gitbook/gitbook.js"></script>
    <script src="gitbook/theme.js"></script>
    
        
        <script src="gitbook/gitbook-plugin-search/search-engine.js"></script>
        
    
        
        <script src="gitbook/gitbook-plugin-search/search.js"></script>
        
    
        
        <script src="gitbook/gitbook-plugin-lunr/lunr.min.js"></script>
        
    
        
        <script src="gitbook/gitbook-plugin-lunr/search-lunr.js"></script>
        
    
        
        <script src="gitbook/gitbook-plugin-sharing/buttons.js"></script>
        
    
        
        <script src="gitbook/gitbook-plugin-fontsettings/fontsettings.js"></script>
        
    

    </body>
</html>

