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/04/28 18:02:25 UTC
[20/57] [abbrv] [partial] activemq-6 git commit: ACTIVEMQ6-1 Artemis
rename
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/ha.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/ha.md b/docs/user-manual/en/ha.md
index 445ba8f..2819006 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
-Apache ActiveMQ allows servers to be linked together as *live - backup* groups
+Apache ActiveMQ Artemis 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 Apache ActiveMQ clients
+Before failover, only the live server is serving the Apache ActiveMQ Artemis 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
-Apache ActiveMQ supports two different strategies for backing up a server
+Apache ActiveMQ Artemis 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
-Apache ActiveMQ defines two types of client failover:
+Apache ActiveMQ Artemis defines two types of client failover:
- Automatic client failover
- Application-level client failover
-Apache ActiveMQ also provides 100% transparent automatic reattachment of
+Apache ActiveMQ Artemis 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
-Apache ActiveMQ clients can be configured to receive knowledge of all live and
+Apache ActiveMQ Artemis 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.
-Apache ActiveMQ clients detect connection failure when it has not received
+Apache ActiveMQ Artemis 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.
-Apache ActiveMQ clients can be configured to discover the list of live-backup
+Apache ActiveMQ Artemis 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 [the examples](examples.md) chapter.
#### A Note on Server Replication
-Apache ActiveMQ does not replicate full server state between live and backup
+Apache ActiveMQ Artemis 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, Apache ActiveMQ will unblock any blocking calls that were in
+To prevent this, Apache ActiveMQ Artemis 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 Apache ActiveMQ will
+the transaction will be automatically rolled back and Apache ActiveMQ Artemis 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.
-Apache ActiveMQ ships with a fully functioning example demonstrating how to do
+Apache ActiveMQ Artemis ships with a fully functioning example demonstrating how to do
this, please see [the examples](examples.md) chapter.
If failover occurs when a commit call is being executed, the server, as
@@ -990,8 +990,8 @@ connection failure: `java.jms.ExceptionListener`. Please consult the JMS
javadoc or any good JMS tutorial for more information on how to use
this.
-The Apache ActiveMQ core API also provides a similar feature in the form of the
-class `org.apache.activemq.core.client.SessionFailureListener`
+The Apache ActiveMQ Artemis core API also provides a similar feature in the form of the
+class `org.apache.activemq.artemis.core.client.SessionFailureListener`
Any ExceptionListener or SessionFailureListener instance will always be
called by ActiveMQ on event of connection failure, **irrespective** of
@@ -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 Apache ActiveMQ in the event that
+`ExceptionListener` will be called by Apache ActiveMQ Artemis 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/8f52a622/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 ad03688..f33611b 100644
--- a/docs/user-manual/en/intercepting-operations.md
+++ b/docs/user-manual/en/intercepting-operations.md
@@ -1,6 +1,6 @@
# Intercepting Operations
-Apache ActiveMQ supports *interceptors* to intercept packets entering and
+Apache ActiveMQ Artemis 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
@@ -23,7 +23,7 @@ public interface Interceptor
For stomp protocol an interceptor must implement the `StompFrameInterceptor class`:
``` java
-package org.apache.activemq.core.protocol.stomp;
+package org.apache.activemq.artemis.core.protocol.stomp;
public interface StompFrameInterceptor
{
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/interoperability.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/interoperability.md b/docs/user-manual/en/interoperability.md
index 3ce1102..914128d 100644
--- a/docs/user-manual/en/interoperability.md
+++ b/docs/user-manual/en/interoperability.md
@@ -3,7 +3,7 @@
## Stomp
[Stomp](http://stomp.github.com/) is a text-orientated wire protocol
-that allows Stomp clients to communicate with Stomp Brokers. Apache ActiveMQ
+that allows Stomp clients to communicate with Stomp Brokers. Apache ActiveMQ Artemis
now supports Stomp 1.0, 1.1 and 1.2.
Stomp clients are available for several languages and platforms making
@@ -11,16 +11,16 @@ it a good choice for interoperability.
## Native Stomp support
-Apache ActiveMQ provides native support for Stomp. To be able to send and
+Apache ActiveMQ Artemis provides native support for Stomp. To be able to send and
receive Stomp messages, you must configure a `NettyAcceptor` with a
`protocols` parameter set to have `stomp`:
<acceptor name="stomp-acceptor">tcp://localhost:61613?protocols=STOMP</acceptor>
-With this configuration, Apache ActiveMQ will accept Stomp connections on the
+With this configuration, Apache ActiveMQ Artemis will accept Stomp connections on the
port `61613` (which is the default port of the Stomp brokers).
-See the `stomp` example which shows how to configure an Apache ActiveMQ server
+See the `stomp` example which shows how to configure an Apache ActiveMQ Artemis server
with Stomp.
### Limitations
@@ -33,30 +33,30 @@ set).
#### Virtual Hosting
-Apache ActiveMQ currently doesn't support virtual hosting, which means the
+Apache ActiveMQ Artemis currently doesn't support virtual hosting, which means the
'host' header in CONNECT fram will be ignored.
#### Heart-beating
-Apache ActiveMQ specifies a minimum value for both client and server heart-beat
+Apache ActiveMQ Artemis specifies a minimum value for both client and server heart-beat
intervals. The minimum interval for both client and server heartbeats is
500 milliseconds. That means if a client sends a CONNECT frame with
heartbeat values lower than 500, the server will defaults the value to
500 milliseconds regardless the values of the 'heart-beat' header in the
frame.
-### Mapping Stomp destinations to Apache ActiveMQ addresses and queues
+### Mapping Stomp destinations to Apache ActiveMQ Artemis addresses and queues
Stomp clients deals with *destinations* when sending messages and
subscribing. Destination names are simply strings which are mapped to
some form of destination on the server - how the server translates these
is left to the server implementation.
-In Apache ActiveMQ, these destinations are mapped to *addresses* and *queues*.
+In Apache ActiveMQ Artemis, these destinations are mapped to *addresses* and *queues*.
When a Stomp client sends a message (using a `SEND` frame), the
specified destination is mapped to an address. When a Stomp client
subscribes (or unsubscribes) for a destination (using a `SUBSCRIBE` or
-`UNSUBSCRIBE` frame), the destination is mapped to an Apache ActiveMQ queue.
+`UNSUBSCRIBE` frame), the destination is mapped to an Apache ActiveMQ Artemis queue.
### STOMP and connection-ttl
@@ -96,7 +96,7 @@ seconds.
#### Using JMS destinations
As explained in [Mapping JMS Concepts to the Core API](jms-core-mapping.md),
-JMS destinations are also mapped to Apache ActiveMQ
+JMS destinations are also mapped to Apache ActiveMQ Artemis
addresses and queues. If you want to use Stomp to send messages to JMS
destinations, the Stomp destinations must follow the same convention:
@@ -123,10 +123,10 @@ destinations, the Stomp destinations must follow the same convention:
^@
-#### Sending and consuming Stomp message from JMS or Apache ActiveMQ Core API
+#### Sending and consuming Stomp message from JMS or Apache ActiveMQ Artemis Core API
Stomp is mainly a text-orientated protocol. To make it simpler to
-interoperate with JMS and Apache ActiveMQ Core API, our Stomp implementation
+interoperate with JMS and Apache ActiveMQ Artemis Core API, our Stomp implementation
checks for presence of the `content-length` header to decide how to map
a Stomp message to a JMS Message or a Core message.
@@ -147,7 +147,7 @@ header to determine the type of the message body (String or bytes).
When receiving Stomp messages via a JMS consumer or a QueueBrowser, the
messages have no properties like JMSMessageID by default. However this
may bring some inconvenience to clients who wants an ID for their
-purpose. Apache ActiveMQ Stomp provides a parameter to enable message ID on
+purpose. Apache ActiveMQ Artemis Stomp provides a parameter to enable message ID on
each incoming Stomp message. If you want each Stomp message to have a
unique ID, just set the `stompEnableMessageId` to true. For example:
@@ -167,15 +167,15 @@ default is `false`.
#### Handling of Large Messages with Stomp
Stomp clients may send very large bodys of frames which can exceed the
-size of Apache ActiveMQ server's internal buffer, causing unexpected errors. To
-prevent this situation from happening, Apache ActiveMQ provides a stomp
+size of Apache ActiveMQ Artemis server's internal buffer, causing unexpected errors. To
+prevent this situation from happening, Apache ActiveMQ Artemis provides a stomp
configuration attribute `stompMinLargeMessageSize`. This attribute
can be configured inside a stomp acceptor, as a parameter. For example:
<acceptor name="stomp-acceptor">tcp://localhost:61613?protocols=STOMP;stompMinLargeMessageSize=10240</acceptor>
The type of this attribute is integer. When this attributed is
-configured, Apache ActiveMQ server will check the size of the body of each
+configured, Apache ActiveMQ Artemis server will check the size of the body of each
Stomp frame arrived from connections established with this acceptor. If
the size of the body is equal or greater than the value of
`stompMinLargeMessageSize`, the message will be persisted as a large
@@ -190,16 +190,16 @@ sending it to stomp clients. The default value of
### Stomp Over Web Sockets
-Apache ActiveMQ also support Stomp over [Web
+Apache ActiveMQ Artemis also support Stomp over [Web
Sockets](http://dev.w3.org/html5/websockets/). Modern web browser which
-support Web Sockets can send and receive Stomp messages from Apache ActiveMQ.
+support Web Sockets can send and receive Stomp messages from Apache ActiveMQ Artemis.
To enable Stomp over Web Sockets, you must configure a `NettyAcceptor`
with a `protocol` parameter set to `stomp_ws`:
<acceptor name="stomp-ws-acceptor">tcp://localhost:61614?protocols=STOMP_WS</acceptor>
-With this configuration, Apache ActiveMQ will accept Stomp connections over Web
+With this configuration, Apache ActiveMQ Artemis will accept Stomp connections over Web
Sockets on the port `61614` with the URL path `/stomp`. Web browser can
then connect to `ws://<server>:61614/stomp` using a Web Socket to send
and receive Stomp messages.
@@ -209,7 +209,7 @@ available from [GitHub](http://github.com/jmesnil/stomp-websocket)
(please see its [documentation](http://jmesnil.net/stomp-websocket/doc/)
for a complete description).
-The `stomp-websockets` example shows how to configure Apache ActiveMQ server to
+The `stomp-websockets` example shows how to configure Apache ActiveMQ Artemis server to
have web browsers and Java applications exchanges messages on a JMS
topic.
@@ -218,22 +218,22 @@ topic.
[StompConnect](http://stomp.codehaus.org/StompConnect) is a server that
can act as a Stomp broker and proxy the Stomp protocol to the standard
JMS API. Consequently, using StompConnect it is possible to turn
-Apache ActiveMQ into a Stomp Broker and use any of the available stomp clients.
+Apache ActiveMQ Artemis into a Stomp Broker and use any of the available stomp clients.
These include clients written in C, C++, c\# and .net etc.
-To run StompConnect first start the Apache ActiveMQ server and make sure that
+To run StompConnect first start the Apache ActiveMQ Artemis server and make sure that
it is using JNDI.
Stomp requires the file `jndi.properties` to be available on the
classpath. This should look something like:
- java.naming.factory.initial=org.apache.activemq.jndi.ActiveMQInitialContextFactory
+ java.naming.factory.initial=ActiveMQInitialContextFactory
Configure any required JNDI resources in this file according to the
documentation.
Make sure this file is in the classpath along with the StompConnect jar
-and the Apache ActiveMQ jars and simply run `java org.codehaus.stomp.jms.Main`.
+and the Apache ActiveMQ Artemis jars and simply run `java org.codehaus.stomp.jms.Main`.
## REST
@@ -241,7 +241,7 @@ Please see [Rest Interface](rest.md)
## AMQP
-Apache ActiveMQ supports the [AMQP
+Apache ActiveMQ Artemis supports the [AMQP
1.0](https://www.oasis-open.org/committees/tc_home.php?wg_abbrev=amqp)
specification. To enable AMQP you must configure a Netty Acceptor to
receive AMQP clients, like so:
@@ -249,7 +249,7 @@ receive AMQP clients, like so:
<acceptor name="stomp-acceptor">tcp://localhost:5672?protocols=AMQP</acceptor>
-Apache ActiveMQ will then accept AMQP 1.0 clients on port 5672 which is the
+Apache ActiveMQ Artemis will then accept AMQP 1.0 clients on port 5672 which is the
default AMQP port.
There are 2 Stomp examples available see proton-j and proton-ruby which
@@ -257,18 +257,18 @@ use the qpid Java and Ruby clients respectively
### AMQP and security
-The Apache ActiveMQ Server accepts AMQP SASL Authentication and will use this
+The Apache ActiveMQ Artemis Server accepts AMQP SASL Authentication and will use this
to map onto the underlying session created for the connection so you can
-use the normal Apache ActiveMQ security configuration.
+use the normal Apache ActiveMQ Artemis security configuration.
### AMQP Links
An AMQP Link is a uni directional transport for messages between a
-source and a target, i.e. a client and the Apache ActiveMQ Broker. A link will
+source and a target, i.e. a client and the Apache ActiveMQ Artemis Broker. A link will
have an endpoint of which there are 2 kinds, a Sender and A Receiver. At
-the Broker a Sender will have its messages converted into an Apache ActiveMQ
+the Broker a Sender will have its messages converted into an Apache ActiveMQ Artemis
Message and forwarded to its destination or target. A Receiver will map
-onto an Apache ActiveMQ Server Consumer and convert Apache ActiveMQ messages back into
+onto an Apache ActiveMQ Artemis Server Consumer and convert Apache ActiveMQ Artemis messages back into
AMQP messages before being delivered.
### AMQP and destinations
@@ -294,27 +294,27 @@ or committed via the coordinator.
> **Note**
>
> AMQP allows the use of multiple transactions per session,
-> `amqp:multi-txns-per-ssn`, however in this version Apache ActiveMQ will only
+> `amqp:multi-txns-per-ssn`, however in this version Apache ActiveMQ Artemis will only
> support single transactions per session
## OpenWire
-Apache ActiveMQ now supports the
+Apache ActiveMQ Artemis now supports the
[OpenWire](http://activemq.apache.org/openwire.html) protocol so that an
-Apache ActiveMQ JMS client can talk directly to an Apache ActiveMQ server. To enable
+Apache ActiveMQ Artemis JMS client can talk directly to an Apache ActiveMQ Artemis server. To enable
OpenWire support you must configure a Netty Acceptor, like so:
<acceptor name="openwire-acceptor">tcp://localhost:61616?protocols=OPENWIRE</acceptor>
-The Apache ActiveMQ server will then listens on port 61616 for incoming
+The Apache ActiveMQ Artemis server will then listens on port 61616 for incoming
openwire commands. Please note the "protocols" is not mandatory here.
-The openwire configuration conforms to Apache ActiveMQ's "Single Port" feature.
+The openwire configuration conforms to Apache ActiveMQ Artemis's "Single Port" feature.
Please refer to [Configuring Single
Port](#configuring-transports.single-port) for details.
Please refer to the openwire example for more coding details.
-Currently we support Apache ActiveMQ clients that using standard JMS APIs. In
-the future we will get more supports for some advanced, Apache ActiveMQ
-specific features into Apache ActiveMQ.
+Currently we support Apache ActiveMQ Artemis clients that using standard JMS APIs. In
+the future we will get more supports for some advanced, Apache ActiveMQ Artemis
+specific features into Apache ActiveMQ Artemis.
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/jms-bridge.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/jms-bridge.md b/docs/user-manual/en/jms-bridge.md
index e169975..d966ad4 100644
--- a/docs/user-manual/en/jms-bridge.md
+++ b/docs/user-manual/en/jms-bridge.md
@@ -1,6 +1,6 @@
# The JMS Bridge
-Apache ActiveMQ includes a fully functional JMS message bridge.
+Apache ActiveMQ Artemis includes a fully functional JMS message bridge.
The function of the bridge is to consume messages from a source queue or
topic, and send them to a target queue or topic, typically on a
@@ -8,18 +8,18 @@ different server.
> *Notice:*
> The JMS Bridge is not intended as a replacement for transformation and more expert systems such as Camel.
-> The JMS Bridge may be useful for fast transfers as this chapter covers, but keep in mind that more complex scenarios requiring transformations will require you to use a more advanced transformation system that will play on use cases that will go beyond Apache ActiveMQ.
+> The JMS Bridge may be useful for fast transfers as this chapter covers, but keep in mind that more complex scenarios requiring transformations will require you to use a more advanced transformation system that will play on use cases that will go beyond Apache ActiveMQ Artemis.
The source and target servers do not have to be in the same cluster
which makes bridging suitable for reliably sending messages from one
cluster to another, for instance across a WAN, and where the connection
may be unreliable.
-A bridge can be deployed as a standalone application, with Apache ActiveMQ
+A bridge can be deployed as a standalone application, with Apache ActiveMQ Artemis
standalone server or inside a JBoss AS instance. The source and the
target can be located in the same virtual machine or another one.
-The bridge can also be used to bridge messages from other non Apache ActiveMQ
+The bridge can also be used to bridge messages from other non Apache ActiveMQ Artemis
JMS servers, as long as they are JMS 1.1 compliant.
> **Note**
@@ -27,7 +27,7 @@ JMS servers, as long as they are JMS 1.1 compliant.
> Do not confuse a JMS bridge with a core bridge. A JMS bridge can be
> used to bridge any two JMS 1.1 compliant JMS providers and uses the
> JMS API. A core bridge (described in [Core Bidges](core-bridges.md)) is used to bridge any two
-> Apache ActiveMQ instances and uses the core API. Always use a core bridge if
+> Apache ActiveMQ Artemis instances and uses the core API. Always use a core bridge if
> you can in preference to a JMS bridge. The core bridge will typically
> provide better performance than a JMS bridge. Also the core bridge can
> provide *once and only once* delivery guarantees without using XA.
@@ -193,7 +193,7 @@ by the parameters passed to its constructor.
The "transactionManager" property points to a JTA transaction manager
implementation and should be set if you need to use the 'ONCE_AND_ONCE_ONLY'
-Quality of Service. Apache ActiveMQ doesn't ship with such an implementation, but
+Quality of Service. Apache ActiveMQ Artemis doesn't ship with such an implementation, but
if you are running within an Application Server you can inject the Transaction
Manager that is shipped.
@@ -204,7 +204,7 @@ the connection factory used to create the connection for the source or
target server.
The configuration example above uses the default implementation provided
-by Apache ActiveMQ that looks up the connection factory using JNDI. For other
+by Apache ActiveMQ Artemis that looks up the connection factory using JNDI. For other
Application Servers or JMS providers a new implementation may have to be
provided. This can easily be done by implementing the interface
`org.apache.activemq.jms.bridge.ConnectionFactoryFactory`.
@@ -215,7 +215,7 @@ Again, similarly, these are used to create or lookup up the
destinations.
In the configuration example above, we have used the default provided by
-Apache ActiveMQ that looks up the destination using JNDI.
+Apache ActiveMQ Artemis that looks up the destination using JNDI.
A new implementation can be provided by implementing
`org.apache.activemq.jms.bridge.DestinationFactory` interface.
@@ -251,7 +251,7 @@ This mode is available for both durable and non-durable messages.
This QoS mode ensures messages will reach the destination from the
source once and only once. (Sometimes this mode is known as "exactly
-once"). If both the source and the destination are on the same Apache ActiveMQ
+once"). If both the source and the destination are on the same Apache ActiveMQ Artemis
server instance then this can be achieved by sending and acknowledging
the messages in the same local transaction. If the source and
destination are on different servers this is achieved by enlisting the
@@ -307,4 +307,4 @@ you will have to bear in mind timeout issues.
Please see [the examples chapter](examples.md) which shows how to configure and use a JMS Bridge with
JBoss AS to send messages to the source destination and consume them
from the target destination and how to configure and use a JMS Bridge between
-two standalone Apache ActiveMQ servers.
+two standalone Apache ActiveMQ Artemis servers.
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/jms-core-mapping.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/jms-core-mapping.md b/docs/user-manual/en/jms-core-mapping.md
index 40190fa..51e87b9 100644
--- a/docs/user-manual/en/jms-core-mapping.md
+++ b/docs/user-manual/en/jms-core-mapping.md
@@ -1,9 +1,9 @@
# Mapping JMS Concepts to the Core API
-This chapter describes how JMS destinations are mapped to Apache ActiveMQ
+This chapter describes how JMS destinations are mapped to Apache ActiveMQ Artemis
addresses.
-Apache ActiveMQ core is JMS-agnostic. It does not have any concept of a JMS
+Apache ActiveMQ Artemis core is JMS-agnostic. It does not have any concept of a JMS
topic. A JMS topic is implemented in core as an address (the topic name)
with zero or more queues bound to it. Each queue bound to that address
represents a topic subscription. Likewise, a JMS queue is implemented as
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/large-messages.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/large-messages.md b/docs/user-manual/en/large-messages.md
index 373f1e4..b2cbe8f 100644
--- a/docs/user-manual/en/large-messages.md
+++ b/docs/user-manual/en/large-messages.md
@@ -1,6 +1,6 @@
# Large Messages
-Apache ActiveMQ supports sending and receiving of huge messages, even when the
+Apache ActiveMQ Artemis supports sending and receiving of huge messages, even when the
client and server are running with limited memory. The only realistic
limit to the size of a message that can be sent or consumed is the
amount of disk space you have available. We have tested sending and
@@ -8,7 +8,7 @@ consuming messages up to 8 GiB in size with a client and server running
in just 50MiB of RAM!
To send a large message, the user can set an `InputStream` on a message
-body, and when that message is sent, Apache ActiveMQ will read the
+body, and when that message is sent, Apache ActiveMQ Artemis will read the
`InputStream`. A `FileInputStream` could be used for example to send a
huge message from a huge file on disk.
@@ -52,9 +52,9 @@ determined by the parameter `minLargeMessageSize`
> **Note**
>
-> Apache ActiveMQ messages are encoded using 2 bytes per character so if the
+> Apache ActiveMQ Artemis messages are encoded using 2 bytes per character so if the
> message data is filled with ASCII characters (which are 1 byte) the
-> size of the resulting Apache ActiveMQ message would roughly double. This is
+> size of the resulting Apache ActiveMQ Artemis message would roughly double. This is
> important when calculating the size of a "large" message as it may
> appear to be less than the `minLargeMessageSize` before it is sent,
> but it then turns into a "large" message once it is encoded.
@@ -63,7 +63,7 @@ The default value is 100KiB.
### Using Core API
-If the Apache ActiveMQ Core API is used, the minimal large message size is
+If the Apache ActiveMQ Artemis Core API is used, the minimal large message size is
specified by `ServerLocator.setMinLargeMessageSize`.
``` java
@@ -85,7 +85,7 @@ 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?minLargeMessageSize=250000
@@ -120,12 +120,12 @@ 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?compressLargeMessages=true
## Streaming large messages
-Apache ActiveMQ supports setting the body of messages using input and output
+Apache ActiveMQ Artemis supports setting the body of messages using input and output
streams (`java.lang.io`)
These streams are then used directly for sending (input streams) and
@@ -213,7 +213,7 @@ _AMQ_LARGE_SIZE.
### Streaming over JMS
-When using JMS, Apache ActiveMQ maps the streaming methods on the core API (see
+When using JMS, Apache ActiveMQ Artemis maps the streaming methods on the core API (see
ClientMessage API table above) by setting object properties . You can use the method
`Message.setObjectProperty` to set the input and output streams.
@@ -264,7 +264,7 @@ messageReceived.setObjectProperty("JMS_AMQ_OutputStream", bufferedOutput);
## Streaming Alternative
If you choose not to use the `InputStream` or `OutputStream` capability
-of Apache ActiveMQ You could still access the data directly in an alternative
+of Apache ActiveMQ Artemis You could still access the data directly in an alternative
fashion.
On the Core API just get the bytes of the body as you normally would.
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/libaio.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/libaio.md b/docs/user-manual/en/libaio.md
index ddb1083..dff4d83 100644
--- a/docs/user-manual/en/libaio.md
+++ b/docs/user-manual/en/libaio.md
@@ -1,6 +1,6 @@
# Libaio Native Libraries
-Apache ActiveMQ distributes a native library, used as a bridge between Apache ActiveMQ
+Apache ActiveMQ Artemis distributes a native library, used as a bridge between Apache ActiveMQ Artemis
and Linux libaio.
`libaio` is a library, developed as part of the Linux kernel project.
@@ -11,13 +11,13 @@ when they have been processed.
We use this in our high performance journal if configured to do so,
please see [Persistence](persistence.md).
-These are the native libraries distributed by Apache ActiveMQ:
+These are the native libraries distributed by Apache ActiveMQ Artemis:
- libActiveMQAIO32.so - x86 32 bits
- libActiveMQAIO64.so - x86 64 bits
-When using libaio, Apache ActiveMQ will always try loading these files as long
+When using libaio, Apache ActiveMQ Artemis will always try loading these files as long
as they are on the [library path](#using-server.library.path).
## Compiling the native libraries
@@ -87,5 +87,5 @@ libactivemq-native-RELEASE.so`. Simply move that file over
`bin` with the proper rename [library
path](#using-server.library.path).
-If you want to perform changes on the Apache ActiveMQ libaio code, you could
+If you want to perform changes on the Apache ActiveMQ Artemis libaio code, you could
just call make directly at the `native-src` directory.
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/logging.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/logging.md b/docs/user-manual/en/logging.md
index cf184a4..c39f9e2 100644
--- a/docs/user-manual/en/logging.md
+++ b/docs/user-manual/en/logging.md
@@ -1,6 +1,6 @@
# Logging
-Apache ActiveMQ uses the JBoss Logging framework to do its logging and is
+Apache ActiveMQ Artemis uses the JBoss Logging framework to do its logging and is
configurable via the `logging.properties` file found in the
configuration directories. This is configured by Default to log to both
the console and to a file.
@@ -21,26 +21,26 @@ There are 6 loggers available which are as follows:
<tbody>
<tr>
<td>org.jboss.logging</td>
- <td>Logs any calls not handled by the Apache ActiveMQ loggers</td>
+ <td>Logs any calls not handled by the Apache ActiveMQ Artemis loggers</td>
</tr>
<tr>
- <td>org.apache.activemq.core.server</td>
+ <td>org.apache.activemq.artemis.core.server</td>
<td>Logs the core server</td>
</tr>
<tr>
- <td>org.apache.activemq.utils</td>
+ <td>org.apache.activemq.artemis.utils</td>
<td>Logs utility calls</td>
</tr>
<tr>
- <td>org.apache.activemq.journal</td>
+ <td>org.apache.activemq.artemis.journal</td>
<td>Logs Journal calls</td>
</tr>
<tr>
- <td>org.apache.activemq.jms</td>
+ <td>org.apache.activemq.artemis.jms</td>
<td>Logs JMS calls</td>
</tr>
<tr>
- <td>org.apache.activemq.integration.bootstrap </td>
+ <td>org.apache.activemq.artemis.integration.bootstrap </td>
<td>Logs bootstrap calls</td>
</tr>
</tbody>
@@ -81,14 +81,14 @@ this is done via the `-Dlogging.configuration` for instance
The following is a typical `logging.properties for a client`
# Root logger option
- loggers=org.jboss.logging,org.apache.activemq.core.server,org.apache.activemq.utils,org.apache.activemq.journal,org.apache.activemq.jms,org.apache.activemq.ra
+ loggers=org.jboss.logging,org.apache.activemq.artemis.core.server,org.apache.activemq.artemis.utils,org.apache.activemq.artemis.journal,org.apache.activemq.artemis.jms,org.apache.activemq.artemis.ra
# Root logger level
logger.level=INFO
- # Apache ActiveMQ logger levels
- logger.org.apache.activemq.core.server.level=INFO
- logger.org.apache.activemq.utils.level=INFO
- logger.org.apache.activemq.jms.level=DEBUG
+ # Apache ActiveMQ Artemis logger levels
+ logger.org.apache.activemq.artemis.core.server.level=INFO
+ logger.org.apache.activemq.artemis.utils.level=INFO
+ logger.org.apache.activemq.artemis.jms.level=DEBUG
# Root logger handlers
logger.handlers=FILE,CONSOLE
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/management.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/management.md b/docs/user-manual/en/management.md
index ae1fed8..f44eff1 100644
--- a/docs/user-manual/en/management.md
+++ b/docs/user-manual/en/management.md
@@ -1,23 +1,23 @@
# Management
-Apache ActiveMQ has an extensive management API that allows a user to modify a
+Apache ActiveMQ Artemis has an extensive management API that allows a user to modify a
server configuration, create new resources (e.g. JMS queues and topics),
inspect these resources (e.g. how many messages are currently held in a
queue) and interact with it (e.g. to remove messages from a queue). All
-the operations allows a client to *manage* Apache ActiveMQ. It also allows
+the operations allows a client to *manage* Apache ActiveMQ Artemis. It also allows
clients to subscribe to management notifications.
-There are 3 ways to manage Apache ActiveMQ:
+There are 3 ways to manage Apache ActiveMQ Artemis:
- Using JMX -- JMX is the standard way to manage Java applications
-- Using the core API -- management operations are sent to Apache ActiveMQ
+- Using the core API -- management operations are sent to Apache ActiveMQ Artemis
server using *core messages*
-- Using the JMS API -- management operations are sent to Apache ActiveMQ
+- Using the JMS API -- management operations are sent to Apache ActiveMQ Artemis
server using *JMS messages*
-Although there are 3 different ways to manage Apache ActiveMQ each API supports
+Although there are 3 different ways to manage Apache ActiveMQ Artemis each API supports
the same functionality. If it is possible to manage a resource using JMX
it is also possible to achieve the same result using Core messages or
JMS messages.
@@ -33,7 +33,7 @@ API is the same.
For each *managed resource*, there exists a Java interface describing
what can be invoked for this type of resource.
-Apache ActiveMQ exposes its managed resources in 2 packages:
+Apache ActiveMQ Artemis exposes its managed resources in 2 packages:
- *Core* resources are located in the
`org.apache.activemq.api.core.management` package
@@ -53,7 +53,7 @@ messages, or JMS messages are used.
### Core Management API
-Apache ActiveMQ defines a core management API to manage core resources. For
+Apache ActiveMQ Artemis defines a core management API to manage core resources. For
full details of the API please consult the javadoc. In summary:
#### Core Server Management
@@ -113,7 +113,7 @@ full details of the API please consult the javadoc. In summary:
- Retrieving the server configuration and attributes
- The `ActiveMQServerControl` exposes Apache ActiveMQ server configuration
+ The `ActiveMQServerControl` exposes Apache ActiveMQ Artemis server configuration
through all its attributes (e.g. `getVersion()` method to retrieve
the server's version, etc.)
@@ -235,7 +235,7 @@ messages with a given property.)
#### Other Core Resources Management
-Apache ActiveMQ allows to start and stop its remote resources (acceptors,
+Apache ActiveMQ Artemis allows to start and stop its remote resources (acceptors,
diverts, bridges, etc.) so that a server can be taken off line for a
given period of time without stopping it completely (e.g. if other
management operations must be performed such as resolving heuristic
@@ -297,7 +297,7 @@ transactions). These resources are:
### JMS Management API
-Apache ActiveMQ defines a JMS Management API to manage JMS *administrated
+Apache ActiveMQ Artemis defines a JMS Management API to manage JMS *administrated
objects* (i.e. JMS queues, topics and connection factories).
#### JMS Server Management
@@ -477,11 +477,11 @@ ObjectName `org.apache.activemq:module=JMS,type=Topic,name="<the topic
## Using Management Via JMX
-Apache ActiveMQ can be managed using
+Apache ActiveMQ Artemis can be managed using
[JMX](http://www.oracle.com/technetwork/java/javase/tech/javamanagement-140525.html).
-The management API is exposed by Apache ActiveMQ using MBeans interfaces.
-Apache ActiveMQ registers its resources with the domain `org.apache.activemq`.
+The management API is exposed by Apache ActiveMQ Artemis using MBeans interfaces.
+Apache ActiveMQ Artemis registers its resources with the domain `org.apache.activemq`.
For example, the `ObjectName` to manage a JMS Queue `exampleQueue` is:
@@ -496,20 +496,20 @@ The MBean's `ObjectName` are built using the helper class
also use `jconsole` to find the `ObjectName` of the MBeans you want to
manage.
-Managing Apache ActiveMQ using JMX is identical to management of any Java
+Managing Apache ActiveMQ Artemis using JMX is identical to management of any Java
Applications using JMX. It can be done by reflection or by creating
proxies of the MBeans.
### Configuring JMX
-By default, JMX is enabled to manage Apache ActiveMQ. It can be disabled by
+By default, JMX is enabled to manage Apache ActiveMQ Artemis. It can be disabled by
setting `jmx-management-enabled` to `false` in
`activemq-configuration.xml`:
- <!-- false to disable JMX management for Apache ActiveMQ -->
+ <!-- false to disable JMX management for Apache ActiveMQ Artemis -->
<jmx-management-enabled>false</jmx-management-enabled>
-If JMX is enabled, Apache ActiveMQ can be managed locally using `jconsole`.
+If JMX is enabled, Apache ActiveMQ Artemis can be managed locally using `jconsole`.
> **Note**
>
@@ -519,9 +519,9 @@ If JMX is enabled, Apache ActiveMQ can be managed locally using `jconsole`.
> to configure the server for remote management (system properties must
> be set in `run.sh` or `run.bat` scripts).
-By default, Apache ActiveMQ server uses the JMX domain "org.apache.activemq".
-To manage several Apache ActiveMQ servers from the *same* MBeanServer, the JMX
-domain can be configured for each individual Apache ActiveMQ server by setting
+By default, Apache ActiveMQ Artemis server uses the JMX domain "org.apache.activemq".
+To manage several Apache ActiveMQ Artemis servers from the *same* MBeanServer, the JMX
+domain can be configured for each individual Apache ActiveMQ Artemis server by setting
`jmx-domain` in `activemq-configuration.xml`:
<!-- use a specific JMX domain for ActiveMQ MBeans -->
@@ -529,14 +529,14 @@ domain can be configured for each individual Apache ActiveMQ server by setting
#### MBeanServer configuration
-When Apache ActiveMQ is run in standalone, it uses the Java Virtual Machine's
+When Apache ActiveMQ Artemis is run in standalone, it uses the Java Virtual Machine's
`Platform MBeanServer` to register its MBeans. By default [Jolokia](http://www.jolokia.org/)
is also deployed to allow access to the mbean server via rest.
### Example
See the [chapters](examples.md) chapter for an example which shows how to use a remote connection to JMX
-and MBean proxies to manage Apache ActiveMQ.
+and MBean proxies to manage Apache ActiveMQ Artemis.
### Exposing JMX using Jolokia
@@ -567,7 +567,7 @@ management API:
- The parameters of the management operation
When such a management message is sent to the management address,
-Apache ActiveMQ server will handle it, extract the information, invoke the
+Apache ActiveMQ Artemis server will handle it, extract the information, invoke the
operation on the managed resources and send a *management reply* to the
management message's reply-to address (specified by
`ClientMessageImpl.REPLYTO_HEADER_NAME`).
@@ -636,7 +636,7 @@ be able to receive and handle management messages. This is also
configured in activemq-configuration.xml:
<!-- users with the admin role will be allowed to manage -->
- <!-- Apache ActiveMQ using management messages -->
+ <!-- Apache ActiveMQ Artemis using management messages -->
<security-setting match="jms.queue.activemq.management">
<permission type="manage" roles="admin" />
</security-setting>
@@ -693,11 +693,11 @@ steps are the same (see Configuring Core Management section).
### Example
See the [examples](examples.md) chapter for an example which shows
-how to use JMS messages to manage the Apache ActiveMQ server.
+how to use JMS messages to manage the Apache ActiveMQ Artemis server.
## Management Notifications
-Apache ActiveMQ emits *notifications* to inform listeners of potentially
+Apache ActiveMQ Artemis emits *notifications* to inform listeners of potentially
interesting events (creation of new resources, security violation,
etc.).
@@ -722,7 +722,7 @@ subscribing to 2 MBeans:
### Core Messages Notifications
-Apache ActiveMQ defines a special *management notification address*. Core
+Apache ActiveMQ Artemis defines a special *management notification address*. Core
queues can be bound to this address so that clients will receive
management notifications as Core messages
@@ -749,7 +749,7 @@ By default, the address is `activemq.notifications`.
### JMS Messages Notifications
-Apache ActiveMQ's notifications can also be received using JMS messages.
+Apache ActiveMQ Artemis's notifications can also be received using JMS messages.
It is similar to receiving notifications using Core API but an important
difference is that JMS requires a JMS Destination to receive the
@@ -894,7 +894,7 @@ header. The timestamp is the un-formatted result of a call to
## Message Counters
Message counters can be used to obtain information on queues *over time*
-as Apache ActiveMQ keeps a history on queue metrics.
+as Apache ActiveMQ Artemis keeps a history on queue metrics.
They can be used to show *trends* on queues. For example, using the
management API, it would be possible to query the number of messages in
@@ -967,7 +967,7 @@ Message counters can be retrieved using the Management API. For example,
to retrieve message counters on a JMS Queue using JMX:
``` java
-// retrieve a connection to Apache ActiveMQ's MBeanServer
+// retrieve a connection to Apache ActiveMQ Artemis's MBeanServer
MBeanServerConnection mbsc = ...
JMSQueueControlMBean queueControl = (JMSQueueControl)MBeanServerInvocationHandler.newProxyInstance(mbsc,
on,
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/message-expiry.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/message-expiry.md b/docs/user-manual/en/message-expiry.md
index b1707eb..61d3d94 100644
--- a/docs/user-manual/en/message-expiry.md
+++ b/docs/user-manual/en/message-expiry.md
@@ -2,18 +2,18 @@
Messages can be set with an optional *time to live* when sending them.
-Apache ActiveMQ will not deliver a message to a consumer after it's time to
+Apache ActiveMQ Artemis will not deliver a message to a consumer after it's time to
live has been exceeded. If the message hasn't been delivered by the time
that time to live is reached the server can discard it.
-Apache ActiveMQ's addresses can be assigned a expiry address so that, when
+Apache ActiveMQ Artemis's addresses can be assigned a expiry address so that, when
messages are expired, they are removed from the queue and sent to the
expiry address. Many different queues can be bound to an expiry address.
These *expired* messages can later be consumed for further inspection.
## Message Expiry
-Using Apache ActiveMQ Core API, you can set an expiration time directly on the
+Using Apache ActiveMQ Artemis Core API, you can set an expiration time directly on the
message:
// message will expire in 5000ms from now
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/message-grouping.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/message-grouping.md b/docs/user-manual/en/message-grouping.md
index 40b683e..cf520fb 100644
--- a/docs/user-manual/en/message-grouping.md
+++ b/docs/user-manual/en/message-grouping.md
@@ -5,7 +5,7 @@ characteristics:
- Messages in a message group share the same group id, i.e. they have
same group identifier property (`JMSXGroupID` for JMS,
- `_AMQ_GROUP_ID` for Apache ActiveMQ Core API).
+ `_AMQ_GROUP_ID` for Apache ActiveMQ Artemis Core API).
- Messages in a message group are always consumed by the same
consumer, even if there are many consumers on a queue. They pin all
@@ -67,7 +67,7 @@ also be set 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?autoGroup=true
Alternatively you can set the group id via the connection factory. All
@@ -77,7 +77,7 @@ can also be set 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?roupID=Group-0
## Example
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/messaging-concepts.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/messaging-concepts.md b/docs/user-manual/en/messaging-concepts.md
index 40bf861..49f9440 100644
--- a/docs/user-manual/en/messaging-concepts.md
+++ b/docs/user-manual/en/messaging-concepts.md
@@ -1,6 +1,6 @@
# Messaging Concepts
-Apache ActiveMQ is an asynchronous messaging system, an example of [Message
+Apache ActiveMQ Artemis is an asynchronous messaging system, an example of [Message
Oriented
Middleware](http://en.wikipedia.org/wiki/Message_oriented_middleware) ,
we'll just call them messaging systems in the remainder of this book.
@@ -140,7 +140,7 @@ require.
## Transactions
Messaging systems typically support the sending and acknowledgement of
-multiple messages in a single local transaction. Apache ActiveMQ also supports
+multiple messages in a single local transaction. Apache ActiveMQ Artemis also supports
the sending and acknowledgement of message as part of a large global
transaction - using the Java mapping of XA: JTA.
@@ -184,7 +184,7 @@ programmatic API so JMS clients and servers from different vendors
cannot directly interoperate since each will use the vendor's own
internal wire protocol.
-Apache ActiveMQ provides a fully compliant JMS 1.1 and JMS 2.0 API.
+Apache ActiveMQ Artemis provides a fully compliant JMS 1.1 and JMS 2.0 API.
### System specific APIs
@@ -194,7 +194,7 @@ of system functionality to be exposed to the client application. API's
like JMS are not normally rich enough to expose all the extra features
that most messaging systems provide.
-Apache ActiveMQ provides its own core client API for clients to use if they
+Apache ActiveMQ Artemis provides its own core client API for clients to use if they
wish to have access to functionality over and above that accessible via
the JMS API.
@@ -216,7 +216,7 @@ use HTTP as their underlying protocol.
The advantage of a REST approach with HTTP is in its simplicity and the
fact the internet is already tuned to deal with HTTP optimally.
-Please see [Rest Interface](rest.md) for using Apache ActiveMQ's RESTful interface.
+Please see [Rest Interface](rest.md) for using Apache ActiveMQ Artemis's RESTful interface.
### STOMP
@@ -226,7 +226,7 @@ theoretically any Stomp client can work with any messaging system that
supports Stomp. Stomp clients are available in many different
programming languages.
-Please see [Stomp](interoperability.md) for using STOMP with Apache ActiveMQ.
+Please see [Stomp](interoperability.md) for using STOMP with Apache ActiveMQ Artemis.
### AMQP
@@ -235,10 +235,10 @@ interoperable messaging. It also defines a wire format, so any AMQP
client can work with any messaging system that supports AMQP. AMQP
clients are available in many different programming languages.
-Apache ActiveMQ implements the [AMQP
+Apache ActiveMQ Artemis implements the [AMQP
1.0](https://www.oasis-open.org/committees/tc_home.php?wg_abbrev=amqp)
specification. Any client that supports the 1.0 specification will be
-able to interact with Apache ActiveMQ.
+able to interact with Apache ActiveMQ Artemis.
## High Availability
@@ -246,7 +246,7 @@ High Availability (HA) means that the system should remain operational
after failure of one or more of the servers. The degree of support for
HA varies between various messaging systems.
-Apache ActiveMQ provides automatic failover where your sessions are
+Apache ActiveMQ Artemis provides automatic failover where your sessions are
automatically reconnected to the backup server on event of live server
failure.
@@ -263,12 +263,12 @@ Degrees of support for clusters varies between messaging systems, with
some systems having fairly basic clusters with the cluster members being
hardly aware of each other.
-Apache ActiveMQ provides very configurable state-of-the-art clustering model
+Apache ActiveMQ Artemis provides very configurable state-of-the-art clustering model
where messages can be intelligently load balanced between the servers in
the cluster, according to the number of consumers on each node, and
whether they are ready for messages.
-Apache ActiveMQ also has the ability to automatically redistribute messages
+Apache ActiveMQ Artemis also has the ability to automatically redistribute messages
between nodes of a cluster to prevent starvation on any particular node.
For full details on clustering, please see [Clusters](clusters.md).
@@ -284,10 +284,10 @@ messages to another queue on a different server. Bridges cope with
unreliable connections, automatically reconnecting when the connections
becomes available again.
-Apache ActiveMQ bridges can be configured with filter expressions to only
+Apache ActiveMQ Artemis bridges can be configured with filter expressions to only
forward certain messages, and transformation can also be hooked in.
-Apache ActiveMQ also allows routing between queues to be configured in server
+Apache ActiveMQ Artemis also allows routing between queues to be configured in server
side configuration. This allows complex routing networks to be set up
forwarding or copying messages from one destination to another, forming
a global network of interconnected brokers.
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/paging.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/paging.md b/docs/user-manual/en/paging.md
index 09e4695..d6c5171 100644
--- a/docs/user-manual/en/paging.md
+++ b/docs/user-manual/en/paging.md
@@ -1,17 +1,17 @@
# Paging
-Apache ActiveMQ transparently supports huge queues containing millions of
+Apache ActiveMQ Artemis transparently supports huge queues containing millions of
messages while the server is running with limited memory.
In such a situation it's not possible to store all of the queues in
-memory at any one time, so Apache ActiveMQ transparently *pages* messages into
+memory at any one time, so Apache ActiveMQ Artemis transparently *pages* messages into
and out of memory as they are needed, thus allowing massive queues with
a low memory footprint.
-Apache ActiveMQ will start paging messages to disk, when the size of all
+Apache ActiveMQ Artemis will start paging messages to disk, when the size of all
messages in memory for an address exceeds a configured maximum size.
-By default, Apache ActiveMQ does not page messages - this must be explicitly
+By default, Apache ActiveMQ Artemis does not page messages - this must be explicitly
configured to activate it.
## Page Files
@@ -52,7 +52,7 @@ Global paging parameters are specified on the main configuration file
Property Name Description Default
-------------------- --------------------------------------------------------------------------------------------------------------------------- -------------
- `paging-directory` Where page files are stored. Apache ActiveMQ will create one folder for each address being paged under this configured location. data/paging
+ `paging-directory` Where page files are stored. Apache ActiveMQ Artemis will create one folder for each address being paged under this configured location. data/paging
: Paging Configuration Parameters
@@ -183,4 +183,4 @@ undesirable state.
## Example
-See the [examples](examples.md) chapter for an example which shows how to use paging with Apache ActiveMQ.
+See the [examples](examples.md) chapter for an example which shows how to use paging with Apache ActiveMQ Artemis.
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/perf-tuning.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/perf-tuning.md b/docs/user-manual/en/perf-tuning.md
index 81132b1..14d1960 100644
--- a/docs/user-manual/en/perf-tuning.md
+++ b/docs/user-manual/en/perf-tuning.md
@@ -1,6 +1,6 @@
# Performance Tuning
-In this chapter we'll discuss how to tune Apache ActiveMQ for optimum
+In this chapter we'll discuss how to tune Apache ActiveMQ Artemis for optimum
performance.
## Tuning persistence
@@ -72,12 +72,12 @@ JMS API
storage.
- Batch many sends or acknowledgements in a single transaction.
- Apache ActiveMQ will only require a network round trip on the commit, not
+ Apache ActiveMQ Artemis will only require a network round trip on the commit, not
on every send or acknowledgement.
## Other Tunings
-There are various other places in Apache ActiveMQ where we can perform some
+There are various other places in Apache ActiveMQ Artemis where we can perform some
tuning:
- Use Asynchronous Send Acknowledgements. If you need to send durable
@@ -125,7 +125,7 @@ tuning:
consumer-window-size. This effectively disables consumer flow
control.
-- Socket NIO vs Socket Old IO. By default Apache ActiveMQ uses old (blocking)
+- Socket NIO vs Socket Old IO. By default Apache ActiveMQ Artemis uses old (blocking)
on the server and the client side (see the chapter on configuring
transports for more information [Configuring the Transport](configuring-transports.md). NIO is much more scalable but
can give you some latency hit compared to old blocking IO. If you
@@ -174,7 +174,7 @@ tuning:
`serveruser`.
- Use `batch-delay` and set `direct-deliver` to false for the best
- throughput for very small messages. Apache ActiveMQ comes with a
+ throughput for very small messages. Apache ActiveMQ Artemis comes with a
preconfigured connector/acceptor pair (`netty-throughput`) in
`activemq-configuration.xml` and JMS connection factory
(`ThroughputConnectionFactory`) in `activemq-jms.xml`which can be
@@ -193,7 +193,7 @@ tunings won't apply to JDKs from other providers (e.g. IBM or JRockit)
`-XX:+UseParallelOldGC` on Sun JDKs.
- Memory settings. Give as much memory as you can to the server.
- Apache ActiveMQ can run in low memory by using paging (described in [Paging](paging.md)) but
+ Apache ActiveMQ Artemis can run in low memory by using paging (described in [Paging](paging.md)) but
if it can run with all queues in RAM this will improve performance.
The amount of memory you require will depend on the size and number
of your queues and the size and number of your messages. Use the JVM
@@ -223,7 +223,7 @@ tunings won't apply to JDKs from other providers (e.g. IBM or JRockit)
> Some popular libraries such as the Spring JMS Template are known
> to use these anti-patterns. If you're using Spring JMS Template
> and you're getting poor performance you know why. Don't blame
- > Apache ActiveMQ! The Spring JMS Template can only safely be used in an
+ > Apache ActiveMQ Artemis! The Spring JMS Template can only safely be used in an
> app server which caches JMS sessions (e.g. using JCA), and only
> then for sending messages. It cannot be safely be used for
> synchronously consuming messages, even in an app server.
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/persistence.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/persistence.md b/docs/user-manual/en/persistence.md
index 517d243..e6f59f5 100644
--- a/docs/user-manual/en/persistence.md
+++ b/docs/user-manual/en/persistence.md
@@ -1,14 +1,14 @@
# Persistence
-In this chapter we will describe how persistence works with Apache ActiveMQ and
+In this chapter we will describe how persistence works with Apache ActiveMQ Artemis and
how to configure it.
-Apache ActiveMQ ships with a high performance journal. Since Apache ActiveMQ handles
+Apache ActiveMQ Artemis ships with a high performance journal. Since Apache ActiveMQ Artemis handles
its own persistence, rather than relying on a database or other 3rd
party persistence engine it is very highly optimised for the specific
messaging use cases.
-An Apache ActiveMQ journal is an *append only* journal. It consists of a set of
+An Apache ActiveMQ Artemis journal is an *append only* journal. It consists of a set of
files on disk. Each file is pre-created to a fixed size and initially
filled with padding. As operations are performed on the server, e.g. add
message, update message, delete message, records are appended to the
@@ -27,12 +27,12 @@ minimise the amount of disk head movement, since an entire disk cylinder
is accessible simply by the disk rotating - the head does not have to
move.
-As delete records are added to the journal, Apache ActiveMQ has a sophisticated
+As delete records are added to the journal, Apache ActiveMQ Artemis has a sophisticated
file garbage collection algorithm which can determine if a particular
journal file is needed any more - i.e. has all its data been deleted in
the same or other files. If so, the file can be reclaimed and re-used.
-Apache ActiveMQ also has a compaction algorithm which removes dead space from
+Apache ActiveMQ Artemis also has a compaction algorithm which removes dead space from
the journal and compresses up the data so it takes up less files on
disk.
@@ -41,7 +41,7 @@ supporting both local and XA transactions.
The majority of the journal is written in Java, however we abstract out
the interaction with the actual file system to allow different pluggable
-implementations. Apache ActiveMQ ships with two implementations:
+implementations. Apache ActiveMQ Artemis ships with two implementations:
- Java [NIO](http://en.wikipedia.org/wiki/New_I/O).
@@ -52,7 +52,7 @@ implementations. Apache ActiveMQ ships with two implementations:
- Linux Asynchronous IO
The second implementation uses a thin native code wrapper to talk to
- the Linux asynchronous IO library (AIO). With AIO, Apache ActiveMQ will be
+ the Linux asynchronous IO library (AIO). With AIO, Apache ActiveMQ Artemis will be
called back when the data has made it to disk, allowing us to avoid
explicit syncs altogether and simply send back confirmation of
completion when AIO informs us that the data has been persisted.
@@ -73,7 +73,7 @@ implementations. Apache ActiveMQ ships with two implementations:
libaio is part of the kernel project.
-The standard Apache ActiveMQ core server uses two instances of the journal:
+The standard Apache ActiveMQ Artemis core server uses two instances of the journal:
- Bindings journal.
@@ -107,7 +107,7 @@ The standard Apache ActiveMQ core server uses two instances of the journal:
This journal instance stores all message related data, including the
message themselves and also duplicate-id caches.
- By default Apache ActiveMQ will try and use an AIO journal. If AIO is not
+ By default Apache ActiveMQ Artemis will try and use an AIO journal. If AIO is not
available, e.g. the platform is not Linux with the correct kernel
version or AIO has not been installed then it will automatically
fall back to using Java NIO which is available on any Java platform.
@@ -116,13 +116,13 @@ The standard Apache ActiveMQ core server uses two instances of the journal:
has a `amq` extension. File size is by the default `10485760`
(configurable), and it is located at the journal folder.
-For large messages, Apache ActiveMQ persists them outside the message journal.
+For large messages, Apache ActiveMQ Artemis persists them outside the message journal.
This is discussed in [Large Messages](large-messages.md).
-Apache ActiveMQ can also be configured to page messages to disk in low memory
+Apache ActiveMQ Artemis can also be configured to page messages to disk in low memory
situations. This is discussed in [Paging](paging.md).
-If no persistence is required at all, Apache ActiveMQ can also be configured
+If no persistence is required at all, Apache ActiveMQ Artemis can also be configured
not to persist any data at all to storage as discussed in the Configuring
the broker for Zero Persistence section.
@@ -182,18 +182,18 @@ The message journal is configured using the following attributes in
Choosing `NIO` chooses the Java NIO journal. Choosing `AIO` chooses
the Linux asynchronous IO journal. If you choose `AIO` but are not
- running Linux or you do not have libaio installed then Apache ActiveMQ will
+ running Linux or you do not have libaio installed then Apache ActiveMQ Artemis will
detect this and automatically fall back to using `NIO`.
- `journal-sync-transactional`
- If this is set to true then Apache ActiveMQ will make sure all transaction
+ If this is set to true then Apache ActiveMQ Artemis will make sure all transaction
data is flushed to disk on transaction boundaries (commit, prepare
and rollback). The default value is `true`.
- `journal-sync-non-transactional`
- If this is set to true then Apache ActiveMQ will make sure non
+ If this is set to true then Apache ActiveMQ Artemis will make sure non
transactional message data (sends and acknowledgements) are flushed
to disk each time. The default value for this is `true`.
@@ -204,8 +204,8 @@ The message journal is configured using the following attributes in
- `journal-min-files`
- The minimum number of files the journal will maintain. When Apache ActiveMQ
- starts and there is no initial message data, Apache ActiveMQ will
+ The minimum number of files the journal will maintain. When Apache ActiveMQ Artemis
+ starts and there is no initial message data, Apache ActiveMQ Artemis will
pre-create `journal-min-files` number of files.
Creating journal files and filling them with padding is a fairly
@@ -327,7 +327,7 @@ The message journal is configured using the following attributes in
## Installing AIO
The Java NIO journal gives great performance, but If you are running
-Apache ActiveMQ using Linux Kernel 2.6 or later, we highly recommend you use
+Apache ActiveMQ Artemis using Linux Kernel 2.6 or later, we highly recommend you use
the `AIO` journal for the very best persistence performance.
It's not possible to use the AIO journal under other operating systems
@@ -344,10 +344,10 @@ Using aptitude, (e.g. on Ubuntu or Debian system):
apt-get install libaio
-## Configuring Apache ActiveMQ for Zero Persistence
+## Configuring Apache ActiveMQ Artemis for Zero Persistence
In some situations, zero persistence is sometimes required for a
-messaging system. Configuring Apache ActiveMQ to perform zero persistence is
+messaging system. Configuring Apache ActiveMQ Artemis to perform zero persistence is
straightforward. Simply set the parameter `persistence-enabled` in
`activemq-configuration.xml` to `false`.
@@ -358,7 +358,7 @@ message data, duplicate id caches or paging data will be persisted.
## Import/Export the Journal Data
You may want to inspect the existent records on each one of the journals
-used by Apache ActiveMQ, and you can use the export/import tool for that
+used by Apache ActiveMQ Artemis, and you can use the export/import tool for that
purpose.
you can export the journal as a text file by using this command:
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/pre-acknowledge.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/pre-acknowledge.md b/docs/user-manual/en/pre-acknowledge.md
index 8ecf8e1..a0daada 100644
--- a/docs/user-manual/en/pre-acknowledge.md
+++ b/docs/user-manual/en/pre-acknowledge.md
@@ -8,14 +8,14 @@ JMS specifies 3 acknowledgement modes:
- `DUPS_OK_ACKNOWLEDGE`
-Apache ActiveMQ supports two additional modes: `PRE_ACKNOWLEDGE` and
+Apache ActiveMQ Artemis supports two additional modes: `PRE_ACKNOWLEDGE` and
`INDIVIDUAL_ACKNOWLEDGE`
In some cases you can afford to lose messages in event of failure, so it
would make sense to acknowledge the message on the server *before*
delivering it to the client.
-This extra mode is supported by Apache ActiveMQ and will call it
+This extra mode is supported by Apache ActiveMQ Artemis and will call it
*pre-acknowledge* mode.
The disadvantage of acknowledging on the server before delivery is that
@@ -45,7 +45,7 @@ arrive soon, overriding the previous price.
This can be configured in a client's JNDI context environment, e.g.
`jndi.properties`, like this:
- java.naming.factory.initial=org.apache.activemq.jndi.ActiveMQInitialContextFactory
+ java.naming.factory.initial=ActiveMQInitialContextFactory
connection.ConnectionFactory=tcp://localhost:61616?preAcknowledge=true
Alternatively, to use pre-acknowledgement mode using the JMS API, create
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/preface.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/preface.md b/docs/user-manual/en/preface.md
index 1efdcda..21c05b0 100644
--- a/docs/user-manual/en/preface.md
+++ b/docs/user-manual/en/preface.md
@@ -1,24 +1,24 @@
# Preface
-What is Apache ActiveMQ?
+What is Apache ActiveMQ Artemis?
-- Apache ActiveMQ is an open source project to build a multi-protocol,
+- Apache ActiveMQ Artemis is an open source project to build a multi-protocol,
embeddable, very high performance, clustered, asynchronous messaging
system.
-- Apache ActiveMQ is an example of Message Oriented Middleware (MoM). For a
+- Apache ActiveMQ Artemis is an example of Message Oriented Middleware (MoM). For a
description of MoMs and other messaging concepts please see the [Messaging Concepts](messaging-concepts.md).
-- For answers to more questions about what Apache ActiveMQ is and what it
+- For answers to more questions about what Apache ActiveMQ Artemis is and what it
isn't please visit the [FAQs wiki
page](todo).
-Why use Apache ActiveMQ? Here are just a few of the reasons:
+Why use Apache ActiveMQ Artemis? Here are just a few of the reasons:
-- 100% open source software. Apache ActiveMQ is licensed using the Apache
+- 100% open source software. Apache ActiveMQ Artemis is licensed using the Apache
Software License v 2.0 to minimise barriers to adoption.
-- Apache ActiveMQ is designed with usability in mind.
+- Apache ActiveMQ Artemis is designed with usability in mind.
- Written in Java. Runs on any platform with a Java 8+ runtime, that's
everything from Windows desktops to IBM mainframes.
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/8f52a622/docs/user-manual/en/project-info.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/project-info.md b/docs/user-manual/en/project-info.md
index b602892..4d8c9eb 100644
--- a/docs/user-manual/en/project-info.md
+++ b/docs/user-manual/en/project-info.md
@@ -1,6 +1,6 @@
# Project Information
-The official Apache ActiveMQ project page is <http://activemq.apache.org//>.
+The official Apache ActiveMQ Artemis project page is <http://activemq.apache.org//>.
## Software Download
@@ -20,11 +20,11 @@ page:<http://activemq.apache.org/download.html>
- Follow us on [twitter](https://twitter.com/activemq)
-- Apache ActiveMQ Git repository is <https://github.com/apache/activemq-6>
+- Apache ActiveMQ Artemis Git repository is <https://github.com/apache/activemq-6>
- All release tags are available from
<https://github.com/apache/activemq-6/releases>
And many thanks to all our contributors, both old and new who helped
-create Apache ActiveMQ.
+create Apache ActiveMQ Artemis.