activemq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From clebertsuco...@apache.org
Subject [1/5] activemq-6 git commit: documentation review fixes
Date Fri, 12 Dec 2014 16:32:48 GMT
Repository: activemq-6
Updated Branches:
  refs/heads/master 1491f4a12 -> 4045e8974


http://git-wip-us.apache.org/repos/asf/activemq-6/blob/b4144013/docs/user-manual/en/slow-consumers.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/slow-consumers.md b/docs/user-manual/en/slow-consumers.md
index ae03d30..5b04565 100644
--- a/docs/user-manual/en/slow-consumers.md
+++ b/docs/user-manual/en/slow-consumers.md
@@ -1,5 +1,4 @@
-Detecting Slow Consumers
-========================
+#Detecting Slow Consumers
 
 In this section we will discuss how ActiveMQ can be configured to deal
 with slow consumers. A slow consumer with a server-side queue (e.g. JMS
@@ -13,8 +12,7 @@ non-durable JMS subscriber would allow the broker to remove the
 subscription and all of its messages freeing up valuable server
 resources.
 
-Configuration required for detecting slow consumers
-===================================================
+## Configuration required for detecting slow consumers
 
 By default the server will not detect slow consumers. If slow consumer
 detection is desired then see ? for more details.

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/b4144013/docs/user-manual/en/spring-integration.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/spring-integration.md b/docs/user-manual/en/spring-integration.md
index 570eac5..00dae1c 100644
--- a/docs/user-manual/en/spring-integration.md
+++ b/docs/user-manual/en/spring-integration.md
@@ -1,5 +1,4 @@
-Spring Integration
-==================
+# Spring Integration
 
 ActiveMQ provides a simple bootstrap class,
 `org.apache.activemq.integration.spring.SpringJmsBootstrap`, for
@@ -44,7 +43,7 @@ taking advantage of this feature:
 
 As you can see, the `listenerContainer` bean references the components
 defined in the `activemq-jms.xml` file. The `SpringJmsBootstrap` class
-extends the EmbeddedJMS class talked about in ? and the same defaults
+extends the EmbeddedJMS class talked about in [JMS API](embedding-activemq.md) and the same
defaults
 and configuration options apply. Also notice that an `init-method` must
 be declared with a start value so that the bean's lifecycle is executed.
 See the javadocs for more details on other properties of the bean class.

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/b4144013/docs/user-manual/en/syntax.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/syntax.md b/docs/user-manual/en/syntax.md
new file mode 100644
index 0000000..6e81a34
--- /dev/null
+++ b/docs/user-manual/en/syntax.md
@@ -0,0 +1,22 @@
+# header 1
+## Header 2
+### Header 3     
+#### Header 4
+
+    <xml>somexml</xml>
+    
+``` java
+ Somejava s = new SomeJava();
+```
+ 
+> **Note**
+>
+> This is a Note
+
+
+
+> **Warning**
+>
+> This is a warning
+
+`literal`

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/b4144013/docs/user-manual/en/thread-pooling.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/thread-pooling.md b/docs/user-manual/en/thread-pooling.md
index 3dee1ea..4a7613e 100644
--- a/docs/user-manual/en/thread-pooling.md
+++ b/docs/user-manual/en/thread-pooling.md
@@ -1,5 +1,4 @@
-Thread management
-=================
+# Thread management
 
 This chapter describes how ActiveMQ uses and pools threads and how you
 can manage them.
@@ -7,8 +6,7 @@ can manage them.
 First we'll discuss how threads are managed and used on the server side,
 then we'll look at the client side.
 
-Server-Side Thread Management
-=============================
+## Server-Side Thread Management
 
 Each ActiveMQ Server maintains a single thread pool for general use, and
 a scheduled thread pool for scheduled use. A Java scheduled thread pool
@@ -45,8 +43,7 @@ transport configuration. See the ? for more information on this.
 There are also a small number of other places where threads are used
 directly, we'll discuss each in turn.
 
-Server Scheduled Thread Pool
-----------------------------
+### Server Scheduled Thread Pool
 
 The server scheduled thread pool is used for most activities on the
 server side that require running periodically or with delays. It maps
@@ -58,8 +55,7 @@ The maximum number of thread used by this pool is configure in
 parameter. The default value is `5` threads. A small number of threads
 is usually sufficient for this pool.
 
-General Purpose Server Thread Pool
-----------------------------------
+### General Purpose Server Thread Pool
 
 This general purpose thread pool is used for most asynchronous actions
 on the server side. It maps internally to a
@@ -87,8 +83,7 @@ javadoc](http://docs.oracle.com/javase/6/docs/api/java/util/concurrent/ThreadPoo
 for more information on unbounded (cached), and bounded (fixed) thread
 pools.
 
-Expiry Reaper Thread
---------------------
+### Expiry Reaper Thread
 
 A single thread is also used on the server side to scan for expired
 messages in queues. We cannot use either of the thread pools for this
@@ -96,8 +91,7 @@ since this thread needs to run at its own configurable priority.
 
 For more information on configuring the reaper, please see ?.
 
-Asynchronous IO
----------------
+### Asynchronous IO
 
 Asynchronous IO has a thread pool for receiving and dispatching events
 out of the native layer. You will find it on a thread dump with the
@@ -109,8 +103,7 @@ that to avoid context switching on libaio that would cause performance
 issues. You will find this thread on a thread dump with the prefix
 ActiveMQ-AIO-writer-pool.
 
-Client-Side Thread Management
-=============================
+## Client-Side Thread Management
 
 On the client side, ActiveMQ maintains a single static scheduled thread
 pool and a single static general thread pool for use by all clients
@@ -129,17 +122,25 @@ To configure a `ClientSessionFactory` instance to use its own pools,
 simply use the appropriate setter methods immediately after creation,
 for example:
 
-    ServerLocator locator = ActiveMQClient.createServerLocatorWithoutHA(...)
-    ClientSessionFactory myFactory = locator.createClientSessionFactory();
-    myFactory.setUseGlobalPools(false);
-    myFactory.setScheduledThreadPoolMaxSize(10);
-    myFactory.setThreadPoolMaxSize(-1);   
+``` java
+ServerLocator locator = ActiveMQClient.createServerLocatorWithoutHA(...)
+
+ClientSessionFactory myFactory = locator.createClientSessionFactory();
+
+myFactory.setUseGlobalPools(false);
+
+myFactory.setScheduledThreadPoolMaxSize(10);
+
+myFactory.setThreadPoolMaxSize(-1); 
+```
 
 If you're using the JMS API, you can set the same parameters on the
 ClientSessionFactory and use it to create the `ConnectionFactory`
 instance, for example:
 
-    ConnectionFactory myConnectionFactory = ActiveMQJMSClient.createConnectionFactory(myFactory);
+``` java
+ConnectionFactory myConnectionFactory = ActiveMQJMSClient.createConnectionFactory(myFactory);
+```
 
 If you're using JNDI to instantiate `ActiveMQConnectionFactory`
 instances, you can also set these parameters in the JNDI context
@@ -148,7 +149,12 @@ environment, e.g. `jndi.properties`. Here's a simple example using the
 by default:
 
     java.naming.factory.initial=org.apache.activemq.jndi.ActiveMQInitialContextFactory
+    
     java.naming.provider.url=tcp://localhost:5445
+    
     connection.ConnectionFactory.useGlobalPools=false
+    
     connection.ConnectionFactory.scheduledThreadPoolMaxSize=10
+    
     connection.ConnectionFactory.threadPoolMaxSize=-1
+

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/b4144013/docs/user-manual/en/tools.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/tools.md b/docs/user-manual/en/tools.md
index a97aa79..cb18451 100644
--- a/docs/user-manual/en/tools.md
+++ b/docs/user-manual/en/tools.md
@@ -1,5 +1,4 @@
-Tools
-=====
+# Tools
 
 ActiveMQ ships with several helpful command line tools. All tools are
 available from the activemq-tools-\<version\>-jar-with-dependencies.jar.

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/b4144013/docs/user-manual/en/transaction-config.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/transaction-config.md b/docs/user-manual/en/transaction-config.md
index 3bdbbc8..12f1bf8 100644
--- a/docs/user-manual/en/transaction-config.md
+++ b/docs/user-manual/en/transaction-config.md
@@ -1,5 +1,4 @@
-Resource Manager Configuration
-==============================
+# Resource Manager Configuration
 
 ActiveMQ has its own Resource Manager for handling the lifespan of JTA
 transactions. When a transaction is started the resource manager is

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/b4144013/docs/user-manual/en/undelivered-messages.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/undelivered-messages.md b/docs/user-manual/en/undelivered-messages.md
index d449102..bc7de7a 100644
--- a/docs/user-manual/en/undelivered-messages.md
+++ b/docs/user-manual/en/undelivered-messages.md
@@ -1,5 +1,4 @@
-Message Redelivery and Undelivered Messages
-===========================================
+# Message Redelivery and Undelivered Messages
 
 Messages can be delivered unsuccessfully (e.g. if the transacted session
 used to consume them is rolled back). Such a message goes back to its
@@ -23,8 +22,7 @@ There are 2 ways to deal with these undelivered messages:
 
 Both options can be combined for maximum flexibility.
 
-Delayed Redelivery
-==================
+## Delayed Redelivery
 
 Delaying redelivery can often be useful in the case that clients
 regularly fail or rollback. Without a delayed redelivery, the system can
@@ -32,19 +30,18 @@ get into a "thrashing" state, with delivery being attempted, the client
 rolling back, and delivery being re-attempted ad infinitum in quick
 succession, consuming valuable CPU and network resources.
 
-Configuring Delayed Redelivery
-------------------------------
+### Configuring Delayed Redelivery
 
 Delayed redelivery is defined in the address-setting configuration:
 
     <!-- delay redelivery of messages for 5s -->
     <address-setting match="jms.queue.exampleQueue">
-       <!-- default is 1.0 --> 
-       <redelivery-delay-multiplier>1.5</redelivery-delay-multiplier>
-       <!-- default is 0 (no delay) --> 
-       <redelivery-delay>5000</redelivery-delay>
-       <!-- default is redelivery-delay * 10 -->
-       <max-redelivery-delay>50000</max-redelivery-delay>
+    <!-- default is 1.0 --> 
+    <redelivery-delay-multiplier>1.5</redelivery-delay-multiplier>
+    <!-- default is 0 (no delay) --> 
+    <redelivery-delay>5000</redelivery-delay>
+    <!-- default is redelivery-delay * 10 -->
+    <max-redelivery-delay>50000</max-redelivery-delay>
      
     </address-setting>
 
@@ -63,17 +60,15 @@ redelivery-delay with a max-redelivery-delay to be taken into account.
 The max-redelivery-delay is defaulted to redelivery-delay \* 10
 
 Address wildcards can be used to configure redelivery delay for a set of
-addresses (see ?), so you don't have to specify redelivery delay
+addresses (see [Understanding the HornetQ Wildcard Syntax](wildcard-syntax.md)), so you don't
have to specify redelivery delay
 individually for each address.
 
-Example
--------
+### Example
 
 See ? for an example which shows how delayed redelivery is configured
 and used with JMS.
 
-Dead Letter Addresses
-=====================
+## Dead Letter Addresses
 
 To prevent a client infinitely receiving the same undelivered message
 (regardless of what is causing the unsuccessful deliveries), messaging
@@ -90,16 +85,15 @@ attempts, they are removed from the queue and sent to the dead letter
 address. These *dead letter* messages can later be consumed for further
 inspection.
 
-Configuring Dead Letter Addresses
----------------------------------
+### Configuring Dead Letter Addresses
 
 Dead letter address is defined in the address-setting configuration:
 
     <!-- undelivered messages in exampleQueue will be sent to the dead letter address
-       deadLetterQueue after 3 unsuccessful delivery attempts -->
+    deadLetterQueue after 3 unsuccessful delivery attempts -->
     <address-setting match="jms.queue.exampleQueue">
-       <dead-letter-address>jms.queue.deadLetterQueue</dead-letter-address>
-       <max-delivery-attempts>3</max-delivery-attempts>
+    <dead-letter-address>jms.queue.deadLetterQueue</dead-letter-address>
+    <max-delivery-attempts>3</max-delivery-attempts>
     </address-setting>
 
 If a `dead-letter-address` is not specified, messages will removed after
@@ -113,10 +107,9 @@ addresses and you can set `max-delivery-attempts` to -1 for a specific
 address setting to allow infinite redeliveries only for this address.
 
 Address wildcards can be used to configure dead letter settings for a
-set of addresses (see ?).
+set of addresses (see [Understanding the HornetQ Wildcard Syntax](wildcard-syntax.md)).
 
-Dead Letter Properties
-----------------------
+### Dead Letter Properties
 
 Dead letter messages which are consumed from a dead letter address have
 the following properties:
@@ -131,14 +124,12 @@ the following properties:
     a String property containing the *original queue* of the dead letter
     message
 
-Example
--------
+### Example
 
 See ? for an example which shows how dead letter is configured and used
 with JMS.
 
-Delivery Count Persistence
-==========================
+## Delivery Count Persistence
 
 In normal use, ActiveMQ does not update delivery count *persistently*
 until a message is rolled back (i.e. the delivery count is not updated

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/b4144013/docs/user-manual/en/using-core.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/using-core.md b/docs/user-manual/en/using-core.md
index 6c9743f..a23883e 100644
--- a/docs/user-manual/en/using-core.md
+++ b/docs/user-manual/en/using-core.md
@@ -1,5 +1,4 @@
-Using Core
-==========
+# Using Core
 
 ActiveMQ core is a completely JMS-agnostic messaging system with its own
 non-JMS API. We call this the *core API*.
@@ -8,8 +7,7 @@ If you don't want to use JMS you can use the core API directly. The core
 API provides all the functionality of JMS but without much of the
 complexity. It also provides features that are not available using JMS.
 
-Core Messaging Concepts
-=======================
+## Core Messaging Concepts
 
 Some of the core messaging concepts are similar to JMS concepts, but
 core messaging concepts differ in some ways. In general the core
@@ -18,8 +16,7 @@ between queues, topics and subscriptions. We'll discuss each of the
 major core messaging concepts in turn, but to see the API in detail,
 please consult the Javadoc.
 
-Message
--------
+### Message
 
 -   A message is the unit of data which is sent between clients and
     servers.
@@ -54,10 +51,9 @@ Message
     the message was sent.
 
 -   ActiveMQ also supports the sending/consuming of very large messages
-    - much larger than can fit in available RAM at any one time.
+    much larger than can fit in available RAM at any one time.
 
-Address
--------
+### Address
 
 A server maintains a mapping between an address and a set of queues.
 Zero or more queues can be bound to a single address. Each queue can be
@@ -80,8 +76,7 @@ messages will also be routed there.
 > the topic. A JMS Queue would be implemented as a single address to
 > which one queue is bound - that queue represents the JMS queue.
 
-Queue
------
+### Queue
 
 Queues can be durable, meaning the messages they contain survive a
 server crash or restart, as long as the messages in them are durable.
@@ -99,8 +94,7 @@ match that filter expression to any queues bound to the address.
 Many queues can be bound to a single address. A particular queue is only
 bound to a maximum of one address.
 
-ServerLocator
--------------
+### ServerLocator
 
 Clients use `ServerLocator` instances to create `ClientSessionFactory`
 instances. `ServerLocator` instances are used to locate servers and
@@ -112,8 +106,7 @@ Connection Factory.
 `ServerLocator` instances are created using the `ActiveMQClient` factory
 class.
 
-ClientSessionFactory
---------------------
+### ClientSessionFactory
 
 Clients use `ClientSessionFactory` instances to create `ClientSession`
 instances. `ClientSessionFactory` instances are basically the connection
@@ -124,8 +117,7 @@ In JMS terms think of them as JMS Connections.
 `ClientSessionFactory` instances are created using the `ServerLocator`
 class.
 
-ClientSession
--------------
+### ClientSession
 
 A client uses a ClientSession for consuming and producing messages and
 for grouping them in transactions. ClientSession instances can support
@@ -147,10 +139,9 @@ messages sent is costly since it requires a network round trip for each
 message sent. By not blocking and receiving send acknowledgements
 asynchronously you can create true end to end asynchronous systems which
 is not possible using the standard JMS API. For more information on this
-advanced feature please see the section ?.
+advanced feature please see the section [Guarantees of sends and commits]{send-guarantees.md).
 
-ClientConsumer
---------------
+### ClientConsumer
 
 Clients use `ClientConsumer` instances to consume messages from a queue.
 Core Messaging supports both synchronous and asynchronous message
@@ -158,8 +149,7 @@ consumption semantics. `ClientConsumer` instances can be configured with
 an optional filter expression and will only consume messages which match
 that expression.
 
-ClientProducer
---------------
+### ClientProducer
 
 Clients create `ClientProducer` instances on `ClientSession` instances
 so they can send messages. ClientProducer instances can specify an
@@ -175,48 +165,48 @@ message.
 > It's an anti-pattern to create new ClientSession, ClientProducer and
 > ClientConsumer instances for each message you produce or consume. If
 > you do this, your application will perform very poorly. This is
-> discussed further in the section on performance tuning ?.
+> discussed further in the section on performance tuning [Performance Tuning](perf-tuning.md).
 
-A simple example of using Core
-==============================
+## A simple example of using Core
 
 Here's a very simple program using the core messaging API to send and
 receive a message. Logically it's comprised of two sections: firstly
 setting up the producer to write a message to an *addresss*, and
 secondly, creating a *queue* for the consumer, creating the consumer and
 *starting* it.
+``` java
+ServerLocator locator = ActiveMQClient.createServerLocatorWithoutHA(new TransportConfiguration(
+                                           InVMConnectorFactory.class.getName()));
 
-    ServerLocator locator = ActiveMQClient.createServerLocatorWithoutHA(new TransportConfiguration(
-                                               InVMConnectorFactory.class.getName()));
+// In this simple example, we just use one session for both producing and receiving
 
-    // In this simple example, we just use one session for both producing and receiving
+ClientSessionFactory factory =  locator.createClientSessionFactory();
+ClientSession session = factory.createSession();
 
-    ClientSessionFactory factory =  locator.createClientSessionFactory();
-    ClientSession session = factory.createSession();
+// A producer is associated with an address ...
 
-    // A producer is associated with an address ...
+ClientProducer producer = session.createProducer("example");
+ClientMessage message = session.createMessage(true);
+message.getBodyBuffer().writeString("Hello");
 
-    ClientProducer producer = session.createProducer("example");
-    ClientMessage message = session.createMessage(true);
-    message.getBodyBuffer().writeString("Hello");
+// We need a queue attached to the address ...
 
-    // We need a queue attached to the address ...
+session.createQueue("example", "example", true);
 
-    session.createQueue("example", "example", true);
+// And a consumer attached to the queue ...
 
-    // And a consumer attached to the queue ...
+ClientConsumer consumer = session.createConsumer("example");
 
-    ClientConsumer consumer = session.createConsumer("example");
+// Once we have a queue, we can send the message ...
 
-    // Once we have a queue, we can send the message ...
+producer.send(message);
 
-    producer.send(message);
+// We need to start the session before we can -receive- messages ...
 
-    // We need to start the session before we can -receive- messages ...
+session.start();
+ClientMessage msgReceived = consumer.receive();
 
-    session.start();
-    ClientMessage msgReceived = consumer.receive();
+System.out.println("message = " + msgReceived.getBodyBuffer().readString());
 
-    System.out.println("message = " + msgReceived.getBodyBuffer().readString());
-
-    session.close();
+session.close();
+```

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/b4144013/docs/user-manual/en/using-jms.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/using-jms.md b/docs/user-manual/en/using-jms.md
index 595dc0e..f3f4ce1 100644
--- a/docs/user-manual/en/using-jms.md
+++ b/docs/user-manual/en/using-jms.md
@@ -1,5 +1,4 @@
-Using JMS
-=========
+# Using JMS
 
 Although ActiveMQ provides a JMS agnostic messaging API, many users will
 be more comfortable using JMS.
@@ -14,7 +13,7 @@ ActiveMQ also ships with a wide range of examples, many of which
 demonstrate JMS API usage. A good place to start would be to play around
 with the simple JMS Queue and Topic example, but we also provide
 examples for many other parts of the JMS API. A full description of the
-examples is available in ?.
+examples is available in [Examples](examples.md).
 
 In this section we'll go through the main steps in configuring the
 server for JMS and creating a simple JMS program. We'll also show how to
@@ -214,19 +213,39 @@ Any property available on the underlying
 this way in addition to the `ha` (boolean) and `type` (String)
 properties. Here are the different options for the `type`:
 
-  type            interface
-  --------------- ------------------------------------
-  CF (default)    javax.jms.ConnectionFactory
-  XA\_CF          javax.jms.XAConnectionFactory
-  QUEUE\_CF       javax.jms.QueueConnectionFactory
-  QUEUE\_XA\_CF   javax.jms.XAQueueConnectionFactory
-  TOPIC\_CF       javax.jms.TopicConnectionFactory
-  TOPIC\_XA\_CF   javax.jms.XATopicConnectionFactory
-
-  : Configuration for Connection Factory Types
-
-Destination JNDI
-----------------
+#### Configuration for Connection Factory Types
+<table>
+  <tr>
+    <th>type</th>
+    <th>interface</th> 
+  </tr>
+  <tr>
+    <td>CF (default)</td>
+    <td>javax.jms.ConnectionFactory</td> 
+  </tr>    
+  <tr>
+    <td>XA_CF</td>
+    <td>javax.jms.XAConnectionFactory</td> 
+  </tr>
+  <tr>
+    <td>QUEUE_CF</td>
+    <td>javax.jms.QueueConnectionFactory</td> 
+  </tr>
+  <tr>
+    <td>QUEUE_XA_CF</td>
+    <td>javax.jms.XAQueueConnectionFactory</td> 
+  </tr>
+  <tr>
+    <td>TOPIC_CF</td>
+    <td>javax.jms.TopicConnectionFactory</td> 
+  </tr>
+  <tr>
+    <td>TOPIC_XA_CF</td>
+    <td>javax.jms.XATopicConnectionFactory</td> 
+  </tr>
+</table>
+
+### Destination JNDI
 
 JMS destinations are also typically looked up via JNDI. As with
 connection factories, destinations can be configured using special
@@ -253,8 +272,7 @@ it could do so simply by using the string "dynamicQueues/OrderQueue".
 Note, the text that follows `dynamicQueues/` or `dynamicTopics/` must
 correspond *exactly* to the name of the destination on the server.
 
-The code
---------
+### The code
 
 Here's the code for the example:
 
@@ -262,49 +280,50 @@ First we'll create a JNDI initial context from which to lookup our JMS
 objects. If the above properties are set in `jndi.properties` and it is
 on the classpath then any new, empty `InitialContext` will be
 initialized using those properties:
+``` java
+InitialContext ic = new InitialContext();
 
-    InitialContext ic = new InitialContext();
+//Now we'll look up the connection factory from which we can create
+//connections to myhost:5445:
 
-Now we'll look up the connection factory from which we can create
-connections to myhost:5445:
+ConnectionFactory cf = (ConnectionFactory)ic.lookup("ConnectionFactory");
 
-    ConnectionFactory cf = (ConnectionFactory)ic.lookup("ConnectionFactory");
+//And look up the Queue:
 
-And look up the Queue:
+Queue orderQueue = (Queue)ic.lookup("queues/OrderQueue");
 
-    Queue orderQueue = (Queue)ic.lookup("queues/OrderQueue");
+//Next we create a JMS connection using the connection factory:
 
-Next we create a JMS connection using the connection factory:
+Connection connection = cf.createConnection();
 
-    Connection connection = cf.createConnection();
+//And we create a non transacted JMS Session, with AUTO\_ACKNOWLEDGE
+//acknowledge mode:
 
-And we create a non transacted JMS Session, with AUTO\_ACKNOWLEDGE
-acknowledge mode:
+Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
 
-    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
+//We create a MessageProducer that will send orders to the queue:
 
-We create a MessageProducer that will send orders to the queue:
+MessageProducer producer = session.createProducer(orderQueue);
 
-    MessageProducer producer = session.createProducer(orderQueue);
+//And we create a MessageConsumer which will consume orders from the
+//queue:
 
-And we create a MessageConsumer which will consume orders from the
-queue:
+MessageConsumer consumer = session.createConsumer(orderQueue);
 
-    MessageConsumer consumer = session.createConsumer(orderQueue);
+//We make sure we start the connection, or delivery won't occur on it:
 
-We make sure we start the connection, or delivery won't occur on it:
+connection.start();
 
-    connection.start();
+//We create a simple TextMessage and send it:
 
-We create a simple TextMessage and send it:
+TextMessage message = session.createTextMessage("This is an order");
+producer.send(message);
 
-    TextMessage message = session.createTextMessage("This is an order");
-    producer.send(message);
+//And we consume the message:
 
-And we consume the message:
-
-    TextMessage receivedMessage = (TextMessage)consumer.receive();
-    System.out.println("Got order: " + receivedMessage.getText());
+TextMessage receivedMessage = (TextMessage)consumer.receive();
+System.out.println("Got order: " + receivedMessage.getText());
+```
 
 It is as simple as that. For a wide range of working JMS examples please
 see the examples directory in the distribution.
@@ -317,10 +336,9 @@ see the examples directory in the distribution.
 > It is an anti-pattern to create new connections, sessions, producers
 > and consumers for each message you produce or consume. If you do this,
 > your application will perform very poorly. This is discussed further
-> in the section on performance tuning ?.
+> in the section on performance tuning [Performance Tuning](perf-tuning.md).
 
-Directly instantiating JMS Resources without using JNDI
-=======================================================
+### Directly instantiating JMS Resources without using JNDI
 
 Although it is a very common JMS usage pattern to lookup JMS
 *Administered Objects* (that's JMS Queue, Topic and ConnectionFactory
@@ -339,51 +357,52 @@ Here's our simple example, rewritten to not use JNDI at all:
 We create the JMS ConnectionFactory object via the ActiveMQJMSClient
 Utility class, note we need to provide connection parameters and specify
 which transport we are using, for more information on connectors please
-see ?.
+see [Configuring the Transport](configuring-transports.md).
+
+``` java                  
+TransportConfiguration transportConfiguration = new TransportConfiguration(NettyConnectorFactory.class.getName());
 
-                  
-    TransportConfiguration transportConfiguration = new TransportConfiguration(NettyConnectorFactory.class.getName());
-    ConnectionFactory cf = ActiveMQJMSClient.createConnectionFactoryWithoutHA(JMSFactoryType.CF,transportConfiguration);
+ConnectionFactory cf = ActiveMQJMSClient.createConnectionFactoryWithoutHA(JMSFactoryType.CF,transportConfiguration);
 
-We also create the JMS Queue object via the ActiveMQJMSClient Utility
-class:
+//We also create the JMS Queue object via the ActiveMQJMSClient Utility
+//class:
 
-    Queue orderQueue = ActiveMQJMSClient.createQueue("OrderQueue");
+Queue orderQueue = ActiveMQJMSClient.createQueue("OrderQueue");
 
-Next we create a JMS connection using the connection factory:
+//Next we create a JMS connection using the connection factory:
 
-    Connection connection = cf.createConnection();
+Connection connection = cf.createConnection();
 
-And we create a non transacted JMS Session, with AUTO\_ACKNOWLEDGE
-acknowledge mode:
+//And we create a non transacted JMS Session, with AUTO\_ACKNOWLEDGE
+//acknowledge mode:
 
-    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
+Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
 
-We create a MessageProducer that will send orders to the queue:
+//We create a MessageProducer that will send orders to the queue:
 
-    MessageProducer producer = session.createProducer(orderQueue);
+MessageProducer producer = session.createProducer(orderQueue);
 
-And we create a MessageConsumer which will consume orders from the
-queue:
+//And we create a MessageConsumer which will consume orders from the
+//queue:
 
-    MessageConsumer consumer = session.createConsumer(orderQueue);
+MessageConsumer consumer = session.createConsumer(orderQueue);
 
-We make sure we start the connection, or delivery won't occur on it:
+//We make sure we start the connection, or delivery won't occur on it:
 
-    connection.start();
+connection.start();
 
-We create a simple TextMessage and send it:
+//We create a simple TextMessage and send it:
 
-    TextMessage message = session.createTextMessage("This is an order");
-    producer.send(message);
+TextMessage message = session.createTextMessage("This is an order");
+producer.send(message);
 
-And we consume the message:
+//And we consume the message:
 
-    TextMessage receivedMessage = (TextMessage)consumer.receive();
-    System.out.println("Got order: " + receivedMessage.getText());
+TextMessage receivedMessage = (TextMessage)consumer.receive();
+System.out.println("Got order: " + receivedMessage.getText());
+```
 
-Setting The Client ID
-=====================
+### Setting The Client ID
 
 This represents the client id for a JMS client and is needed for
 creating durable subscriptions. It is possible to configure this on the
@@ -391,8 +410,7 @@ connection factory and can be set via the `client-id` element. Any
 connection created by this connection factory will have this set as its
 client id.
 
-Setting The Batch Size for DUPS\_OK
-===================================
+### Setting The Batch Size for DUPS_OK
 
 When the JMS acknowledge mode is set to `DUPS_OK` it is possible to
 configure the consumer so that it sends acknowledgements in batches
@@ -400,8 +418,7 @@ rather that one at a time, saving valuable bandwidth. This can be
 configured via the connection factory via the `dups-ok-batch-size`
 element and is set in bytes. The default is 1024 \* 1024 bytes = 1 MiB.
 
-Setting The Transaction Batch Size
-==================================
+### Setting The Transaction Batch Size
 
 When receiving messages in a transaction it is possible to configure the
 consumer to send acknowledgements in batches rather than individually

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/b4144013/docs/user-manual/en/using-server.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/using-server.md b/docs/user-manual/en/using-server.md
index 9998646..55837cd 100644
--- a/docs/user-manual/en/using-server.md
+++ b/docs/user-manual/en/using-server.md
@@ -1,5 +1,4 @@
-Using the Server
-================
+# Using the Server
 
 This chapter will familiarise you with how to use the ActiveMQ server.
 
@@ -13,8 +12,7 @@ with a JMS Service and JNDI service enabled.
 When running embedded in JBoss Application Server the layout may be
 slightly different but by-and-large will be the same.
 
-Starting and Stopping the standalone server
-===========================================
+## Starting and Stopping the standalone server
 
 In the distribution you will find a directory called `bin`.
 
@@ -42,8 +40,7 @@ used. The configuration can be changed e.g. by running
 `./activemq run -- xml:../config/clustered/bootstrap.xml` or another
 config of your choosing.
 
-Server JVM settings
-===================
+## Server JVM settings
 
 The run scripts set some JVM settings for tuning the garbage collection
 policy and heap size. We recommend using a parallel garbage collection
@@ -56,8 +53,7 @@ would for any Java program.
 If you wish to add any more JVM arguments or tune the existing ones, the
 run scripts are the place to do it.
 
-Pre-configured Options
-======================
+## Pre-configured Options
 
 The distribution contains several standard configuration sets for
 running:
@@ -73,8 +69,7 @@ running:
 You can of course create your own configuration and specify any
 configuration when running the run script.
 
-Library Path
-============
+## Library Path
 
 If you're using the [Asynchronous IO Journal](#aio-journal) on Linux,
 you need to specify `java.library.path` as a property on your Java
@@ -83,16 +78,14 @@ options. This is done automatically in the scripts.
 If you don't specify `java.library.path` at your Java options then the
 JVM will use the environment variable `LD_LIBRARY_PATH`.
 
-System properties
-=================
+## System properties
 
 ActiveMQ can take a system property on the command line for configuring
 logging.
 
 For more information on configuring logging, please see ?.
 
-Configuration files
-===================
+## Configuration files
 
 The configuration file used to bootstrap the server (e.g.
 `bootstrap.xml` by default) references the specific broker configuration
@@ -149,8 +142,7 @@ respectively. It is also possible to not supply a default. i.e.
 `${activemq.remoting.netty.host}`, however the system property *must* be
 supplied in that case.
 
-Bootstrap File
-==============
+## Bootstrap File
 
 The stand-alone server is basically a set of POJOs which are
 instantiated by Airline commands.
@@ -164,19 +156,13 @@ The bootstrap file is very simple. Let's take a look at an example:
 
        <basic-security/>
 
-       <naming bindAddress="localhost" port="1099" rmiBindAddress="localhost" rmiPort="1098"/>
-
     </broker>
 
--   core
-
-    Instantiates a core server using the configuration file from the
+-   core - Instantiates a core server using the configuration file from the
     `configuration` attribute. This is the main broker POJO necessary to
     do all the real messaging work.
 
--   jms
-
-    This deploys any JMS Objects such as JMS Queues, Topics and
+-   jms - This deploys any JMS Objects such as JMS Queues, Topics and
     ConnectionFactory instances from the `activemq-jms.xml` file
     specified. It also provides a simple management API for manipulating
     JMS Objects. On the whole it just translates and delegates its work
@@ -184,13 +170,7 @@ The bootstrap file is very simple. Let's take a look at an example:
     and ConnectionFactories from server side configuration and don't
     require the JMS management interface this can be disabled.
 
--   naming
-
-    Instantiates a naming server which implements JNDI. This is used by
-    JMS clients
-
-The main configuration file.
-============================
+## The main configuration file.
 
 The configuration for the ActiveMQ core server is contained in
 `activemq-configuration.xml`. This is what the FileConfiguration bean

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/b4144013/docs/user-manual/en/vertx-integration.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/vertx-integration.md b/docs/user-manual/en/vertx-integration.md
index 0b89d79..ea4d6f8 100644
--- a/docs/user-manual/en/vertx-integration.md
+++ b/docs/user-manual/en/vertx-integration.md
@@ -1,5 +1,4 @@
-Vert.x Integration
-==================
+# Vert.x Integration
 
 [Vert.x](http://vertx.io/) is a lightweight, high performance
 application platform for the JVM that's designed for modern mobile, web,
@@ -9,20 +8,19 @@ can now redirect and persist any vert.x messages to ActiveMQ and route
 those messages to a specified vertx address by configuring ActiveMQ
 vertx incoming and outgoing vertx connector services.
 
-Configuring a Vertx Incoming Connector Service
-==============================================
+## Configuring a Vertx Incoming Connector Service
 
 Vertx Incoming Connector services receive messages from vertx event bus
 and route them to a ActiveMQ queue. Such a service can be configured as
 follows:
 
-        <connector-service name="vertx-incoming-connector">
-        <factory-class>org.apache.activemq.integration.vertx.VertxIncomingConnectorServiceFactory</factory-class>
-        <param key="host" value="127.0.0.1"/>
-        <param key="port" value="0"/>
-        <param key="queue" value="jms.queue.vertxQueue"/>
-        <param key="vertx-address" value="vertx.in.eventaddress"/>
-        </connector-service>
+    <connector-service name="vertx-incoming-connector">
+    <factory-class>org.apache.activemq.integration.vertx.VertxIncomingConnectorServiceFactory</factory-class>
+    <param key="host" value="127.0.0.1"/>
+    <param key="port" value="0"/>
+    <param key="queue" value="jms.queue.vertxQueue"/>
+    <param key="vertx-address" value="vertx.in.eventaddress"/>
+    </connector-service>
         
 
 Shown are the required params for the connector service:
@@ -46,21 +44,20 @@ parameters
 -   `vertx-address`. The vertx address to listen to. default is
     org.apache.activemq.
 
-Configuring a Vertx Outgoing Connector Service
-==============================================
+## Configuring a Vertx Outgoing Connector Service
 
 Vertx Outgoing Connector services fetch vertx messages from a ActiveMQ
 queue and put them to vertx event bus. Such a service can be configured
 as follows:
 
-        <connector-service name="vertx-outgoing-connector">
-        <factory-class>org.apache.activemq.integration.vertx.VertxOutgoingConnectorServiceFactory</factory-class>
-        <param key="host" value="127.0.0.1"/>
-        <param key="port" value="0"/>
-        <param key="queue" value="jms.queue.vertxQueue"/>
-        <param key="vertx-address" value="vertx.out.eventaddress"/>
-        <param key="publish" value="true"/>
-        </connector-service>
+    <connector-service name="vertx-outgoing-connector">
+    <factory-class>org.apache.activemq.integration.vertx.VertxOutgoingConnectorServiceFactory</factory-class>
+    <param key="host" value="127.0.0.1"/>
+    <param key="port" value="0"/>
+    <param key="queue" value="jms.queue.vertxQueue"/>
+    <param key="vertx-address" value="vertx.out.eventaddress"/>
+    <param key="publish" value="true"/>
+    </connector-service>
         
 
 Shown are the required params for the connector service:

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/b4144013/docs/user-manual/en/wildcard-routing.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/wildcard-routing.md b/docs/user-manual/en/wildcard-routing.md
index cabf9bd..7491571 100644
--- a/docs/user-manual/en/wildcard-routing.md
+++ b/docs/user-manual/en/wildcard-routing.md
@@ -1,5 +1,4 @@
-Routing Messages With Wild Cards
-================================
+# Routing Messages With Wild Cards
 
 ActiveMQ allows the routing of messages via wildcard addresses.
 

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/b4144013/docs/user-manual/en/wildcard-syntax.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/wildcard-syntax.md b/docs/user-manual/en/wildcard-syntax.md
index 3fe7b37..da599d8 100644
--- a/docs/user-manual/en/wildcard-syntax.md
+++ b/docs/user-manual/en/wildcard-syntax.md
@@ -1,5 +1,4 @@
-Understanding the ActiveMQ Wildcard Syntax
-==========================================
+# Understanding the ActiveMQ Wildcard Syntax
 
 ActiveMQ uses a specific syntax for representing wildcards in security
 settings, address settings and when creating consumers.


Mime
View raw message