activemq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From clebertsuco...@apache.org
Subject [21/57] [abbrv] [partial] activemq-6 git commit: ACTIVEMQ6-1 Artemis rename
Date Tue, 28 Apr 2015 16:02:26 GMT
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/architecture.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/architecture.md b/docs/user-manual/en/architecture.md
index e1053a4..b20efec 100644
--- a/docs/user-manual/en/architecture.md
+++ b/docs/user-manual/en/architecture.md
@@ -1,31 +1,31 @@
 # Architecture
 
-In this section we will give an overview of the Apache ActiveMQ high level
+In this section we will give an overview of the Apache ActiveMQ Artemis high level
 architecture.
 
 ## Core Architecture
 
-Apache ActiveMQ core is designed simply as set of Plain Old Java Objects
+Apache ActiveMQ Artemis core is designed simply as set of Plain Old Java Objects
 (POJOs) - we hope you like its clean-cut design.
 
 We've also designed it to have as few dependencies on external jars as
-possible. In fact, Apache ActiveMQ core has only one jar dependency, netty.jar,
+possible. In fact, Apache ActiveMQ Artemis core has only one jar dependency, netty.jar,
 other than the standard JDK classes! This is because we use some of the
 netty buffer classes internally.
 
-This allows Apache ActiveMQ to be easily embedded in your own project, or
+This allows Apache ActiveMQ Artemis to be easily embedded in your own project, or
 instantiated in any dependency injection framework such as Spring or
 Google Guice.
 
-Each Apache ActiveMQ server has its own ultra high performance persistent
+Each Apache ActiveMQ Artemis server has its own ultra high performance persistent
 journal, which it uses for message and other persistence.
 
 Using a high performance journal allows outrageous persistence message
 performance, something not achievable when using a relational database
 for persistence.
 
-Apache ActiveMQ clients, potentially on different physical machines interact
-with the Apache ActiveMQ server. Apache ActiveMQ currently provides two APIs for
+Apache ActiveMQ Artemis clients, potentially on different physical machines interact
+with the Apache ActiveMQ Artemis server. Apache ActiveMQ Artemis currently provides two APIs for
 messaging at the client side:
 
 1. Core client API. This is a simple intuitive Java API that allows the
@@ -35,7 +35,7 @@ messaging at the client side:
 2. JMS client API. The standard JMS API is available at the client
     side.
 
-Apache ActiveMQ also provides different protocol implementations on the server so you can use respective clients for these protocols:
+Apache ActiveMQ Artemis also provides different protocol implementations on the server so you can use respective clients for these protocols:
 
 1. Stomp
 2. OpenWire
@@ -45,13 +45,13 @@ Apache ActiveMQ also provides different protocol implementations on the server s
 JMS semantics are implemented by a JMS facade layer on the client
 side.
 
-The Apache ActiveMQ server does not speak JMS and in fact does not know
+The Apache ActiveMQ Artemis server does not speak JMS and in fact does not know
 anything about JMS, it is a protocol agnostic messaging server designed
 to be used with multiple different protocols.
 
 When a user uses the JMS API on the client side, all JMS interactions
-are translated into operations on the Apache ActiveMQ core client API before
-being transferred over the wire using the Apache ActiveMQ wire format.
+are translated into operations on the Apache ActiveMQ Artemis core client API before
+being transferred over the wire using the Apache ActiveMQ Artemis wire format.
 
 The server always just deals with core API interactions.
 
@@ -59,47 +59,47 @@ A schematic illustrating this relationship is shown in figure 3.1 below:
 
 ![ActiveMQ architecture1](images/architecture1.jpg)
 
-Figure 3.1 shows two user applications interacting with an Apache ActiveMQ
+Figure 3.1 shows two user applications interacting with an Apache ActiveMQ Artemis
 server. User Application 1 is using the JMS API, while User Application
 2 is using the core client API directly.
 
 You can see from the diagram that the JMS API is implemented by a thin
 facade layer on the client side.
 
-## Apache ActiveMQ embedded in your own application
+## Apache ActiveMQ Artemis embedded in your own application
 
-Apache ActiveMQ core is designed as a set of simple POJOs so if you have an
+Apache ActiveMQ Artemis core is designed as a set of simple POJOs so if you have an
 application that requires messaging functionality internally but you
-don't want to expose that as an Apache ActiveMQ server you can directly
-instantiate and embed Apache ActiveMQ servers in your own application.
+don't want to expose that as an Apache ActiveMQ Artemis server you can directly
+instantiate and embed Apache ActiveMQ Artemis servers in your own application.
 
-For more information on embedding Apache ActiveMQ, see [Embedding Apache ActiveMQ](embedding-Apache activemq.md).
+For more information on embedding Apache ActiveMQ Artemis, see [Embedding Apache ActiveMQ Artemis](embedding-Apache ActiveMQ Artemis.md).
 
-## Apache ActiveMQ integrated with a JEE application server
+## Apache ActiveMQ Artemis integrated with a Java EE application server
 
-Apache ActiveMQ provides its own fully functional Java Connector Architecture
-(JCA) adaptor which enables it to be integrated easily into any JEE
+Apache ActiveMQ Artemis provides its own fully functional Java Connector Architecture
+(JCA) adaptor which enables it to be integrated easily into any Java EE
 compliant application server or servlet engine.
 
-JEE application servers provide Message Driven Beans (MDBs), which are a
+Java EE application servers provide Message Driven Beans (MDBs), which are a
 special type of Enterprise Java Beans (EJBs) that can process messages
 from sources such as JMS systems or mail systems.
 
 Probably the most common use of an MDB is to consume messages from a JMS
 messaging system.
 
-According to the JEE specification, a JEE application server uses a JCA
+According to the Java EE specification, a Java EE application server uses a JCA
 adapter to integrate with a JMS messaging system so it can consume
 messages for MDBs.
 
-However, the JCA adapter is not only used by the JEE application server
+However, the JCA adapter is not only used by the Java EE application server
 for *consuming* messages via MDBs, it is also used when sending message
 to the JMS messaging system e.g. from inside an EJB or servlet.
 
-When integrating with a JMS messaging system from inside a JEE
+When integrating with a JMS messaging system from inside a Java EE
 application server it is always recommended that this is done via a JCA
 adaptor. In fact, communicating with a JMS messaging system directly,
-without using JCA would be illegal according to the JEE specification.
+without using JCA would be illegal according to the Java EE specification.
 
 The application server's JCA service provides extra functionality such
 as connection pooling and automatic transaction enlistment, which are
@@ -109,13 +109,13 @@ without going through a JCA adapter, but this is not recommended since
 you will not be able to take advantage of the JCA features, such as
 caching of JMS sessions, which can result in poor performance.
 
-Figure 3.2 below shows a JEE application server integrating with a
-Apache ActiveMQ server via the Apache ActiveMQ JCA adaptor. Note that all
+Figure 3.2 below shows a Java EE application server integrating with a
+Apache ActiveMQ Artemis server via the Apache ActiveMQ Artemis JCA adaptor. Note that all
 communication between EJB sessions or entity beans and Message Driven
-beans go through the adaptor and not directly to Apache ActiveMQ.
+beans go through the adaptor and not directly to Apache ActiveMQ Artemis.
 
 The large arrow with the prohibited sign shows an EJB session bean
-talking directly to the Apache ActiveMQ server. This is not recommended as
+talking directly to the Apache ActiveMQ Artemis server. This is not recommended as
 you'll most likely end up creating a new connection and session every
 time you want to interact from the EJB, which is an anti-pattern.
 
@@ -123,10 +123,10 @@ time you want to interact from the EJB, which is an anti-pattern.
 
 For more information on using the JCA adaptor, please see [Application Server Integration and Java EE](appserver-integration.md).
 
-## Apache ActiveMQ stand-alone server
+## Apache ActiveMQ Artemis stand-alone server
 
-Apache ActiveMQ can also be deployed as a stand-alone server. This means a
-fully independent messaging server not dependent on a JEE application
+Apache ActiveMQ Artemis can also be deployed as a stand-alone server. This means a
+fully independent messaging server not dependent on a Java EE application
 server.
 
 The standard stand-alone messaging server configuration comprises a core

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/client-classpath.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/client-classpath.md b/docs/user-manual/en/client-classpath.md
index 748fe0c..931ad4a 100644
--- a/docs/user-manual/en/client-classpath.md
+++ b/docs/user-manual/en/client-classpath.md
@@ -1,19 +1,19 @@
 # The Client Classpath
 
-Apache ActiveMQ requires several jars on the *Client Classpath* depending on
-whether the client uses Apache ActiveMQ Core API, JMS, and JNDI.
+Apache ActiveMQ Artemis requires several jars on the *Client Classpath* depending on
+whether the client uses Apache ActiveMQ Artemis Core API, JMS, and JNDI.
 
 > **Warning**
 >
 > All the jars mentioned here can be found in the `lib` directory of the
-> Apache ActiveMQ distribution. Be sure you only use the jars from the correct
+> Apache ActiveMQ Artemis distribution. Be sure you only use the jars from the correct
 > version of the release, you *must not* mix and match versions of jars
-> from different Apache ActiveMQ versions. Mixing and matching different jar
+> from different Apache ActiveMQ Artemis versions. Mixing and matching different jar
 > versions may cause subtle errors and failures to occur.
 
-## Apache ActiveMQ Core Client
+## Apache ActiveMQ Artemis Core Client
 
-If you are using just a pure Apache ActiveMQ Core client (i.e. no JMS) then you
+If you are using just a pure Apache ActiveMQ Artemis Core client (i.e. no JMS) then you
 need `activemq-core-client.jar`, `activemq-commons.jar`, and `netty.jar`
 on your client classpath.
 

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/client-reconnection.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/client-reconnection.md b/docs/user-manual/en/client-reconnection.md
index 661d987..5cd7fb0 100644
--- a/docs/user-manual/en/client-reconnection.md
+++ b/docs/user-manual/en/client-reconnection.md
@@ -1,6 +1,6 @@
 # Client Reconnection and Session Reattachment
 
-Apache ActiveMQ clients can be configured to automatically reconnect or
+Apache ActiveMQ Artemis clients can be configured to automatically reconnect or
 re-attach to the server in the event that a failure is detected in the
 connection between the client and the server.
 
@@ -11,14 +11,14 @@ network failure, and the target server was not restarted, then the
 sessions will still be existent on the server, assuming the client
 hasn't been disconnected for more than connection-ttl [Detecting Dead Connections](connection-ttl.md)
 
