camel-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From davscl...@apache.org
Subject [07/14] camel git commit: Use single line header for adoc files
Date Wed, 11 Jan 2017 18:27:12 GMT
http://git-wip-us.apache.org/repos/asf/camel/blob/28429681/components/camel-jms/src/main/docs/jms-component.adoc
----------------------------------------------------------------------
diff --git a/components/camel-jms/src/main/docs/jms-component.adoc b/components/camel-jms/src/main/docs/jms-component.adoc
index c0bd57c..1596260 100644
--- a/components/camel-jms/src/main/docs/jms-component.adoc
+++ b/components/camel-jms/src/main/docs/jms-component.adoc
@@ -1,4 +1,4 @@
-# JMS Component
+## JMS Component
 ifdef::env-github[]
 :icon-smile: :smiley:
 :caution-caption: :boom:
@@ -14,9 +14,7 @@ ifndef::env-github[]
 endif::[]
 
 
-[[JMS-JMSComponent]]
-JMS Component
-~~~~~~~~~~~~~
+### JMS Component
 
 [TIP]
 ====
@@ -66,9 +64,7 @@ for this component:
 </dependency>
 ------------------------------------------------------------
 
-[[JMS-URIformat]]
-URI format
-^^^^^^^^^^
+### URI format
 
 --------------------------------------------
 jms:[queue:|topic:]destinationName[?options]
@@ -99,13 +95,9 @@ jms:topic:Stocks.Prices
 You append query options to the URI using the following format,
 `?option=value&option=value&...`
 
-[[JMS-Notes]]
-Notes
-^^^^^
+### Notes
 
-[[JMS-UsingActiveMQ]]
-Using ActiveMQ
-++++++++++++++
+#### Using ActiveMQ
 
 The JMS component reuses Spring 2's `JmsTemplate` for sending messages.
 This is not ideal for use in a non-J2EE container and typically requires
@@ -120,9 +112,7 @@ then we recommend that you either:
 optimized to use ActiveMQ efficiently
 * Use the `PoolingConnectionFactory` in ActiveMQ.
 
-[[JMS-TransactionsandCacheLevels]]
-Transactions and Cache Levels
-+++++++++++++++++++++++++++++
+#### Transactions and Cache Levels
 
 If you are consuming messages and using transactions
 (`transacted=true`) then the default settings for cache level can impact
@@ -148,9 +138,7 @@ level accordingly to:
 So you can say the default setting is conservative. Consider using
 `cacheLevelName=CACHE_CONSUMER` if you are using non-XA transactions.
 
-[[JMS-DurableSubscriptions]]
-Durable Subscriptions
-+++++++++++++++++++++
+#### Durable Subscriptions
 
 If you wish to use durable topic subscriptions, you need to specify both
 `clientId` and `durableSubscriptionName`. The value of the `clientId`
@@ -160,9 +148,7 @@ http://activemq.apache.org/virtual-destinations.html[Virtual Topics]
 instead to avoid this limitation. More background on durable messaging
 http://activemq.apache.org/how-do-durable-queues-and-topics-work.html[here].
 
-[[JMS-MessageHeaderMapping]]
-Message Header Mapping
-++++++++++++++++++++++
+#### Message Header Mapping
 
 When using message headers, the JMS specification states that header
 names must be valid Java identifiers. So try to name your headers to be
@@ -185,9 +171,7 @@ Camel consume the message
 * Hyphen is replaced by `_HYPHEN_` and the replacement is reversed when
 Camel consumes the message
 
-[[JMS-Options]]
-Options
-^^^^^^^
+### Options
 
 You can configure many different properties on the JMS endpoint which
 map to properties on the
@@ -203,9 +187,7 @@ uses for sending and receiving messages. So you can get more information
 about these properties by consulting the relevant Spring documentation.
 ====
 
-[[JMS-Componentoptions]]
-Component options
-+++++++++++++++++
+#### Component options
 
 
 
@@ -308,9 +290,7 @@ The JMS component supports 74 options which are listed below.
 
 
 
-[[JMS-Endpointoptions]]
-Endpoint options
-++++++++++++++++
+#### Endpoint options
 
 
 
@@ -425,9 +405,7 @@ The JMS component supports 86 endpoint options which are listed below:
 
 
 
-[[JMS-MessageMappingbetweenJMSandCamel]]
-Message Mapping between JMS and Camel
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+### Message Mapping between JMS and Camel
 
 Camel automatically maps messages between `javax.jms.Message` and
 `org.apache.camel.Message`.
@@ -470,9 +448,7 @@ following body type:
 |`javax.jms.ObjectMessage` |`Object`
 |=============================================
 
-[[JMS-Disablingauto-mappingofJMSmessages]]
-Disabling auto-mapping of JMS messages
-++++++++++++++++++++++++++++++++++++++
+#### Disabling auto-mapping of JMS messages
 
 You can use the `mapJmsMessage` option to disable the auto-mapping
 above. If disabled, Camel will not try to map the received JMS message,
@@ -481,9 +457,7 @@ the overhead of mapping and let Camel just pass through the JMS message.
 For instance, it even allows you to route `javax.jms.ObjectMessage` JMS
 messages with classes you do *not* have on the classpath.
 
-[[JMS-UsingacustomMessageConverter]]
-Using a custom MessageConverter
-+++++++++++++++++++++++++++++++
+#### Using a custom MessageConverter
 
 You can use the `messageConverter` option to do the mapping yourself in
 a Spring `org.springframework.jms.support.converter.MessageConverter`
@@ -500,9 +474,7 @@ from("file://inbox/order").to("jms:queue:order?messageConverter=#myMessageConver
 You can also use a custom message converter when consuming from a JMS
 destination.
 
-[[JMS-Controllingthemappingstrategyselected]]
-Controlling the mapping strategy selected
-+++++++++++++++++++++++++++++++++++++++++
+#### Controlling the mapping strategy selected
 
 You can use the `jmsMessageType` option on the endpoint URL to force a
 specific message type for all messages.
@@ -527,9 +499,7 @@ from("file://inbox/order").setHeader("CamelJmsMessageType", JmsMessageType.Text)
 The possible values are defined in the `enum` class,
 `org.apache.camel.jms.JmsMessageType`.
 
-[[JMS-Messageformatwhensending]]
-Message format when sending
-^^^^^^^^^^^^^^^^^^^^^^^^^^^
+### Message format when sending
 
 The exchange that is sent over the JMS wire must conform to the
 http://java.sun.com/j2ee/1.4/docs/api/javax/jms/Message.html[JMS Message
@@ -566,9 +536,7 @@ at *DEBUG* level if it drops a given header value. For example:
   - Ignoring non primitive header: order of class: org.apache.camel.component.jms.issues.DummyOrder with value: DummyOrder{orderId=333, itemId=4444, quantity=2}
 ----------------------------------------------------------------------------------------------------------------------------------------------------------------
 
-[[JMS-Messageformatwhenreceiving]]
-Message format when receiving
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+### Message format when receiving
 
 Camel adds the following properties to the `Exchange` when it receives a
 message:
@@ -614,9 +582,7 @@ As all the above information is standard JMS you can check the
 http://java.sun.com/javaee/5/docs/api/javax/jms/Message.html[JMS
 documentation] for further details.
 
-[[JMS-AboutusingCameltosendandreceivemessagesandJMSReplyTo]]
-About using Camel to send and receive messages and JMSReplyTo
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+### About using Camel to send and receive messages and JMSReplyTo
 
 The JMS component is complex and you have to pay close attention to how
 it works in some cases. So this is a short summary of some of the
@@ -634,9 +600,7 @@ endpoint: `disableReplyTo`, `preserveMessageQos`, `explicitQosEnabled`.
 All this can be a tad complex to understand and configure to support
 your use case.
 
-[[JMS-JmsProducer]]
-JmsProducer
-+++++++++++
+#### JmsProducer
 
 The `JmsProducer` behaves as follows, depending on configuration:
 
@@ -663,9 +627,7 @@ instruct Camel to keep the `JMSReplyTo`. In all situations the
 sending the message.
 |=======================================================================
 
-[[JMS-JmsConsumer]]
-JmsConsumer
-+++++++++++
+#### JmsConsumer
 
 The `JmsConsumer` behaves as follows, depending on configuration:
 
@@ -695,9 +657,7 @@ from("activemq:queue:in")
    .to("bean:handleOrder");
 ------------------------------------------------------
 
-[[JMS-Reuseendpointandsendtodifferentdestinationscomputedatruntime]]
-Reuse endpoint and send to different destinations computed at runtime
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+### Reuse endpoint and send to different destinations computed at runtime
 
 If you need to send messages to a lot of different JMS destinations, it
 makes sense to reuse a JMS endpoint and specify the real destination in
@@ -751,9 +711,7 @@ them to the created JMS message in order to avoid the accidental loops
 in the routes (in scenarios when the message will be forwarded to the
 another JMS endpoint).
 
-[[JMS-ConfiguringdifferentJMSproviders]]
-Configuring different JMS providers
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+### Configuring different JMS providers
 
 You can configure your JMS provider in link:spring.html[Spring] XML as
 follows:
@@ -774,9 +732,7 @@ spring context for the scheme name you use for
 link:endpoint.html[Endpoint] link:uris.html[URIs] and having the
 link:component.html[Component] resolve the endpoint URIs.
 
-[[JMS-UsingJNDItofindtheConnectionFactory]]
-Using JNDI to find the ConnectionFactory
-++++++++++++++++++++++++++++++++++++++++
+#### Using JNDI to find the ConnectionFactory
 
 If you are using a J2EE container, you might need to look up JNDI to
 find the JMS `ConnectionFactory` rather than use the usual `<bean>`
@@ -797,9 +753,7 @@ http://static.springsource.org/spring/docs/3.0.x/spring-framework-reference/html
 jee schema] in the Spring reference documentation for more details about
 JNDI lookup.
 
-[[JMS-ConcurrentConsuming]]
-Concurrent Consuming
-^^^^^^^^^^^^^^^^^^^^
+### Concurrent Consuming
 
 A common requirement with JMS is to consume messages concurrently in
 multiple threads in order to make an application more responsive. You
@@ -818,9 +772,7 @@ You can configure this option in one of the following ways:
 * On the endpoint URI or,
 * By invoking `setConcurrentConsumers()` directly on the `JmsEndpoint`.
 
-[[JMS-ConcurrentConsumingwithasyncconsumer]]
-Concurrent Consuming with async consumer
-++++++++++++++++++++++++++++++++++++++++
+#### Concurrent Consuming with async consumer
 
 Notice that each concurrent consumer will only pickup the next available
 message from the JMS broker, when the current message has been fully
@@ -837,9 +789,7 @@ from("jms:SomeQueue?concurrentConsumers=20&asyncConsumer=true").
   bean(MyClass.class);
 ----------------------------------------------------------------
 
-[[JMS-Request-replyoverJMS]]
-Request-reply over JMS
-^^^^^^^^^^^^^^^^^^^^^^
+### Request-reply over JMS
 
 Camel supports link:request-reply.html[Request Reply] over JMS. In
 essence the MEP of the Exchange should be `InOut` when you send a
@@ -945,9 +895,7 @@ from(xxx)
 .to(zzz);
 -------------------------------------------------------
 
-[[JMS-Request-replyoverJMSandusingasharedfixedreplyqueue]]
-Request-reply over JMS and using a shared fixed reply queue
-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#### Request-reply over JMS and using a shared fixed reply queue
 
 If you use a fixed reply queue when doing
 link:request-reply.html[Request Reply] over JMS as shown in the example
