You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@activemq.apache.org by cl...@apache.org on 2015/03/03 18:18:56 UTC
[6/9] activemq-6 git commit: update user manual to use the phrase
'Apache ActiveMQ'
update user manual to use the phrase 'Apache ActiveMQ'
Project: http://git-wip-us.apache.org/repos/asf/activemq-6/repo
Commit: http://git-wip-us.apache.org/repos/asf/activemq-6/commit/9d72cefd
Tree: http://git-wip-us.apache.org/repos/asf/activemq-6/tree/9d72cefd
Diff: http://git-wip-us.apache.org/repos/asf/activemq-6/diff/9d72cefd
Branch: refs/heads/master
Commit: 9d72cefd925adac2b3f0ecccc58598343a7f4c93
Parents: 67c0ce5
Author: Andy Taylor <an...@apache.org>
Authored: Tue Mar 3 16:12:34 2015 +0000
Committer: Andy Taylor <an...@apache.org>
Committed: Tue Mar 3 16:36:33 2015 +0000
----------------------------------------------------------------------
docs/user-manual/en/README.md | 4 +-
docs/user-manual/en/SUMMARY.md | 4 +-
docs/user-manual/en/aerogear-integration.md | 2 +-
docs/user-manual/en/architecture.md | 48 ++++----
docs/user-manual/en/client-classpath.md | 12 +-
docs/user-manual/en/client-reconnection.md | 8 +-
docs/user-manual/en/clusters.md | 66 +++++-----
docs/user-manual/en/configuration-index.md | 26 ++--
docs/user-manual/en/configuring-transports.md | 20 +--
docs/user-manual/en/connection-ttl.md | 12 +-
docs/user-manual/en/core-bridges.md | 8 +-
docs/user-manual/en/diverts.md | 2 +-
docs/user-manual/en/duplicate-detection.md | 6 +-
docs/user-manual/en/embedding-activemq.md | 36 +++---
docs/user-manual/en/examples.md | 130 ++++++++++----------
docs/user-manual/en/filter-expressions.md | 8 +-
docs/user-manual/en/flow-control.md | 24 ++--
docs/user-manual/en/ha.md | 28 ++---
docs/user-manual/en/intercepting-operations.md | 2 +-
docs/user-manual/en/interoperability.md | 76 ++++++------
docs/user-manual/en/jms-bridge.md | 20 +--
docs/user-manual/en/jms-core-mapping.md | 4 +-
docs/user-manual/en/large-messages.md | 16 +--
docs/user-manual/en/libaio.md | 8 +-
docs/user-manual/en/logging.md | 6 +-
docs/user-manual/en/management.md | 62 +++++-----
docs/user-manual/en/message-expiry.md | 6 +-
docs/user-manual/en/message-grouping.md | 2 +-
docs/user-manual/en/messaging-concepts.md | 26 ++--
docs/user-manual/en/paging.md | 12 +-
docs/user-manual/en/perf-tuning.md | 14 +--
docs/user-manual/en/persistence.md | 42 +++----
docs/user-manual/en/pre-acknowledge.md | 4 +-
docs/user-manual/en/preface.md | 14 +--
docs/user-manual/en/project-info.md | 6 +-
docs/user-manual/en/rest.md | 114 ++++++++---------
docs/user-manual/en/security.md | 14 +--
docs/user-manual/en/send-guarantees.md | 16 +--
docs/user-manual/en/slow-consumers.md | 2 +-
docs/user-manual/en/spring-integration.md | 6 +-
docs/user-manual/en/thread-pooling.md | 14 +--
docs/user-manual/en/tools.md | 4 +-
docs/user-manual/en/transaction-config.md | 6 +-
docs/user-manual/en/undelivered-messages.md | 8 +-
docs/user-manual/en/using-core.md | 10 +-
docs/user-manual/en/using-jms.md | 18 +--
docs/user-manual/en/using-server.md | 22 ++--
docs/user-manual/en/vertx-integration.md | 10 +-
docs/user-manual/en/wildcard-routing.md | 2 +-
docs/user-manual/en/wildcard-syntax.md | 6 +-
examples/jms/queue/pom.xml | 2 +-
51 files changed, 509 insertions(+), 509 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/docs/user-manual/en/README.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/README.md b/docs/user-manual/en/README.md
index 3eae03d..1d35c43 100644
--- a/docs/user-manual/en/README.md
+++ b/docs/user-manual/en/README.md
@@ -1,7 +1,7 @@
-ActiveMQ User Manual
+Apache ActiveMQ User Manual
====================
-The User manual is an in depth manual on all aspects of ActiveMQ
+The User manual is an in depth manual on all aspects of Apache ActiveMQ
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/docs/user-manual/en/SUMMARY.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/SUMMARY.md b/docs/user-manual/en/SUMMARY.md
index 000a539..d9f0d34 100644
--- a/docs/user-manual/en/SUMMARY.md
+++ b/docs/user-manual/en/SUMMARY.md
@@ -13,7 +13,7 @@
* [The Client Classpath](client-classpath.md)
* [Examples](examples.md)
* [Routing Messages With Wild Cards](wildcard-routing.md)
-* [Understanding the ActiveMQ Wildcard Syntax](wildcard-syntax.md)
+* [Understanding the Apache ActiveMQ Wildcard Syntax](wildcard-syntax.md)
* [Filter Expressions](filter-expressions.md)
* [Persistence](persistence.md)
* [Configuring Transports](configuring-transports.md)
@@ -45,7 +45,7 @@
* [Thread management](thread-pooling.md)
* [Logging](logging.md)
* [REST Interface](rest.md)
-* [Embedding ActiveMQ](embedding-activemq.md)
+* [Embedding Apache ActiveMQ](embedding-activemq.md)
* [Spring Integration](spring-integration.md)
* [AeroGear Integration](aerogear-integration.md)
* [VertX Integration](vertx-integration.md)
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/docs/user-manual/en/aerogear-integration.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/aerogear-integration.md b/docs/user-manual/en/aerogear-integration.md
index 57c30a8..df1f3e0 100644
--- a/docs/user-manual/en/aerogear-integration.md
+++ b/docs/user-manual/en/aerogear-integration.md
@@ -2,7 +2,7 @@
AeroGears push technology provides support for different push
notification technologies like Google Cloud Messaging, Apple's APNs or
-Mozilla's SimplePush. ActiveMQ allows you to configure a Connector
+Mozilla's SimplePush. Apache ActiveMQ allows you to configure a Connector
Service that will consume messages from a queue and forward them to an
AeroGear push server and subsequently sent as notifications to mobile
devices.
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/docs/user-manual/en/architecture.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/architecture.md b/docs/user-manual/en/architecture.md
index 8390490..0290a9f 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 ActiveMQ high level
+In this section we will give an overview of the Apache ActiveMQ high level
architecture.
## Core Architecture
-ActiveMQ core is designed simply as set of Plain Old Java Objects
+Apache ActiveMQ 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, ActiveMQ core has only one jar dependency, netty.jar,
+possible. In fact, Apache ActiveMQ 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 ActiveMQ to be easily embedded in your own project, or
+This allows Apache ActiveMQ to be easily embedded in your own project, or
instantiated in any dependency injection framework such as Spring or
Google Guice.
-Each ActiveMQ server has its own ultra high performance persistent
+Each Apache ActiveMQ 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.
-ActiveMQ clients, potentially on different physical machines interact
-with the ActiveMQ server. ActiveMQ currently provides two APIs for
+Apache ActiveMQ clients, potentially on different physical machines interact
+with the Apache ActiveMQ server. Apache ActiveMQ 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.
-ActiveMQ also provides different protocol implementations on the server so you can use respective clients for these protocols:
+Apache ActiveMQ 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 @@ ActiveMQ also provides different protocol implementations on the server so you c
JMS semantics are implemented by a JMS facade layer on the client
side.
-The ActiveMQ server does not speak JMS and in fact does not know
+The Apache ActiveMQ 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 ActiveMQ core client API before
-being transferred over the wire using the ActiveMQ wire format.
+are translated into operations on the Apache ActiveMQ core client API before
+being transferred over the wire using the Apache ActiveMQ wire format.
The server always just deals with core API interactions.
@@ -59,25 +59,25 @@ A schematic illustrating this relationship is shown in figure 3.1 below:
-Figure 3.1 shows two user applications interacting with a ActiveMQ
+Figure 3.1 shows two user applications interacting with an Apache ActiveMQ
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.
-## ActiveMQ embedded in your own application
+## Apache ActiveMQ embedded in your own application
-ActiveMQ core is designed as a set of simple POJOs so if you have an
+Apache ActiveMQ 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 a ActiveMQ server you can directly
-instantiate and embed ActiveMQ servers in your own application.
+don't want to expose that as an Apache ActiveMQ server you can directly
+instantiate and embed Apache ActiveMQ servers in your own application.
-For more information on embedding ActiveMQ, see [Embedding ActiveMQ](embedding-activemq.md).
+For more information on embedding Apache ActiveMQ, see [Embedding Apache ActiveMQ](embedding-Apache activemq.md).
-## ActiveMQ integrated with a JEE application server
+## Apache ActiveMQ integrated with a JEE application server
-ActiveMQ provides its own fully functional Java Connector Architecture
+Apache ActiveMQ provides its own fully functional Java Connector Architecture
(JCA) adaptor which enables it to be integrated easily into any JEE
compliant application server or servlet engine.
@@ -110,12 +110,12 @@ 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
-ActiveMQ server via the ActiveMQ JCA adaptor. Note that all
+Apache ActiveMQ server via the Apache ActiveMQ JCA adaptor. Note that all
communication between EJB sessions or entity beans and Message Driven
-beans go through the adaptor and not directly to ActiveMQ.
+beans go through the adaptor and not directly to Apache ActiveMQ.
The large arrow with the prohibited sign shows an EJB session bean
-talking directly to the ActiveMQ server. This is not recommended as
+talking directly to the Apache ActiveMQ 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,9 +123,9 @@ 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).
-## ActiveMQ stand-alone server
+## Apache ActiveMQ stand-alone server
-ActiveMQ can also be deployed as a stand-alone server. This means a
+Apache ActiveMQ can also be deployed as a stand-alone server. This means a
fully independent messaging server not dependent on a JEE application
server.
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/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 120fce5..748fe0c 100644
--- a/docs/user-manual/en/client-classpath.md
+++ b/docs/user-manual/en/client-classpath.md
@@ -1,19 +1,19 @@
# The Client Classpath
-ActiveMQ requires several jars on the *Client Classpath* depending on
-whether the client uses ActiveMQ Core API, JMS, and JNDI.
+Apache ActiveMQ requires several jars on the *Client Classpath* depending on
+whether the client uses Apache ActiveMQ Core API, JMS, and JNDI.
> **Warning**
>
> All the jars mentioned here can be found in the `lib` directory of the
-> ActiveMQ distribution. Be sure you only use the jars from the correct
+> Apache ActiveMQ 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 ActiveMQ versions. Mixing and matching different jar
+> from different Apache ActiveMQ versions. Mixing and matching different jar
> versions may cause subtle errors and failures to occur.
-## ActiveMQ Core Client
+## Apache ActiveMQ Core Client
-If you are using just a pure ActiveMQ Core client (i.e. no JMS) then you
+If you are using just a pure Apache ActiveMQ 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/9d72cefd/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 140189f..661d987 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
-ActiveMQ clients can be configured to automatically reconnect or
+Apache ActiveMQ 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, ActiveMQ will automatically re-attach the client
+In this scenario, Apache ActiveMQ 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 ActiveMQ clients send commands to their servers they store each sent
+As Apache ActiveMQ 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, ActiveMQ will automatically reconnect the connection and
+In this case, Apache ActiveMQ 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.
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/docs/user-manual/en/clusters.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/clusters.md b/docs/user-manual/en/clusters.md
index 831501d..6dc8f15 100644
--- a/docs/user-manual/en/clusters.md
+++ b/docs/user-manual/en/clusters.md
@@ -2,9 +2,9 @@
## Clusters Overview
-ActiveMQ clusters allow groups of ActiveMQ servers to be grouped
+Apache ActiveMQ clusters allow groups of Apache ActiveMQ servers to be grouped
together in order to share message processing load. Each active node in
-the cluster is an active ActiveMQ server which manages its own messages
+the cluster is an active Apache ActiveMQ 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 ActiveMQ will redistribute messages between
+message redistribution where Apache ActiveMQ 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 ActiveMQ files. Do not
-> copy the ActiveMQ *data* (i.e. the `bindings`, `journal`, and
+> However, care must be taken when copying the Apache ActiveMQ files. Do not
+> copy the Apache ActiveMQ *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 ActiveMQ connections to clients and to other servers over
+around normal Apache ActiveMQ 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
-ActiveMQ server. All broadcast groups must be defined in a
+Apache ActiveMQ 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 ActiveMQ can load it.
+ file is in the java resource path so that Apache ActiveMQ 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 activemq to use this stacks for channel creation, you have to make
+want Apache activemq 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 ActiveMQ:
+Discovery groups are used in two places in Apache ActiveMQ:
- 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 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 ActiveMQ connections.
+normal Apache ActiveMQ connections.
> **Note**
>
@@ -274,7 +274,7 @@ normal 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 ActiveMQ server. Let's look at an example:
+discovery groups defined by Apache ActiveMQ 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 ActiveMQ can load it.
+ file is in the java resource path so that Apache ActiveMQ 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 a ActiveMQ client to use discovery to
+Let's discuss how to configure an Apache ActiveMQ 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.
@@ -511,7 +511,7 @@ ClientSession session = factory.createSession();
## Server-Side Message Load Balancing
If cluster connections are defined between nodes of a cluster, then
-ActiveMQ will load balance messages arriving at a particular node from a
+Apache ActiveMQ 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.
-ActiveMQ cluster connections can be configured to always blindly load
+Apache ActiveMQ 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 ActiveMQ
+There can be zero or more cluster connections defined per Apache ActiveMQ
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 ActiveMQ Server can effectively take
+ different addresses a single Apache ActiveMQ 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
- ActiveMQ will *not* forward messages to other nodes if there are no
+ Apache ActiveMQ 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 ActiveMQ will only forward messages
+ If this is set to `false` then Apache ActiveMQ 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. ActiveMQ can be
+ directly connected to it via a cluster connection. Apache ActiveMQ can be
configured to also load balance messages to nodes which might be
- connected to it only indirectly with other ActiveMQ servers as
+ connected to it only indirectly with other Apache ActiveMQ servers as
intermediates in a chain.
- This allows ActiveMQ to be configured in more complex topologies and
+ This allows Apache ActiveMQ 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 ActiveMQ serves which are directly
+ are only load balanced to other Apache ActiveMQ serves which are directly
connected to this server. This parameter is optional.
- `confirmation-window-size`. The size (in bytes) of the window used
@@ -770,7 +770,7 @@ connection has been made.
### Cluster User Credentials
When creating connections between nodes of a cluster to form a cluster
-connection, ActiveMQ uses a cluster user and cluster password which is
+connection, Apache ActiveMQ uses a cluster user and cluster password which is
defined in `activemq-configuration.xml`:
<cluster-user>ACTIVEMQ.CLUSTER.ADMIN.USER</cluster-user>
@@ -780,18 +780,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, ActiveMQ
+> the default values. If they are not changed from the default, Apache ActiveMQ
> will detect this and pester you with a warning on every start-up.
## Client-Side Load balancing
-With ActiveMQ client-side load balancing, subsequent sessions created
+With Apache ActiveMQ 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. ActiveMQ provides four out-of-the-box load balancing
+configurable. Apache ActiveMQ 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
@@ -908,7 +908,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 ActiveMQ can be configured to automatically
+redistribution Apache ActiveMQ 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.
@@ -937,7 +937,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 ActiveMQ wildcard syntax (described in [Wildcard Syntax](wildcard-syntax.md)).
+conforms to the Apache ActiveMQ 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
@@ -953,7 +953,7 @@ redistribute immediately since the new consumer will arrive shortly.
## Cluster topologies
-ActiveMQ clusters can be connected together in many different
+Apache ActiveMQ clusters can be connected together in many different
topologies, let's consider the two most common ones here
### Symmetric cluster
@@ -1012,13 +1012,13 @@ which does have consumers.
### Scaling Down
-ActiveMQ supports scaling down a cluster with no message loss (even for
+Apache ActiveMQ 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. ActiveMQ can be configured to do
+them to another node in the cluster. Apache ActiveMQ 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/9d72cefd/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 8ece98e..c5b32be 100644
--- a/docs/user-manual/en/configuration-index.md
+++ b/docs/user-manual/en/configuration-index.md
@@ -1800,21 +1800,21 @@ element is used by the server side JMS service to load JMS Queues, Topics
Using Masked Passwords in Configuration Files
---------------------------------------------
-By default all passwords in ActiveMQ server's configuration files are in
+By default all passwords in Apache ActiveMQ 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.
-ActiveMQ can be configured to use 'masked' passwords in its
+Apache ActiveMQ 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 ActiveMQ loads a masked
+files with the new masked password. When Apache ActiveMQ loads a masked
password, it uses a suitable 'decoder' to decode it into real password.
-ActiveMQ provides a default password encoder and decoder. Optionally
+Apache ActiveMQ provides a default password encoder and decoder. Optionally
users can use or implement their own encoder and decoder for masking the
passwords.
@@ -1845,7 +1845,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, ActiveMQ will
+When a Connector or Acceptor configuration is initialised, Apache ActiveMQ 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
@@ -1885,7 +1885,7 @@ example 2
<mask-password>true</mask-password>
<cluster-password>80cf731af62c290</cluster-password>
-This indicates the cluster password is a masked value and ActiveMQ will
+This indicates the cluster password is a masked value and Apache ActiveMQ 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.
@@ -1909,7 +1909,7 @@ followed by key/value pairs, separated by semi-colons. For example:
\<property name="useMaskedPassword"\>true\</property\>
\<property
name="passwordCodec"\>com.foo.FooDecoder;key=value\</property\>
-ActiveMQ will load this property and initialize the class with a
+Apache ActiveMQ 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.
@@ -1944,7 +1944,7 @@ will have to be in masked form.
### Masking passwords in activemq-users.properties
-ActiveMQ's built-in security manager uses plain properties files
+Apache ActiveMQ'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.
@@ -1961,7 +1961,7 @@ Bridges. Example:
<mask-password>true</mask-password>
<password-codec>org.apache.activemq.utils.DefaultSensitiveStringCodec;key=hello world</password-codec>
-When so configured, the ActiveMQ security manager will initialize a
+When so configured, the Apache ActiveMQ 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.
@@ -1974,7 +1974,7 @@ 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 ActiveMQ provides a default built-in Decoder.
+For user's convenience Apache ActiveMQ provides a default built-in Decoder.
However a user can if they so wish implement their own.
#### The built-in Decoder
@@ -1998,7 +1998,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 ActiveMQ's classpath and configure
+Simply make sure the decoder is in Apache ActiveMQ's classpath and configure
the server to use it as follows:
<password-codec>com.foo.SomeDecoder;key1=value1;key2=value2</password-codec>
@@ -2014,7 +2014,7 @@ Then configure your cluster-password like this:
<mask-password>true</mask-password>
<cluster-password>masked_password</cluster-password>
-When ActiveMQ reads the cluster-password it will initialize the
+When Apache ActiveMQ 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.
@@ -2050,4 +2050,4 @@ need String type. So a new decoder would be defined like
}
Last but not least, once you get your own decoder, please add it to the
-classpath. Otherwise ActiveMQ will fail to load it!
+classpath. Otherwise Apache ActiveMQ will fail to load it!
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/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 a275549..26c607e 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
-ActiveMQ transports and where and how they're configured.
+Apache ActiveMQ transports and where and how they're configured.
## Understanding Acceptors
-One of the most important concepts in ActiveMQ transports is the
+One of the most important concepts in Apache ActiveMQ 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
-ActiveMQ server.
+Apache ActiveMQ server.
In the above example we're defining an acceptor that uses
[Netty](http://netty.io/) to listen for connections at port
@@ -139,7 +139,7 @@ etc
## Configuring the Netty transport
-Out of the box, ActiveMQ currently uses
+Out of the box, Apache ActiveMQ 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
-ActiveMQ supports using a single port for all
-protocols, ActiveMQ will automatically detect which protocol is being
-used CORE, AMQP, STOMP or OPENWIRE and use the appropriate ActiveMQ
+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
handler. It will also detect whether protocols such as HTTP or Web
Sockets are being used and also use the appropriate decoders
@@ -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, ActiveMQ can
+- `batchDelay`. Before writing packets to the transport, Apache ActiveMQ 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, ActiveMQ will,
+- `nioRemotingThreads`. When configured to use NIO, Apache ActiveMQ 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 ActiveMQ will now automatically detect if http
+ single port support Apache ActiveMQ 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/9d72cefd/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 5e3b795..ae26341 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 ActiveMQ deals with crashed clients and clients which have
+explain how Apache ActiveMQ deals with crashed clients and clients which have
exited without cleanly closing their resources.
## Cleaning up Dead Connection Resources on the Server
-Before a ActiveMQ client application exits it is considered good
+Before an Apache ActiveMQ 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.
-ActiveMQ supports client reconnection, so we don't want to clean up
+Apache ActiveMQ 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.
-ActiveMQ makes all of this configurable. For each `ClientSessionFactory`
+Apache ActiveMQ 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,7 +120,7 @@ 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, ActiveMQ will detect this at garbage collection
+If you fail to do so, Apache ActiveMQ 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):
@@ -132,7 +132,7 @@ session):
at org.apache.activemq.core.client.impl.DelegatingSession.<init>(DelegatingSession.java:83)
at org.acme.yourproject.YourClass (YourClass.java:666)
-ActiveMQ will then close the connection / client session for you.
+Apache ActiveMQ 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
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/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 b1e4e6e..2965d3f 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 ActiveMQ
+forward them to a target address, typically on a different Apache ActiveMQ
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 ActiveMQ
+In summary, bridges are a way to reliably connect two separate Apache ActiveMQ
servers together. With a core bridge both source and target servers must
-be ActiveMQ servers.
+be Apache ActiveMQ 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 a ActiveMQ node with another ActiveMQ
+> Core bridges are for linking an Apache ActiveMQ node with another Apache ActiveMQ
> 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
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/docs/user-manual/en/diverts.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/diverts.md b/docs/user-manual/en/diverts.md
index 98c0a59..3876a22 100644
--- a/docs/user-manual/en/diverts.md
+++ b/docs/user-manual/en/diverts.md
@@ -1,6 +1,6 @@
# Diverting and Splitting Message Flows
-ActiveMQ allows you to configure objects called *diverts* with some
+Apache ActiveMQ 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/9d72cefd/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 64a16f1..eeb4eaf 100644
--- a/docs/user-manual/en/duplicate-detection.md
+++ b/docs/user-manual/en/duplicate-detection.md
@@ -1,9 +1,9 @@
# Duplicate Message Detection
-ActiveMQ includes powerful automatic duplicate message detection,
+Apache ActiveMQ 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 ActiveMQ uses it and how
+will explain what duplicate detection is, how Apache ActiveMQ 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 ActiveMQ provides automatic duplicate messages
+To solve these issues Apache ActiveMQ provides automatic duplicate messages
detection for messages sent to addresses.
## Using Duplicate Detection for Message Sending
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/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 2f32e37..e2383c0 100644
--- a/docs/user-manual/en/embedding-activemq.md
+++ b/docs/user-manual/en/embedding-activemq.md
@@ -1,31 +1,31 @@
-# Embedding ActiveMQ
+# Embedding Apache ActiveMQ
-ActiveMQ is designed as set of simple Plain Old Java Objects (POJOs).
-This means ActiveMQ can be instantiated and run in any dependency
+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
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*
-ActiveMQ clients and servers in its own application code to perform that
-functionality. We call this *embedding* ActiveMQ.
+Apache ActiveMQ clients and servers in its own application code to perform that
+functionality. We call this *embedding* Apache ActiveMQ.
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 ActiveMQ can be done in very few easy steps. Instantiate the
+Embedding Apache ActiveMQ can be done in very few easy steps. Instantiate the
configuration object, instantiate the server, start it, and you have a
-ActiveMQ running in your virtual machine. It's as simple and easy as
+Apache ActiveMQ running in your virtual machine. It's as simple and easy as
that.
## Simple Config File Embedding
-The simplest way to embed ActiveMQ is to use the embedded wrapper
-classes and configure ActiveMQ through its configuration files. There
+The simplest way to embed Apache ActiveMQ is to use the embedded wrapper
+classes and configure Apache ActiveMQ through its configuration files. There
are two different helper classes for this depending on whether your
-using the ActiveMQ Core API or JMS.
+using the Apache ActiveMQ Core API or JMS.
## Core API Only
-For instantiating a core ActiveMQ Server only, the steps are pretty
+For instantiating a core Apache ActiveMQ Server only, the steps are pretty
simple. The example requires that you have defined a configuration file
`activemq-configuration.xml` in your classpath:
@@ -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 ActiveMQ Server instance:
+core, non-JMS Apache ActiveMQ Server instance:
Create the configuration object - this contains configuration
-information for a ActiveMQ instance. The setter methods of this class
+information for an Apache ActiveMQ instance. The setter methods of this class
allow you to programmatically set configuration options as describe in
the [Server Configuration](configuration-index.md) section.
@@ -158,7 +158,7 @@ then set the JmsConfiguration property of the EmbeddedJMS class. Here is
an example of this:
``` java
-// Step 1. Create ActiveMQ core configuration, and set the properties accordingly
+// Step 1. Create Apache ActiveMQ 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 ActiveMQ core server and the JMS configuration
+// Step 5. Start the JMS Server using the Apache ActiveMQ 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 ActiveMQ
+Please see the examples for an example which shows how to setup and run Apache ActiveMQ
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 ActiveMQ.
+Spring and Apache ActiveMQ.
-ActiveMQ standalone uses [Airline](https://github.com/airlift/airline) to bootstrap.
+Apache ActiveMQ standalone uses [Airline](https://github.com/airlift/airline) to bootstrap.
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/docs/user-manual/en/examples.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/examples.md b/docs/user-manual/en/examples.md
index 2be7f06..8a73f04 100644
--- a/docs/user-manual/en/examples.md
+++ b/docs/user-manual/en/examples.md
@@ -1,7 +1,7 @@
Examples
========
-The ActiveMQ distribution comes with over 70 run out-of-the-box examples
+The Apache ActiveMQ 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
--------------------------
-ActiveMQ also supports Application-Layer failover, useful in the case
+Apache ActiveMQ 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 ActiveMQ which will be called by ActiveMQ
+a JMS `ExceptionListener` with Apache ActiveMQ which will be called by Apache ActiveMQ
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 ActiveMQ
+Core bridges are used to create message flows between any two Apache ActiveMQ
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
-ActiveMQ.
+Apache ActiveMQ.
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 ActiveMQ does
+of the cluster. In other words it demonstrates how Apache ActiveMQ 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 ActiveMQ you can specify a maximum consume rate at which a JMS
+With Apache ActiveMQ 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 ActiveMQ will ensure that messages are
+If this value is specified then Apache ActiveMQ 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 ActiveMQ can be
+The `delayed-redelivery` example demonstrates how Apache ActiveMQ 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
------
-ActiveMQ diverts allow messages to be transparently "diverted" or copied
+Apache ActiveMQ 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 ActiveMQ. Durable subscriptions are a standard part of
+subscription with Apache ActiveMQ. 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 ActiveMQ XML files.
+regular Apache ActiveMQ 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).
-ActiveMQ can assign an expiry address to a given queue so that when
+Apache ActiveMQ 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.
-ActiveMQ Resource Adapter example
+Apache ActiveMQ 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 ActiveMQ to use
+The `http-transport` example shows you how to configure Apache ActiveMQ 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 ActiveMQ also supports the direct instantiation of
+come to the rescue Apache ActiveMQ also supports the direct instantiation of
these administered objects on the client side so you don't have to use
JNDI for JMS.
Interceptor
-----------
-ActiveMQ allows an application to use an interceptor to hook into the
+Apache ActiveMQ allows an application to use an interceptor to hook into the
messaging system. Interceptors allow you to handle various message
-events in ActiveMQ.
+events in Apache ActiveMQ.
JAAS
----
-The `jaas` example shows you how to configure ActiveMQ to use JAAS for
-security. ActiveMQ can leverage JAAS to delegate user authentication and
+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
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 ActiveMQ and use a CompletionListener to be notified
+asynchronously to Apache ActiveMQ 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 ActiveMQ servers.
+standalone Apache ActiveMQ servers.
JMS Context
-----------
The `jms-context` example shows how to send and receive a message to a
-JMS Queue using ActiveMQ by using a JMS Context.
+JMS Queue using Apache ActiveMQ 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 ActiveMQ using JMX.
+The `jmx` example shows how to manage Apache ActiveMQ using JMX.
Large Message
-------------
The `large-message` example shows you how to send and receive very large
-messages with ActiveMQ. ActiveMQ supports the sending and receiving of
+messages with Apache ActiveMQ. Apache ActiveMQ 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 ActiveMQ doesn't just do a simple socket stream
+restart. In other words Apache ActiveMQ 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 ActiveMQ using JMS Messages
+The `management` example shows how to manage Apache ActiveMQ using JMS Messages
to invoke management operations on the server.
Management Notification
-----------------------
The `management-notification` example shows how to receive management
-notifications from ActiveMQ using JMS messages. ActiveMQ servers emit
+notifications from Apache ActiveMQ using JMS messages. Apache ActiveMQ 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 ActiveMQ. Message groups allow you to pin messages so they
+groups with Apache ActiveMQ. 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 ActiveMQ via a connection factory.
+groups with Apache ActiveMQ 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, ActiveMQ consumers buffer messages from the server in a
+By default, Apache ActiveMQ 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 ActiveMQ client would have to
+`MessageListener onMessage()` method, the Apache ActiveMQ 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, ActiveMQ pre-fetches messages into a
+performance. Therefore, by default, Apache ActiveMQ pre-fetches messages into a
buffer on each consumer.
-In some case buffering is not desirable, and ActiveMQ allows it to be
+In some case buffering is not desirable, and Apache ActiveMQ 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.
-ActiveMQ implements failover of client connections between live and
+Apache ActiveMQ 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 a ActiveMQ server to
-communicate with an ActiveMQ JMS client that uses open-wire protocol.
+The `Openwire` example shows how to configure an Apache ActiveMQ server to
+communicate with an Apache ActiveMQ JMS client that uses open-wire protocol.
Paging
------
-The `paging` example shows how ActiveMQ can support huge queues even
+The `paging` example shows how Apache ActiveMQ 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 ActiveMQ allows this with an extra
+client. This example demonstrates how Apache ActiveMQ allows this with an extra
acknowledgement mode.
Message Producer Rate Limiting
------------------------------
-The `producer-rte-limit` example demonstrates how, with ActiveMQ, you
+The `producer-rte-limit` example demonstrates how, with Apache ActiveMQ, you
can specify a maximum send rate at which a JMS message producer will
send messages.
Proton Qpid
-----------
-ActiveMQ can be configured to accept requests from any AMQP client that
+Apache ActiveMQ 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
-----------
-ActiveMQ can be configured to accept requests from any AMQP client that
+Apache ActiveMQ 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. ActiveMQ can be configured
+notifying any user ExceptionListener objects. Apache ActiveMQ 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 ActiveMQ Rest API
+An example showing how to use the Apache ActiveMQ Rest API
Scheduled Message
-----------------
The `scheduled-message` example shows you how to send a scheduled
-message to a JMS Queue with ActiveMQ. Scheduled messages won't get
+message to a JMS Queue with Apache ActiveMQ. 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 ActiveMQ.
+security with Apache ActiveMQ.
Send Acknowledgements
---------------------
-The `send-acknowledgements` example shows you how to use ActiveMQ's
+The `send-acknowledgements` example shows you how to use Apache ActiveMQ'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 ActiveMQ's Spring
+This example shows how to use embedded JMS using Apache ActiveMQ's Spring
integration.
SSL Transport
-------------
-The `ssl-enabled` shows you how to configure SSL with ActiveMQ to send
+The `ssl-enabled` shows you how to configure SSL with Apache ActiveMQ to send
and receive message.
Static Message Selector
-----------------------
-The `static-selector` example shows you how to configure a ActiveMQ core
+The `static-selector` example shows you how to configure an Apache ActiveMQ core
queue with static message selectors (filters).
Static Message Selector Using JMS
---------------------------------
-The `static-selector-jms` example shows you how to configure a ActiveMQ
+The `static-selector-jms` example shows you how to configure an Apache ActiveMQ
queue with static message selectors (filters) using JMS.
Stomp
-----
-The `stomp` example shows you how to configure a ActiveMQ server to send
+The `stomp` example shows you how to configure an Apache ActiveMQ server to send
and receive Stomp messages.
Stomp1.1
--------
-The `stomp` example shows you how to configure a ActiveMQ server to send
+The `stomp` example shows you how to configure an Apache ActiveMQ server to send
and receive Stomp messages via a Stomp 1.1 connection.
Stomp1.2
--------
-The `stomp` example shows you how to configure a ActiveMQ server to send
+The `stomp` example shows you how to configure an Apache ActiveMQ 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 a ActiveMQ
+The `stomp-websockets` example shows you how to configure an Apache ActiveMQ
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 ActiveMQ.
+with Apache ActiveMQ.
-ActiveMQ has extremely flexible clustering which allows you to set-up
+Apache ActiveMQ 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
---------------
-ActiveMQ supports topic hierarchies. With a topic hierarchy you can
+Apache ActiveMQ 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 ActiveMQ.
+JMS Topic, and subscribe them using selectors with Apache ActiveMQ.
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.
-ActiveMQ implements failover of client connections between live and
+Apache ActiveMQ 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 ActiveMQ.
+with Apache ActiveMQ.
XA Heuristic
------------
The `xa-heuristic` example shows you how to make an XA heuristic
-decision through ActiveMQ Management Interface. A heuristic decision is
+decision through Apache ActiveMQ 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 ActiveMQ.
+XA transaction in Apache ActiveMQ.
XA Send
-------
The `xa-send` example shows you how message sending behaves in an XA
-transaction in ActiveMQ.
+transaction in Apache ActiveMQ.
Core API Examples
=================
@@ -752,5 +752,5 @@ directory and type `ant`
Embedded
--------
-The `embedded` example shows how to embed the ActiveMQ server within
+The `embedded` example shows how to embed the Apache ActiveMQ server within
your own code.
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/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 3326584..61736fb 100644
--- a/docs/user-manual/en/filter-expressions.md
+++ b/docs/user-manual/en/filter-expressions.md
@@ -1,6 +1,6 @@
# Filter Expressions
-ActiveMQ provides a powerful filter language based on a subset of the
+Apache ActiveMQ 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 ActiveMQ
+Filter expressions are used in several places in Apache ActiveMQ
- 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 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 ActiveMQ
+There are some differences between JMS selector expressions and Apache ActiveMQ
core filter expressions. Whereas JMS selector expressions operate on a
-JMS message, ActiveMQ core filter expressions operate on a core message.
+JMS message, Apache ActiveMQ 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/9d72cefd/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 2be852c..3982ea4 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, ActiveMQ consumers buffer messages from the server in a
+By default, Apache ActiveMQ 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,
-ActiveMQ would have to go the server to request the next message. In
+Apache ActiveMQ 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, ActiveMQ pre-fetches messages into a buffer on each
+To prevent this, Apache ActiveMQ 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 ActiveMQ Core API is used, the consumer window size is specified by
+If Apache ActiveMQ Core API is used, the consumer window size is specified by
`ServerLocator.setConsumerWindowSize()` method and some of the
`ClientSession.createConsumer()` methods.
@@ -108,7 +108,7 @@ 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 ActiveMQ to
+Please see the examples for an example which shows how to configure Apache ActiveMQ 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 ActiveMQ core API is being used the rate can be set via the
+If the Apache ActiveMQ 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.
@@ -158,12 +158,12 @@ prevent consumer buffering when dealing with slow consumers.
## Producer flow control
-ActiveMQ also can limit the amount of data sent from a client to a
+Apache ActiveMQ 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, ActiveMQ
+In a similar way to consumer window based flow control, Apache ActiveMQ
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 ActiveMQ core API is being used, window size can be set via the
+If the Apache ActiveMQ core API is being used, window size can be set via the
`ServerLocator.setProducerWindowSize(int producerWindowSize)` method.
#### Using JMS
@@ -260,8 +260,8 @@ control.
### Rate limited flow control
-ActiveMQ also allows the rate a producer can emit message to be limited,
-in units of messages per second. By specifying such a rate, ActiveMQ
+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
will ensure that producer never produces messages at a rate higher than
that specified.
@@ -274,7 +274,7 @@ Please see the ? for a working example of limiting producer rate.
#### Using Core API
-If the ActiveMQ core API is being used the rate can be set via the
+If the Apache ActiveMQ 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.
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/docs/user-manual/en/ha.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/ha.md b/docs/user-manual/en/ha.md
index 6db1263..bab189b 100644
--- a/docs/user-manual/en/ha.md
+++ b/docs/user-manual/en/ha.md
@@ -9,14 +9,14 @@ event of server failure so client applications can continue to operate*.
## Live - Backup Groups
-ActiveMQ allows servers to be linked together as *live - backup* groups
+Apache ActiveMQ allows servers to be linked together as *live - backup* groups
where each live server can have 1 or more backup servers. A backup
server is owned by only one live server. Backup servers are not
operational until failover occurs, however 1 chosen backup, which will
be in passive mode, announces its status and waits to take over the live
servers work
-Before failover, only the live server is serving the ActiveMQ clients
+Before failover, only the live server is serving the Apache ActiveMQ clients
while the backup servers remain passive or awaiting to become a backup
server. When a live server crashes or is brought down in the correct
mode, the backup server currently in passive mode will become live and
@@ -28,7 +28,7 @@ live server coming back up and automatically stop.
### HA Policies
-ActiveMQ supports two different strategies for backing up a server
+Apache ActiveMQ supports two different strategies for backing up a server
*shared store* and *replication*. Which is configured via the
`ha-policy` configuration element.
@@ -789,13 +789,13 @@ be high enough to deal with the time needed to scale down.
## Failover Modes
-ActiveMQ defines two types of client failover:
+Apache ActiveMQ defines two types of client failover:
- Automatic client failover
- Application-level client failover
-ActiveMQ also provides 100% transparent automatic reattachment of
+Apache ActiveMQ also provides 100% transparent automatic reattachment of
connections to the same server (e.g. in case of transient network
problems). This is similar to failover, except it is reconnecting to the
same server and is discussed in [Client Reconnection and Session Reattachment](client-reconnection.md)
@@ -807,14 +807,14 @@ knowledge of non persistent queues.
### Automatic Client Failover
-ActiveMQ clients can be configured to receive knowledge of all live and
+Apache ActiveMQ clients can be configured to receive knowledge of all live and
backup servers, so that in event of connection failure at the client -
live server connection, the client will detect this and reconnect to the
backup server. The backup server will then automatically recreate any
sessions and consumers that existed on each connection before failover,
thus saving the user from having to hand-code manual reconnection logic.
-ActiveMQ clients detect connection failure when it has not received
+Apache ActiveMQ clients detect connection failure when it has not received
packets from the server within the time given by
`client-failure-check-period` as explained in section [Detecting Dead Connections](connection-ttl.md). If the client
does not receive data in good time, it will assume the connection has
@@ -822,7 +822,7 @@ failed and attempt failover. Also if the socket is closed by the OS,
usually if the server process is killed rather than the machine itself
crashing, then the client will failover straight away.
-ActiveMQ clients can be configured to discover the list of live-backup
+Apache ActiveMQ clients can be configured to discover the list of live-backup
server groups in a number of different ways. They can be configured
explicitly or probably the most common way of doing this is to use
*server discovery* for the client to automatically discover the list.
@@ -857,7 +857,7 @@ JMS sessions, please see ? and ?.
#### A Note on Server Replication
-ActiveMQ does not replicate full server state between live and backup
+Apache ActiveMQ does not replicate full server state between live and backup
servers. When the new session is automatically recreated on the backup
it won't have any knowledge of messages already sent or acknowledged in
that session. Any in-flight sends or acknowledgements at the time of
@@ -898,14 +898,14 @@ session will not have any knowledge of the call that was in progress.
This call might otherwise hang for ever, waiting for a response that
will never come.
-To prevent this, ActiveMQ will unblock any blocking calls that were in
+To prevent this, Apache ActiveMQ will unblock any blocking calls that were in
progress at the time of failover by making them throw a
`javax.jms.JMSException` (if using JMS), or a `ActiveMQException` with
error code `ActiveMQException.UNBLOCKED`. It is up to the client code to
catch this exception and retry any operations if desired.
If the method being unblocked is a call to commit(), or prepare(), then
-the transaction will be automatically rolled back and ActiveMQ will
+the transaction will be automatically rolled back and Apache ActiveMQ will
throw a `javax.jms.TransactionRolledBackException` (if using JMS), or a
`ActiveMQException` with error code
`ActiveMQException.TRANSACTION_ROLLED_BACK` if using the core API.
@@ -940,7 +940,7 @@ local rollback code as necessary. There is no need to manually rollback
the session - it is already rolled back. The user can then just retry
the transactional operations again on the same session.
-ActiveMQ ships with a fully functioning example demonstrating how to do
+Apache ActiveMQ ships with a fully functioning example demonstrating how to do
this, please see ?
If failover occurs when a commit call is being executed, the server, as
@@ -990,7 +990,7 @@ connection failure: `java.jms.ExceptionListener`. Please consult the JMS
javadoc or any good JMS tutorial for more information on how to use
this.
-The ActiveMQ core API also provides a similar feature in the form of the
+The Apache ActiveMQ core API also provides a similar feature in the form of the
class `org.apache.activemq.core.client.SessionFailureListener`
Any ExceptionListener or SessionFailureListener instance will always be
@@ -1037,7 +1037,7 @@ application level.
To implement application-level failover, if you're using JMS then you
need to set an `ExceptionListener` class on the JMS connection. The
-`ExceptionListener` will be called by ActiveMQ in the event that
+`ExceptionListener` will be called by Apache ActiveMQ in the event that
connection failure is detected. In your `ExceptionListener`, you would
close your old JMS connections, potentially look up new connection
factory instances from JNDI and creating new connections.
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/9d72cefd/docs/user-manual/en/intercepting-operations.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/intercepting-operations.md b/docs/user-manual/en/intercepting-operations.md
index edfd133..3a4d83a 100644
--- a/docs/user-manual/en/intercepting-operations.md
+++ b/docs/user-manual/en/intercepting-operations.md
@@ -1,6 +1,6 @@
# Intercepting Operations
-ActiveMQ supports *interceptors* to intercept packets entering and
+Apache ActiveMQ supports *interceptors* to intercept packets entering and
exiting the server. Incoming and outgoing interceptors are be called for
any packet entering or exiting the server respectively. This allows
custom code to be executed, e.g. for auditing packets, filtering or