-In this scenario, Apache ActiveMQ will automatically re-attach the client
+In this scenario, Apache ActiveMQ Artemis will automatically re-attach the client
 sessions to the server sessions when the connection reconnects. This is
 done 100% transparently and the client can continue exactly as if
 nothing had happened.
 
 The way this works is as follows:
 
-As Apache ActiveMQ clients send commands to their servers they store each sent
+As Apache ActiveMQ Artemis clients send commands to their servers they store each sent
 command in an in-memory buffer. In the case that connection failure
 occurs and the client subsequently reattaches to the same server, as
 part of the reattachment protocol the server informs the client during
@@ -59,7 +59,7 @@ crashing or being stopped. In this case any sessions will no longer be
 existent on the server and it won't be possible to 100% transparently
 re-attach to them.
 
-In this case, Apache ActiveMQ will automatically reconnect the connection and
+In this case, Apache ActiveMQ Artemis will automatically reconnect the connection and
 *recreate* any sessions and consumers on the server corresponding to the
 sessions and consumers on the client. This process is exactly the same
 as what happens during failover onto a backup server.
@@ -114,7 +114,7 @@ If you're using JMS and you're using JNDI on the client to look up your
 JMS connection factory instances then you can specify these parameters
 in the JNDI context environment in, e.g. `jndi.properties`:
 
-    java.naming.factory.initial = org.apache.activemq.jndi.ActiveMQInitialContextFactory
+    java.naming.factory.initial = ActiveMQInitialContextFactory
     connection.ConnectionFactory=tcp://localhost:61616?retryInterval=1000&retryIntervalMultiplier=1.5&maxRetryInterval=60000&reconnectAttempts=1000
 
 If you're using JMS, but instantiating your JMS connection factory

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/clusters.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/clusters.md b/docs/user-manual/en/clusters.md
index baf9690..d9a128c 100644
--- a/docs/user-manual/en/clusters.md
+++ b/docs/user-manual/en/clusters.md
@@ -2,9 +2,9 @@
 
 ## Clusters Overview
 
-Apache ActiveMQ clusters allow groups of Apache ActiveMQ servers to be grouped
+Apache ActiveMQ Artemis clusters allow groups of Apache ActiveMQ Artemis servers to be grouped
 together in order to share message processing load. Each active node in
-the cluster is an active Apache ActiveMQ server which manages its own messages
+the cluster is an active Apache ActiveMQ Artemis server which manages its own messages
 and handles its own connections.
 
 The cluster is formed by each node declaring *cluster connections* to
@@ -22,7 +22,7 @@ in this chapter.
 
 We'll also discuss client side load balancing, where we can balance
 client connections across the nodes of the cluster, and we'll consider
-message redistribution where Apache ActiveMQ will redistribute messages between
+message redistribution where Apache ActiveMQ Artemis will redistribute messages between
 nodes to avoid starvation.
 
 Another important part of clustering is *server discovery* where servers
@@ -33,8 +33,8 @@ connect to them with the minimum of configuration.
 >
 > Once a cluster node has been configured it is common to simply copy
 > that configuration to other nodes to produce a symmetric cluster.