@@ -981,9 +929,7 @@ Notice this will cause the Camel to send pull requests to the message
 broker more frequent, and thus require more network traffic. +
  It is generally recommended to use temporary queues if possible.
 
-[[JMS-Request-replyoverJMSandusinganexclusivefixedreplyqueue]]
-Request-reply over JMS and using an exclusive fixed reply queue
-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#### Request-reply over JMS and using an exclusive fixed reply queue
 
 *Available as of Camel 2.9*
 
@@ -1030,9 +976,7 @@ node in the cluster may pickup messages which was intended as a reply on
 another node. For clustered environments its recommended to use shared
 reply queues instead.
 
-[[JMS-Synchronizingclocksbetweensendersandreceivers]]
-Synchronizing clocks between senders and receivers
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+### Synchronizing clocks between senders and receivers
 
 When doing messaging between systems, its desirable that the systems
 have synchronized clocks. For example when sending a link:jms.html[JMS]
@@ -1044,9 +988,7 @@ clocks. If you are using http://activemq.apache.org/[ActiveMQ] then you
 can use the http://activemq.apache.org/timestampplugin.html[timestamp
 plugin] to synchronize clocks.
 
-[[JMS-Abouttimetolive]]
-About time to live
-^^^^^^^^^^^^^^^^^^
+### About time to live
 
 Read first above about synchronized clocks.
 
@@ -1112,9 +1054,7 @@ example to indicate a 5 sec., you set `timeToLive=5000`. The option
 also for InOnly messaging. The `requestTimeout` option is not being used
 for InOnly messaging.
 
-[[JMS-EnablingTransactedConsumption]]
-Enabling Transacted Consumption
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+### Enabling Transacted Consumption
 
 A common requirement is to consume from a queue in a transaction and
 then process the message using the Camel route. To do this, just ensure
@@ -1169,9 +1109,7 @@ http://tmielke.blogspot.com/2012/03/camel-jms-with-transactions-lessons.html[her
 and
 http://forum.springsource.org/showthread.php?123631-JMS-DMLC-not-caching%20connection-when-using-TX-despite-cacheLevel-CACHE_CONSUMER&p=403530&posted=1#post403530[here].
 
-[[JMS-UsingJMSReplyToforlatereplies]]
-Using JMSReplyTo for late replies
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+### Using JMSReplyTo for late replies
 
 When using Camel as a JMS listener, it sets an Exchange property with
 the value of the ReplyTo `javax.jms.Destination` object, having the key
@@ -1210,25 +1148,19 @@ For example:
     }
 ----------------------------------------------------------------------------------------------------------------------------------------
 
-[[JMS-Usingarequesttimeout]]
-Using a request timeout
-^^^^^^^^^^^^^^^^^^^^^^^
+### Using a request timeout
 
 In the sample below we send a link:request-reply.html[Request Reply]
 style message link:exchange.html[Exchange] (we use the `requestBody`
 method = `InOut`) to the slow queue for further processing in Camel and
 we wait for a return reply:
 
-[[JMS-Samples]]
-Samples
-^^^^^^^
+### Samples
 
 JMS is used in many examples for other components as well. But we
 provide a few samples below to get started.
 
-[[JMS-ReceivingfromJMS]]
-Receiving from JMS
-++++++++++++++++++
+#### Receiving from JMS
 
 In the following sample we configure a route that receives JMS messages
 and routes the message to a POJO:
@@ -1250,9 +1182,7 @@ from("jms:topic:OrdersTopic").
     to("jms:queue:BigSpendersQueue");
 ----------------------------------------------
 
-[[JMS-SendingtoJMS]]
-Sending to JMS
-++++++++++++++
+#### Sending to JMS
 
 In the sample below we poll a file folder and send the file content to a
 JMS topic. As we want the content of the file as a `TextMessage` instead
@@ -1265,16 +1195,12 @@ from("file://orders").
   to("jms:topic:OrdersTopic");
 ------------------------------
 
-[[JMS-UsingAnnotations]]
-Using link:bean-integration.html[Annotations]
-+++++++++++++++++++++++++++++++++++++++++++++
+#### Using link:bean-integration.html[Annotations]
 
 Camel also has annotations so you can use link:pojo-consuming.html[POJO
 Consuming] and link:pojo-producing.html[POJO Producing].
 
-[[JMS-SpringDSLsample]]
-Spring DSL sample
-+++++++++++++++++
+#### Spring DSL sample
 
 The preceding examples use the Java DSL. Camel also supports Spring XML
 DSL. Here is the big spender sample using Spring DSL:
@@ -1290,9 +1216,7 @@ DSL. Here is the big spender sample using Spring DSL:
 </route>
 ---------------------------------------------------
 
-[[JMS-Othersamples]]
-Other samples
-+++++++++++++
+#### Other samples
 
 JMS appears in many of the examples for other components and EIP
 patterns, as well in this Camel documentation. So feel free to browse
@@ -1300,9 +1224,7 @@ the documentation. If you have time, check out the this tutorial that
 uses JMS but focuses on how well Spring Remoting and Camel works
 together link:tutorial-jmsremoting.html[Tutorial-JmsRemoting].
 
-[[JMS-UsingJMSasaDeadLetterQueuestoringExchange]]
-Using JMS as a Dead Letter Queue storing Exchange
-+++++++++++++++++++++++++++++++++++++++++++++++++
+#### Using JMS as a Dead Letter Queue storing Exchange
 
 Normally, when using link:jms.html[JMS] as the transport, it only
 transfers the body and headers as the payload. If you want to use
@@ -1336,9 +1258,7 @@ Exception cause = exchange.getProperty(Exchange.EXCEPTION_CAUGHT, Exception.clas
 String problem = cause.getMessage();
 -----------------------------------------------------------------------------------
 
-[[JMS-UsingJMSasaDeadLetterChannelstoringerroronly]]
-Using JMS as a Dead Letter Channel storing error only
-+++++++++++++++++++++++++++++++++++++++++++++++++++++
+#### Using JMS as a Dead Letter Channel storing error only
 
 You can use JMS to store the cause error message or to store a custom
 body, which you can initialize yourself. The following example uses the
@@ -1360,9 +1280,7 @@ You can, however, use any link:expression.html[Expression] to send
 whatever you like. For example, you can invoke a method on a Bean or use
 a custom processor.
 
-[[JMS-SendinganInOnlymessageandkeepingtheJMSReplyToheader]]
-Sending an InOnly message and keeping the JMSReplyTo header
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+### Sending an InOnly message and keeping the JMSReplyTo header
 
 When sending to a link:jms.html[JMS] destination using *camel-jms* the
 producer will use the MEP to detect if its _InOnly_ or _InOut_ messaging.
@@ -1386,9 +1304,7 @@ For example to send an _InOnly_ message to the foo queue, but with a
 Notice we use `preserveMessageQos=true` to instruct Camel to keep the
 `JMSReplyTo` header.
 
-[[JMS-SettingJMSprovideroptionsonthedestination]]
-Setting JMS provider options on the destination
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+### Setting JMS provider options on the destination
 
 Some JMS providers, like IBM's WebSphere MQ need options to be set on
 the JMS destination. For example, you may need to specify the
@@ -1427,9 +1343,7 @@ wmq.setDestinationResolver(new DestinationResolver() {
 });
 ----------------------------------------------------------------------------------------------------------------------------------
 
-[[JMS-SeeAlso]]
-See Also
-^^^^^^^^
+### See Also
 
 * link:configuring-camel.html[Configuring Camel]
 * link:component.html[Component]
@@ -1440,4 +1354,4 @@ See Also
 * link:bean-integration.html[Bean Integration]
 * link:tutorial-jmsremoting.html[Tutorial-JmsRemoting]
 * http://activemq.apache.org/jmstemplate-gotchas.html[JMSTemplate
-gotchas]
+gotchas]
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/camel/blob/28429681/components/camel-jmx/src/main/docs/jmx-component.adoc
----------------------------------------------------------------------
diff --git a/components/camel-jmx/src/main/docs/jmx-component.adoc b/components/camel-jmx/src/main/docs/jmx-component.adoc
index 6d1aa8c..df88101 100644
--- a/components/camel-jmx/src/main/docs/jmx-component.adoc
+++ b/components/camel-jmx/src/main/docs/jmx-component.adoc
@@ -1,4 +1,4 @@
-# JMX Component
+## JMX Component
 ifdef::env-github[]
 :caution-caption: :boom:
 :important-caption: :exclamation:
@@ -7,9 +7,7 @@ ifdef::env-github[]
 :warning-caption: :warning:
 endif::[]
 
-[[CamelJMX-CamelJMX]]
-Camel JMX
-~~~~~~~~~
+### Camel JMX
 
 Apache Camel has extensive support for JMX to allow you to monitor and
 control the Camel managed objects with a JMX client.
@@ -19,9 +17,7 @@ subscribe to MBean notifications. This page is about how to manage and
 monitor Camel using JMX.
 
 
-[[CamelJMX-Options]]
-Options
-^^^^^^^
+### Options
 
 // component options: START
 The JMX component has no options.
@@ -68,9 +64,7 @@ The JMX component supports 30 endpoint options which are listed below:
 {% endraw %}
 // endpoint options: END
 
-[[CamelJMX-ActivatingJMXinCamel]]
-Activating JMX in Camel
-^^^^^^^^^^^^^^^^^^^^^^^
+### Activating JMX in Camel
 
 [NOTE]
 ====
@@ -86,9 +80,7 @@ From *Camel 2.9* onwards, the Spring JARs are *no* longer required to
 run Camel in JMX mode.
 ====
 
-[[CamelJMX-UsingJMXtomanageApacheCamel]]
-Using JMX to manage Apache Camel
-++++++++++++++++++++++++++++++++
+#### Using JMX to manage Apache Camel
 
 By default, JMX instrumentation agent is enabled in Camel, which means
 that Camel runtime creates and registers MBean management objects with a
@@ -131,9 +123,7 @@ Spring configuration:
 Spring configuration always takes precedence over system properties when
 they both present. It is true for all JMX related configurations.
 
-[[CamelJMX-DisablingJMXinstrumentationagentinCamel]]
-Disabling JMX instrumentation agent in Camel
-++++++++++++++++++++++++++++++++++++++++++++
+#### Disabling JMX instrumentation agent in Camel
 
 You can disable JMX instrumentation agent by setting the Java VM system
 property as follow:
@@ -165,9 +155,7 @@ CamelContext camel = new DefaultCamelContext();
 camel.disableJMX();
 ----
 
-[[CamelJMX-LocatingaMBeanServerintheJavaVM]]
-Locating a MBeanServer in the Java VM
-+++++++++++++++++++++++++++++++++++++
+#### Locating a MBeanServer in the Java VM
 
 Each CamelContext can have an instance of
 http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/spi/InstrumentationAgent.html[`InstrumentationAgent`]
@@ -235,9 +223,7 @@ Spring configuration:
 </camelContext>
 ----
 
-[[CamelJMX-CreatingJMXRMIConnectorServer]]
-Creating JMX RMI Connector Server
-+++++++++++++++++++++++++++++++++
+#### Creating JMX RMI Connector Server
 
 JMX connector server enables MBeans to be remotely managed by a JMX
 client such as JConsole; Camel JMX RMI connector server can be
@@ -260,9 +246,7 @@ Spring configuration:
 </camelContext>
 ----
 
-[[CamelJMX-JMXServiceURL]]
-JMX Service URL
-+++++++++++++++
+#### JMX Service URL
 
 The default JMX Service URL has the format:
 
