You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by da...@apache.org on 2017/01/11 18:27:12 UTC
[07/14] camel git commit: Use single line header for adoc files
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