-> However, care must be taken when copying the Apache ActiveMQ files. Do not
-> copy the Apache ActiveMQ *data* (i.e. the `bindings`, `journal`, and
+> However, care must be taken when copying the Apache ActiveMQ Artemis files. Do not
+> copy the Apache ActiveMQ Artemis *data* (i.e. the `bindings`, `journal`, and
 > `large-messages` directories) from one node to another. When a node is
 > started for the first time and initializes its journal files it also
 > persists a special identifier to the `journal` directory. This id
@@ -55,7 +55,7 @@ connection details to:
     all the other servers in the cluster.
 
 This information, let's call it the Cluster Topology, is actually sent
-around normal Apache ActiveMQ connections to clients and to other servers over
+around normal Apache ActiveMQ Artemis connections to clients and to other servers over
 cluster connections. This being the case we need a way of establishing
 the initial first connection. This can be done using dynamic discovery
 techniques like
@@ -85,7 +85,7 @@ JGroups to broadcast connector pairs information.
 
 Broadcast groups are defined in the server configuration file
 `activemq-configuration.xml`. There can be many broadcast groups per
-Apache ActiveMQ server. All broadcast groups must be defined in a
+Apache ActiveMQ Artemis server. All broadcast groups must be defined in a
 `broadcast-groups` element.
 
 Let's take a look at an example broadcast group from
@@ -159,7 +159,7 @@ following:
 
 -   `jgroups-file` attribute. This is the name of JGroups configuration
     file. It will be used to initialize JGroups channels. Make sure the
-    file is in the java resource path so that Apache ActiveMQ can load it.
+    file is in the java resource path so that Apache ActiveMQ Artemis can load it.
 
 -   `jgroups-channel` attribute. The name that JGroups channels connect
     to for broadcasting.
@@ -226,7 +226,7 @@ The following is an example of a JGroups file
     </config>
 
 As it shows, the file content defines a jgroups protocol stacks. If you
-want Apache activemq to use this stacks for channel creation, you have to make
+want Apache ActiveMQ Artemis to use this stacks for channel creation, you have to make
 sure the value of `jgroups-file` in your broadcast-group/discovery-group
 configuration to be the name of this jgroups configuration file. For
 example if the above stacks configuration is stored in a file named
@@ -249,7 +249,7 @@ list for that server.
 If it has not received a broadcast from a particular server for a length
 of time it will remove that server's entry from its list.
 
-Discovery groups are used in two places in Apache ActiveMQ:
+Discovery groups are used in two places in Apache ActiveMQ Artemis:
 
 -   By cluster connections so they know how to obtain an initial
     connection to download the topology
@@ -260,7 +260,7 @@ Discovery groups are used in two places in Apache ActiveMQ:
 Although a discovery group will always accept broadcasts, its current
 list of available live and backup servers is only ever used when an
 initial connection is made, from then server discovery is done over the
-normal Apache ActiveMQ connections.
+normal Apache ActiveMQ Artemis connections.
 
 > **Note**
 >
@@ -274,7 +274,7 @@ normal Apache ActiveMQ connections.
 For cluster connections, discovery groups are defined in the server side
 configuration file `activemq-configuration.xml`. All discovery groups
 must be defined inside a `discovery-groups` element. There can be many
-discovery groups defined by Apache ActiveMQ server. Let's look at an example:
+discovery groups defined by Apache ActiveMQ Artemis server. Let's look at an example:
 
     <discovery-groups>
        <discovery-group name="my-discovery-group">
@@ -331,7 +331,7 @@ details as following:
 
 -   `jgroups-file` attribute. This is the name of JGroups configuration
     file. It will be used to initialize JGroups channels. Make sure the
-    file is in the java resource path so that Apache ActiveMQ can load it.
+    file is in the java resource path so that Apache ActiveMQ Artemis can load it.
 
 -   `jgroups-channel` attribute. The name that JGroups channels connect
     to for receiving broadcasts.
@@ -345,7 +345,7 @@ details as following:
 
 #### Discovery Groups on the Client Side
 
-Let's discuss how to configure an Apache ActiveMQ client to use discovery to
+Let's discuss how to configure an Apache ActiveMQ Artemis client to use discovery to
 discover a list of servers to which it can connect. The way to do this
 differs depending on whether you're using JMS or the core API.
 
@@ -358,7 +358,7 @@ ensure the host:port combination matches the group-address and
 group-port from the corresponding `broadcast-group` on the server. Let's
 take a look at an example:
 
-    java.naming.factory.initial = org.apache.activemq.jndi.ActiveMQInitialContextFactory
+    java.naming.factory.initial = ActiveMQInitialContextFactory
     connectionFactory.myConnectionFactory=udp://231.7.7.7:9876
 
 The element `discovery-group-ref` specifies the name of a discovery
@@ -462,7 +462,7 @@ If you're using JMS and you're using JNDI on the client to look up your
 JMS connection factory instances then you can specify these parameters
 in the JNDI context environment in, e.g. `jndi.properties`:
 
-    java.naming.factory.initial=org.apache.activemq.jndi.ActiveMQInitialContextFactory
+    java.naming.factory.initial=ActiveMQInitialContextFactory
     connectionFactory.myConnectionFactory=(tcp://myhost:61616,tcp://myhost2:61616)
 
 The `connectionFactory.myConnectionFactory` contains a list of servers to use for the
@@ -511,7 +511,7 @@ ClientSession session = factory.createSession();
 ## Server-Side Message Load Balancing
 
 If cluster connections are defined between nodes of a cluster, then
-Apache ActiveMQ will load balance messages arriving at a particular node from a
+Apache ActiveMQ Artemis will load balance messages arriving at a particular node from a
 client.
 
 Let's take a simple example of a cluster of four nodes A, B, C, and D
@@ -537,7 +537,7 @@ following order between the nodes: B, D, C, A, B, D, C, A, B, D. The
 exact order depends on the order the nodes started up, but the algorithm
 used is round robin.
 
-Apache ActiveMQ cluster connections can be configured to always blindly load
+Apache ActiveMQ Artemis cluster connections can be configured to always blindly load
 balance messages in a round robin fashion irrespective of whether there
 are any matching consumers on other nodes, but they can be a bit
 cleverer than that and also be configured to only distribute to other
@@ -551,7 +551,7 @@ Cluster connections group servers into clusters so that messages can be
 load balanced between the nodes of the cluster. Let's take a look at a
 typical cluster connection. Cluster connections are always defined in
 `activemq-configuration.xml` inside a `cluster-connection` element.
-There can be zero or more cluster connections defined per Apache ActiveMQ
+There can be zero or more cluster connections defined per Apache ActiveMQ Artemis
 server.
 
     <cluster-connections>
@@ -598,7 +598,7 @@ specified. The following shows all the available configuration options
     connections with different values of `address`, simultaneously
     balancing messages for those addresses, potentially to different
     clusters of servers. By having multiple cluster connections on
-    different addresses a single Apache ActiveMQ Server can effectively take
+    different addresses a single Apache ActiveMQ Artemis Server can effectively take
     part in multiple clusters simultaneously.
 
     Be careful not to have multiple cluster connections with overlapping
@@ -704,11 +704,11 @@ specified. The following shows all the available configuration options
     robin'd even though the same queues on the other nodes of the
     cluster may have no consumers at all, or they may have consumers
     that have non matching message filters (selectors). Note that
-    Apache ActiveMQ will *not* forward messages to other nodes if there are no
+    Apache ActiveMQ Artemis will *not* forward messages to other nodes if there are no
     *queues* of the same name on the other nodes, even if this parameter
     is set to `true`.
 
-    If this is set to `false` then Apache ActiveMQ will only forward messages
+    If this is set to `false` then Apache ActiveMQ Artemis will only forward messages
     to other nodes of the cluster if the address to which they are being
     forwarded has queues which have consumers, and if those consumers
     have message filters (selectors) at least one of those selectors
@@ -718,17 +718,17 @@ specified. The following shows all the available configuration options
 
 -   `max-hops`. When a cluster connection decides the set of nodes to
     which it might load balance a message, those nodes do not have to be
-    directly connected to it via a cluster connection. Apache ActiveMQ can be
+    directly connected to it via a cluster connection. Apache ActiveMQ Artemis can be
     configured to also load balance messages to nodes which might be
-    connected to it only indirectly with other Apache ActiveMQ servers as
+    connected to it only indirectly with other Apache ActiveMQ Artemis servers as
     intermediates in a chain.
 
-    This allows Apache ActiveMQ to be configured in more complex topologies and
+    This allows Apache ActiveMQ Artemis to be configured in more complex topologies and
     still provide message load balancing. We'll discuss this more later
     in this chapter.
 
     The default value for this parameter is `1`, which means messages
-    are only load balanced to other Apache ActiveMQ serves which are directly
+    are only load balanced to other Apache ActiveMQ Artemis serves which are directly
     connected to this server. This parameter is optional.
 
 -   `confirmation-window-size`. The size (in bytes) of the window used
@@ -774,7 +774,7 @@ connection has been made.
 ### Cluster User Credentials
 
 When creating connections between nodes of a cluster to form a cluster
-connection, Apache ActiveMQ uses a cluster user and cluster password which is
+connection, Apache ActiveMQ Artemis uses a cluster user and cluster password which is
 defined in `activemq-configuration.xml`:
 
     <cluster-user>ACTIVEMQ.CLUSTER.ADMIN.USER</cluster-user>
@@ -784,18 +784,18 @@ defined in `activemq-configuration.xml`:
 >
 > It is imperative that these values are changed from their default, or
 > remote clients will be able to make connections to the server using
-> the default values. If they are not changed from the default, Apache ActiveMQ
+> the default values. If they are not changed from the default, Apache ActiveMQ Artemis
 > will detect this and pester you with a warning on every start-up.
 
 ## Client-Side Load balancing
 
-With Apache ActiveMQ client-side load balancing, subsequent sessions created
+With Apache ActiveMQ Artemis client-side load balancing, subsequent sessions created
 using a single session factory can be connected to different nodes of
 the cluster. This allows sessions to spread smoothly across the nodes of
 a cluster and not be "clumped" on any particular node.
 
 The load balancing policy to be used by the client factory is
-configurable. Apache ActiveMQ provides four out-of-the-box load balancing
+configurable. Apache ActiveMQ Artemis provides four out-of-the-box load balancing
 policies, and you can also implement your own and use that.
 
 The out-of-the-box policies are
@@ -843,7 +843,7 @@ JMS connection factory instances then you can specify these parameters
 in the JNDI context environment in, e.g. `jndi.properties`, to specify
 the load balancing policy directly:
 
-    java.naming.factory.initial=org.apache.activemq.jndi.ActiveMQInitialContextFactory
+    java.naming.factory.initial=ActiveMQInitialContextFactory
     connection.myConnectionFactory=tcp://localhost:61616?loadBalancingPolicyClassName=org.apache.activemq.api.core.client.loadbalance.RandomConnectionLoadBalancingPolicy
 
 The above example would instantiate a JMS connection factory that uses
@@ -912,7 +912,7 @@ consumers on the queue the message won't get consumed and we have a
 *starvation* situation.
 
 This is where message redistribution comes in. With message
-redistribution Apache ActiveMQ can be configured to automatically
+redistribution Apache ActiveMQ Artemis can be configured to automatically
 *redistribute* messages from queues which have no consumers back to
 other nodes in the cluster which do have matching consumers.
 
@@ -941,7 +941,7 @@ with "jms.", so the above would enable instant (no delay) redistribution
 for all JMS queues and topic subscriptions.
 
 The attribute `match` can be an exact match or it can be a string that
-conforms to the Apache ActiveMQ wildcard syntax (described in [Wildcard Syntax](wildcard-syntax.md)).
+conforms to the Apache ActiveMQ Artemis wildcard syntax (described in [Wildcard Syntax](wildcard-syntax.md)).
 
 The element `redistribution-delay` defines the delay in milliseconds
 after the last consumer is closed on a queue before redistributing
@@ -957,7 +957,7 @@ redistribute immediately since the new consumer will arrive shortly.
 
 ## Cluster topologies
 
-Apache ActiveMQ clusters can be connected together in many different
+Apache ActiveMQ Artemis clusters can be connected together in many different
 topologies, let's consider the two most common ones here
 
 ### Symmetric cluster
@@ -1016,13 +1016,13 @@ which does have consumers.
 
 ### Scaling Down
 
-Apache ActiveMQ supports scaling down a cluster with no message loss (even for
+Apache ActiveMQ Artemis supports scaling down a cluster with no message loss (even for
 non-durable messages). This is especially useful in certain environments
 (e.g. the cloud) where the size of a cluster may change relatively
 frequently. When scaling up a cluster (i.e. adding nodes) there is no
 risk of message loss, but when scaling down a cluster (i.e. removing
 nodes) the messages on those nodes would be lost unless the broker sent
-them to another node in the cluster. Apache ActiveMQ can be configured to do
+them to another node in the cluster. Apache ActiveMQ Artemis can be configured to do
 just that.
 
 The simplest way to enable this behavior is to set `scale-down` to

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/configuration-index.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/configuration-index.md b/docs/user-manual/en/configuration-index.md
index 994c402..21b8fe6 100644
--- a/docs/user-manual/en/configuration-index.md
+++ b/docs/user-manual/en/configuration-index.md
@@ -235,21 +235,21 @@ Name | Type | Description
 Using Masked Passwords in Configuration Files
 ---------------------------------------------
 
-By default all passwords in Apache ActiveMQ server's configuration files are in
+By default all passwords in Apache ActiveMQ Artemis server's configuration files are in
 plain text form. This usually poses no security issues as those files
 should be well protected from unauthorized accessing. However, in some
 circumstances a user doesn't want to expose its passwords to more eyes
 than necessary.
 
-Apache ActiveMQ can be configured to use 'masked' passwords in its
+Apache ActiveMQ Artemis can be configured to use 'masked' passwords in its
 configuration files. A masked password is an obscure string
 representation of a real password. To mask a password a user will use an
 'encoder'. The encoder takes in the real password and outputs the masked
 version. A user can then replace the real password in the configuration
-files with the new masked password. When Apache ActiveMQ loads a masked
+files with the new masked password. When Apache ActiveMQ Artemis loads a masked
 password, it uses a suitable 'decoder' to decode it into real password.
 
-Apache ActiveMQ provides a default password encoder and decoder. Optionally
+Apache ActiveMQ Artemis provides a default password encoder and decoder. Optionally
 users can use or implement their own encoder and decoder for masking the
 passwords.
 
@@ -280,7 +280,7 @@ trust-store-password. Because Acceptors and Connectors are pluggable
 implementations, each transport will have different password masking
 needs.
 
-When a Connector or Acceptor configuration is initialised, Apache ActiveMQ will
+When a Connector or Acceptor configuration is initialised, Apache ActiveMQ Artemis will
 add the "mask-password" and "password-codec" values to the Connector or
 Acceptors params using the keys `activemq.usemaskedpassword` and
 `activemq.passwordcodec` respectively. The Netty and InVM
@@ -324,7 +324,7 @@ example 2
 <cluster-password>80cf731af62c290</cluster-password>
 ```
 
-This indicates the cluster password is a masked value and Apache ActiveMQ will
+This indicates the cluster password is a masked value and Apache ActiveMQ Artemis will
 use its built-in decoder to decode it. All other passwords in the
 configuration file, Connectors, Acceptors and Bridges, will also use
 masked passwords.
@@ -350,7 +350,7 @@ followed by key/value pairs, separated by semi-colons. For example:
 <property name="passwordCodec">com.foo.FooDecoder;key=value</property>
 ```
 
-Apache ActiveMQ will load this property and initialize the class with a
+Apache ActiveMQ Artemis will load this property and initialize the class with a
 parameter map containing the "key"-\>"value" pair. If `passwordCodec` is
 not specified, the built-in decoder is used.
 
@@ -387,7 +387,7 @@ will have to be in masked form.
 
 ### Masking passwords in activemq-users.properties
 
-Apache ActiveMQ's built-in security manager uses plain properties files
+Apache ActiveMQ Artemis's built-in security manager uses plain properties files
 where the user passwords are specified in plaintext forms by default. To
 mask those parameters the following two properties need to be set
 in the 'bootstrap.xml' file.
@@ -403,10 +403,10 @@ Bridges. Example:
 
 ```xml
 <mask-password>true</mask-password>
-<password-codec>org.apache.activemq.utils.DefaultSensitiveStringCodec;key=hello world</password-codec>
+<password-codec>org.apache.activemq.artemis.utils.DefaultSensitiveStringCodec;key=hello world</password-codec>
 ```
 
-When so configured, the Apache ActiveMQ security manager will initialize a
+When so configured, the Apache ActiveMQ Artemis security manager will initialize a
 DefaultSensitiveStringCodec with the parameters "key"-\>"hello world",
 then use it to decode all the masked passwords in this configuration
 file.
@@ -419,23 +419,23 @@ its original clear text form in order to be used in various security
 operations. The algorithm used for decoding must match that for
 encoding. Otherwise the decoding may not be successful.
 
-For user's convenience Apache ActiveMQ provides a default built-in Decoder.
+For user's convenience Apache ActiveMQ Artemis provides a default built-in Decoder.
 However a user can if they so wish implement their own.
 
 #### The built-in Decoder
 
 Whenever no decoder is specified in the configuration file, the built-in
 decoder is used. The class name for the built-in decoder is
-org.apache.activemq.utils.DefaultSensitiveStringCodec. It has both
+org.apache.activemq.artemis.utils.DefaultSensitiveStringCodec. It has both
 encoding and decoding capabilities. It uses java.crypto.Cipher utilities
 to encrypt (encode) a plaintext password and decrypt a mask string using
 same algorithm. Using this decoder/encoder is pretty straightforward. To
-get a mask for a password, just run the main class at org.apache.activemq.utils.DefaultSensitiveStringCodec.
+get a mask for a password, just run the main class at org.apache.activemq.artemis.utils.DefaultSensitiveStringCodec.
 
 An easy way to do it is through activemq-tools-<VERSION>-jar-with-dependencies.jar since it has all the dependencies:
 
 ```sh
-    java -cp activemq-tools-6.0.0-jar-with-dependencies.jar org.apache.activemq.utils.DefaultSensitiveStringCodec "your plaintext password"
+    java -cp activemq-tools-6.0.0-jar-with-dependencies.jar org.apache.activemq.artemis.utils.DefaultSensitiveStringCodec "your plaintext password"
 ```
 
 If you don't want to use the jar-with-dependencies, make sure the classpath is correct. You'll get something like
@@ -449,7 +449,7 @@ Just copy "80cf731af62c290" and replace your plaintext password with it.
 #### Using a different decoder
 
 It is possible to use a different decoder rather than the built-in one.
-Simply make sure the decoder is in Apache ActiveMQ's classpath and configure
+Simply make sure the decoder is in Apache ActiveMQ Artemis's classpath and configure
 the server to use it as follows:
 
 ```xml
@@ -471,7 +471,7 @@ Then configure your cluster-password like this:
     <cluster-password>masked_password</cluster-password>
 ```
 
-When Apache ActiveMQ reads the cluster-password it will initialize the
+When Apache ActiveMQ Artemis reads the cluster-password it will initialize the
 NewDecoder and use it to decode "mask\_password". It also process all
 passwords using the new defined decoder.
 
@@ -511,4 +511,4 @@ public class MyNewDecoder implements SensitiveDataCodec<String>
 ```
 
 Last but not least, once you get your own decoder, please add it to the
-classpath. Otherwise Apache ActiveMQ will fail to load it!
+classpath. Otherwise Apache ActiveMQ Artemis will fail to load it!

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/configuring-transports.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/configuring-transports.md b/docs/user-manual/en/configuring-transports.md
index 26c607e..b85e4fe 100644
--- a/docs/user-manual/en/configuring-transports.md
+++ b/docs/user-manual/en/configuring-transports.md
@@ -1,11 +1,11 @@
 # Configuring the Transport
 
 In this chapter we'll describe the concepts required for understanding
-Apache ActiveMQ transports and where and how they're configured.
+Apache ActiveMQ Artemis transports and where and how they're configured.
 
 ## Understanding Acceptors
 
-One of the most important concepts in Apache ActiveMQ transports is the
+One of the most important concepts in Apache ActiveMQ Artemis transports is the
 *acceptor*. Let's dive straight in and take a look at an acceptor
 defined in xml in the configuration file `activemq-configuration.xml`.
 
@@ -18,7 +18,7 @@ one or more acceptors defined in the `acceptors` element. There's no
 upper limit to the number of acceptors per server.
 
 Each acceptor defines a way in which connections can be made to the
-Apache ActiveMQ server.
+Apache ActiveMQ Artemis server.
 
 In the above example we're defining an acceptor that uses
 [Netty](http://netty.io/) to listen for connections at port
@@ -73,11 +73,11 @@ couple of reasons for this:
 
     That's defined by the `java.naming.provider.url` element in the JNDI
     context environment, e.g. `jndi.properties`. Behind the scenes, the
-    `org.apache.activemq.jndi.ActiveMQInitialContextFactory` uses the
+    `ActiveMQInitialContextFactory` uses the
     `java.naming.provider.url` to construct the transport. Here's a
     simple example:
 
-        java.naming.factory.initial=org.apache.activemq.jndi.ActiveMQInitialContextFactory
+        java.naming.factory.initial=ActiveMQInitialContextFactory
         connectionFactory.MyConnectionFactory=tcp://myhost:61616
 
 ## Configuring the transport directly from the client side.
@@ -99,12 +99,12 @@ uses the standard Netty TCP transport and will try and connect on port
 ``` java
 Map<String, Object> connectionParams = new HashMap<String, Object>();
 
-connectionParams.put(org.apache.activemq.core.remoting.impl.netty.TransportConstants.PORT_PROP_NAME,
+connectionParams.put(org.apache.activemq.artemis.core.remoting.impl.netty.TransportConstants.PORT_PROP_NAME,
                     61617);
 
 TransportConfiguration transportConfiguration =
     new TransportConfiguration(
-    "org.apache.activemq.core.remoting.impl.netty.NettyConnectorFactory",
+    "org.apache.activemq.artemis.core.remoting.impl.netty.NettyConnectorFactory",
     connectionParams);
 
 ServerLocator locator = ActiveMQClient.createServerLocatorWithoutHA(transportConfiguration);
@@ -123,11 +123,11 @@ on the server side or define a connection factory in `activemq-jms.xml`:
 ``` java
 Map<String, Object> connectionParams = new HashMap<String, Object>();
 
-connectionParams.put(org.apache.activemq.core.remoting.impl.netty.TransportConstants.PORT_PROP_NAME, 61617);
+connectionParams.put(org.apache.activemq.artemis.core.remoting.impl.netty.TransportConstants.PORT_PROP_NAME, 61617);
 
 TransportConfiguration transportConfiguration =
     new TransportConfiguration(
-    "org.apache.activemq.core.remoting.impl.netty.NettyConnectorFactory",
+    "org.apache.activemq.artemis.core.remoting.impl.netty.NettyConnectorFactory",
     connectionParams);
 
 ConnectionFactory connectionFactory = ActiveMQJMSClient.createConnectionFactoryWithoutHA(JMSFactoryType.CF, transportConfiguration);
@@ -139,7 +139,7 @@ etc
 
 ## Configuring the Netty transport
 
-Out of the box, Apache ActiveMQ currently uses
+Out of the box, Apache ActiveMQ Artemis currently uses
 [Netty](http://netty.io/), a high performance low level
 network library.
 
@@ -151,9 +151,9 @@ We believe this caters for the vast majority of transport requirements.
 
 ## Single Port Support
 
-Apache ActiveMQ supports using a single port for all
-protocols, Apache ActiveMQ will automatically detect which protocol is being
-used CORE, AMQP, STOMP or OPENWIRE and use the appropriate Apache ActiveMQ
+Apache ActiveMQ Artemis supports using a single port for all
+protocols, Apache ActiveMQ Artemis will automatically detect which protocol is being
+used CORE, AMQP, STOMP or OPENWIRE and use the appropriate Apache ActiveMQ Artemis
 handler. It will also detect whether protocols such as HTTP or Web
 Sockets are being used and also use the appropriate decoders
 
@@ -181,7 +181,7 @@ client. This works well with firewall policies that typically only allow
 connections to be initiated in one direction.
 
 All the valid Netty transport keys are defined in the class
-`org.apache.activemq.core.remoting.impl.netty.TransportConstants`. Most
+`org.apache.activemq.artemis.core.remoting.impl.netty.TransportConstants`. Most
 parameters can be used either with acceptors or connectors, some only
 work with acceptors. The following parameters can be used to configure
 Netty for simple TCP:
@@ -242,7 +242,7 @@ Netty for simple TCP:
     TCP receive buffer in bytes. The default value for this property is
     `32768` bytes (32KiB).
 
--   `batchDelay`. Before writing packets to the transport, Apache ActiveMQ can
+-   `batchDelay`. Before writing packets to the transport, Apache ActiveMQ Artemis can
     be configured to batch up writes for a maximum of `batchDelay`
     milliseconds. This can increase overall throughput for very small
     messages. It does so at the expense of an increase in average
@@ -261,7 +261,7 @@ Netty for simple TCP:
     throughput set `directDeliver` to `false
                             `.
 
--   `nioRemotingThreads`. When configured to use NIO, Apache ActiveMQ will,
+-   `nioRemotingThreads`. When configured to use NIO, Apache ActiveMQ Artemis will,
     by default, use a number of threads equal to three times the number
     of cores (or hyper-threads) as reported by
     `Runtime.getRuntime().availableProcessors()` for processing incoming
@@ -399,7 +399,7 @@ Netty HTTP uses the same properties as Netty TCP but adds the following
 additional properties:
 
 -   `httpEnabled`. This is now no longer needed as of version 2.4. With
-    single port support Apache ActiveMQ will now automatically detect if http
+    single port support Apache ActiveMQ Artemis will now automatically detect if http
     is being used and configure itself.
 
 -   `httpClientIdleTime`. How long a client can be idle before

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/connection-ttl.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/connection-ttl.md b/docs/user-manual/en/connection-ttl.md
index ae26341..cd3c301 100644
--- a/docs/user-manual/en/connection-ttl.md
+++ b/docs/user-manual/en/connection-ttl.md
@@ -1,12 +1,12 @@
 # Detecting Dead Connections
 
 In this section we will discuss connection time-to-live (TTL) and
-explain how Apache ActiveMQ deals with crashed clients and clients which have
+explain how Apache ActiveMQ Artemis deals with crashed clients and clients which have
 exited without cleanly closing their resources.
 
 ## Cleaning up Dead Connection Resources on the Server
 
-Before an Apache ActiveMQ client application exits it is considered good
+Before an Apache ActiveMQ Artemis client application exits it is considered good
 practice that it should close its resources in a controlled manner,
 using a `finally` block.
 
@@ -81,12 +81,12 @@ running out of memory or other resources.
 We have to balance the requirement for cleaning up dead client resources
 with the fact that sometimes the network between the client and the
 server can fail and then come back, allowing the client to reconnect.
-Apache ActiveMQ supports client reconnection, so we don't want to clean up
+Apache ActiveMQ Artemis supports client reconnection, so we don't want to clean up
 "dead" server side resources too soon or this will prevent any client
 from reconnecting, as it won't be able to find its old sessions on the
 server.
 
-Apache ActiveMQ makes all of this configurable. For each `ClientSessionFactory`
+Apache ActiveMQ Artemis makes all of this configurable. For each `ClientSessionFactory`
 we define a *connection TTL*. Basically, the TTL determines how long the
 server will keep a connection alive in the absence of any data arriving
 from the client. The client will automatically send "ping" packets
@@ -120,19 +120,19 @@ As previously discussed, it's important that all core client sessions
 and JMS connections are always closed explicitly in a `finally` block
 when you are finished using them.
 
-If you fail to do so, Apache ActiveMQ will detect this at garbage collection
+If you fail to do so, Apache ActiveMQ Artemis will detect this at garbage collection
 time, and log a warning similar to the following in the logs (If you are
 using JMS the warning will involve a JMS connection not a client
 session):
 
-    [Finalizer] 20:14:43,244 WARNING [org.apache.activemq.core.client.impl.DelegatingSession]  I'm closing a ClientSession you left open. Please make sure you close all ClientSessions explicitly before let
+    [Finalizer] 20:14:43,244 WARNING [org.apache.activemq.artemis.core.client.impl.DelegatingSession]  I'm closing a ClientSession you left open. Please make sure you close all ClientSessions explicitly before let
     ting them go out of scope!
-    [Finalizer] 20:14:43,244 WARNING [org.apache.activemq.core.client.impl.DelegatingSession]  The session you didn't close was created here:
+    [Finalizer] 20:14:43,244 WARNING [org.apache.activemq.artemis.core.client.impl.DelegatingSession]  The session you didn't close was created here:
     java.lang.Exception
-       at org.apache.activemq.core.client.impl.DelegatingSession.<init>(DelegatingSession.java:83)
+       at org.apache.activemq.artemis.core.client.impl.DelegatingSession.<init>(DelegatingSession.java:83)
        at org.acme.yourproject.YourClass (YourClass.java:666)
 
-Apache ActiveMQ will then close the connection / client session for you.
+Apache ActiveMQ Artemis will then close the connection / client session for you.
 
 Note that the log will also tell you the exact line of your user code
 where you created the JMS connection / client session that you later did
@@ -177,17 +177,17 @@ from a thread pool so that the remoting thread is not tied up for too
 long. Please note that processing operations asynchronously on another
 thread adds a little more latency. These packets are:
 
--   `org.apache.activemq.core.protocol.core.impl.wireformat.RollbackMessage`
+-   `org.apache.activemq.artemis.core.protocol.core.impl.wireformat.RollbackMessage`
 
--   `org.apache.activemq.core.protocol.core.impl.wireformat.SessionCloseMessage`
+-   `org.apache.activemq.artemis.core.protocol.core.impl.wireformat.SessionCloseMessage`
 
--   `org.apache.activemq.core.protocol.core.impl.wireformat.SessionCommitMessage`
+-   `org.apache.activemq.artemis.core.protocol.core.impl.wireformat.SessionCommitMessage`
 
--   `org.apache.activemq.core.protocol.core.impl.wireformat.SessionXACommitMessage`
+-   `org.apache.activemq.artemis.core.protocol.core.impl.wireformat.SessionXACommitMessage`
 
--   `org.apache.activemq.core.protocol.core.impl.wireformat.SessionXAPrepareMessage`
+-   `org.apache.activemq.artemis.core.protocol.core.impl.wireformat.SessionXAPrepareMessage`
 
--   `org.apache.activemq.core.protocol.core.impl.wireformat.SessionXARollbackMessage`
+-   `org.apache.activemq.artemis.core.protocol.core.impl.wireformat.SessionXARollbackMessage`
 
 To disable asynchronous connection execution, set the parameter
 `async-connection-execution-enabled` in `activemq-configuration.xml` to

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/core-bridges.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/core-bridges.md b/docs/user-manual/en/core-bridges.md
index 3bf4f9d..d4b5b5e 100644
--- a/docs/user-manual/en/core-bridges.md
+++ b/docs/user-manual/en/core-bridges.md
@@ -1,7 +1,7 @@
 # Core Bridges
 
 The function of a bridge is to consume messages from a source queue, and
-forward them to a target address, typically on a different Apache ActiveMQ
+forward them to a target address, typically on a different Apache ActiveMQ Artemis
 server.
 
 The source and target servers do not have to be in the same cluster
@@ -14,9 +14,9 @@ connection is lost, e.g. due to network failure, the bridge will retry
 connecting to the target until it comes back online. When it comes back
 online it will resume operation as normal.
 
-In summary, bridges are a way to reliably connect two separate Apache ActiveMQ
+In summary, bridges are a way to reliably connect two separate Apache ActiveMQ Artemis
 servers together. With a core bridge both source and target servers must
-be Apache ActiveMQ servers.
+be Apache ActiveMQ Artemis servers.
 
 Bridges can be configured to provide *once and only once* delivery
 guarantees even in the event of the failure of the source or the target
@@ -27,7 +27,7 @@ server. They do this by using duplicate detection (described in [Duplicate Detec
 > Although they have similar function, don't confuse core bridges with
 > JMS bridges!
 >
-> Core bridges are for linking an Apache ActiveMQ node with another Apache ActiveMQ
+> Core bridges are for linking an Apache ActiveMQ Artemis node with another Apache ActiveMQ Artemis
 > node and do not use the JMS API. A JMS Bridge is used for linking any
 > two JMS 1.1 compliant JMS providers. So, a JMS Bridge could be used
 > for bridging to or from different JMS compliant messaging system. It's
@@ -102,7 +102,7 @@ Let's take a look at all the parameters in turn:
 
 -   `transformer-class-name`. An optional transformer-class-name can be
     specified. This is the name of a user-defined class which implements
-    the `org.apache.activemq.core.server.cluster.Transformer` interface.
+    the `org.apache.activemq.artemis.core.server.cluster.Transformer` interface.
 
     If this is specified then the transformer's `transform()` method
     will be invoked with the message before it is forwarded. This gives

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/diverts.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/diverts.md b/docs/user-manual/en/diverts.md
index 3876a22..c54b9b1 100644
--- a/docs/user-manual/en/diverts.md
+++ b/docs/user-manual/en/diverts.md
@@ -1,6 +1,6 @@
 # Diverting and Splitting Message Flows
 
-Apache ActiveMQ allows you to configure objects called *diverts* with some
+Apache ActiveMQ Artemis allows you to configure objects called *diverts* with some
 simple server configuration.
 
 Diverts allow you to transparently divert messages routed to one address

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/duplicate-detection.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/duplicate-detection.md b/docs/user-manual/en/duplicate-detection.md
index e02fcaf..6d9efe4 100644
--- a/docs/user-manual/en/duplicate-detection.md
+++ b/docs/user-manual/en/duplicate-detection.md
@@ -1,9 +1,9 @@
 # Duplicate Message Detection
 
-Apache ActiveMQ includes powerful automatic duplicate message detection,
+Apache ActiveMQ Artemis includes powerful automatic duplicate message detection,
 filtering out duplicate messages without you having to code your own
 fiddly duplicate detection logic at the application level. This chapter
-will explain what duplicate detection is, how Apache ActiveMQ uses it and how
+will explain what duplicate detection is, how Apache ActiveMQ Artemis uses it and how
 and where to configure it.
 
 When sending messages from a client to a server, or indeed from a server
@@ -34,7 +34,7 @@ server or connection fails while the transaction commit is being
 processed it is also indeterminate whether the transaction was
 successfully committed or not!
 
-To solve these issues Apache ActiveMQ provides automatic duplicate messages
+To solve these issues Apache ActiveMQ Artemis provides automatic duplicate messages
 detection for messages sent to addresses.
 
 ## Using Duplicate Detection for Message Sending
@@ -101,7 +101,7 @@ message.setStringProperty(HDR_DUPLICATE_DETECTION_ID.toString(), myUniqueID);
 ## Configuring the Duplicate ID Cache
 
 The server maintains caches of received values of the
-`org.apache.activemq.core.message.impl.HDR_DUPLICATE_DETECTION_ID`
+`org.apache.activemq.artemis.core.message.impl.HDR_DUPLICATE_DETECTION_ID`
 property sent to each address. Each address has its own distinct cache.
 
 The cache is a circular fixed size cache. If the cache has a maximum

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/embedding-activemq.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/embedding-activemq.md b/docs/user-manual/en/embedding-activemq.md
index e2383c0..dced121 100644
--- a/docs/user-manual/en/embedding-activemq.md
+++ b/docs/user-manual/en/embedding-activemq.md
@@ -1,36 +1,36 @@
-# Embedding Apache ActiveMQ
+# Embedding Apache ActiveMQ Artemis
 
-Apache ActiveMQ is designed as set of simple Plain Old Java Objects (POJOs).
-This means Apache ActiveMQ can be instantiated and run in any dependency
+Apache ActiveMQ Artemis is designed as set of simple Plain Old Java Objects (POJOs).
+This means Apache ActiveMQ Artemis can be instantiated and run in any dependency
 injection framework such as Spring or Google Guice. It also means that if you have an application that could use
 messaging functionality internally, then it can *directly instantiate*
-Apache ActiveMQ clients and servers in its own application code to perform that
-functionality. We call this *embedding* Apache ActiveMQ.
+Apache ActiveMQ Artemis clients and servers in its own application code to perform that
+functionality. We call this *embedding* Apache ActiveMQ Artemis.
 
 Examples of applications that might want to do this include any
 application that needs very high performance, transactional, persistent
 messaging but doesn't want the hassle of writing it all from scratch.
 
-Embedding Apache ActiveMQ can be done in very few easy steps. Instantiate the
+Embedding Apache ActiveMQ Artemis can be done in very few easy steps. Instantiate the
 configuration object, instantiate the server, start it, and you have a
-Apache ActiveMQ running in your virtual machine. It's as simple and easy as
+Apache ActiveMQ Artemis running in your virtual machine. It's as simple and easy as
 that.
 
 ## Simple Config File Embedding
 
-The simplest way to embed Apache ActiveMQ is to use the embedded wrapper
-classes and configure Apache ActiveMQ through its configuration files. There
+The simplest way to embed Apache ActiveMQ Artemis is to use the embedded wrapper
+classes and configure Apache ActiveMQ Artemis through its configuration files. There
 are two different helper classes for this depending on whether your
-using the Apache ActiveMQ Core API or JMS.
+using the Apache ActiveMQ Artemis Core API or JMS.
 
 ## Core API Only
 
-For instantiating a core Apache ActiveMQ Server only, the steps are pretty
+For instantiating a core Apache ActiveMQ Artemis Server only, the steps are pretty
 simple. The example requires that you have defined a configuration file
 `activemq-configuration.xml` in your classpath:
 
 ``` java
-import org.apache.activemq.core.server.embedded.EmbeddedActiveMQ;
+import org.apache.activemq.artemis.core.server.embedded.EmbeddedActiveMQ;
 
 ...
 
@@ -102,10 +102,10 @@ javadocs for this class for more details on other config options.
 ## POJO instantiation - Embedding Programmatically
 
 You can follow this step-by-step guide to programmatically embed the
-core, non-JMS Apache ActiveMQ Server instance:
+core, non-JMS Apache ActiveMQ Artemis Server instance:
 
 Create the configuration object - this contains configuration
-information for an Apache ActiveMQ instance. The setter methods of this class
+information for an Apache ActiveMQ Artemis instance. The setter methods of this class
 allow you to programmatically set configuration options as describe in
 the [Server Configuration](configuration-index.md) section.
 
@@ -114,8 +114,8 @@ The acceptors are configured through `ConfigurationImpl`. Just add the
 the main configuration file.
 
 ``` java
-import org.apache.activemq.core.config.Configuration;
-import org.apache.activemq.core.config.impl.ConfigurationImpl;
+import org.apache.activemq.artemis.core.config.Configuration;
+import org.apache.activemq.artemis.core.config.impl.ConfigurationImpl;
 
 ...
 
@@ -133,8 +133,8 @@ You need to instantiate an instance of
 the configuration object to it.
 
 ``` java
-import org.apache.activemq.api.core.server.ActiveMQ;
-import org.apache.activemq.core.server.embedded.EmbeddedActiveMQ;
+import org.apache.activemq.artemis.api.core.server.ActiveMQ;
+import org.apache.activemq.artemis.core.server.embedded.EmbeddedActiveMQ;
 
 ...
 
@@ -158,7 +158,7 @@ then set the JmsConfiguration property of the EmbeddedJMS class. Here is
 an example of this:
 
 ``` java
-// Step 1. Create Apache ActiveMQ core configuration, and set the properties accordingly
+// Step 1. Create Apache ActiveMQ Artemis core configuration, and set the properties accordingly
 Configuration configuration = new ConfigurationImpl();
 configuration.setPersistenceEnabled(false);
 configuration.setSecurityEnabled(false);
@@ -176,20 +176,20 @@ jmsConfig.getConnectionFactoryConfigurations().add(cfConfig);
 JMSQueueConfiguration queueConfig = new JMSQueueConfigurationImpl("queue1", null, false, "/queue/queue1");
 jmsConfig.getQueueConfigurations().add(queueConfig);
 
-// Step 5. Start the JMS Server using the Apache ActiveMQ core server and the JMS configuration
+// Step 5. Start the JMS Server using the Apache ActiveMQ Artemis core server and the JMS configuration
 EmbeddedJMS jmsServer = new EmbeddedJMS();
 jmsServer.setConfiguration(configuration);
 jmsServer.setJmsConfiguration(jmsConfig);
 jmsServer.start();
 ```
 
-Please see the examples for an example which shows how to setup and run Apache ActiveMQ
+Please see the examples for an example which shows how to setup and run Apache ActiveMQ Artemis
 embedded with JMS.
 
 ## Dependency Frameworks
 
 You may also choose to use a dependency injection framework such as
 The Spring Framework. See [Spring Integration](spring-integration.md) for more details on
-Spring and Apache ActiveMQ.
+Spring and Apache ActiveMQ Artemis.
 
-Apache ActiveMQ standalone uses [Airline](https://github.com/airlift/airline) to bootstrap.
+Apache ActiveMQ Artemis standalone uses [Airline](https://github.com/airlift/airline) to bootstrap.

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/examples.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/examples.md b/docs/user-manual/en/examples.md
index 1725d09..30e499e 100644
--- a/docs/user-manual/en/examples.md
+++ b/docs/user-manual/en/examples.md
@@ -1,7 +1,7 @@
 Examples
 ========
 
-The Apache ActiveMQ distribution comes with over 90 run out-of-the-box examples
+The Apache ActiveMQ Artemis distribution comes with over 90 run out-of-the-box examples
 demonstrating many of the features.
 
 The examples are available in the distribution, in the `examples`
@@ -39,11 +39,11 @@ Applet.
 Application-Layer Failover
 --------------------------
 
-Apache ActiveMQ also supports Application-Layer failover, useful in the case
+Apache ActiveMQ Artemis also supports Application-Layer failover, useful in the case
 that replication is not enabled on the server side.
 
 With Application-Layer failover, it's up to the application to register
-a JMS `ExceptionListener` with Apache ActiveMQ which will be called by Apache ActiveMQ
+a JMS `ExceptionListener` with Apache ActiveMQ Artemis which will be called by Apache ActiveMQ Artemis
 in the event that connection failure is detected.
 
 The code in the `ExceptionListener` then recreates the JMS connection,
@@ -64,7 +64,7 @@ The `bridge` example demonstrates a core bridge deployed on one server,
 which consumes messages from a local queue and forwards them to an
 address on a second server.
 
-Core bridges are used to create message flows between any two Apache ActiveMQ
+Core bridges are used to create message flows between any two Apache ActiveMQ Artemis
 servers which are remotely separated. Core bridges are resilient and
 will cope with temporary connection failure allowing them to be an ideal
 choice for forwarding over unreliable connections, e.g. a WAN.
@@ -73,7 +73,7 @@ Browser
 -------
 
 The `browser` example shows you how to use a JMS `QueueBrowser` with
-Apache ActiveMQ.
+Apache ActiveMQ Artemis.
 
 Queues are a standard part of JMS, please consult the JMS 1.1
 specification for full details.
@@ -99,7 +99,7 @@ Client-Side Load-Balancing
 
 The `client-side-load-balancing` example demonstrates how sessions
 created from a single JMS `Connection` can be created to different nodes
-of the cluster. In other words it demonstrates how Apache ActiveMQ does
+of the cluster. In other words it demonstrates how Apache ActiveMQ Artemis does
 client-side load-balancing of sessions across the cluster.
 
 Clustered Durable Subscription
@@ -169,11 +169,11 @@ and we verify that both subscribers receive all the sent messages.
 Message Consumer Rate Limiting
 ------------------------------
 
-With Apache ActiveMQ you can specify a maximum consume rate at which a JMS
+With Apache ActiveMQ Artemis you can specify a maximum consume rate at which a JMS
 MessageConsumer will consume messages. This can be specified when
 creating or deploying the connection factory.
 
-If this value is specified then Apache ActiveMQ will ensure that messages are
+If this value is specified then Apache ActiveMQ Artemis will ensure that messages are
 never consumed at a rate higher than the specified rate. This is a form
 of consumer throttling.
 
@@ -197,7 +197,7 @@ can be consumed for further investigation.
 Delayed Redelivery
 ------------------
 
-The `delayed-redelivery` example demonstrates how Apache ActiveMQ can be
+The `delayed-redelivery` example demonstrates how Apache ActiveMQ Artemis can be
 configured to provide a delayed redelivery in the case a message needs
 to be redelivered.
 
@@ -210,7 +210,7 @@ succession, using up valuable CPU and network resources.
 Divert
 ------
 
-Apache ActiveMQ diverts allow messages to be transparently "diverted" or copied
+Apache ActiveMQ Artemis diverts allow messages to be transparently "diverted" or copied
 from one address to another with just some simple configuration defined
 on the server side.
 
@@ -218,7 +218,7 @@ Durable Subscription
 --------------------
 
 The `durable-subscription` example shows you how to use a durable
-subscription with Apache ActiveMQ. Durable subscriptions are a standard part of
+subscription with Apache ActiveMQ Artemis. Durable subscriptions are a standard part of
 JMS, please consult the JMS 1.1 specification for full details.
 
 Unlike non-durable subscriptions, the key function of durable
@@ -239,7 +239,7 @@ Embedded Simple
 ---------------
 
 The `embedded` example shows how to embed JMS within your own code using
-regular Apache ActiveMQ XML files.
+regular Apache ActiveMQ Artemis XML files.
 
 Message Expiration
 ------------------
@@ -250,12 +250,12 @@ limited period of time before being removed. JMS specification states
 that clients should not receive messages that have been expired (but it
 does not guarantee this will not happen).
 
-Apache ActiveMQ can assign an expiry address to a given queue so that when
+Apache ActiveMQ Artemis can assign an expiry address to a given queue so that when
 messages are expired, they are removed from the queue and sent to the
 expiry address. These "expired" messages can later be consumed from the
 expiry address for further inspection.
 
-Apache ActiveMQ Resource Adapter example
+Apache ActiveMQ Artemis Resource Adapter example
 ---------------------------------
 
 This examples shows how to build the activemq resource adapters a rar
@@ -264,7 +264,7 @@ for deployment in other Application Server's
 HTTP Transport
 --------------
 
-The `http-transport` example shows you how to configure Apache ActiveMQ to use
+The `http-transport` example shows you how to configure Apache ActiveMQ Artemis to use
 the HTTP protocol as its transport layer.
 
 Instantiate JMS Objects Directly
@@ -275,22 +275,22 @@ instances are looked up from JNDI before being used by the client code.
 This objects are called "administered objects" in JMS terminology.
 
 However, in some cases a JNDI server may not be available or desired. To
-come to the rescue Apache ActiveMQ also supports the direct instantiation of
+come to the rescue Apache ActiveMQ Artemis also supports the direct instantiation of
 these administered objects on the client side so you don't have to use
 JNDI for JMS.
 
 Interceptor
 -----------
 
-Apache ActiveMQ allows an application to use an interceptor to hook into the
+Apache ActiveMQ Artemis allows an application to use an interceptor to hook into the
 messaging system. Interceptors allow you to handle various message
-events in Apache ActiveMQ.
+events in Apache ActiveMQ Artemis.
 
 JAAS
 ----
 
-The `jaas` example shows you how to configure Apache ActiveMQ to use JAAS for
-security. Apache ActiveMQ can leverage JAAS to delegate user authentication and
+The `jaas` example shows you how to configure Apache ActiveMQ Artemis to use JAAS for
+security. Apache ActiveMQ Artemis can leverage JAAS to delegate user authentication and
 authorization to existing security infrastructure.
 
 JMS Auto Closable
@@ -304,20 +304,20 @@ JMS Completion Listener
 -----------------------
 
 The `jms-completion-listener` example shows how to send a message
-asynchronously to Apache ActiveMQ and use a CompletionListener to be notified
+asynchronously to Apache ActiveMQ Artemis and use a CompletionListener to be notified
 of the Broker receiving it.
 
 JMS Bridge
 ----------
 
 The `jms-brige` example shows how to setup a bridge between two
-standalone Apache ActiveMQ servers.
+standalone Apache ActiveMQ Artemis servers.
 
 JMS Context
 -----------
 
 The `jms-context` example shows how to send and receive a message to a
-JMS Queue using Apache ActiveMQ by using a JMS Context.
+JMS Queue using Apache ActiveMQ Artemis by using a JMS Context.
 
 A JMSContext is part of JMS 2.0 and combines the JMS Connection and
 Session Objects into a simple Interface.
@@ -333,19 +333,19 @@ so you can share the load across different threads and connections.
 JMX Management
 --------------
 
-The `jmx` example shows how to manage Apache ActiveMQ using JMX.
+The `jmx` example shows how to manage Apache ActiveMQ Artemis using JMX.
 
 Large Message
 -------------
 
 The `large-message` example shows you how to send and receive very large
-messages with Apache ActiveMQ. Apache ActiveMQ supports the sending and receiving of
+messages with Apache ActiveMQ Artemis. Apache ActiveMQ Artemis supports the sending and receiving of
 huge messages, much larger than can fit in available RAM on the client
 or server. Effectively the only limit to message size is the amount of
 disk space you have on the server.
 
 Large messages are persisted on the server so they can survive a server
-restart. In other words Apache ActiveMQ doesn't just do a simple socket stream
+restart. In other words Apache ActiveMQ Artemis doesn't just do a simple socket stream
 from the sender to the consumer.
 
 Last-Value Queue
@@ -363,14 +363,14 @@ are only interested by the latest price for a particular stock.
 Management
 ----------
 
-The `management` example shows how to manage Apache ActiveMQ using JMS Messages
+The `management` example shows how to manage Apache ActiveMQ Artemis using JMS Messages
 to invoke management operations on the server.
 
 Management Notification
 -----------------------
 
 The `management-notification` example shows how to receive management
-notifications from Apache ActiveMQ using JMS messages. Apache ActiveMQ servers emit
+notifications from Apache ActiveMQ Artemis using JMS messages. Apache ActiveMQ Artemis servers emit
 management notifications when events of interest occur (consumers are
 created or closed, addresses are created or deleted, security
 authentication fails, etc.).
@@ -385,7 +385,7 @@ Message Group
 -------------
 
 The `message-group` example shows you how to configure and use message
-groups with Apache ActiveMQ. Message groups allow you to pin messages so they
+groups with Apache ActiveMQ Artemis. Message groups allow you to pin messages so they
 are only consumed by a single consumer. Message groups are sets of
 messages that has the following characteristics:
 
@@ -399,7 +399,7 @@ Message Group
 -------------
 
 The `message-group2` example shows you how to configure and use message
-groups with Apache ActiveMQ via a connection factory.
+groups with Apache ActiveMQ Artemis via a connection factory.
 
 Message Priority
 ----------------
@@ -434,19 +434,19 @@ backups but forcing failover back to the original live server
 No Consumer Buffering
 ---------------------
 
-By default, Apache ActiveMQ consumers buffer messages from the server in a
+By default, Apache ActiveMQ Artemis consumers buffer messages from the server in a
 client side buffer before you actually receive them on the client side.
 This improves performance since otherwise every time you called
 receive() or had processed the last message in a
-`MessageListener onMessage()` method, the Apache ActiveMQ client would have to
+`MessageListener onMessage()` method, the Apache ActiveMQ Artemis client would have to
 go the server to request the next message, which would then get sent to
 the client side, if one was available.
 
 This would involve a network round trip for every message and reduce
-performance. Therefore, by default, Apache ActiveMQ pre-fetches messages into a
+performance. Therefore, by default, Apache ActiveMQ Artemis pre-fetches messages into a
 buffer on each consumer.
 
-In some case buffering is not desirable, and Apache ActiveMQ allows it to be
+In some case buffering is not desirable, and Apache ActiveMQ Artemis allows it to be
 switched off. This example demonstrates that.
 
 Non-Transaction Failover With Server Data Replication
@@ -457,7 +457,7 @@ as a live-backup pair for high availability (HA), and a client using a
 *non-transacted* JMS session failing over from live to backup when the
 live server is crashed.
 
-Apache ActiveMQ implements failover of client connections between live and
+Apache ActiveMQ Artemis implements failover of client connections between live and
 backup servers. This is implemented by the replication of state between
 live and backup nodes. When replication is configured and a live node
 crashes, the client connections can carry and continue to send and
@@ -468,13 +468,13 @@ messages will be lost or delivered twice.
 OpenWire
 --------
 
-The `Openwire` example shows how to configure an Apache ActiveMQ server to
-communicate with an Apache ActiveMQ JMS client that uses open-wire protocol.
+The `Openwire` example shows how to configure an Apache ActiveMQ Artemis server to
+communicate with an Apache ActiveMQ Artemis JMS client that uses open-wire protocol.
 
 Paging
 ------
 
-The `paging` example shows how Apache ActiveMQ can support huge queues even
+The `paging` example shows how Apache ActiveMQ Artemis can support huge queues even
 when the server is running in limited RAM. It does this by transparently
 *paging* messages to disk, and *depaging* them when they are required.
 
@@ -490,27 +490,27 @@ All of these standard modes involve sending acknowledgements from the
 client to the server. However in some cases, you really don't mind
 losing messages in event of failure, so it would make sense to
 acknowledge the message on the server before delivering it to the
-client. This example demonstrates how Apache ActiveMQ allows this with an extra
+client. This example demonstrates how Apache ActiveMQ Artemis allows this with an extra
 acknowledgement mode.
 
 Message Producer Rate Limiting
 ------------------------------
 
-The `producer-rte-limit` example demonstrates how, with Apache ActiveMQ, you
+The `producer-rte-limit` example demonstrates how, with Apache ActiveMQ Artemis, you
 can specify a maximum send rate at which a JMS message producer will
 send messages.
 
 Proton Qpid
 -----------
 
-Apache ActiveMQ can be configured to accept requests from any AMQP client that
+Apache ActiveMQ Artemis can be configured to accept requests from any AMQP client that
 supports the 1.0 version of the protocol. This `proton-j` example shows
 a simply qpid java 1.0 client example.
 
 Proton Ruby
 -----------
 
-Apache ActiveMQ can be configured to accept requests from any AMQP client that
+Apache ActiveMQ Artemis can be configured to accept requests from any AMQP client that
 supports the 1.0 version of the protocol. This example shows a simply
 proton ruby client that sends and receives messages
 
@@ -542,7 +542,7 @@ Reattach Node example
 
 The `Reattach Node` example shows how a client can try to reconnect to
 the same server instead of failing the connection immediately and
-notifying any user ExceptionListener objects. Apache ActiveMQ can be configured
+notifying any user ExceptionListener objects. Apache ActiveMQ Artemis can be configured
 to automatically retry the connection, and reattach to the server when
 it becomes available again across the network.
 
@@ -581,25 +581,25 @@ A simple example showing the JMS request-response pattern.
 Rest example
 ------------
 
-An example showing how to use the Apache ActiveMQ Rest API
+An example showing how to use the Apache ActiveMQ Artemis Rest API
 
 Scheduled Message
 -----------------
 
 The `scheduled-message` example shows you how to send a scheduled
-message to a JMS Queue with Apache ActiveMQ. Scheduled messages won't get
+message to a JMS Queue with Apache ActiveMQ Artemis. Scheduled messages won't get
 delivered until a specified time in the future.
 
 Security
 --------
 
 The `security` example shows you how configure and use role based queue
-security with Apache ActiveMQ.
+security with Apache ActiveMQ Artemis.
 
 Send Acknowledgements
 ---------------------
 
-The `send-acknowledgements` example shows you how to use Apache ActiveMQ's
+The `send-acknowledgements` example shows you how to use Apache ActiveMQ Artemis's
 advanced *asynchronous send acknowledgements* feature to obtain
 acknowledgement from the server that sends have been received and
 processed in a separate stream to the sent messages.
@@ -607,49 +607,49 @@ processed in a separate stream to the sent messages.
 Spring Integration
 ------------------
 
-This example shows how to use embedded JMS using Apache ActiveMQ's Spring
+This example shows how to use embedded JMS using Apache ActiveMQ Artemis's Spring
 integration.
 
 SSL Transport
 -------------
 
-The `ssl-enabled` shows you how to configure SSL with Apache ActiveMQ to send
+The `ssl-enabled` shows you how to configure SSL with Apache ActiveMQ Artemis to send
 and receive message.
 
 Static Message Selector
 -----------------------
 
-The `static-selector` example shows you how to configure an Apache ActiveMQ core
+The `static-selector` example shows you how to configure an Apache ActiveMQ Artemis core
 queue with static message selectors (filters).
 
 Static Message Selector Using JMS
 ---------------------------------
 
-The `static-selector-jms` example shows you how to configure an Apache ActiveMQ
+The `static-selector-jms` example shows you how to configure an Apache ActiveMQ Artemis
 queue with static message selectors (filters) using JMS.
 
 Stomp
 -----
 
-The `stomp` example shows you how to configure an Apache ActiveMQ server to send
+The `stomp` example shows you how to configure an Apache ActiveMQ Artemis server to send
 and receive Stomp messages.
 
 Stomp1.1
 --------
 
-The `stomp` example shows you how to configure an Apache ActiveMQ server to send
+The `stomp` example shows you how to configure an Apache ActiveMQ Artemis server to send
 and receive Stomp messages via a Stomp 1.1 connection.
 
 Stomp1.2
 --------
 
-The `stomp` example shows you how to configure an Apache ActiveMQ server to send
+The `stomp` example shows you how to configure an Apache ActiveMQ Artemis server to send
 and receive Stomp messages via a Stomp 1.2 connection.
 
 Stomp Over Web Sockets
 ----------------------
 
-The `stomp-websockets` example shows you how to configure an Apache ActiveMQ
+The `stomp-websockets` example shows you how to configure an Apache ActiveMQ Artemis
 server to send and receive Stomp messages directly from Web browsers
 (provided they support Web Sockets).
 
@@ -657,9 +657,9 @@ Symmetric Cluster
 -----------------
 
 The `symmetric-cluster` example demonstrates a symmetric cluster set-up
-with Apache ActiveMQ.
+with Apache ActiveMQ Artemis.
 
-Apache ActiveMQ has extremely flexible clustering which allows you to set-up
+Apache ActiveMQ Artemis has extremely flexible clustering which allows you to set-up
 servers in many different topologies. The most common topology that
 you'll perhaps be familiar with if you are used to application server
 clustering is a symmetric cluster.
@@ -681,7 +681,7 @@ A simple example demonstrating a JMS topic.
 Topic Hierarchy
 ---------------
 
-Apache ActiveMQ supports topic hierarchies. With a topic hierarchy you can
+Apache ActiveMQ Artemis supports topic hierarchies. With a topic hierarchy you can
 register a subscriber with a wild-card and that subscriber will receive
 any messages sent to an address that matches the wild card.
 
@@ -689,7 +689,7 @@ Topic Selector 1
 ----------------
 
 The `topic-selector-example1` example shows you how to send message to a
-JMS Topic, and subscribe them using selectors with Apache ActiveMQ.
+JMS Topic, and subscribe them using selectors with Apache ActiveMQ Artemis.
 
 Topic Selector 2
 ----------------
@@ -705,7 +705,7 @@ live-backup pair for high availability (HA), and a client using a
 transacted JMS session failing over from live to backup when the live
 server is crashed.
 
-Apache ActiveMQ implements failover of client connections between live and
+Apache ActiveMQ Artemis implements failover of client connections between live and
 backup servers. This is implemented by the sharing of a journal between
 the servers. When a live node crashes, the client connections can carry
 and continue to send and consume messages. When transacted sessions are
@@ -722,13 +722,13 @@ Transactional Session
 ---------------------
 
 The `transactional` example shows you how to use a transactional Session
-with Apache ActiveMQ.
+with Apache ActiveMQ Artemis.
 
 XA Heuristic
 ------------
 
 The `xa-heuristic` example shows you how to make an XA heuristic
-decision through Apache ActiveMQ Management Interface. A heuristic decision is
+decision through Apache ActiveMQ Artemis Management Interface. A heuristic decision is
 a unilateral decision to commit or rollback an XA transaction branch
 after it has been prepared.
 
@@ -736,13 +736,13 @@ XA Receive
 ----------
 
 The `xa-receive` example shows you how message receiving behaves in an
-XA transaction in Apache ActiveMQ.
+XA transaction in Apache ActiveMQ Artemis.
 
 XA Send
 -------
 
 The `xa-send` example shows you how message sending behaves in an XA
-transaction in Apache ActiveMQ.
+transaction in Apache ActiveMQ Artemis.
 Core API Examples
 =================
 
@@ -752,5 +752,5 @@ directory and type `ant`
 Embedded
 --------
 
-The `embedded` example shows how to embed the Apache ActiveMQ server within
+The `embedded` example shows how to embed the Apache ActiveMQ Artemis server within
 your own code.

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/filter-expressions.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/filter-expressions.md b/docs/user-manual/en/filter-expressions.md
index 4375dc0..a958a9d 100644
--- a/docs/user-manual/en/filter-expressions.md
+++ b/docs/user-manual/en/filter-expressions.md
@@ -1,6 +1,6 @@
 # Filter Expressions
 
-Apache ActiveMQ provides a powerful filter language based on a subset of the
+Apache ActiveMQ Artemis provides a powerful filter language based on a subset of the
 SQL 92 expression syntax.
 
 It is the same as the syntax used for JMS selectors, but the predefined
@@ -8,7 +8,7 @@ identifiers are different. For documentation on JMS selector syntax
 please the JMS javadoc for
 [javax.jms.Message](http://docs.oracle.com/javaee/6/api/javax/jms/Message.html).
 
-Filter expressions are used in several places in Apache ActiveMQ
+Filter expressions are used in several places in Apache ActiveMQ Artemis
 
 -   Predefined Queues. When pre-defining a queue, in
     `activemq-configuration.xml` in either the core or jms configuration a filter
@@ -24,9 +24,9 @@ Filter expressions are used in several places in Apache ActiveMQ
 -   Filter are also used programmatically when creating consumers,
     queues and in several places as described in [management](management.md).
 
-There are some differences between JMS selector expressions and Apache ActiveMQ
+There are some differences between JMS selector expressions and Apache ActiveMQ Artemis
 core filter expressions. Whereas JMS selector expressions operate on a
-JMS message, Apache ActiveMQ core filter expressions operate on a core message.
+JMS message, Apache ActiveMQ Artemis core filter expressions operate on a core message.
 
 The following identifiers can be used in a core filter expressions to
 refer to attributes of the core message in an expression:

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/flow-control.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/flow-control.md b/docs/user-manual/en/flow-control.md
index 0f9ce42..92eabb0 100644
--- a/docs/user-manual/en/flow-control.md
+++ b/docs/user-manual/en/flow-control.md
@@ -17,17 +17,17 @@ they cannot be processed in time.
 
 ## Window-Based Flow Control
 
-By default, Apache ActiveMQ consumers buffer messages from the server in a
+By default, Apache ActiveMQ Artemis consumers buffer messages from the server in a
 client side buffer before the client consumes them. This improves
 performance: otherwise every time the client consumes a message,
-Apache ActiveMQ would have to go the server to request the next message. In
+Apache ActiveMQ Artemis would have to go the server to request the next message. In
 turn, this message would then get sent to the client side, if one was
 available.
 
 A network round trip would be involved for *every* message and
 considerably reduce performance.
 
-To prevent this, Apache ActiveMQ pre-fetches messages into a buffer on each
+To prevent this, Apache ActiveMQ Artemis pre-fetches messages into a buffer on each
 consumer. The total maximum size of messages (in bytes) that will be
 buffered on each consumer is determined by the `consumerWindowSize`
 parameter.
@@ -89,7 +89,7 @@ of 1MiB is fine in most cases.
 
 ### Using Core API
 
-If Apache ActiveMQ Core API is used, the consumer window size is specified by
+If Apache ActiveMQ Artemis Core API is used, the consumer window size is specified by
 `ServerLocator.setConsumerWindowSize()` method and some of the
 `ClientSession.createConsumer()` methods.
 
@@ -101,14 +101,14 @@ environment, e.g. `jndi.properties`. Here's a simple example using the
 "ConnectionFactory" connection factory which is available in the context
 by default:
 
-    java.naming.factory.initial=org.apache.activemq.jndi.ActiveMQInitialContextFactory
+    java.naming.factory.initial=ActiveMQInitialContextFactory
     connectionFactory.myConnectionFactory=tcp://localhost:61616?consumerWindowSize=0
 
 If the connection factory is directly instantiated, the consumer window
 size is specified by `ActiveMQConnectionFactory.setConsumerWindowSize()`
 method.
 
-Please see the examples for an example which shows how to configure Apache ActiveMQ to
+Please see the examples for an example which shows how to configure Apache ActiveMQ Artemis to
 prevent consumer buffering when dealing with slow consumers.
 
 ## Rate limited flow control
@@ -127,7 +127,7 @@ Please see ? for a working example of limiting consumer rate.
 
 ### Using Core API
 
-If the Apache ActiveMQ core API is being used the rate can be set via the
+If the Apache ActiveMQ Artemis core API is being used the rate can be set via the
 `ServerLocator.setConsumerMaxRate(int consumerMaxRate)` method or
 alternatively via some of the `ClientSession.createConsumer()` methods.
 
@@ -138,7 +138,7 @@ max rate can be configured in the JNDI context environment, e.g.
 `jndi.properties`. Here's a simple example using the "ConnectionFactory"
 connection factory which is available in the context by default:
 
-    java.naming.factory.initial=org.apache.activemq.jndi.ActiveMQInitialContextFactory
+    java.naming.factory.initial=ActiveMQInitialContextFactory
     java.naming.provider.url=tcp://localhost:61616?consumerMaxRate=10
 
 If the connection factory is directly instantiated, the max rate size
@@ -158,12 +158,12 @@ prevent consumer buffering when dealing with slow consumers.
 
 ## Producer flow control
 
-Apache ActiveMQ also can limit the amount of data sent from a client to a
+Apache ActiveMQ Artemis also can limit the amount of data sent from a client to a
 server to prevent the server being overwhelmed.
 
 ### Window based flow control
 
-In a similar way to consumer window based flow control, Apache ActiveMQ
+In a similar way to consumer window based flow control, Apache ActiveMQ Artemis
 producers, by default, can only send messages to an address as long as
 they have sufficient credits to do so. The amount of credits required to
 send a message is given by the size of the message.
@@ -180,7 +180,7 @@ prevents the remoting connection from getting overloaded.
 
 #### Using Core API
 
-If the Apache ActiveMQ core API is being used, window size can be set via the
+If the Apache ActiveMQ Artemis core API is being used, window size can be set via the
 `ServerLocator.setProducerWindowSize(int producerWindowSize)` method.
 
 #### Using JMS
@@ -191,7 +191,7 @@ e.g. `jndi.properties`. Here's a simple example using the
 "ConnectionFactory" connection factory which is available in the context
 by default:
 
-    java.naming.factory.initial=org.apache.activemq.jndi.ActiveMQInitialContextFactory
+    java.naming.factory.initial=ActiveMQInitialContextFactory
     connectionFactory.myConnectionFactory=tcp://localhost:61616?producerWindowSize=10
 
 If the connection factory is directly instantiated, the producer window
@@ -260,8 +260,8 @@ control.
 
 ### Rate limited flow control
 
-Apache ActiveMQ also allows the rate a producer can emit message to be limited,
-in units of messages per second. By specifying such a rate, Apache ActiveMQ
+Apache ActiveMQ Artemis also allows the rate a producer can emit message to be limited,
+in units of messages per second. By specifying such a rate, Apache ActiveMQ Artemis
 will ensure that producer never produces messages at a rate higher than
 that specified.
 
@@ -274,7 +274,7 @@ Please see [the examples chapter](examples.md) for a working example of limiting
 
 #### Using Core API
 
-If the Apache ActiveMQ core API is being used the rate can be set via the
+If the Apache ActiveMQ Artemis core API is being used the rate can be set via the
 `ServerLocator.setProducerMaxRate(int producerMaxRate)` method or
 alternatively via some of the `ClientSession.createProducer()` methods.
 
@@ -285,7 +285,7 @@ max rate size can be configured in the JNDI context environment, e.g.
 `jndi.properties`. Here's a simple example using the "ConnectionFactory"
 connection factory which is available in the context by default:
 
-    java.naming.factory.initial=org.apache.activemq.jndi.ActiveMQInitialContextFactory
+    java.naming.factory.initial=ActiveMQInitialContextFactory
     connectionFactory.myConnectionFactory=tcp://localhost:61616?producerMaxRate=10
 
 If the connection factory is directly instantiated, the max rate size


Mime
View raw message