@@ -357,9 +341,7 @@ When the connector port option is set, the JMX service URL will become:
 service:jmx:rmi://localhost:<connectorPort>/jndi/rmi://localhost:<registryPort>/<serviceUrlPath>
 ----
 
-[[CamelJMX-TheSystemPropertiesforCamelJMXsupport]]
-The System Properties for Camel JMX support
-+++++++++++++++++++++++++++++++++++++++++++
+#### The System Properties for Camel JMX support
 
 [width="100%",cols="1m,1,3",options="header",]
 |=======================================================================
@@ -371,9 +353,7 @@ feature in Camel
 See more system properties in this section below: _jmxAgent Properties
 Reference_.
 
-[[CamelJMX-HowtouseauthenticationwithJMX]]
-How to use authentication with JMX
-++++++++++++++++++++++++++++++++++
+#### How to use authentication with JMX
 
 JMX in the JDK have features for authentication and also for using
 secure connections over SSL. You have to refer to the SUN documentation
@@ -382,13 +362,9 @@ how to use this:
 * http://java.sun.com/j2se/1.5.0/docs/guide/management/agent.html
 * http://java.sun.com/javase/6/docs/technotes/guides/management/agent.html
 
-[[CamelJMX-JMXinsideanApplicationServer]]
-JMX inside an Application Server
-++++++++++++++++++++++++++++++++
+#### JMX inside an Application Server
 
-[[CamelJMX-Tomcat6]]
-Tomcat 6
-++++++++
+#### Tomcat 6
 
 See http://tomcat.apache.org/tomcat-6.0-doc/monitoring.html[this page]
 for details about enabling JMX in Tomcat.
@@ -404,9 +380,7 @@ set the following options...
     -Dcom.sun.management.jmxremote.authenticate=false
 ----
 
-[[CamelJMX-JBossAS4]]
-JBoss AS 4
-++++++++++
+#### JBoss AS 4
 
 By default JBoss creates its own `MBeanServer`. To allow Camel to expose
 to the same server follow these steps:
@@ -426,9 +400,7 @@ Add the following property to your `JAVA_OPTS` by editing `run.sh` or
 `run.conf` `-Djboss.platform.mbeanserver`. See
 http://wiki.jboss.org/wiki/JBossMBeansInJConsole
 
-[[CamelJMX-WebSphere]]
-WebSphere
-+++++++++
+#### WebSphere
 
 Alter the `mbeanServerDefaultDomain` to be `WebSphere`:
 
@@ -437,9 +409,7 @@ Alter the `mbeanServerDefaultDomain` to be `WebSphere`:
 <camel:jmxAgent id="agent" createConnector="true" mbeanObjectDomainName="org.yourname" usePlatformMBeanServer="false" mbeanServerDefaultDomain="WebSphere"/>
 ----
 
-[[CamelJMX-OracleOC4j]]
-Oracle OC4j
-+++++++++++
+#### Oracle OC4j
 
 The Oracle OC4J J2EE application server will not allow Camel to access
 the platform `MBeanServer`. You can identify this in the log as Camel
@@ -456,17 +426,13 @@ java.lang.SecurityException: Unauthorized access from application: xx to MBean:
 To resolve this you should disable the JMX agent in Camel, see section
 _Disabling JMX instrumentation agent in Camel_.
 
-[[CamelJMX-AdvancedJMXConfiguration]]
-Advanced JMX Configuration
-++++++++++++++++++++++++++
+#### Advanced JMX Configuration
 
 The Spring configuration file allows you to configure how Camel is
 exposed to JMX for management. In some cases, you could specify more
 information here, like the connector's port or the path name.
 
-[[CamelJMX-Example:]]
-Example:
-++++++++
+#### Example:
 
 [source,xml]
 ----
@@ -499,9 +465,7 @@ SUNJMX=-Dcom.sun.management.jmxremote=true -Dcom.sun.management.jmxremote.port=1
 for Camel, as additional startup parameters for the JVM. If you start
 Camel directly, you'll have to pass these parameters yourself.)
 
-[[CamelJMX-jmxAgentPropertiesReference]]
-`jmxAgent` Properties Reference
-+++++++++++++++++++++++++++++++
+#### `jmxAgent` Properties Reference
 
 [width="100%",cols="25%,25%,25%,25%",options="header",]
 |=======================================================================
@@ -567,9 +531,7 @@ usage of each incoming and outgoing endpoints).
 |=======================================================================
 
 
-[[CamelJMX-ConfiguringwhethertoregisterMBeansalways,fornewroutesorjustbydefault]]
-Configuring whether to register MBeans always, for new routes or just by default
-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#### Configuring whether to register MBeans always, for new routes or just by default
 
 
 *Available as of Camel 2.7*
@@ -600,13 +562,9 @@ also be registered. This could potential lead to system degration due
 the rising number of mbeans in the registry. A MBean is not a
 light-weight object and thus consumes memory.
 
-[[CamelJMX-MonitoringCamelusingJMX]]
-Monitoring Camel using JMX
-^^^^^^^^^^^^^^^^^^^^^^^^^^
+### Monitoring Camel using JMX
 
-[[CamelJMX-UsingJConsoletomonitorCamel]]
-Using JConsole to monitor Camel
-+++++++++++++++++++++++++++++++
+#### Using JConsole to monitor Camel
 
 The `CamelContext` should appear in the list of local connections, if
 you are running JConsole on the same host as Camel.
@@ -619,9 +577,7 @@ Using the Apache Camel with JConsole:
 
 image:camel-jmx.png[image]
 
-[[CamelJMX-Whichendpointsareregistered]]
-Which endpoints are registered
-++++++++++++++++++++++++++++++
+#### Which endpoints are registered
 
 In *Camel 2.1* onwards *only* `singleton` endpoints are registered as
 the overhead for non singleton will be substantial in cases where
@@ -629,15 +585,11 @@ thousands or millions of endpoints are used. This can happens when using
 a link:recipient-list.html[Recipient List] EIP or from a
 `ProducerTemplate` that sends a lot of messages.
 
-[[CamelJMX-Whichprocessorsareregistered]]
-Which processors are registered
-+++++++++++++++++++++++++++++++
+#### Which processors are registered
 
 See link:why-is-my-processor-not-showing-up-in-jconsole.html[this FAQ].
 
-[[CamelJMX-HowtousetheJMXNotificationListenertolistenthecamelevents]]
-How to use the JMX NotificationListener to listen the camel events?
-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#### How to use the JMX NotificationListener to listen the camel events?
 
 The Camel notification events give a coarse grained overview what is
 happening. You can see lifecycle event from context and endpoints and
@@ -680,9 +632,7 @@ context.getManagementStrategy().getManagementAgent().getMBeanServer().addNotific
     }, null);
 ----
 
-[[CamelJMX-UsingtheTracerMBeantogetfinegrainedtracing]]
-Using the Tracer MBean to get fine grained tracing
-++++++++++++++++++++++++++++++++++++++++++++++++++
+#### Using the Tracer MBean to get fine grained tracing
 
 Additionally to the coarse grained notifications above *Camel 2.9.0*
 support JMX Notification for fine grained trace events.
@@ -703,13 +653,9 @@ route with all exchange and message details:
 
 image:jconsole_trace_notifications.png[image]
 
-[[CamelJMX-UsingJMXforyourownCamelCode]]
-Using JMX for your own Camel Code
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+### Using JMX for your own Camel Code
 
-[[CamelJMX-RegisteringyourownManagedEndpoints]]
-Registering your own Managed Endpoints
-++++++++++++++++++++++++++++++++++++++
+#### Registering your own Managed Endpoints
 
 *Available as of Camel 2.0* +
 You can decorate your own endpoints with Spring managed annotations
@@ -764,9 +710,7 @@ Notice from *Camel 2.9* onwards its encouraged to use the
 the `org.apache.camel.api.management` package. This allows your custom
 code to not depend on Spring JARs.
 
-[[CamelJMX-ProgrammingyourownManagedServices]]
-Programming your own Managed Services
-+++++++++++++++++++++++++++++++++++++
+#### Programming your own Managed Services
 
 *Available as of Camel 2.1*
 
@@ -820,9 +764,7 @@ types such as:
 
 And in the future we will add additional wrappers for more EIP patterns.
 
-[[CamelJMX-ManagementNamingStrategy]]
-ManagementNamingStrategy
-++++++++++++++++++++++++
+#### ManagementNamingStrategy
 
 *Available as of Camel 2.1*
 
@@ -831,9 +773,7 @@ Camel provides a pluggable API for naming strategy by
 implementation is used to compute the MBean names that all MBeans are
 registered with.
 
-[[CamelJMX-Managementnamingpattern]]
-Management naming pattern
-+++++++++++++++++++++++++
+#### Management naming pattern
 
 *Available as of Camel 2.10*
 
@@ -975,9 +915,7 @@ install a 2nd Camel application that has the same `CamelContext` id and
 `managementNamePattern` then Camel will fail upon starting, and report a
 MBean already exists exception.
 
-[[CamelJMX-ManagementStrategy]]
-ManagementStrategy
-++++++++++++++++++
+#### ManagementStrategy
 
 *Available as of Camel 2.1*
 
@@ -990,9 +928,7 @@ does, for example, is make it easier to provide an adapter for other
 management products. In addition, it also allows you to provide more
 details and features that are provided out of the box at Apache.
 
-[[CamelJMX-Configuringlevelofgranularityforperformancestatistics]]
-Configuring level of granularity for performance statistics
-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#### Configuring level of granularity for performance statistics
 
 *Available as of Camel 2.1*
 
@@ -1053,9 +989,7 @@ And from Spring DSL you do:
 </camelContext>
 ----
 
-[[CamelJMX-Hidingsensitiveinformation]]
-Hiding sensitive information
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+### Hiding sensitive information
 
 *Available as of Camel 2.12*
 
@@ -1087,9 +1021,7 @@ And from Spring DSL you do:
 This will mask link:uris.html[URIs] having options such as password and
 passphrase, and use `xxxxxx` as the replacement value.
 
-[[CamelJMX-DeclaringwhichJMXattributesandoperationstomask]]
-Declaring which JMX attributes and operations to mask
-+++++++++++++++++++++++++++++++++++++++++++++++++++++
+#### Declaring which JMX attributes and operations to mask
 
 On the `org.apache.camel.api.management.ManagedAttribute` and
 `org.apache.camel.api.management.ManagedOperation`, the attribute `mask`
@@ -1107,10 +1039,8 @@ declared that the `EndpointUri` JMX attribute is masked:
 String getEndpointUri();
 ----
 
-[[CamelJMX-SeeAlso]]
-See Also
-^^^^^^^^
+### See Also
 
 * link:management-example.html[Management Example]
 * link:why-is-my-processor-not-showing-up-in-jconsole.html[Why is my
-processor not showing up in JConsole]
+processor not showing up in JConsole]
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/camel/blob/28429681/components/camel-johnzon/src/main/docs/json-johnzon-dataformat.adoc
----------------------------------------------------------------------
diff --git a/components/camel-johnzon/src/main/docs/json-johnzon-dataformat.adoc b/components/camel-johnzon/src/main/docs/json-johnzon-dataformat.adoc
index 965e573..b10ebef 100644
--- a/components/camel-johnzon/src/main/docs/json-johnzon-dataformat.adoc
+++ b/components/camel-johnzon/src/main/docs/json-johnzon-dataformat.adoc
@@ -1,4 +1,4 @@
-# JSon Johnzon DataFormat
+## JSon Johnzon DataFormat
 
 *Available as of Camel 2.18*
 
@@ -12,9 +12,7 @@ from("activemq:My.Queue").
   to("mqseries:Another.Queue");
 -------------------------------
 
-[[Johnzon-Options]]
-Johnzon Options
-^^^^^^^^^^^^^^^
+### Johnzon Options
 
 
 
@@ -50,9 +48,7 @@ The JSon Johnzon dataformat supports 17 options which are listed below.
 
 
 
-[[Johnzon-Dependencies]]
-Dependencies
-^^^^^^^^^^^^
+### Dependencies
 
 To use Johnzon in your camel routes you need to add the dependency
 on *camel-johnzon* which implements this data format.
@@ -69,4 +65,4 @@ link:download.html[the download page for the latest versions]).
   <version>x.x.x</version>
   <!-- use the same version as your Camel core version -->
 </dependency>
-----------------------------------------------------------
+----------------------------------------------------------
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/camel/blob/28429681/components/camel-jolt/src/main/docs/jolt-component.adoc
----------------------------------------------------------------------
diff --git a/components/camel-jolt/src/main/docs/jolt-component.adoc b/components/camel-jolt/src/main/docs/jolt-component.adoc
index ed25e5a..6011851 100644
--- a/components/camel-jolt/src/main/docs/jolt-component.adoc
+++ b/components/camel-jolt/src/main/docs/jolt-component.adoc
@@ -1,4 +1,4 @@
-# JOLT Component
+## JOLT Component
 
 *Available as of Camel 2.16*
 
@@ -21,9 +21,7 @@ their `pom.xml` for this component:
 
  
 
-[[JOLT-URIformat]]
-URI format
-^^^^^^^^^^
+### URI format
 
 [source,java]
 -----------------------
@@ -37,9 +35,7 @@ invoke; or the complete URL of the remote specification
 You can append query options to the URI in the following
 format, `?option=value&option=value&...`
 
-[[JOLT-Options]]
-Options
-^^^^^^^
+### Options
 
 
 
@@ -82,9 +78,7 @@ The JOLT component supports 6 endpoint options which are listed below:
 
 
 
-[[JOLT-Samples]]
-Samples
-^^^^^^^
+### Samples
 
 For example you could use something like
 
@@ -115,12 +109,9 @@ from("direct:in").
 
  
 
-[[JOLT-SeeAlso]]
-See Also
-^^^^^^^^
+### See Also
 
 * link:configuring-camel.html[Configuring Camel]
 * link:component.html[Component]
 * link:endpoint.html[Endpoint]
-* link:getting-started.html[Getting Started]
-
+* link:getting-started.html[Getting Started]
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/camel/blob/28429681/components/camel-josql/src/main/docs/sql-language.adoc
----------------------------------------------------------------------
diff --git a/components/camel-josql/src/main/docs/sql-language.adoc b/components/camel-josql/src/main/docs/sql-language.adoc
index 7038d5f..502897f 100644
--- a/components/camel-josql/src/main/docs/sql-language.adoc
+++ b/components/camel-josql/src/main/docs/sql-language.adoc
@@ -1,4 +1,4 @@
-# SQL Language
+## SQL Language
 
 The SQL support is added by http://josql.sourceforge.net/[JoSQL] and is
 primarily used for performing SQL queries on in-memory objects. If you
@@ -53,9 +53,7 @@ And the spring DSL:
    <to uri="queue:bar"/>
 --------------------------------------
 
-[[SQL-Options]]
-Options
-^^^^^^^
+### Options
 
 
 // language options: START
@@ -73,9 +71,7 @@ The SQL language supports 1 options which are listed below.
 // language options: END
 
 
-[[SQL-Loadingscriptfromexternalresource]]
-Loading script from external resource
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+### Loading script from external resource
 
 *Available as of Camel 2.11*
 
@@ -87,4 +83,4 @@ eg to refer to a file on the classpath you can do:
 [source,java]
 ----------------------------------------------------------
 .setHeader("myHeader").sql("resource:classpath:mysql.sql")
-----------------------------------------------------------
+----------------------------------------------------------
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/camel/blob/28429681/components/camel-jpa/src/main/docs/jpa-component.adoc
----------------------------------------------------------------------
diff --git a/components/camel-jpa/src/main/docs/jpa-component.adoc b/components/camel-jpa/src/main/docs/jpa-component.adoc
index e79d410..c8af852 100644
--- a/components/camel-jpa/src/main/docs/jpa-component.adoc
+++ b/components/camel-jpa/src/main/docs/jpa-component.adoc
@@ -1,4 +1,4 @@
-# JPA Component
+## JPA Component
 
 The *jpa* component enables you to store and retrieve Java objects from
 persistent storage using EJB 3's Java Persistence Architecture (JPA),
@@ -18,9 +18,7 @@ for this component:
 </dependency>
 ------------------------------------------------------------
 
-[[JPA-Sendingtotheendpoint]]
-Sending to the endpoint
-^^^^^^^^^^^^^^^^^^^^^^^
+### Sending to the endpoint
 
 You can store a Java entity bean in a database by sending it to a JPA
 producer endpoint. The body of the _In_ message is assumed to be an
@@ -36,9 +34,7 @@ If the body does not contain one of the previous listed types, put a
 link:message-translator.html[Message Translator] in front of the
 endpoint to perform the necessary conversion first.
 
-[[JPA-Consumingfromtheendpoint]]
-Consuming from the endpoint
-^^^^^^^^^^^^^^^^^^^^^^^^^^^
+### Consuming from the endpoint
 
 Consuming messages from a JPA consumer endpoint removes (or updates)
 entity beans in the database. This allows you to use a database table as
@@ -64,9 +60,7 @@ which will be invoked on your entity bean before it has been processed
 If you are consuming a lot (100K+) of rows and experience OutOfMemory
 problems you should set the maximumResults to sensible value.
 
-[[JPA-URIformat]]
-URI format
-^^^^^^^^^^
+### URI format
 
 [source,java]
 -----------------------------
@@ -82,9 +76,7 @@ For consuming, the _entityClassName_ is mandatory.
 You can append query options to the URI in the following format,
 `?option=value&option=value&...`
 
-[[JPA-Options]]
-Options
-^^^^^^^
+### Options
 
 
 
@@ -170,9 +162,7 @@ The JPA component supports 42 endpoint options which are listed below:
 
 
 
-[[JPA-MessageHeaders]]
-Message Headers
-^^^^^^^^^^^^^^^
+### Message Headers
 
 Camel adds the following message headers to the exchange:
 
@@ -192,9 +182,7 @@ reason why the support for this header has been dropped.
 
 |=======================================================================
 
-[[JPA-ConfiguringEntityManagerFactory]]
-Configuring EntityManagerFactory
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+### Configuring EntityManagerFactory
 
 Its strongly advised to configure the JPA component to use a specific
 `EntityManagerFactory` instance. If failed to do so each `JpaEndpoint`
@@ -217,9 +205,7 @@ you do not need to configure this on the `JpaComponent` as shown above.
 You only need to do so if there is ambiguity, in which case Camel will
 log a WARN.
 
-[[JPA-ConfiguringTransactionManager]]
-Configuring TransactionManager
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+### Configuring TransactionManager
 
 Since *Camel 2.3* the `JpaComponent` will auto lookup the
 `TransactionManager` from the link:registry.html[Registry.] If Camel
@@ -244,9 +230,7 @@ explicitly configure a JPA component that references the
 </bean>
 -------------------------------------------------------------------
 
-[[JPA-Usingaconsumerwithanamedquery]]
-Using a consumer with a named query
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+### Using a consumer with a named query
 
 For consuming only selected entities, you can use the
 `consumer.namedQuery` URI query option. First, you have to define the
@@ -269,9 +253,7 @@ from("jpa://org.apache.camel.examples.MultiSteps?consumer.namedQuery=step1")
 .to("bean:myBusinessLogic");
 ----------------------------------------------------------------------------
 
-[[JPA-Usingaconsumerwithaquery]]
-Using a consumer with a query
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+### Using a consumer with a query
 
 For consuming only selected entities, you can use the `consumer.query`
 URI query option. You only have to define the query option:
@@ -282,9 +264,7 @@ from("jpa://org.apache.camel.examples.MultiSteps?consumer.query=select o from or
 .to("bean:myBusinessLogic");
 ---------------------------------------------------------------------------------------------------------------------------------------
 
-[[JPA-Usingaconsumerwithanativequery]]
-Using a consumer with a native query
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+### Using a consumer with a native query
 
 For consuming only selected entities, you can use the
 `consumer.nativeQuery` URI query option. You only have to define the
@@ -299,16 +279,12 @@ from("jpa://org.apache.camel.examples.MultiSteps?consumer.nativeQuery=select * f
 If you use the native query option, you will receive an object array in
 the message body.
 
-[[JPA-Example]]
-Example
-^^^^^^^
+### Example
 
 See link:tracer-example.html[Tracer Example] for an example using
 link:jpa.html[JPA] to store traced messages into a database.
 
-[[JPA-UsingtheJPAbasedidempotentrepository]]
-Using the JPA based idempotent repository
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+### Using the JPA based idempotent repository
 
 In this section we will use the JPA based idempotent repository.
 
@@ -380,14 +356,11 @@ argument to the JVM:
 Then it will all become green again
 image:https://cwiki.apache.org/confluence/s/en_GB/5982/f2b47fb3d636c8bc9fd0b11c0ec6d0ae18646be7.1/_/images/icons/emoticons/smile.png[(smile)]
 
-[[JPA-SeeAlso]]
-See Also
-^^^^^^^^
+### See Also
 
 * link:configuring-camel.html[Configuring Camel]
 * link:component.html[Component]
 * link:endpoint.html[Endpoint]
 * link:getting-started.html[Getting Started]
 
-* link:tracer-example.html[Tracer Example]
-
+* link:tracer-example.html[Tracer Example]
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/camel/blob/28429681/components/camel-jsch/src/main/docs/scp-component.adoc
----------------------------------------------------------------------
diff --git a/components/camel-jsch/src/main/docs/scp-component.adoc b/components/camel-jsch/src/main/docs/scp-component.adoc
index c92cbf5..3d4b6c0 100644
--- a/components/camel-jsch/src/main/docs/scp-component.adoc
+++ b/components/camel-jsch/src/main/docs/scp-component.adoc
@@ -1,4 +1,4 @@
-# SCP Component
+## SCP Component
 
 The *camel-jsch* component supports the
 http://en.wikipedia.org/wiki/Secure_copy[SCP protocol] using the Client
@@ -19,9 +19,7 @@ for this component:
 </dependency>
 ------------------------------------------------------------
 
-[[Jsch-URIformat]]
-URI format
-^^^^^^^^^^
+### URI format
 
 [source,java]
 ---------------------------------------
@@ -35,9 +33,7 @@ The file name can be specified either in the <path> part of the URI or
 as a "CamelFileName" header on the message (`Exchange.FILE_NAME` if used
 in code).
 
-[[Jsch-Options]]
-Options
-^^^^^^^
+### Options
 
 
 
@@ -102,20 +98,15 @@ The SCP component supports 22 endpoint options which are listed below:
 
 
 
-[[Jsch-Limitations]]
-Limitations
-^^^^^^^^^^^
+### Limitations
 
 Currently camel-jsch only supports a
 http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/Producer.html[Producer]
 (i.e. copy files to another host). 
 
-[[Jsch-SeeAlso]]
-See Also
-^^^^^^^^
+### See Also
 
 * link:configuring-camel.html[Configuring Camel]
 * link:component.html[Component]
 * link:endpoint.html[Endpoint]
-* link:getting-started.html[Getting Started]
-
+* link:getting-started.html[Getting Started]
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/camel/blob/28429681/components/camel-jsonpath/src/main/docs/jsonpath-language.adoc
----------------------------------------------------------------------
diff --git a/components/camel-jsonpath/src/main/docs/jsonpath-language.adoc b/components/camel-jsonpath/src/main/docs/jsonpath-language.adoc
index 766cec4..57f6fec 100644
--- a/components/camel-jsonpath/src/main/docs/jsonpath-language.adoc
+++ b/components/camel-jsonpath/src/main/docs/jsonpath-language.adoc
@@ -1,4 +1,4 @@
-# JSonPath Language
+## JSonPath Language
 
 *Available as of Camel 2.13*
 
@@ -18,9 +18,7 @@ from("queue:books.new")
       .to("jms:queue:book.expensive")
 -----------------------------------------------------
 
-[[JSonPath-Options]]
-JSonPath Options
-^^^^^^^^^^^^^^^^
+### JSonPath Options
 
 
 // language options: START
@@ -42,9 +40,7 @@ The JSonPath language supports 4 options which are listed below.
 
 
 
-[[JSonPath-UsingXMLconfiguration]]
-Using XML configuration
-^^^^^^^^^^^^^^^^^^^^^^^
+### Using XML configuration
 
 If you prefer to configure your routes in your link:spring.html[Spring]
 XML file then you can use link:jsonpath.html[JSonPath] expressions as
@@ -72,16 +68,12 @@ follows
   </camelContext>
 -------------------------------------------------------------------------
 
-[[JSonPath-Syntax]]
-Syntax
-^^^^^^
+### Syntax
 
 See the https://code.google.com/p/json-path/[JSonPath] project page for
 further examples.
 
-[[JSonPath-SupportedType]]
-Supported message body types
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+### Supported message body types
 
 Camel JSonPath supports message body using the following types:
 
@@ -104,9 +96,7 @@ If a message body is of unsupported type then an exception is thrown by default,
 can configure JSonPath to suppress exceptions (see below)
 
 
-[[JSonPath-Suppressexceptions]]
-Suppress exceptions
-~~~~~~~~~~~~~~~~~~~
+### Suppress exceptions
 
 *Available as of Camel 2.16*
 
@@ -149,9 +139,7 @@ And in XML DSL:
 
 This option is also available on the `@JsonPath` annotation.
 
-[[JSonPath-InlineSimple]]
-Inline Simple exceptions
-~~~~~~~~~~~~~~~~~~~~~~~~
+### Inline Simple exceptions
 
 *Available as of Camel 2.18*
 
@@ -207,9 +195,7 @@ And in XML DSL:
 --------------------------------------------------------------------------
 
 
-[[JSonPath-JSonPathinjection]]
-JSonPath injection
-~~~~~~~~~~~~~~~~~~
+### JSonPath injection
 
 You can use link:bean-integration.html[Bean Integration] to invoke a
 method on a bean and use various languages such as JSonPath to extract a
@@ -228,9 +214,7 @@ public class Foo {
 }
 ---------------------------------------------------------------------------------------------------
 
-[[JSonPath-EncodingDetection]]
-Encoding Detection
-~~~~~~~~~~~~~~~~~~
+### Encoding Detection
 
 *Since Camel version 2.16*, the encoding of the JSON document is
 detected automatically, if the document is encoded in unicode  (UTF-8,
@@ -240,9 +224,7 @@ you enter the document in String format to the JSONPath component or you
 can specify the encoding in the header "*CamelJsonPathJsonEncoding*"
 (JsonpathConstants.HEADER_JSON_ENCODING).
 
-[[JSonPath-Dependencies]]
-Dependencies
-^^^^^^^^^^^^
+### Dependencies
 
 To use JSonPath in your camel routes you need to add the a dependency on
 *camel-jsonpath* which implements the JSonPath language.
@@ -258,4 +240,4 @@ link:download.html[the download page for the latest versions]).
   <artifactId>camel-jsonpath</artifactId>
   <version>x.x.x</version>
 </dependency>
------------------------------------------
+-----------------------------------------
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/camel/blob/28429681/components/camel-jt400/src/main/docs/jt400-component.adoc
----------------------------------------------------------------------
diff --git a/components/camel-jt400/src/main/docs/jt400-component.adoc b/components/camel-jt400/src/main/docs/jt400-component.adoc
index 1f0720c..84150ef 100644
--- a/components/camel-jt400/src/main/docs/jt400-component.adoc
+++ b/components/camel-jt400/src/main/docs/jt400-component.adoc
@@ -1,4 +1,4 @@
-# JT400 Component
+## JT400 Component
 
 The *`jt400`* component allows you to exchanges messages with an AS/400
 system using data queues.
@@ -16,9 +16,7 @@ for this component:
 </dependency>
 ------------------------------------------------------------
 
-[[JT400-URIformat]]
-URI format
-^^^^^^^^^^
+### URI format
 
 [source,java]
 ----------------------------------------------------------------------
@@ -35,9 +33,7 @@ jt400://user:password@system/QSYS.LIB/LIBRARY.LIB/program.PGM[?options]
 You can append query options to the URI in the following format,
 `?option=value&option=value&...`
 
-[[JT400-options]]
-JT400 options
-^^^^^^^^^^^^^
+### JT400 options
 
 // component options: START
 The JT400 component supports 1 options which are listed below.
@@ -100,9 +96,7 @@ The JT400 component supports 34 endpoint options which are listed below:
 // endpoint options: END
 
 
-[[JT400-Usage]]
-Usage
-^^^^^
+### Usage
 
 When configured as a consumer endpoint, the endpoint will poll a data
 queue on a remote system. For every entry on the data queue, a new
@@ -111,9 +105,7 @@ formatted either as a `String` or a `byte[]`, depending on the format.
 For a provider endpoint, the _In_ message body contents will be put on
 the data queue as either raw bytes or text.
 
-[[JT400-Connectionpool]]
-Connection pool
-^^^^^^^^^^^^^^^
+### Connection pool
 
 *Available as of Camel 2.10*
 
@@ -121,9 +113,7 @@ Connection pooling is in use from Camel 2.10 onwards. You can explicit
 configure a connection pool on the Jt400Component, or as an uri option
 on the endpoint.
 
-[[JT400-Remoteprogramcall]]
-Remote program call (*Camel 2.7*)
-+++++++++++++++++++++++++++++++++
+#### Remote program call (*Camel 2.7*)
 
 This endpoint expects the input to be either a String array or byte[]
 array (depending on format) and handles all the CCSID handling through
@@ -134,9 +124,7 @@ String array or byte[] array with the values as they were returned by
 the program (the input only parameters will contain the same data as the
 beginning of the invocation). This endpoint does not implement a provider endpoint!
 
-[[JT400-Example]]
-Example
-^^^^^^^
+### Example
 
 In the snippet below, the data for an exchange sent to the
 `direct:george` endpoint will be put in the data queue `PENNYLANE` in
@@ -155,9 +143,7 @@ public class Jt400RouteBuilder extends RouteBuilder {
 }
 -------------------------------------------------------------------------------------------------------
 
-[[JT400-Remoteprogramcallexample]]
-Remote program call example (*Camel 2.7*)
-+++++++++++++++++++++++++++++++++++++++++
+#### Remote program call example (*Camel 2.7*)
 
 In the snippet below, the data Exchange sent to the direct:work endpoint
 will contain three string that will be used as the arguments for the
@@ -175,9 +161,7 @@ public class Jt400RouteBuilder extends RouteBuilder {
 }
 ---------------------------------------------------------------------------------------------------------------------------------------------------------
 
-[[JT400-Writingtokeyeddataqueues]]
-Writing to keyed data queues
-++++++++++++++++++++++++++++
+#### Writing to keyed data queues
 
 [source,java]
 ------------------------------------------------------------------------
@@ -185,9 +169,7 @@ from("jms:queue:input")
 .to("jt400://username:password@system/lib.lib/MSGINDQ.DTAQ?keyed=true");
 ------------------------------------------------------------------------
 
-[[JT400-Readingfromkeyeddataqueues]]
-Reading from keyed data queues
-++++++++++++++++++++++++++++++
+#### Reading from keyed data queues
 
 [source,java]
 -------------------------------------------------------------------------------------------------------
@@ -195,12 +177,9 @@ from("jt400://username:password@system/lib.lib/MSGOUTDQ.DTAQ?keyed=true&searchKe
 .to("jms:queue:output");
 -------------------------------------------------------------------------------------------------------
 
-[[JT400-SeeAlso]]
-See Also
-^^^^^^^^
+### See Also
 
 * link:configuring-camel.html[Configuring Camel]
 * link:component.html[Component]
 * link:endpoint.html[Endpoint]
-* link:getting-started.html[Getting Started]
-
+* link:getting-started.html[Getting Started]
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/camel/blob/28429681/components/camel-juel/src/main/docs/el-language.adoc
----------------------------------------------------------------------
diff --git a/components/camel-juel/src/main/docs/el-language.adoc b/components/camel-juel/src/main/docs/el-language.adoc
index 440d2a3..10a0679 100644
--- a/components/camel-juel/src/main/docs/el-language.adoc
+++ b/components/camel-juel/src/main/docs/el-language.adoc
@@ -1,4 +1,4 @@
-# EL Language
+## EL Language
 [[EL-EL]]
 EL
 ~~
@@ -42,9 +42,7 @@ link:message-filter.html[Message Filter] or as an
 link:expression.html[Expression] for a
 link:recipient-list.html[Recipient List]
 
-[[EL-Options]]
-EL Options
-^^^^^^^^^^
+### EL Options
 
 
 
@@ -64,9 +62,7 @@ The EL language supports 1 options which are listed below.
 
 
 
-[[EL-Variables]]
-Variables
-^^^^^^^^^
+### Variables
 
 [width="100%",cols="10%,10%,80%",options="header",]
 |=======================================================================
@@ -79,9 +75,7 @@ Variables
 |out |Message |the exchange.out message
 |=======================================================================
 
-[[EL-Samples]]
-Samples
-^^^^^^^
+### Samples
 
 You can use EL dot notation to invoke operations. If you for instance
 have a body that contains a POJO that has a `getFamiliyName` method then
@@ -92,9 +86,7 @@ you can construct the syntax as follows:
 "${in.body.familyName}"
 -----------------------
 
-[[EL-Dependencies]]
-Dependencies
-^^^^^^^^^^^^
+### Dependencies
 
 To use EL in your camel routes you need to add the a dependency on
 *camel-juel* which implements the EL language.
@@ -113,4 +105,4 @@ link:download.html[the download page for the latest versions]).
 -------------------------------------
 
 Otherwise you'll also need to include
-http://repo2.maven.org/maven2/de/odysseus/juel/juel/2.1.3/juel-2.1.3.jar[JUEL].
+http://repo2.maven.org/maven2/de/odysseus/juel/juel/2.1.3/juel-2.1.3.jar[JUEL].
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/camel/blob/28429681/components/camel-jxpath/src/main/docs/jxpath-language.adoc
----------------------------------------------------------------------
diff --git a/components/camel-jxpath/src/main/docs/jxpath-language.adoc b/components/camel-jxpath/src/main/docs/jxpath-language.adoc
index 3d6f0d8..de69ead 100644
--- a/components/camel-jxpath/src/main/docs/jxpath-language.adoc
+++ b/components/camel-jxpath/src/main/docs/jxpath-language.adoc
@@ -1,4 +1,4 @@
-# JXPath Language
+## JXPath Language
 
 Camel supports http://commons.apache.org/jxpath/[JXPath] to allow
 link:xpath.html[XPath] expressions to be used on beans in an
@@ -19,9 +19,7 @@ from("queue:foo").filter().
   to("queue:bar")
 ---------------------------
 
-[[JXPath-Options]]
-JXPath Options
-^^^^^^^^^^^^^^
+### JXPath Options
 
 
 // language options: START
@@ -41,9 +39,7 @@ The JXPath language supports 2 options which are listed below.
 
 
 
-[[JXPath-Variables]]
-Variables
-^^^^^^^^^
+### Variables
 
 [width="100%",cols="10%,10%,80%",options="header",]
 |=======================================================================
@@ -56,9 +52,7 @@ Variables
 |out |Message |the exchange.out message
 |=======================================================================
 
-[[JXPath-Options]]
-Options
-^^^^^^^
+### Options
 
 [width="100%",cols="10%,10%,80%",options="header",]
 |=======================================================================
@@ -72,9 +66,7 @@ http://commons.apache.org/proper/commons-jxpath//users-guide.html#Lenient_Mode[J
 Documentation] This option is by default false.
 |=======================================================================
 
-[[JXPath-UsingXMLconfiguration]]
-Using XML configuration
-^^^^^^^^^^^^^^^^^^^^^^^
+### Using XML configuration
 
 If you prefer to configure your routes in your link:spring.html[Spring]
 XML file then you can use JXPath expressions as follows
@@ -99,18 +91,14 @@ XML file then you can use JXPath expressions as follows
 </beans>
 ---------------------------------------------------------------------------------------------------------------
 
-[[JXPath-Examples]]
-Examples
-^^^^^^^^
+### Examples
 
 Here is a simple
 http://svn.apache.org/repos/asf/camel/trunk/components/camel-jxpath/src/test/java/org/apache/camel/language/jxpath/JXPathFilterTest.java[example]
 using a JXPath expression as a predicate in a
 link:message-filter.html[Message Filter]
 
-[[JXPath-JXPathinjection]]
-JXPath injection
-~~~~~~~~~~~~~~~~
+### JXPath injection
 
 You can use link:bean-integration.html[Bean Integration] to invoke a
 method on a bean and use various languages such as JXPath to extract a
@@ -129,9 +117,7 @@ public class Foo {
 }
 ---------------------------------------------------------------------------------------------
 
-[[JXPath-Loadingscriptfromexternalresource]]
-Loading script from external resource
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+### Loading script from external resource
 
 *Available as of Camel 2.11*
 
@@ -145,9 +131,7 @@ eg to refer to a file on the classpath you can do:
 .setHeader("myHeader").jxpath("resource:classpath:myjxpath.txt")
 ----------------------------------------------------------------
 
-[[JXPath-Dependencies]]
-Dependencies
-^^^^^^^^^^^^
+### Dependencies
 
 To use JXpath in your camel routes you need to add the a dependency on
 *camel-jxpath* which implements the JXpath language.
@@ -167,4 +151,4 @@ link:download.html[the download page for the latest versions]).
 
 Otherwise, you'll also need
 http://repo2.maven.org/maven2/commons-jxpath/commons-jxpath/1.3/commons-jxpath-1.3.jar[Commons
-JXPath].
+JXPath].
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/camel/blob/28429681/components/camel-kafka/src/main/docs/kafka-component.adoc
----------------------------------------------------------------------
diff --git a/components/camel-kafka/src/main/docs/kafka-component.adoc b/components/camel-kafka/src/main/docs/kafka-component.adoc
index 1700c0e..79b7c50 100644
--- a/components/camel-kafka/src/main/docs/kafka-component.adoc
+++ b/components/camel-kafka/src/main/docs/kafka-component.adoc
@@ -1,4 +1,4 @@
-# Kafka Component
+## Kafka Component
 
 *Available as of Camel 2.13*
 
@@ -18,15 +18,11 @@ for this component.
 </dependency>
 ------------------------------------------------------------
 
-[[Kafka-Camel2.17ornewer]]
-Camel 2.17 or newer
-+++++++++++++++++++
+#### Camel 2.17 or newer
 
 Scala is no longer used, as we use the kafka java client.
 
-[[Kafka-Camel2.16orolder]]
-Camel 2.16 or older
-+++++++++++++++++++
+#### Camel 2.16 or older
 
 And then the Scala libraries of choice. camel-kafka does not include
 that dependency, but assumes it is provided. For example to use Scala
@@ -41,9 +37,7 @@ that dependency, but assumes it is provided. For example to use Scala
     </dependency>
 --------------------------------------------
 
-[[Kafka-URIformat]]
-URI format
-^^^^^^^^^^
+### URI format
 
 [source,java]
 ---------------------------
@@ -52,9 +46,7 @@ kafka:server:port[?options]
 
  
 
-[[Kafka-Options]]
-Options (Camel 2.16 or older)
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+### Options (Camel 2.16 or older)
 
 
 
@@ -203,13 +195,9 @@ For more information about Producer/Consumer configuration:
 http://kafka.apache.org/documentation.html#newconsumerconfigs[http://kafka.apache.org/documentation.html#newconsumerconfigs]
 http://kafka.apache.org/documentation.html#producerconfigs[http://kafka.apache.org/documentation.html#producerconfigs]
 
-[[Kafka-Samples]]
-Samples
-^^^^^^^
+### Samples
 
-[[Kafka-Camel2.16orolder.1]]
-Camel 2.16 or older
-+++++++++++++++++++
+#### Camel 2.16 or older
 
 Consuming messages:
 
@@ -222,9 +210,7 @@ Producing messages:
 
 See unit tests of camel-kafka for more examples
 
-[[Kafka-Camel2.17ornewer]]
-Camel 2.17 or newer
-+++++++++++++++++++
+#### Camel 2.17 or newer
 
 Consuming messages:
 
@@ -276,9 +262,7 @@ from("direct:start").process(new Processor() {
 
  
 
-[[Kafka-Endpoints]]
-Endpoints
-~~~~~~~~~
+### Endpoints
 
 Camel supports the link:message-endpoint.html[Message Endpoint] pattern
 using the
@@ -306,12 +290,9 @@ implements the link:polling-consumer.html[Polling Consumer] pattern for
 consuming message exchanges from the endpoint via a
 http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/PollingConsumer.html[PollingConsumer]
 
-[[Kafka-SeeAlso]]
-See Also
-^^^^^^^^
+### See Also
 
 * link:configuring-camel.html[Configuring Camel]
 * link:message-endpoint.html[Message Endpoint] pattern
 * link:uris.html[URIs]
-* link:writing-components.html[Writing Components]
-
+* link:writing-components.html[Writing Components]
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/camel/blob/28429681/components/camel-kestrel/src/main/docs/kestrel-component.adoc
----------------------------------------------------------------------
diff --git a/components/camel-kestrel/src/main/docs/kestrel-component.adoc b/components/camel-kestrel/src/main/docs/kestrel-component.adoc
index ba8d963..025a475 100644
--- a/components/camel-kestrel/src/main/docs/kestrel-component.adoc
+++ b/components/camel-kestrel/src/main/docs/kestrel-component.adoc
@@ -1,4 +1,4 @@
-# Kestrel Component
+## Kestrel Component
 
 The Kestrel component allows messages to be sent to a
 https://github.com/robey/kestrel[Kestrel] queue, or messages to be
@@ -10,9 +10,7 @@ WARNING: The kestrel project is inactive and the Camel team regard this
 components as deprecated.
 
 
-[[Kestrel-URIformat]]
-URI format
-^^^^^^^^^^
+### URI format
 
 [source,java]
 -------------------------------------------
@@ -59,9 +57,7 @@ concurrently from a queue:
 kestrel://kserver03:22133/massive?concurrentConsumers=25&waitTimeMs=500
 -----------------------------------------------------------------------
 
-[[Kestrel-Options]]
-Options
-^^^^^^^
+### Options
 
 
 
@@ -108,9 +104,7 @@ The Kestrel component supports 8 endpoint options which are listed below:
 
 
 
-[[Kestrel-ConfiguringtheKestrelcomponentusingSpringXML]]
-Configuring the Kestrel component using Spring XML
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+### Configuring the Kestrel component using Spring XML
 
 The simplest form of explicit configuration is as follows:
 
@@ -162,13 +156,9 @@ can set up a KestrelConfiguration POJO as follows:
 </beans>
 ---------------------------------------------------------------------------------------------------------------
 
-[[Kestrel-UsageExamples]]
-Usage Examples
-^^^^^^^^^^^^^^
+### Usage Examples
 
-[[Kestrel-Example1:Consuming]]
-Example 1: Consuming
-++++++++++++++++++++
+#### Example 1: Consuming
 
 [source,java]
 -------------------------------------------------------------------------------
@@ -185,9 +175,7 @@ public class MyConsumer {
 }
 -------------------------------------------
 
-[[Kestrel-Example2:Producing]]
-Example 2: Producing
-++++++++++++++++++++
+#### Example 2: Producing
 
 [source,java]
 ------------------------------------------------------------------------------
@@ -201,9 +189,7 @@ public class MyProducer {
 }
 ------------------------------------------------------------------------------
 
-[[Kestrel-Example3:SpringXMLConfiguration]]
-Example 3: Spring XML Configuration
-+++++++++++++++++++++++++++++++++++
+#### Example 3: Spring XML Configuration
 
 [source,xml]
 ----------------------------------------------------------------------------------------
@@ -228,17 +214,13 @@ public class MyBean {
 }
 -------------------------------------------
 
-[[Kestrel-Dependencies]]
-Dependencies
-^^^^^^^^^^^^
+### Dependencies
 
 The Kestrel component has the following dependencies:
 
 * `spymemcached` 2.5 (or greater)
 
-[[Kestrel-spymemcached]]
-spymemcached
-++++++++++++
+#### spymemcached
 
 You *must* have the `spymemcached` jar on your classpath. Here is a
 snippet you can use in your pom.xml:
@@ -273,12 +255,9 @@ you may need to set `enableAssertions` to `false`. Please refer to the
 http://maven.apache.org/plugins/maven-surefire-plugin/test-mojo.html[surefire:test
 reference] for details.
 
-[[Kestrel-SeeAlso]]
-See Also
-^^^^^^^^
+### See Also
 
 * link:configuring-camel.html[Configuring Camel]
 * link:component.html[Component]
 * link:endpoint.html[Endpoint]
-* link:getting-started.html[Getting Started]
-
+* link:getting-started.html[Getting Started]
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/camel/blob/28429681/components/camel-krati/src/main/docs/krati-component.adoc
----------------------------------------------------------------------
diff --git a/components/camel-krati/src/main/docs/krati-component.adoc b/components/camel-krati/src/main/docs/krati-component.adoc
index 996356e..0268736 100644
--- a/components/camel-krati/src/main/docs/krati-component.adoc
+++ b/components/camel-krati/src/main/docs/krati-component.adoc
@@ -1,4 +1,4 @@
-# Krati Component
+## Krati Component
 
 *Available as of Camel 2.9*
 
@@ -25,9 +25,7 @@ for this component:
 </dependency>
 ------------------------------------------------------------
 
-[[Krati-URIformat]]
-URI format
-^^^^^^^^^^
+### URI format
 
 [source,java]
 -------------------------------------------
@@ -40,9 +38,7 @@ krati will use for its datastore.
 You can append query options to the URI in the following format,
 `?option=value&option=value&...`
 
-[[Krati-KratiOptions]]
-Krati Options
-^^^^^^^^^^^^^
+### Krati Options
 
 
 // component options: START
@@ -107,9 +103,7 @@ krati:/tmp/krati?operation=CamelKratiGet&initialCapacity=10000&keySerializer=#my
 For producer endpoint you can override all of the above URI options by
 passing the appropriate headers to the message.
 
-[[Krati-MessageHeadersfordatastore]]
-Message Headers for datastore
-+++++++++++++++++++++++++++++
+#### Message Headers for datastore
 
 [width="100%",cols="10%,90%",options="header",]
 |=======================================================================
@@ -123,13 +117,9 @@ CamelKratiDelete, CamelKratiDeleteAll
 |`CamelKratiValue` |The value.
 |=======================================================================
 
-[[Krati-UsageSamples]]
-Usage Samples
-^^^^^^^^^^^^^
+### Usage Samples
 
-[[Krati-Example1:Puttingtothedatastore.]]
-Example 1: Putting to the datastore.
-++++++++++++++++++++++++++++++++++++
+#### Example 1: Putting to the datastore.
 
 This example will show you how you can store any message inside a
 datastore.
@@ -152,9 +142,7 @@ route.
         </route>
 ------------------------------------------------------------
 
-[[Krati-Example2:GettingReadingfromadatastore]]
-Example 2: Getting/Reading from a datastore
-+++++++++++++++++++++++++++++++++++++++++++
+#### Example 2: Getting/Reading from a datastore
 
 This example will show you how you can read the contnet of a datastore.
 
@@ -178,9 +166,7 @@ route.
 </route>
 -----------------------------------------------------------------------------
 
-[[Krati-Example3:Consumingfromadatastore]]
-Example 3: Consuming from a datastore
-+++++++++++++++++++++++++++++++++++++
+#### Example 3: Consuming from a datastore
 
 This example will consume all items that are under the specified
 datastore.
@@ -201,9 +187,7 @@ You can achieve the same goal by using xml, as you can see below.
 </route>
 ------------------------------------------------------
 
-[[Krati-IdempotentRepository]]
-Idempotent Repository
-^^^^^^^^^^^^^^^^^^^^^
+### Idempotent Repository
 
 As already mentioned this component also offers and idemptonet
 repository which can be used for filtering out duplicate messages.
@@ -213,8 +197,6 @@ repository which can be used for filtering out duplicate messages.
 from("direct://in").idempotentConsumer(header("messageId"), new KratiIdempotentRepositroy("/tmp/idempotent").to("log://out");
 -----------------------------------------------------------------------------------------------------------------------------
 
-[[Krati-Seealso]]
-See also
-++++++++
+#### See also
 
-http://sna-projects.com/krati/[Krati Website]
+http://sna-projects.com/krati/[Krati Website]
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/camel/blob/28429681/components/camel-kubernetes/src/main/docs/kubernetes-component.adoc
----------------------------------------------------------------------
diff --git a/components/camel-kubernetes/src/main/docs/kubernetes-component.adoc b/components/camel-kubernetes/src/main/docs/kubernetes-component.adoc
index 4978059..f7d30b7 100644
--- a/components/camel-kubernetes/src/main/docs/kubernetes-component.adoc
+++ b/components/camel-kubernetes/src/main/docs/kubernetes-component.adoc
@@ -1,4 +1,4 @@
-# Kubernetes Component
+## Kubernetes Component
 
 *Available as of Camel 2.17*
 
@@ -18,9 +18,7 @@ their `pom.xml` for this component:
 </dependency>
 ------------------------------------------------------------
 
-[[Kubernetes-URIformat]]
-URI format
-^^^^^^^^^^
+### URI format
 
 [source,java]
 ------------------------------
@@ -30,9 +28,7 @@ kubernetes:masterUrl[?options]
 You can append query options to the URI in the following
 format, `?option=value&option=value&...`
 
-[[Kubernetes-Options]]
-Options
-^^^^^^^
+### Options
 
 
 // component options: START
@@ -91,9 +87,7 @@ The Kubernetes component supports 28 endpoint options which are listed below:
 
 
 
-[[Kubernetes-Headers]]
-Headers
-^^^^^^^
+### Headers
 
 [width="100%",cols="10%,10%,80%",options="header",]
 |=======================================================================
@@ -174,4 +168,4 @@ Headers
 |CamelKubernetesConfigMapsLabels |Map |ConfigMap labels
 
 |CamelKubernetesConfigData |Map |ConfigMap Data
-|=======================================================================
+|=======================================================================
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/camel/blob/28429681/components/camel-ldap/src/main/docs/ldap-component.adoc
----------------------------------------------------------------------
diff --git a/components/camel-ldap/src/main/docs/ldap-component.adoc b/components/camel-ldap/src/main/docs/ldap-component.adoc
index 2489e78..b711cea 100644
--- a/components/camel-ldap/src/main/docs/ldap-component.adoc
+++ b/components/camel-ldap/src/main/docs/ldap-component.adoc
@@ -1,4 +1,4 @@
-# LDAP Component
+## LDAP Component
 
 The *ldap* component allows you to perform searches in LDAP servers
 using filters as the message payload. +
@@ -18,9 +18,7 @@ for this component:
 </dependency>
 ------------------------------------------------------------
 
-[[LDAP-URIformat]]
-URI format
-^^^^^^^^^^
+### URI format
 
 [source,java]
 -----------------------------
@@ -36,9 +34,7 @@ the start of a route.
 You can append query options to the URI in the following format,
 `?option=value&option=value&...`
 
-[[LDAP-Options]]
-Options
-^^^^^^^
+### Options
 
 
 // component options: START
@@ -67,16 +63,12 @@ The LDAP component supports 6 endpoint options which are listed below:
 
 
 
-[[LDAP-Result]]
-Result
-^^^^^^
+### Result
 
 The result is returned in the Out body as a
 `ArrayList<javax.naming.directory.SearchResult>` object.
 
-[[LDAP-DirContext]]
-DirContext
-^^^^^^^^^^
+### DirContext
 
 The URI, `ldap:ldapserver`, references a Spring bean with the ID,
 `ldapserver`. The `ldapserver` bean may be defined as follows:
@@ -104,9 +96,7 @@ or that the context supports concurrency. In the Spring framework,
 `prototype` scoped objects are instantiated each time they are looked
 up.
 
-[[LDAP-Samples]]
-Samples
-^^^^^^^
+### Samples
 
 Following on from the Spring configuration above, the code sample below
 sends an LDAP request to filter search a group for a member. The Common
@@ -145,9 +135,7 @@ if the LDAP entry has a Common Name, use a filter expression like:
 (cn=*)
 ------
 
-[[LDAP-Bindingusingcredentials]]
-Binding using credentials
-+++++++++++++++++++++++++
+#### Binding using credentials
 
 A Camel end user donated this sample code he used to bind to the ldap
 server using credentials.
@@ -192,9 +180,7 @@ System.out.println(out.getOut().getBody());
 context.stop();
 ---------------------------------------------------------------------------------------
 
-[[LDAP-ConfiguringSSL]]
-Configuring SSL
-^^^^^^^^^^^^^^^
+### Configuring SSL
 
 All required is to create a custom socket factory and reference it in
 the InitialDirContext bean - see below sample.
@@ -335,12 +321,9 @@ public class CustomSocketFactory extends SSLSocketFactory {
 
  
 
-[[LDAP-SeeAlso]]
-See Also
-^^^^^^^^
+### See Also
 
 * link:configuring-camel.html[Configuring Camel]
 * link:component.html[Component]
 * link:endpoint.html[Endpoint]
-* link:getting-started.html[Getting Started]
-
+* link:getting-started.html[Getting Started]
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/camel/blob/28429681/components/camel-linkedin/camel-linkedin-component/src/main/docs/linkedin-component.adoc
----------------------------------------------------------------------
diff --git a/components/camel-linkedin/camel-linkedin-component/src/main/docs/linkedin-component.adoc b/components/camel-linkedin/camel-linkedin-component/src/main/docs/linkedin-component.adoc
index fa81b62..ca5c9dc 100644
--- a/components/camel-linkedin/camel-linkedin-component/src/main/docs/linkedin-component.adoc
+++ b/components/camel-linkedin/camel-linkedin-component/src/main/docs/linkedin-component.adoc
@@ -1,4 +1,4 @@
-# Linkedin Component
+## Linkedin Component
 
 *Available as of Camel 2.14*
 
@@ -29,9 +29,7 @@ for this component:
     </dependency>
 -----------------------------------------------
 
-[[LinkedIn-URIformat]]
-URI format
-^^^^^^^^^^
+### URI format
 
 [source,java]
 -------------------------------------------------
@@ -48,9 +46,7 @@ Endpoint prefix can be one of:
 * posts
 * search
 
-[[LinkedIn-LinkedInComponent.1]]
-LinkedInComponent
-^^^^^^^^^^^^^^^^^
+### LinkedInComponent
 
 
 
@@ -101,9 +97,7 @@ The Linkedin component supports 16 endpoint options which are listed below:
 // endpoint options: END
 
 
-[[LinkedIn-ProducerEndpoints:]]
-Producer Endpoints:
-^^^^^^^^^^^^^^^^^^^
+### Producer Endpoints:
 
 Producer endpoints can use endpoint prefixes followed by endpoint names
 and associated options described next. A shorthand alias can be used for
@@ -125,9 +119,7 @@ For more information on the endpoints and options see LinkedIn REST API
 documentation
 at https://developer.linkedin.com/rest[https://developer.linkedin.com/rest]. 
 
-[[LinkedIn-Endpointprefixcomments]]
-Endpoint prefix _comments_
-++++++++++++++++++++++++++
+#### Endpoint prefix _comments_
 
 The following endpoints can be invoked with the prefix *comments* as
 follows:
@@ -158,9 +150,7 @@ URI Options for _comments_
 |fields |String
 |=======================================================================
 
-[[LinkedIn-Endpointprefixcompanies]]
-Endpoint prefix _companies_
-+++++++++++++++++++++++++++
+#### Endpoint prefix _companies_
 
 The following endpoints can be invoked with the prefix *companies* as
 follows:
@@ -265,9 +255,7 @@ matching endpoints.
 |updatecomment |org.apache.camel.component.linkedin.api.model.UpdateComment
 |=======================================================================
 
-[[LinkedIn-Endpointprefixgroups]]
-Endpoint prefix _groups_
-++++++++++++++++++++++++
+#### Endpoint prefix _groups_
 
 The following endpoints can be invoked with the prefix *groups* as
 follows:
@@ -298,9 +286,7 @@ URI Options for _groups_
 |post |org.apache.camel.component.linkedin.api.model.Post
 |=======================================================================
 
-[[LinkedIn-Endpointprefixjobs]]
-Endpoint prefix _jobs_
-++++++++++++++++++++++
+#### Endpoint prefix _jobs_
 
 The following endpoints can be invoked with the prefix *jobs* as
 follows:
@@ -339,9 +325,7 @@ URI Options for _jobs_
 |partner_job_id |Long
 |=======================================================================
 
-[[LinkedIn-Endpointprefixpeople]]
-Endpoint prefix _people_
-++++++++++++++++++++++++
+#### Endpoint prefix _people_
 
 The following endpoints can be invoked with the prefix *people* as
 follows:
@@ -495,9 +479,7 @@ if other options do not satisfy matching endpoints.
 |updatecomment |org.apache.camel.component.linkedin.api.model.UpdateComment
 |=======================================================================
 
-[[LinkedIn-Endpointprefixposts]]
-Endpoint prefix _posts_
-+++++++++++++++++++++++
+#### Endpoint prefix _posts_
 
 The following endpoints can be invoked with the prefix *posts* as
 follows:
@@ -555,9 +537,7 @@ options do not satisfy matching endpoints.
 |start |Long
 |=======================================================================
 
-[[LinkedIn-Endpointprefixsearch]]
-Endpoint prefix _search_
-++++++++++++++++++++++++
+#### Endpoint prefix _search_
 
 The following endpoints can be invoked with the prefix *search* as
 follows:
@@ -637,9 +617,7 @@ satisfy matching endpoints.
 |title |String
 |=======================================================================
 
-[[LinkedIn-ConsumerEndpoints]]
-Consumer Endpoints
-^^^^^^^^^^^^^^^^^^
+### Consumer Endpoints
 
 Any of the producer endpoints can be used as a consumer endpoint.
 Consumer endpoints can
@@ -651,25 +629,19 @@ be executed once for each exchange. To change this behavior use the
 property *consumer.splitResults=true* to return a single exchange for
 the entire list or array. 
 
-[[LinkedIn-MessageHeaders]]
-Message Headers
-^^^^^^^^^^^^^^^
+### Message Headers
 
 Any URI option can be provided in a message header for producer
 endpoints with a *CamelLinkedIn.* prefix.
 
-[[LinkedIn-Messagebody]]
-Message body
-^^^^^^^^^^^^
+### Message body
 
 All result message bodies utilize objects provided by the Camel LinkedIn
 API SDK, which is built using Apache CXF JAX-RS. Producer endpoints can
 specify the option name for incoming message body in the *inBody*
 endpoint parameter.
 
-[[LinkedIn-Usecases]]
-Use cases
-^^^^^^^^^
+### Use cases
 
 The following route gets user's profile:
 
@@ -697,4 +669,4 @@ The following route uses a producer with dynamic header options. The
         .setHeader("CamelLinkedIn.person_id", header("personId"))
         .to("linkedin://people/connectionsById")
         .to("bean://bar");
------------------------------------------------------------------
+-----------------------------------------------------------------
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/camel/blob/28429681/components/camel-lucene/src/main/docs/lucene-component.adoc
----------------------------------------------------------------------
diff --git a/components/camel-lucene/src/main/docs/lucene-component.adoc b/components/camel-lucene/src/main/docs/lucene-component.adoc
index 289186d..4cccec4 100644
--- a/components/camel-lucene/src/main/docs/lucene-component.adoc
+++ b/components/camel-lucene/src/main/docs/lucene-component.adoc
@@ -1,4 +1,4 @@
-# Lucene Component
+## Lucene Component
 
 *Available as of Camel 2.2*
 
@@ -33,9 +33,7 @@ for this component:
 </dependency>
 ------------------------------------------------------------
 
-[[Lucene-URIformat]]
-URI format
-^^^^^^^^^^
+### URI format
 
 [source,java]
 ------------------------------------
@@ -46,9 +44,7 @@ lucene:searcherName:query[?options]
 You can append query options to the URI in the following format,
 `?option=value&option=value&...`
 
-[[Lucene-InsertOptions]]
-Insert Options
-^^^^^^^^^^^^^^
+### Insert Options
 
 
 
@@ -94,13 +90,9 @@ The Lucene component supports 7 endpoint options which are listed below:
 
 
 
-[[Lucene-Sending/ReceivingMessagestoFromthecache]]
-Sending/Receiving Messages to/from the cache
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+### Sending/Receiving Messages to/from the cache
 
-[[Lucene-MessageHeaders]]
-Message Headers
-+++++++++++++++
+#### Message Headers
 
 [width="100%",cols="10%,90%",options="header",]
 |=======================================================================
@@ -113,9 +105,7 @@ wildcards and phrases
 documentation when returning hit information.
 |=======================================================================
 
-[[Lucene-LuceneProducers]]
-Lucene Producers
-++++++++++++++++
+#### Lucene Producers
 
 This component supports 2 producer endpoints.
 
@@ -129,20 +119,14 @@ property name called 'QUERY'. The value of the header property 'QUERY'
 is a Lucene Query. For more details on how to create Lucene Queries
 check out http://lucene.apache.org/java/3_0_0/queryparsersyntax.html[http://lucene.apache.org/java/3_0_0/queryparsersyntax.html]
 
-[[Lucene-LuceneProcessor]]
-Lucene Processor
-++++++++++++++++
+#### Lucene Processor
 
 There is a processor called LuceneQueryProcessor available to perform
 queries against lucene without the need to create a producer.
 
-[[Lucene-LuceneUsageSamples]]
-Lucene Usage Samples
-^^^^^^^^^^^^^^^^^^^^
+### Lucene Usage Samples
 
-[[Lucene-Example1:CreatingaLuceneindex]]
-Example 1: Creating a Lucene index
-++++++++++++++++++++++++++++++++++
+#### Example 1: Creating a Lucene index
 
 [source,java]
 ------------------------------------------------------------------------------------
@@ -156,9 +140,7 @@ RouteBuilder builder = new RouteBuilder() {
 };
 ------------------------------------------------------------------------------------
 
-[[Lucene-Example2:LoadingpropertiesintotheJNDIregistryintheCamelContext]]
-Example 2: Loading properties into the JNDI registry in the Camel Context
-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#### Example 2: Loading properties into the JNDI registry in the Camel Context
 
 [source,java]
 -----------------------------------------------------------------
@@ -177,9 +159,7 @@ protected JndiRegistry createRegistry() throws Exception {
 CamelContext context = new DefaultCamelContext(createRegistry());
 -----------------------------------------------------------------
 
-[[Lucene-Example2:PerformingsearchesusingaQueryProducer]]
-Example 2: Performing searches using a Query Producer
-+++++++++++++++++++++++++++++++++++++++++++++++++++++
+#### Example 2: Performing searches using a Query Producer
 
 [source,java]
 ----------------------------------------------------------------------------------------------------
@@ -210,9 +190,7 @@ RouteBuilder builder = new RouteBuilder() {
 };
 ----------------------------------------------------------------------------------------------------
 
-[[Lucene-Example3:PerformingsearchesusingaQueryProcessor]]
-Example 3: Performing searches using a Query Processor
-++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#### Example 3: Performing searches using a Query Processor
 
 [source,java]
 -------------------------------------------------------------------------------------------------------
@@ -244,4 +222,4 @@ RouteBuilder builder = new RouteBuilder() {
        }).to("mock:searchResult");
    }
 };
--------------------------------------------------------------------------------------------------------
+-------------------------------------------------------------------------------------------------------
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/camel/blob/28429681/components/camel-lumberjack/src/main/docs/lumberjack-component.adoc
----------------------------------------------------------------------
diff --git a/components/camel-lumberjack/src/main/docs/lumberjack-component.adoc b/components/camel-lumberjack/src/main/docs/lumberjack-component.adoc
index 3f0ee80..b94c81c 100644
--- a/components/camel-lumberjack/src/main/docs/lumberjack-component.adoc
+++ b/components/camel-lumberjack/src/main/docs/lumberjack-component.adoc
@@ -1,4 +1,4 @@
-# Lumberjack Component
+## Lumberjack Component
 
 *Available as of Camel 2.18*
 
@@ -20,9 +20,7 @@ Maven users will need to add the following dependency to their `pom.xml` for thi
 </dependency>
 ------------------------------------------------------------
 
-[[Lumberjack-URIformat]]
-URI format
-^^^^^^^^^^
+### URI format
 
 [source,java]
 ------------------------------------
@@ -33,9 +31,7 @@ lumberjack:host:port
 You can append query options to the URI in the following format,
 `?option=value&option=value&...`
 
-[[Lumberjack-Options]]
-Options
-^^^^^^^
+### Options
 
 
 
@@ -82,19 +78,13 @@ The Lumberjack component supports 7 endpoint options which are listed below:
 
 
 
-[[Lumberjack-Result]]
-Result
-^^^^^^
+### Result
 
 The result body is a `Map<String, Object>` object.
 
-[[Lumberjack-LumberjackUsageSamples]]
-Lumberjack Usage Samples
-^^^^^^^^^^^^^^^^^^^^^^^^
+### Lumberjack Usage Samples
 
-[[Lumberjack-Example1:]]
-Example 1: Streaming the log messages
-+++++++++++++++++++++++++++++++++++++
+#### Example 1: Streaming the log messages
 
 [source,java]
 ------------------------------------------------------------------------------------
@@ -105,5 +95,4 @@ RouteBuilder builder = new RouteBuilder() {
            to("stream:out");                        // Write it into the output stream
     }
 };
-------------------------------------------------------------------------------------
-
+------------------------------------------------------------------------------------
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/camel/blob/28429681/components/camel-lzf/src/main/docs/lzf-dataformat.adoc
----------------------------------------------------------------------
diff --git a/components/camel-lzf/src/main/docs/lzf-dataformat.adoc b/components/camel-lzf/src/main/docs/lzf-dataformat.adoc
index b873ceb..00e2fc7 100644
--- a/components/camel-lzf/src/main/docs/lzf-dataformat.adoc
+++ b/components/camel-lzf/src/main/docs/lzf-dataformat.adoc
@@ -1,4 +1,4 @@
-# LZF Deflate Compression DataFormat
+## LZF Deflate Compression DataFormat
 
 The
 LZF https://cwiki.apache.org/confluence/display/CAMEL/Data+Format[Data
@@ -9,9 +9,7 @@ endpoint. The compression capability is quite useful when you deal with
 large XML and Text based payloads or when you read messages previously
 comressed using LZF algotithm.
 
-[[LZFDataFormat-Options]]
-Options
-^^^^^^^
+### Options
 
 // dataformat options: START
 The LZF Deflate Compression dataformat supports 2 options which are listed below.
@@ -28,9 +26,7 @@ The LZF Deflate Compression dataformat supports 2 options which are listed below
 {% endraw %}
 // dataformat options: END
 
-[[LZFDataFormat-Marshal]]
-Marshal
-^^^^^^^
+### Marshal
 
 In this example we marshal a regular text/XML payload to a compressed
 payload employing LZF compression format and send it an ActiveMQ queue
@@ -41,9 +37,7 @@ called MY_QUEUE.
 from("direct:start").marshal().lzf().to("activemq:queue:MY_QUEUE");
 -------------------------------------------------------------------
 
-[[LZFDataFormat-Unmarshal]]
-Unmarshal
-^^^^^^^^^
+### Unmarshal
 
 In this example we unmarshal a LZF payload from an ActiveMQ queue called
 MY_QUEUE to its original format, and forward it for processing to
@@ -54,9 +48,7 @@ the `UnGZippedMessageProcessor`.
 from("activemq:queue:MY_QUEUE").unmarshal().lzf().process(new UnCompressedMessageProcessor());
 ----------------------------------------------------------------------------------------------
 
-[[LZFDataFormat-Dependencies]]
-Dependencies
-^^^^^^^^^^^^
+### Dependencies
 
 To useLZF compression in your camel routes you need to add a dependency
 on *camel-lzf* which implements this data format.
@@ -74,4 +66,4 @@ download page for the latest versions]).
   <version>x.x.x</version>
   <!-- use the same version as your Camel core version -->
 </dependency>
-----------------------------------------------------------
+----------------------------------------------------------
\ No newline at end of file


Mime
View raw message