You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by ac...@apache.org on 2016/05/19 08:46:43 UTC
[1/4] camel git commit: Added camel-quartz2 and camel-rabbitmq docs
to Gitbook
Repository: camel
Updated Branches:
refs/heads/master bb32e1d84 -> 7cfced8b5
Added camel-quartz2 and camel-rabbitmq docs to Gitbook
Project: http://git-wip-us.apache.org/repos/asf/camel/repo
Commit: http://git-wip-us.apache.org/repos/asf/camel/commit/e27f6320
Tree: http://git-wip-us.apache.org/repos/asf/camel/tree/e27f6320
Diff: http://git-wip-us.apache.org/repos/asf/camel/diff/e27f6320
Branch: refs/heads/master
Commit: e27f6320ff0330399c4171ea715b7c21b8fd32f6
Parents: bb32e1d
Author: Andrea Cosentino <an...@gmail.com>
Authored: Thu May 19 10:26:35 2016 +0200
Committer: Andrea Cosentino <an...@gmail.com>
Committed: Thu May 19 10:26:35 2016 +0200
----------------------------------------------------------------------
.../camel-quartz2/src/main/docs/quartz2.adoc | 339 +++++++++++++++++++
.../camel-rabbitmq/src/main/docs/rabbitmq.adoc | 252 ++++++++++++++
docs/user-manual/en/SUMMARY.md | 2 +
3 files changed, 593 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/camel/blob/e27f6320/components/camel-quartz2/src/main/docs/quartz2.adoc
----------------------------------------------------------------------
diff --git a/components/camel-quartz2/src/main/docs/quartz2.adoc b/components/camel-quartz2/src/main/docs/quartz2.adoc
new file mode 100644
index 0000000..f21f45f
--- /dev/null
+++ b/components/camel-quartz2/src/main/docs/quartz2.adoc
@@ -0,0 +1,339 @@
+[[Quartz2-Quartz2Component]]
+Quartz2 Component
+~~~~~~~~~~~~~~~~~
+
+*Available as of Camel 2.12.0*
+
+The *quartz2:* component provides a scheduled delivery of messages using
+the http://www.quartz-scheduler.org/[Quartz Scheduler 2.x]. +
+ Each endpoint represents a different timer (in Quartz terms, a Trigger
+and JobDetail).
+
+Maven users will need to add the following dependency to their `pom.xml`
+for this component:
+
+[source,xml]
+------------------------------------------------------------
+<dependency>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-quartz2</artifactId>
+ <version>x.x.x</version>
+ <!-- use the same version as your Camel core version -->
+</dependency>
+------------------------------------------------------------
+
+*NOTE:* Quartz 2.x API is not compatible with Quartz 1.x. If you need to
+remain on old Quartz 1.x, please +
+ use the old link:quartz.html[Quartz] component instead.
+
+[[Quartz2-URIformat]]
+URI format
+^^^^^^^^^^
+
+[source,java]
+---------------------------------------------
+quartz2://timerName?options
+quartz2://groupName/timerName?options
+quartz2://groupName/timerName?cron=expression
+quartz2://timerName?cron=expression
+---------------------------------------------
+
+The component uses either a `CronTrigger` or a `SimpleTrigger`. If no
+cron expression is provided, the component uses a simple trigger. If no
+`groupName` is provided, the quartz component uses the `Camel` group
+name.
+
+You can append query options to the URI in the following format,
+`?option=value&option=value&...`
+
+[[Quartz2-Options]]
+Options
+^^^^^^^
+
+
+// component options: START
+The Quartz2 component supports 9 options which are listed below.
+
+
+
+{% raw %}
+[width="100%",cols="2s,1m,8",options="header"]
+|=======================================================================
+| Name | Java Type | Description
+| autoStartScheduler | boolean | Whether or not the scheduler should be auto started. This options is default true
+| startDelayedSeconds | int | Seconds to wait before starting the quartz scheduler.
+| prefixJobNameWithEndpointId | boolean | Whether to prefix the quartz job with the endpoint id. This option is default false.
+| enableJmx | boolean | Whether to enable Quartz JMX which allows to manage the Quartz scheduler from JMX. This options is default true
+| properties | Properties | Properties to configure the Quartz scheduler.
+| propertiesFile | String | File name of the properties to load from the classpath
+| prefixInstanceName | boolean | Whether to prefix the Quartz Scheduler instance name with the CamelContext name. This is enabled by default to let each CamelContext use its own Quartz scheduler instance by default. You can set this option to false to reuse Quartz scheduler instances between multiple CamelContext's.
+| schedulerFactory | SchedulerFactory | To use the custom SchedulerFactory which is used to create the Scheduler.
+| scheduler | Scheduler | To use the custom configured Quartz scheduler instead of creating a new Scheduler.
+|=======================================================================
+{% endraw %}
+// component options: END
+
+
+
+// endpoint options: START
+The Quartz2 component supports 21 endpoint options which are listed below:
+
+{% raw %}
+[width="100%",cols="2s,1,1m,1m,5",options="header"]
+|=======================================================================
+| Name | Group | Default | Java Type | Description
+| groupName | consumer | Camel | String | The quartz group name to use. The combination of group name and timer name should be unique.
+| triggerName | consumer | | String | *Required* The quartz timer name to use. The combination of group name and timer name should be unique.
+| bridgeErrorHandler | consumer | false | boolean | Allows for bridging the consumer to the Camel routing Error Handler which mean any exceptions occurred while the consumer is trying to pickup incoming messages or the likes will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions that will be logged at WARN/ERROR level and ignored.
+| cron | consumer | | String | Specifies a cron expression to define when to trigger.
+| deleteJob | consumer | true | boolean | If set to true then the trigger automatically delete when route stop. Else if set to false it will remain in scheduler. When set to false it will also mean user may reuse pre-configured trigger with camel Uri. Just ensure the names match. Notice you cannot have both deleteJob and pauseJob set to true.
+| durableJob | consumer | false | boolean | Whether or not the job should remain stored after it is orphaned (no triggers point to it).
+| pauseJob | consumer | false | boolean | If set to true then the trigger automatically pauses when route stop. Else if set to false it will remain in scheduler. When set to false it will also mean user may reuse pre-configured trigger with camel Uri. Just ensure the names match. Notice you cannot have both deleteJob and pauseJob set to true.
+| recoverableJob | consumer | false | boolean | Instructs the scheduler whether or not the job should be re-executed if a 'recovery' or 'fail-over' situation is encountered.
+| stateful | consumer | false | boolean | Uses a Quartz PersistJobDataAfterExecution and DisallowConcurrentExecution instead of the default job.
+| exceptionHandler | consumer (advanced) | | ExceptionHandler | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this options is not in use. By default the consumer will deal with exceptions that will be logged at WARN/ERROR level and ignored.
+| customCalendar | advanced | | Calendar | Specifies a custom calendar to avoid specific range of date
+| exchangePattern | advanced | InOnly | ExchangePattern | Sets the default exchange pattern when creating an exchange
+| jobParameters | advanced | | Map | To configure additional options on the job.
+| prefixJobNameWithEndpointId | advanced | false | boolean | Whether the job name should be prefixed with endpoint id
+| synchronous | advanced | false | boolean | Sets whether synchronous processing should be strictly used or Camel is allowed to use asynchronous processing (if supported).
+| triggerParameters | advanced | | Map | To configure additional options on the trigger.
+| usingFixedCamelContextName | advanced | false | boolean | If it is true JobDataMap uses the CamelContext name directly to reference the CamelContext if it is false JobDataMap uses use the CamelContext management name which could be changed during the deploy time.
+| autoStartScheduler | scheduler | true | boolean | Whether or not the scheduler should be auto started.
+| fireNow | scheduler | false | boolean | If it is true will fire the trigger when the route is start when using SimpleTrigger.
+| startDelayedSeconds | scheduler | | int | Seconds to wait before starting the quartz scheduler.
+| triggerStartDelay | scheduler | 500 | long | In case of scheduler has already started we want the trigger start slightly after current time to ensure endpoint is fully started before the job kicks in.
+|=======================================================================
+{% endraw %}
+// endpoint options: END
+
+
+For example, the following routing rule will fire two timer events to
+the `mock:results` endpoint:
+
+[source,java]
+--------------------------------------------------------------------------------------------------------------------------
+from("quartz2://myGroup/myTimerName?trigger.repeatInterval=2&trigger.repeatCount=1").routeId("myRoute").to("mock:result");
+--------------------------------------------------------------------------------------------------------------------------
+
+When using `stateful=true`, the
+http://quartz-scheduler.org/api/2.0.0/org/quartz/JobDataMap.html[JobDataMap]
+is re-persisted after every execution of the job, thus preserving state
+for the next execution.
+
+INFO: *Running in OSGi and having multiple bundles with quartz
+routes*
+If you run in OSGi such as Apache ServiceMix, or Apache Karaf, and have
+multiple bundles with Camel routes that start from
+link:quartz2.html[Quartz2] endpoints, then make sure if you assign an `id`
+to the <camelContext> that this id is unique, as this is
+required by the `QuartzScheduler` in the OSGi container. If you do not
+set any `id` on <camelContext> then a unique id is auto assigned, and there is no problem.
+
+[[Quartz2-Configuringquartz.propertiesfile]]
+Configuring quartz.properties file
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+By default Quartz will look for a `quartz.properties` file in the
+`org/quartz` directory of the classpath. If you are using WAR
+deployments this means just drop the quartz.properties in
+`WEB-INF/classes/org/quartz`.
+
+However the Camel link:quartz2.html[Quartz2] component also allows you
+to configure properties:
+
+[width="100%",cols="10%,10%,10%,70%",options="header",]
+|=======================================================================
+|Parameter |Default |Type |Description
+
+|`properties` |`null` |`Properties` |You can configure a `java.util.Properties` instance.
+
+|`propertiesFile` |`null` |`String` |File name of the properties to load from the classpath
+|=======================================================================
+
+To do this you can configure this in Spring XML as follows
+
+[source,xml]
+-------------------------------------------------------------------------------
+<bean id="quartz" class="org.apache.camel.component.quartz2.QuartzComponent">
+ <property name="propertiesFile" value="com/mycompany/myquartz.properties"/>
+</bean>
+-------------------------------------------------------------------------------
+
+[[Quartz2-EnablingQuartzschedulerinJMX]]
+Enabling Quartz scheduler in JMX
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+You need to configure the quartz scheduler properties to enable JMX. +
+ That is typically setting the option
+`"org.quartz.scheduler.jmx.export"` to a `true` value in the
+configuration file.
+
+From Camel 2.13 onwards Camel will automatic set this option to true,
+unless explicit disabled.
+
+[[Quartz2-StartingtheQuartzscheduler]]
+Starting the Quartz scheduler
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The link:quartz2.html[Quartz2] component offers an option to let the
+Quartz scheduler be started delayed, or not auto started at all.
+
+This is an example:
+
+[source,xml]
+------------------------------------------------------------------------------
+<bean id="quartz2" class="org.apache.camel.component.quartz2.QuartzComponent">
+ <property name="startDelayedSeconds" value="5"/>
+</bean>
+------------------------------------------------------------------------------
+
+[[Quartz2-Clustering]]
+Clustering
+^^^^^^^^^^
+
+If you use Quartz in clustered mode, e.g. the `JobStore` is clustered.
+Then the link:quartz2.html[Quartz2] component will *not* pause/remove
+triggers when a node is being stopped/shutdown. This allows the trigger
+to keep running on the other nodes in the cluster.
+
+*Note*: When running in clustered node no checking is done to ensure
+unique job name/group for endpoints.
+
+[[Quartz2-MessageHeaders]]
+Message Headers
+^^^^^^^^^^^^^^^
+
+Camel adds the getters from the Quartz Execution Context as header
+values. The following headers are added: +
+ `calendar`, `fireTime`, `jobDetail`, `jobInstance`, `jobRuntTime`,
+`mergedJobDataMap`, `nextFireTime`, `previousFireTime`, `refireCount`,
+`result`, `scheduledFireTime`, `scheduler`, `trigger`, `triggerName`,
+`triggerGroup`.
+
+The `fireTime` header contains the `java.util.Date` of when the exchange
+was fired.
+
+[[Quartz2-UsingCronTriggers]]
+Using Cron Triggers
+^^^^^^^^^^^^^^^^^^^
+
+Quartz supports
+http://www.quartz-scheduler.org/documentation/quartz-2.x/tutorials/crontrigger[Cron-like
+expressions] for specifying timers in a handy format. You can use these
+expressions in the `cron` URI parameter; though to preserve valid URI
+encoding we allow + to be used instead of spaces.
+
+For example, the following will fire a message every five minutes
+starting at 12pm (noon) to 6pm on weekdays:
+
+[source,java]
+------------------------------------------------------------------------------------------------
+from("quartz2://myGroup/myTimerName?cron=0+0/5+12-18+?+*+MON-FRI").to("activemq:Totally.Rocks");
+------------------------------------------------------------------------------------------------
+
+which is equivalent to using the cron expression
+
+[source,java]
+-----------------------
+0 0/5 12-18 ? * MON-FRI
+-----------------------
+
+The following table shows the URI character encodings we use to preserve
+valid URI syntax:
+
+[width="100%",cols="50%,50%",options="header",]
+|=======================================================================
+|URI Character |Cron character
+
+|`+` | _Space_
+|=======================================================================
+
+[[Quartz2-Specifyingtimezone]]
+Specifying time zone
+^^^^^^^^^^^^^^^^^^^^
+
+The Quartz Scheduler allows you to configure time zone per trigger. For
+example to use a timezone of your country, then you can do as follows:
+
+[source,java]
+--------------------------------------------------------------------------------------------
+quartz2://groupName/timerName?cron=0+0/5+12-18+?+*+MON-FRI&trigger.timeZone=Europe/Stockholm
+--------------------------------------------------------------------------------------------
+
+The timeZone value is the values accepted by `java.util.TimeZone`.
+
+[[Quartz2-UsingQuartzScheduledPollConsumerScheduler]]
+Using QuartzScheduledPollConsumerScheduler
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The link:quartz2.html[Quartz2] component provides a
+link:polling-consumer.html[Polling Consumer] scheduler which allows to
+use cron based scheduling for link:polling-consumer.html[Polling
+Consumer] such as the link:file2.html[File] and link:ftp2.html[FTP]
+consumers.
+
+For example to use a cron based expression to poll for files every 2nd
+second, then a Camel route can be define simply as:
+
+[source,java]
+---------------------------------------------------------------------
+ from("file:inbox?scheduler=quartz2&scheduler.cron=0/2+*+*+*+*+?")
+ .to("bean:process");
+---------------------------------------------------------------------
+
+Notice we define the `scheduler=quartz2` to instruct Camel to use the
+link:quartz2.html[Quartz2] based scheduler. Then we use `scheduler.xxx`
+options to configure the scheduler. The link:quartz2.html[Quartz2]
+scheduler requires the cron option to be set.
+
+The following options is supported:
+
+[width="100%",cols="10%,10%,10%,70%",options="header",]
+|=======================================================================
+|Parameter |Default |Type |Description
+
+|`quartzScheduler` |`null` |`org.quartz.Scheduler` |To use a custom Quartz scheduler. If none configure then the shared
+scheduler from the link:quartz2.html[Quartz2] component is used.
+
+|`cron` |`null` |`String` |*Mandatory*: To define the cron expression for triggering the polls.
+
+|`triggerId` |`null` |`String` |To specify the trigger id. If none provided then an UUID is generated
+and used.
+
+|`triggerGroup` |`QuartzScheduledPollConsumerScheduler` |`String` |To specify the trigger group.
+
+|`timeZone` |`Default` |`TimeZone` |The time zone to use for the CRON trigger.
+|=======================================================================
+
+*Important:* Remember configuring these options from the endpoint
+link:uris.html[URIs] must be prefixed with `scheduler.`.
+For example to configure the trigger id and group:
+
+[source,java]
+-----------------------------------------------------------------------------------------------------------------------------
+ from("file:inbox?scheduler=quartz2&scheduler.cron=0/2+*+*+*+*+?&scheduler.triggerId=myId&scheduler.triggerGroup=myGroup")
+ .to("bean:process");
+-----------------------------------------------------------------------------------------------------------------------------
+
+There is also a CRON scheduler in link:spring.html[Spring], so you can
+use the following as well:
+
+[source,java]
+--------------------------------------------------------------------
+ from("file:inbox?scheduler=spring&scheduler.cron=0/2+*+*+*+*+?")
+ .to("bean:process");
+--------------------------------------------------------------------
+
+[[Quartz2-SeeAlso]]
+See Also
+^^^^^^^^
+
+* link:configuring-camel.html[Configuring Camel]
+* link:component.html[Component]
+* link:endpoint.html[Endpoint]
+* link:getting-started.html[Getting Started]
+
+* link:quartz.html[Quartz]
+* link:timer.html[Timer]
+
http://git-wip-us.apache.org/repos/asf/camel/blob/e27f6320/components/camel-rabbitmq/src/main/docs/rabbitmq.adoc
----------------------------------------------------------------------
diff --git a/components/camel-rabbitmq/src/main/docs/rabbitmq.adoc b/components/camel-rabbitmq/src/main/docs/rabbitmq.adoc
new file mode 100644
index 0000000..2e59a32
--- /dev/null
+++ b/components/camel-rabbitmq/src/main/docs/rabbitmq.adoc
@@ -0,0 +1,252 @@
+[[RabbitMQ-RabbitMQComponent]]
+RabbitMQ Component
+~~~~~~~~~~~~~~~~~~
+
+*Available as of Camel 2.12*
+
+The *rabbitmq:* component allows you produce and consume messages from
+http://www.rabbitmq.com/[RabbitMQ] instances. Using the RabbitMQ AMQP
+client, this component offers a pure RabbitMQ approach over the generic
+http://camel.apache.org/amqp.html[AMQP] component.
+
+Maven users will need to add the following dependency to their `pom.xml`
+for this component:
+
+[source,xml]
+------------------------------------------------------------
+<dependency>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-rabbitmq</artifactId>
+ <version>x.x.x</version>
+ <!-- use the same version as your Camel core version -->
+</dependency>
+------------------------------------------------------------
+
+[[RabbitMQ-URIformat]]
+URI format
+^^^^^^^^^^
+
+[source,java]
+-------------------------------------------------
+rabbitmq://hostname[:port]/exchangeName?[options]
+-------------------------------------------------
+
+Where *hostname* is the hostname of the running rabbitmq instance or
+cluster. Port is optional and if not specified then defaults to the
+RabbitMQ client default (5672). The exchange name determines which
+exchange produced messages will sent to. In the case of consumers, the
+exchange name determines which exchange the queue will bind to.
+
+[[RabbitMQ-Options]]
+Options
+^^^^^^^
+
+
+// component options: START
+The RabbitMQ component has no options.
+// component options: END
+
+
+
+// endpoint options: START
+The RabbitMQ component supports 53 endpoint options which are listed below:
+
+{% raw %}
+[width="100%",cols="2s,1,1m,1m,5",options="header"]
+|=======================================================================
+| Name | Group | Default | Java Type | Description
+| hostname | common | | String | *Required* The hostname of the running rabbitmq instance or cluster.
+| portNumber | common | 5672 | int | *Required* Port number for the host with the running rabbitmq instance or cluster. Default value is 5672.
+| exchangeName | common | | String | *Required* The exchange name determines which exchange produced messages will sent to. In the case of consumers the exchange name determines which exchange the queue will bind to.
+| autoDelete | common | true | boolean | If it is true the exchange will be deleted when it is no longer in use
+| connectionTimeout | common | 60000 | int | Connection timeout
+| deadLetterExchange | common | | String | The name of the dead letter exchange
+| deadLetterExchangeType | common | direct | String | The type of the dead letter exchange
+| deadLetterQueue | common | | String | The name of the dead letter queue
+| deadLetterRoutingKey | common | | String | The routing key for the dead letter exchange
+| declare | common | true | boolean | If the option is true camel declare the exchange and queue name and bind them together. If the option is false camel won't declare the exchange and queue name on the server.
+| durable | common | true | boolean | If we are declaring a durable exchange (the exchange will survive a server restart)
+| exchangeType | common | direct | String | The exchange type such as direct or topic.
+| queue | common | | String | The queue to receive messages from
+| routingKey | common | | String | The routing key to use when binding a consumer queue to the exchange. For producer routing keys you set the header rabbitmq.ROUTING_KEY.
+| skipExchangeDeclare | common | false | boolean | This can be used if we need to declare the queue but not the exchange
+| skipQueueDeclare | common | false | boolean | If true the producer will not declare and bind a queue. This can be used for directing messages via an existing routing key.
+| vhost | common | / | String | The vhost for the channel
+| autoAck | consumer | true | boolean | If messages should be auto acknowledged
+| bridgeErrorHandler | consumer | false | boolean | Allows for bridging the consumer to the Camel routing Error Handler which mean any exceptions occurred while the consumer is trying to pickup incoming messages or the likes will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions that will be logged at WARN/ERROR level and ignored.
+| concurrentConsumers | consumer | 1 | int | Number of concurrent consumers when consuming from broker. (eg similar as to the same option for the JMS component).
+| prefetchCount | consumer | | int | The maximum number of messages that the server will deliver 0 if unlimited. You need to specify the option of prefetchSize prefetchCount prefetchGlobal at the same time
+| prefetchEnabled | consumer | false | boolean | Enables the quality of service on the RabbitMQConsumer side. You need to specify the option of prefetchSize prefetchCount prefetchGlobal at the same time
+| prefetchGlobal | consumer | false | boolean | If the settings should be applied to the entire channel rather than each consumer You need to specify the option of prefetchSize prefetchCount prefetchGlobal at the same time
+| prefetchSize | consumer | | int | The maximum amount of content (measured in octets) that the server will deliver 0 if unlimited. You need to specify the option of prefetchSize prefetchCount prefetchGlobal at the same time
+| exceptionHandler | consumer (advanced) | | ExceptionHandler | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this options is not in use. By default the consumer will deal with exceptions that will be logged at WARN/ERROR level and ignored.
+| threadPoolSize | consumer (advanced) | 10 | int | The consumer uses a Thread Pool Executor with a fixed number of threads. This setting allows you to set that number of threads.
+| bridgeEndpoint | producer | false | boolean | If the bridgeEndpoint is true the producer will ignore the message header of rabbitmq.EXCHANGE_NAME and rabbitmq.ROUTING_KEY
+| channelPoolMaxSize | producer | 10 | int | Get maximum number of opened channel in pool
+| channelPoolMaxWait | producer | 1000 | long | Set the maximum number of milliseconds to wait for a channel from the pool
+| immediate | producer | false | boolean | This flag tells the server how to react if the message cannot be routed to a queue consumer immediately. If this flag is set the server will return an undeliverable message with a Return method. If this flag is zero the server will queue the message but with no guarantee that it will ever be consumed. If the header is present rabbitmq.IMMEDIATE it will override this option.
+| mandatory | producer | false | boolean | This flag tells the server how to react if the message cannot be routed to a queue. If this flag is set the server will return an unroutable message with a Return method. If this flag is zero the server silently drops the message. If the header is present rabbitmq.MANDATORY it will override this option.
+| publisherAcknowledgements | producer | false | boolean | When true the message will be published with publisher acknowledgements turned on
+| publisherAcknowledgementsTimeout | producer | | long | The amount of time in milliseconds to wait for a basic.ack response from RabbitMQ server
+| addresses | advanced | | Address[] | If this option is set camel-rabbitmq will try to create connection based on the setting of option addresses. The addresses value is a string which looks like server1:12345 server2:12345
+| automaticRecoveryEnabled | advanced | | Boolean | Enables connection automatic recovery (uses connection implementation that performs automatic recovery when connection shutdown is not initiated by the application)
+| clientProperties | advanced | | Map | Connection client properties (client info used in negotiating with the server)
+| connectionFactory | advanced | | ConnectionFactory | To use a custom RabbitMQ connection factory. When this option is set all connection options (connectionTimeout requestedChannelMax...) set on URI are not used
+| exchangeArgsConfigurer | advanced | | ArgsConfigurer | Set the configurer for setting the exchange args in Channel.exchangeDeclare
+| exchangePattern | advanced | InOnly | ExchangePattern | Sets the default exchange pattern when creating an exchange
+| networkRecoveryInterval | advanced | | Integer | Network recovery interval in milliseconds (interval used when recovering from network failure)
+| queueArgsConfigurer | advanced | | ArgsConfigurer | Set the configurer for setting the queue args in Channel.queueDeclare
+| requestedChannelMax | advanced | 0 | int | Connection requested channel max (max number of channels offered)
+| requestedFrameMax | advanced | 0 | int | Connection requested frame max (max size of frame offered)
+| requestedHeartbeat | advanced | 60 | int | Connection requested heartbeat (heart-beat in seconds offered)
+| requestTimeout | advanced | | long | Set timeout for waiting for a reply when using the InOut Exchange Pattern (in milliseconds)
+| requestTimeoutCheckerInterval | advanced | | long | Set requestTimeoutCheckerInterval for inOut exchange
+| synchronous | advanced | false | boolean | Sets whether synchronous processing should be strictly used or Camel is allowed to use asynchronous processing (if supported).
+| topologyRecoveryEnabled | advanced | | Boolean | Enables connection topology recovery (should topology recovery be performed)
+| transferException | advanced | false | boolean | When true and an inOut Exchange failed on the consumer side send the caused Exception back in the response
+| password | security | guest | String | Password for authenticated access
+| sslProtocol | security | | String | Enables SSL on connection accepted value are true TLS and 'SSLv3
+| trustManager | security | | TrustManager | Configure SSL trust manager SSL should be enabled for this option to be effective
+| username | security | guest | String | Username in case of authenticated access
+|=======================================================================
+{% endraw %}
+// endpoint options: END
+
+
+See
+http://www.rabbitmq.com/releases/rabbitmq-java-client/current-javadoc/com/rabbitmq/client/ConnectionFactory.html[http://www.rabbitmq.com/releases/rabbitmq-java-client/current-javadoc/com/rabbitmq/client/ConnectionFactory.html]
+and the AMQP specification for more information on connection options.
+
+[[RabbitMQ-Customconnectionfactory]]
+Custom connection factory
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+[source,xml]
+----------------------------------------------------------------------------------------
+<bean id="customConnectionFactory" class="com.rabbitmq.client.ConnectionFactory">
+ <property name="host" value="localhost"/>
+ <property name="port" value="5672"/>
+ <property name="username" value="camel"/>
+ <property name="password" value="bugsbunny"/>
+</bean>
+<camelContext>
+ <route>
+ <from uri="direct:rabbitMQEx2"/>
+ <to uri="rabbitmq://localhost:5672/ex2?connectionFactory=#customConnectionFactory"/>
+ </route>
+</camelContext>
+----------------------------------------------------------------------------------------
+
+
+Headers
+
+The following headers are set on exchanges when consuming messages.
+
+[width="100%",cols="10%,90%",options="header",]
+|=======================================================================
+|Property |Value
+
+|`rabbitmq.ROUTING_KEY` |The routing key that was used to receive the message, or the routing key
+that will be used when producing a message
+
+|`rabbitmq.EXCHANGE_NAME` |The exchange the message was received from
+
+|`rabbitmq.DELIVERY_TAG` |The rabbitmq delivery tag of the received message
+
+|`rabbitmq.REQUEUE` |*Camel 2.14.2:* This is used by the consumer to control rejection of the
+message. When the consumer is complete processing the exchange, and if
+the exchange failed, then the consumer is going to reject the message
+from the RabbitMQ broker. The value of this header controls this
+behavior. If the value is false (by default) then the message is
+discarded/dead-lettered. If the value is true, then the message is
+re-queued.�
+|=======================================================================
+
+The following headers are used by the producer. If these are set on the
+camel exchange then they will be set on the RabbitMQ message.
+
+[width="100%",cols="10%,90%",options="header",]
+|=======================================================================
+|Property |Value
+
+|`rabbitmq.ROUTING_KEY` |The routing key that will be used when sending the message
+
+|`rabbitmq.EXCHANGE_NAME` |The exchange the message was received from, or sent to
+
+|`rabbitmq.CONTENT_TYPE` |The contentType to set on the RabbitMQ message
+
+|`rabbitmq.PRIORITY` |The priority header to set on the RabbitMQ message
+
+|`rabbitmq.CORRELATIONID` |The correlationId to set on the RabbitMQ message
+
+|`rabbitmq.MESSAGE_ID` |The message id to set on the RabbitMQ message
+
+|`rabbitmq.DELIVERY_MODE` |If the message should be persistent or not
+
+|`rabbitmq.USERID` |The userId to set on the RabbitMQ message
+
+|`rabbitmq.CLUSTERID` |The clusterId to set on the RabbitMQ message
+
+|`rabbitmq.REPLY_TO` |The replyTo to set on the RabbitMQ message
+
+|`rabbitmq.CONTENT_ENCODING` |The contentEncoding to set on the RabbitMQ message
+
+|`rabbitmq.TYPE` |The type to set on the RabbitMQ message
+
+|`rabbitmq.EXPIRATION` |The expiration to set on the RabbitMQ message
+
+|`rabbitmq.TIMESTAMP` |The timestamp to set on the RabbitMQ message
+
+|`rabbitmq.APP_ID` |The appId to set on the RabbitMQ message
+|=======================================================================
+
+Headers are set by the consumer once the message is received. The
+producer will also set the headers for downstream processors once the
+exchange has taken place. Any headers set prior to production that the
+producer sets will be overriden.
+
+[[RabbitMQ-MessageBody]]
+Message Body
+^^^^^^^^^^^^
+
+The component will use the camel exchange in body as the rabbit mq
+message body. The camel exchange in object must be convertible to a byte
+array. Otherwise the producer will throw an exception of unsupported
+body type.
+
+[[RabbitMQ-Samples]]
+Samples
+^^^^^^^
+
+To receive messages from a queue that is bound to an exchange A with the
+routing key B,
+
+[source,java]
+-------------------------------------------
+from("rabbitmq://localhost/A?routingKey=B")
+-------------------------------------------
+
+To receive messages from a queue with a single thread with auto
+acknowledge disabled.
+
+[source,java]
+--------------------------------------------------------------------------
+from("rabbitmq://localhost/A?routingKey=B&threadPoolSize=1&autoAck=false")
+--------------------------------------------------------------------------
+
+To send messages to an exchange called C
+
+[source,java]
+-------------------------------
+...to("rabbitmq://localhost/B")
+-------------------------------
+
+[[RabbitMQ-SeeAlso]]
+See Also
+^^^^^^^^
+
+* link:configuring-camel.html[Configuring Camel]
+* link:component.html[Component]
+* link:endpoint.html[Endpoint]
+* link:getting-started.html[Getting Started]
+
http://git-wip-us.apache.org/repos/asf/camel/blob/e27f6320/docs/user-manual/en/SUMMARY.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/SUMMARY.md b/docs/user-manual/en/SUMMARY.md
index 4f215ba..2cf6ae4 100644
--- a/docs/user-manual/en/SUMMARY.md
+++ b/docs/user-manual/en/SUMMARY.md
@@ -219,7 +219,9 @@
* [Printer](lpr.adoc)
* [Properties](properties.adoc)
* [Quartz](quartz.adoc)
+ * [Quartz2](quartz2.adoc)
* [Quickfix](quickfix.adoc)
+ * [RabbitMQ](rabbitmq.adoc)
* [Scp](scp.adoc)
* [SJMS](sjms.adoc)
* [SJMS Batch](sjms-batch.adoc)
[4/4] camel git commit: Added camel-routebox docs to Gitbook
Posted by ac...@apache.org.
Added camel-routebox docs to Gitbook
Project: http://git-wip-us.apache.org/repos/asf/camel/repo
Commit: http://git-wip-us.apache.org/repos/asf/camel/commit/7cfced8b
Tree: http://git-wip-us.apache.org/repos/asf/camel/tree/7cfced8b
Diff: http://git-wip-us.apache.org/repos/asf/camel/diff/7cfced8b
Branch: refs/heads/master
Commit: 7cfced8b5beb380c4da05d491a287357f0e17e16
Parents: c29aafb
Author: Andrea Cosentino <an...@gmail.com>
Authored: Thu May 19 10:45:37 2016 +0200
Committer: Andrea Cosentino <an...@gmail.com>
Committed: Thu May 19 10:45:37 2016 +0200
----------------------------------------------------------------------
.../camel-routebox/src/main/docs/routebox.adoc | 281 +++++++++++++++++++
docs/user-manual/en/SUMMARY.md | 1 +
2 files changed, 282 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/camel/blob/7cfced8b/components/camel-routebox/src/main/docs/routebox.adoc
----------------------------------------------------------------------
diff --git a/components/camel-routebox/src/main/docs/routebox.adoc b/components/camel-routebox/src/main/docs/routebox.adoc
new file mode 100644
index 0000000..503d53b
--- /dev/null
+++ b/components/camel-routebox/src/main/docs/routebox.adoc
@@ -0,0 +1,281 @@
+[[Routebox-RouteboxComponent]]
+Routebox Component
+~~~~~~~~~~~~~~~~~~
+
+*Available as of Camel 2.6*
+
+*Routebox subject for change*
+
+The Routebox component will be revisited in upcoming releases to see if
+it can be further simplified, be more intuitive and user friendly. The
+related link:context.html[Context] component may be regardes as the
+simpler component. This component may be @deprecated in favor of
+link:context.html[Context].
+
+The *routebox* component enables the creation of specialized endpoints
+that offer encapsulation and a strategy based indirection service to a
+collection of camel routes hosted in an automatically created or user
+injected camel context.
+
+Routebox endpoints are camel endpoints that may be invoked directly on
+camel routes. The routebox endpoint performs the following key functions
+
+* encapsulation - acts as a blackbox, hosting a collection of camel
+routes stored in an inner camel context. The inner context is fully
+under the control of the routebox component and is *JVM bound*.
+* strategy based indirection - direct payloads sent to the routebox
+endpoint along a camel route to specific inner routes based on a user
+defined internal routing strategy or a dispatch map.
+* exchange propagation - forward exchanges modified by the routebox
+endpoint to the next segment of the camel route.
+
+The routebox component supports both consumer and producer endpoints.
+
+Producer endpoints are of two flavors
+
+* Producers that send or dispatch incoming requests to a external
+routebox consumer endpoint
+* Producers that directly invoke routes in an internal embedded camel
+context thereby not sending requests to an external consumer.
+
+Maven users will need to add the following dependency to their `pom.xml`
+for this component:
+
+[source,xml]
+------------------------------------------------------------
+<dependency>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-routebox</artifactId>
+ <version>x.x.x</version>
+ <!-- use the same version as your Camel core version -->
+</dependency>
+------------------------------------------------------------
+
+[[Routebox-TheneedforaCamelRouteboxendpoint]]
+The need for a Camel Routebox endpoint
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The routebox component is designed to ease integration in complex
+environments needing
+
+* a large collection of routes and
+* involving a wide set of endpoint technologies needing integration in
+different ways
+
+In such environments, it is often necessary to craft an integration
+solution by creating a sense of layering among camel routes effectively
+organizing them into
+
+* Coarse grained or higher level routes - aggregated collection of inner
+or lower level routes exposed as Routebox endpoints that represent an
+integration focus area. For example
+
+[width="100%",cols="50%,50%",options="header",]
+|=======================================================================
+|Focus Area |Coarse grained Route Examples
+
+|Department Focus |HR routes, Sales routes etc
+
+|Supply chain & B2B Focus |Shipping routes, Fulfillment routes, 3rd party services etc
+
+|Technology Focus |Database routes, JMS routes, Scheduled batch routes etc
+|=======================================================================
+
+* Fine grained routes - routes that execute a singular and specific
+business and/or integration pattern.
+
+Requests sent to Routebox endpoints on coarse grained routes can then
+delegate requests to inner fine grained routes to achieve a specific
+integration objective, collect the final inner result, and continue to
+progress to the next step along the coarse-grained route.
+
+[[Routebox-URIformat]]
+URI format
+^^^^^^^^^^
+
+[source,java]
+-------------------------------
+routebox:routeboxname[?options]
+-------------------------------
+
+You can append query options to the URI in the following format,
+`?option=value&option=value&...`
+
+[[Routebox-Options]]
+Options
+^^^^^^^
+
+
+// component options: START
+The RouteBox component has no options.
+// component options: END
+
+
+
+// endpoint options: START
+The RouteBox component supports 18 endpoint options which are listed below:
+
+{% raw %}
+[width="100%",cols="2s,1,1m,1m,5",options="header"]
+|=======================================================================
+| Name | Group | Default | Java Type | Description
+| routeboxName | common | | String | *Required* Logical name for the routebox (eg like a queue name)
+| dispatchMap | common | | Map | A string representing a key in the Camel Registry matching an object value of the type HashMap. The HashMap key should contain strings that can be matched against the value set for the exchange header ROUTE_DISPATCH_KEY. The HashMap value should contain inner route consumer URI's to which requests should be directed.
+| dispatchStrategy | common | | RouteboxDispatchStrategy | To use a custom RouteboxDispatchStrategy which allows to use custom dispatching instead of the default.
+| forkContext | common | true | boolean | Whether to fork and create a new inner CamelContext instead of reusing the same CamelContext.
+| innerProtocol | common | direct | String | The Protocol used internally by the Routebox component. Can be Direct or SEDA. The Routebox component currently offers protocols that are JVM bound.
+| queueSize | common | | int | Create a fixed size queue to receive requests.
+| bridgeErrorHandler | consumer | false | boolean | Allows for bridging the consumer to the Camel routing Error Handler which mean any exceptions occurred while the consumer is trying to pickup incoming messages or the likes will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions that will be logged at WARN/ERROR level and ignored.
+| pollInterval | consumer | 1000 | long | The timeout used when polling from seda. When a timeout occurs the consumer can check whether it is allowed to continue running. Setting a lower value allows the consumer to react more quickly upon shutdown.
+| threads | consumer | 20 | int | Number of threads to be used by the routebox to receive requests.
+| exceptionHandler | consumer (advanced) | | ExceptionHandler | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this options is not in use. By default the consumer will deal with exceptions that will be logged at WARN/ERROR level and ignored.
+| connectionTimeout | producer | 20000 | long | Timeout in millis used by the producer when sending a message.
+| sendToConsumer | producer | true | boolean | Dictates whether a Producer endpoint sends a request to an external routebox consumer. If the setting is false the Producer creates an embedded inner context and processes requests internally.
+| exchangePattern | advanced | InOnly | ExchangePattern | Sets the default exchange pattern when creating an exchange
+| innerContext | advanced | | CamelContext | A string representing a key in the Camel Registry matching an object value of the type org.apache.camel.CamelContext. If a CamelContext is not provided by the user a CamelContext is automatically created for deployment of inner routes.
+| innerProducerTemplate | advanced | | ProducerTemplate | The ProducerTemplate to use by the internal embeded CamelContext
+| innerRegistry | advanced | | Registry | To use a custom registry for the internal embedded CamelContext.
+| routeBuilders | advanced | | String | A string representing a key in the Camel Registry matching an object value of the type List. If the user does not supply an innerContext pre-primed with inner routes the routeBuilders option must be provided as a non-empty list of RouteBuilders containing inner routes
+| synchronous | advanced | false | boolean | Sets whether synchronous processing should be strictly used or Camel is allowed to use asynchronous processing (if supported).
+|=======================================================================
+{% endraw %}
+// endpoint options: END
+
+
+[[Routebox-SendingReceivingMessagestofromtheroutebox]]
+Sending/Receiving Messages to/from the routebox
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Before sending requests it is necessary to properly configure the
+routebox by loading the required URI parameters into the Registry as
+shown below. In the case of Spring, if the necessary beans are declared
+correctly, the registry is automatically populated by Camel.
+
+[[Routebox-Step1:LoadinginnerroutedetailsintotheRegistry]]
+Step 1: Loading inner route details into the Registry
++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+[source,java]
+------------------------------------------------------------------------------------------------------------
+@Override
+protected JndiRegistry createRegistry() throws Exception {
+ JndiRegistry registry = new JndiRegistry(createJndiContext());
+
+ // Wire the routeDefinitions & dispatchStrategy to the outer camelContext where the routebox is declared
+ List<RouteBuilder> routes = new ArrayList<RouteBuilder>();
+ routes.add(new SimpleRouteBuilder());
+ registry.bind("registry", createInnerRegistry());
+ registry.bind("routes", routes);
+
+ // Wire a dispatch map to registry
+ HashMap<String, String> map = new HashMap<String, String>();
+ map.put("addToCatalog", "seda:addToCatalog");
+ map.put("findBook", "seda:findBook");
+ registry.bind("map", map);
+
+ // Alternatively wiring a dispatch strategy to the registry
+ registry.bind("strategy", new SimpleRouteDispatchStrategy());
+
+ return registry;
+}
+
+private JndiRegistry createInnerRegistry() throws Exception {
+ JndiRegistry innerRegistry = new JndiRegistry(createJndiContext());
+ BookCatalog catalogBean = new BookCatalog();
+ innerRegistry.bind("library", catalogBean);
+
+ return innerRegistry;
+}
+...
+CamelContext context = new DefaultCamelContext(createRegistry());
+------------------------------------------------------------------------------------------------------------
+
+[[Routebox-Step2:OptionalyusingaDispatchStrategyinsteadofaDispatchMap]]
+Step 2: Optionaly using a Dispatch Strategy instead of a Dispatch Map
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+Using a dispatch Strategy involves implementing the interface
+_org.apache.camel.component.routebox.strategy.RouteboxDispatchStrategy_
+as shown in the example below.
+
+[source,java]
+-------------------------------------------------------------------------------------------------------------------------------------------------
+public class SimpleRouteDispatchStrategy implements RouteboxDispatchStrategy {
+
+ /* (non-Javadoc)
+ * @see org.apache.camel.component.routebox.strategy.RouteboxDispatchStrategy#selectDestinationUri(java.util.List, org.apache.camel.Exchange)
+ */
+ public URI selectDestinationUri(List<URI> activeDestinations,
+ Exchange exchange) {
+ URI dispatchDestination = null;
+
+ String operation = exchange.getIn().getHeader("ROUTE_DISPATCH_KEY", String.class);
+ for (URI destination : activeDestinations) {
+ if (destination.toASCIIString().equalsIgnoreCase("seda:" + operation)) {
+ dispatchDestination = destination;
+ break;
+ }
+ }
+
+ return dispatchDestination;
+ }
+}
+-------------------------------------------------------------------------------------------------------------------------------------------------
+
+[[Routebox-Step2:Launchingarouteboxconsumer]]
+Step 2: Launching a routebox consumer
++++++++++++++++++++++++++++++++++++++
+
+When creating a route consumer, note that the # entries in the
+routeboxUri are matched to the created inner registry, routebuilder list
+and dispatchStrategy/dispatchMap in the CamelContext Registry. Note that
+all routebuilders and associated routes are launched in the routebox
+created inner context
+
+[source,java]
+----------------------------------------------------------------------------------------------------------------------
+private String routeboxUri = "routebox:multipleRoutes?innerRegistry=#registry&routeBuilders=#routes&dispatchMap=#map";
+
+public void testRouteboxRequests() throws Exception {
+ CamelContext context = createCamelContext();
+ template = new DefaultProducerTemplate(context);
+ template.start();
+
+ context.addRoutes(new RouteBuilder() {
+ public void configure() {
+ from(routeboxUri)
+ .to("log:Routes operation performed?showAll=true");
+ }
+ });
+ context.start();
+
+ // Now use the ProducerTemplate to send the request to the routebox
+ template.requestBodyAndHeader(routeboxUri, book, "ROUTE_DISPATCH_KEY", "addToCatalog");
+}
+----------------------------------------------------------------------------------------------------------------------
+
+[[Routebox-Step3:Usingarouteboxproducer]]
+Step 3: Using a routebox producer
++++++++++++++++++++++++++++++++++
+
+When sending requests to the routebox, it is not necessary for producers
+do not need to know the inner route endpoint URI and they can simply
+invoke the Routebox URI endpoint with a dispatch strategy or dispatchMap
+as shown below
+
+It is necessary to set a special exchange Header called
+*ROUTE_DISPATCH_KEY* (optional for Dispatch Strategy) with a key that
+matches a key in the dispatch map so that the request can be sent to the
+correct inner route
+
+[source,java]
+-----------------------------------------------------------------------------------------------------------
+from("direct:sendToStrategyBasedRoutebox")
+ .to("routebox:multipleRoutes?innerRegistry=#registry&routeBuilders=#routes&dispatchStrategy=#strategy")
+ .to("log:Routes operation performed?showAll=true");
+
+from ("direct:sendToMapBasedRoutebox")
+ .setHeader("ROUTE_DISPATCH_KEY", constant("addToCatalog"))
+ .to("routebox:multipleRoutes?innerRegistry=#registry&routeBuilders=#routes&dispatchMap=#map")
+ .to("log:Routes operation performed?showAll=true");
+-----------------------------------------------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/camel/blob/7cfced8b/docs/user-manual/en/SUMMARY.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/SUMMARY.md b/docs/user-manual/en/SUMMARY.md
index 56c4b6b..61c7c58 100644
--- a/docs/user-manual/en/SUMMARY.md
+++ b/docs/user-manual/en/SUMMARY.md
@@ -224,6 +224,7 @@
* [RabbitMQ](rabbitmq.adoc)
* [Restlet](restlet.adoc)
* [RMI](rmi.adoc)
+ * [Routebox](routebox.adoc)
* [Scp](scp.adoc)
* [SJMS](sjms.adoc)
* [SJMS Batch](sjms-batch.adoc)
[2/4] camel git commit: Added camel-restlet docs to Gitbook
Posted by ac...@apache.org.
Added camel-restlet docs to Gitbook
Project: http://git-wip-us.apache.org/repos/asf/camel/repo
Commit: http://git-wip-us.apache.org/repos/asf/camel/commit/036ee6ba
Tree: http://git-wip-us.apache.org/repos/asf/camel/tree/036ee6ba
Diff: http://git-wip-us.apache.org/repos/asf/camel/diff/036ee6ba
Branch: refs/heads/master
Commit: 036ee6ba10aeee0a08c2f876415904ad39132317
Parents: e27f632
Author: Andrea Cosentino <an...@gmail.com>
Authored: Thu May 19 10:34:27 2016 +0200
Committer: Andrea Cosentino <an...@gmail.com>
Committed: Thu May 19 10:34:27 2016 +0200
----------------------------------------------------------------------
.../camel-restlet/src/main/docs/restlet.adoc | 396 +++++++++++++++++++
docs/user-manual/en/SUMMARY.md | 1 +
2 files changed, 397 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/camel/blob/036ee6ba/components/camel-restlet/src/main/docs/restlet.adoc
----------------------------------------------------------------------
diff --git a/components/camel-restlet/src/main/docs/restlet.adoc b/components/camel-restlet/src/main/docs/restlet.adoc
new file mode 100644
index 0000000..03a3e8a
--- /dev/null
+++ b/components/camel-restlet/src/main/docs/restlet.adoc
@@ -0,0 +1,396 @@
+[[Restlet-RestletComponent]]
+Restlet Component
+~~~~~~~~~~~~~~~~~
+
+The *Restlet* component provides http://www.restlet.org[Restlet] based
+link:endpoint.html[endpoints] for consuming and producing RESTful
+resources.
+
+Maven users will need to add the following dependency to their `pom.xml`
+for this component:
+
+[source,xml]
+------------------------------------------------------------
+<dependency>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-restlet</artifactId>
+ <version>x.x.x</version>
+ <!-- use the same version as your Camel core version -->
+</dependency>
+------------------------------------------------------------
+
+[[Restlet-URIformat]]
+URI format
+^^^^^^^^^^
+
+[source,java]
+----------------------------
+restlet:restletUrl[?options]
+----------------------------
+
+Format of restletUrl:
+
+[source,java]
+--------------------------------------------
+protocol://hostname[:port][/resourcePattern]
+--------------------------------------------
+
+Restlet promotes decoupling of protocol and application concerns. The
+reference implementation of
+http://www.noelios.com/products/restlet-engine[Restlet Engine] supports
+a number of protocols. However, we have tested the HTTP protocol only.
+The default port is port 80. We do not automatically switch default port
+based on the protocol yet.
+
+You can append query options to the URI in the following format,
+`?option=value&option=value&...`
+
+�
+
+INFO: It seems Restlet is case sensitive in understanding headers. For example
+to use content-type, use Content-Type, and for location use Location and
+so on.
+
+WARNING: We have received a report about drop in performance in camel-restlet in
+Camel 2.14.0 and 2.14.1. We have reported this to the Restlet team in
+https://github.com/restlet/restlet-framework-java/issues/996[issue 996].
+To remedy the issue then from Camel 2.14.2 onwards you can set
+synchronous=true as option on the endpoint uris, Or set it on the
+RestletComponent as a global option so all endpoints inherit this
+option.
+
+[[Restlet-Options]]
+Options
+^^^^^^^
+
+
+// component options: START
+The Restlet component supports 20 options which are listed below.
+
+
+
+{% raw %}
+[width="100%",cols="2s,1m,8",options="header"]
+|=======================================================================
+| Name | Java Type | Description
+| controllerDaemon | Boolean | Indicates if the controller thread should be a daemon (not blocking JVM exit).
+| controllerSleepTimeMs | Integer | Time for the controller thread to sleep between each control.
+| inboundBufferSize | Integer | The size of the buffer when reading messages.
+| maxConnectionsPerHost | Integer | Maximum number of concurrent connections per host (IP address).
+| maxThreads | Integer | Maximum threads that will service requests.
+| lowThreads | Integer | Number of worker threads determining when the connector is considered overloaded.
+| maxTotalConnections | Integer | Maximum number of concurrent connections in total.
+| minThreads | Integer | Minimum threads waiting to service requests.
+| outboundBufferSize | Integer | The size of the buffer when writing messages.
+| persistingConnections | Boolean | Indicates if connections should be kept alive after a call.
+| pipeliningConnections | Boolean | Indicates if pipelining connections are supported.
+| threadMaxIdleTimeMs | Integer | Time for an idle thread to wait for an operation before being collected.
+| useForwardedForHeader | Boolean | Lookup the X-Forwarded-For header supported by popular proxies and caches and uses it to populate the Request.getClientAddresses() method result. This information is only safe for intermediary components within your local network. Other addresses could easily be changed by setting a fake header and should not be trusted for serious security checks.
+| reuseAddress | Boolean | Enable/disable the SO_REUSEADDR socket option. See java.io.ServerSocketreuseAddress property for additional details.
+| maxQueued | Integer | Maximum number of calls that can be queued if there aren't any worker thread available to service them. If the value is '0' then no queue is used and calls are rejected if no worker thread is immediately available. If the value is '-1' then an unbounded queue is used and calls are never rejected.
+| disableStreamCache | boolean | Determines whether or not the raw input stream from Restlet is cached or not (Camel will read the stream into a in memory/overflow to file Stream caching) cache. By default Camel will cache the Restlet input stream to support reading it multiple times to ensure Camel can retrieve all data from the stream. However you can set this option to true when you for example need to access the raw stream such as streaming it directly to a file or other persistent store. DefaultRestletBinding will copy the request input stream into a stream cache and put it into message body if this option is false to support reading the stream multiple times.
+| port | int | To configure the port number for the restlet consumer routes. This allows to configure this once to reuse the same port for these consumers.
+| synchronous | Boolean | Whether to use synchronous Restlet Client for the producer. Setting this option to true can yield faster performance as it seems the Restlet synchronous Client works better.
+| enabledConverters | List | A list of converters to enable as full class name or simple class name. All the converters automatically registered are enabled if empty or null
+| headerFilterStrategy | HeaderFilterStrategy | To use a custom HeaderFilterStrategy to filter header to and from Camel message.
+|=======================================================================
+{% endraw %}
+// component options: END
+
+
+
+// endpoint options: START
+The Restlet component supports 21 endpoint options which are listed below:
+
+{% raw %}
+[width="100%",cols="2s,1,1m,1m,5",options="header"]
+|=======================================================================
+| Name | Group | Default | Java Type | Description
+| protocol | common | | String | *Required* The protocol to use which is http or https
+| host | common | | String | *Required* The hostname of the restlet service
+| port | common | 80 | int | *Required* The port number of the restlet service
+| uriPattern | common | | String | The resource pattern such as /customer/id
+| restletMethod | common | GET | Method | On a producer endpoint specifies the request method to use. On a consumer endpoint specifies that the endpoint consumes only restletMethod requests.
+| bridgeErrorHandler | consumer | false | boolean | Allows for bridging the consumer to the Camel routing Error Handler which mean any exceptions occurred while the consumer is trying to pickup incoming messages or the likes will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions that will be logged at WARN/ERROR level and ignored.
+| restletMethods | consumer | | String | Specify one or more methods separated by commas (e.g. restletMethods=postput) to be serviced by a restlet consumer endpoint. If both restletMethod and restletMethods options are specified the restletMethod setting is ignored. The possible methods are: ALLCONNECTDELETEGETHEADOPTIONSPATCHPOSTPUTTRACE
+| restletUriPatterns | consumer | | List | Specify one ore more URI templates to be serviced by a restlet consumer endpoint using the notation to reference a List in the Camel Registry. If a URI pattern has been defined in the endpoint URI both the URI pattern defined in the endpoint and the restletUriPatterns option will be honored.
+| exceptionHandler | consumer (advanced) | | ExceptionHandler | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this options is not in use. By default the consumer will deal with exceptions that will be logged at WARN/ERROR level and ignored.
+| connectTimeout | producer | 30000 | int | The Client will give up connection if the connection is timeout 0 for unlimited wait.
+| socketTimeout | producer | 30000 | int | The Client socket receive timeout 0 for unlimited wait.
+| throwExceptionOnFailure | producer | true | boolean | Whether to throw exception on a producer failure. If this option is false then the http status code is set as a message header which can be checked if it has an error value.
+| autoCloseStream | producer (advanced) | false | boolean | Whether to auto close the stream representation as response from calling a REST service using the restlet producer. If the response is streaming and the option streamRepresentation is enabled then you may want to auto close the InputStream from the streaming response to ensure the input stream is closed when the Camel Exchange is done being routed. However if you need to read the stream outside a Camel route you may need to not auto close the stream.
+| streamRepresentation | producer (advanced) | false | boolean | Whether to support stream representation as response from calling a REST service using the restlet producer. If the response is streaming then this option can be enabled to use an java.io.InputStream as the message body on the Camel Message body. If using this option you may want to enable the autoCloseStream option as well to ensure the input stream is closed when the Camel Exchange is done being routed. However if you need to read the stream outside a Camel route you may need to not auto close the stream.
+| disableStreamCache | advanced | false | boolean | Determines whether or not the raw input stream from Restlet is cached or not (Camel will read the stream into a in memory/overflow to file Stream caching) cache. By default Camel will cache the Restlet input stream to support reading it multiple times to ensure Camel can retrieve all data from the stream. However you can set this option to true when you for example need to access the raw stream such as streaming it directly to a file or other persistent store. DefaultRestletBinding will copy the request input stream into a stream cache and put it into message body if this option is false to support reading the stream multiple times.
+| exchangePattern | advanced | InOnly | ExchangePattern | Sets the default exchange pattern when creating an exchange
+| headerFilterStrategy | advanced | | HeaderFilterStrategy | To use a custom HeaderFilterStrategy to filter header to and from Camel message.
+| restletBinding | advanced | | RestletBinding | To use a custom RestletBinding to bind between Restlet and Camel message.
+| synchronous | advanced | false | boolean | Sets whether synchronous processing should be strictly used or Camel is allowed to use asynchronous processing (if supported).
+| restletRealm | security | | Map | To configure the security realms of restlet as a map.
+| sslContextParameters | security | | SSLContextParameters | To configure security using SSLContextParameters.
+|=======================================================================
+{% endraw %}
+// endpoint options: END
+
+
+[[Restlet-MessageHeaders]]
+Message Headers
+^^^^^^^^^^^^^^^
+
+[width="100%",cols="10%,10%,80%",options="header",]
+|=======================================================================
+|Name |Type |Description
+
+|`Content-Type` |`String` |Specifies the content type, which can be set on the OUT message by the
+application/processor. The value is the `content-type` of the response
+message. If this header is not set, the content type is based on the
+object type of the OUT message body. In Camel 2.3 onward, if the
+Content-Type header is specified in the Camel IN message, the value of
+the header determine the content type for the Restlet request message.��
+Otherwise, it is defaulted to "application/x-www-form-urlencoded'. Prior
+to release 2.3, it is not possible to change the request content type
+default.
+
+|`CamelAcceptContentType` |`String` |*Since Camel 2.9.3, 2.10.0:* The HTTP Accept request header.
+
+|`CamelHttpMethod` |`String` |The HTTP request method. This is set in the IN message header.
+
+|`CamelHttpQuery` |`String` |The query string of the request URI. It is set on the IN message by
+`DefaultRestletBinding` when the restlet component receives a request.
+
+|`CamelHttpResponseCode` |`String` or `Integer` |The response code can be set on the OUT message by the
+application/processor. The value is the response code of the response
+message. If this header is not set, the response code is set by the
+restlet runtime engine.
+
+|`CamelHttpUri` |`String` |The HTTP request URI. This is set in the IN message header.
+
+|`CamelRestletLogin` |`String` |Login name for basic authentication. It is set on the IN message by the
+application and gets filtered before the restlet request header by
+Camel.
+
+|`CamelRestletPassword` |`String` |Password name for basic authentication. It is set on the IN message by
+the application and gets filtered before the restlet request header by
+Camel.
+
+|`CamelRestletRequest` |`Request` |*Camel 2.8:* The `org.restlet.Request` object which holds all request
+details.
+
+|`CamelRestletResponse` |`Response` |*Camel 2.8:* The `org.restlet.Response` object. You can use this to
+create responses using the API from Restlet. See examples below.
+
+|`org.restlet.*` | |Attributes of a Restlet message that get propagated to Camel IN headers.
+
+|`cache-control` |`String` or `List<CacheDirective>` |*Camel 2.11:* User can set the cache-control with the String value or
+the List of CacheDirective of Restlet from the camel message header.
+|=======================================================================
+
+[[Restlet-MessageBody]]
+Message Body
+^^^^^^^^^^^^
+
+Camel will store the restlet response from the external server on the
+OUT body. All headers from the IN message will be copied to the OUT
+message, so that headers are preserved during routing.
+
+[[Restlet-Samples]]
+Samples
+^^^^^^^
+
+[[Restlet-RestletEndpointwithAuthentication]]
+Restlet Endpoint with Authentication
+++++++++++++++++++++++++++++++++++++
+
+The following route starts a `restlet` consumer endpoint that listens
+for `POST` requests on http://localhost:8080. The processor creates a
+response that echoes the request body and the value of the `id` header.
+
+The `restletRealm` setting in the URI query is used to look up a Realm
+Map in the registry. If this option is specified, the restlet consumer
+uses the information to authenticate user logins. Only _authenticated_
+requests can access the resources. In this sample, we create a Spring
+application context that serves as a registry. The bean ID of the Realm
+Map should match the _restletRealmRef_.
+
+The following sample starts a `direct` endpoint that sends requests to
+the server on http://localhost:8080 (that is, our restlet consumer
+endpoint).
+
+That is all we need. We are ready to send a request and try out the
+restlet component:
+
+The sample client sends a request to the `direct:start-auth` endpoint
+with the following headers:
+
+* `CamelRestletLogin` (used internally by Camel)
+* `CamelRestletPassword` (used internally by Camel)
+* `id` (application header)
+
+NOTE: `org.apache.camel.restlet.auth.login` and
+`org.apache.camel.restlet.auth.password` will not be propagated as
+Restlet header.
+
+The sample client gets a response like the following:
+
+[source,text]
+--------------------------------------------------
+received [<order foo='1'/>] as an order id = 89531
+--------------------------------------------------
+
+[[Restlet-SinglerestletendpointtoservicemultiplemethodsandURItemplates]]
+Single restlet endpoint to service multiple methods and URI templates
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+It is possible to create a single route to service multiple HTTP methods
+using the `restletMethods` option. This snippet also shows how to
+retrieve the request method from the header:
+
+In addition to servicing multiple methods, the next snippet shows how to
+create an endpoint that supports multiple URI templates using the
+`restletUriPatterns` option. The request URI is available in the header
+of the IN message as well. If a URI pattern has been defined in the
+endpoint URI (which is not the case in this sample), both the URI
+pattern defined in the endpoint and the `restletUriPatterns` option will
+be honored.
+
+The `restletUriPatterns=#uriTemplates` option references the
+`List<String>` bean defined in the Spring XML configuration.
+
+[source,xml]
+--------------------------------------------------------
+<util:list id="uriTemplates">
+ <value>/users/{username}</value>
+ <value>/atom/collection/{id}/component/{cid}</value>
+</util:list>
+--------------------------------------------------------
+
+[[Restlet-UsingRestletAPItopopulateresponse]]
+Using Restlet API to populate response
+++++++++++++++++++++++++++++++++++++++
+
+*Available as of Camel 2.8*
+
+You may want to use the `org.restlet.Response` API to populate the
+response. This gives you full access to the Restlet API and fine grained
+control of the response. See the route snippet below where we generate
+the response from an inlined Camel link:processor.html[Processor]:
+
+*Generating response using Restlet Response API*
+
+[[Restlet-Configuringmaxthreadsoncomponent]]
+Configuring max threads on component
+++++++++++++++++++++++++++++++++++++
+
+To configure the max threads options you must do this on the component,
+such as:
+
+[source,xml]
+-------------------------------------------------------------------------------
+<bean id="restlet" class="org.apache.camel.component.restlet.RestletComponent">
+ <property name="maxThreads" value="100"/>
+</bean>
+-------------------------------------------------------------------------------
+
+[[Restlet-UsingtheRestletservletwithinawebapp]]
+Using the Restlet servlet within a webapp
++++++++++++++++++++++++++++++++++++++++++
+
+*Available as of Camel 2.8* +
+ There are
+http://www.restlet.org/documentation/2.0/jee/ext/org/restlet/ext/servlet/ServerServlet.html[three
+possible ways] to configure a Restlet application within a servlet
+container and using the subclassed SpringServerServlet enables
+configuration within Camel by injecting the Restlet Component.
+
+Use of the Restlet servlet within a servlet container enables routes to
+be configured with relative paths in URIs (removing the restrictions of
+hard-coded absolute URIs) and for the hosting servlet container to
+handle incoming requests (rather than have to spawn a separate server
+process on a new port).
+
+To configure, add the following to your camel-context.xml;
+
+[source,xml]
+-----------------------------------------------------------------------------------------------
+<camelContext>
+ <route id="RS_RestletDemo">
+ <from uri="restlet:/demo/{id}" />
+ <transform>
+ <simple>Request type : ${header.CamelHttpMethod} and ID : ${header.id}</simple>
+ </transform>
+ </route>
+</camelContext>
+
+<bean id="RestletComponent" class="org.restlet.Component" />
+
+<bean id="RestletComponentService" class="org.apache.camel.component.restlet.RestletComponent">
+ <constructor-arg index="0">
+ <ref bean="RestletComponent" />
+ </constructor-arg>
+</bean>
+-----------------------------------------------------------------------------------------------
+
+And add this to your web.xml;
+
+[source,xml]
+---------------------------------------------------------------------------
+<!-- Restlet Servlet -->
+<servlet>
+ <servlet-name>RestletServlet</servlet-name>
+ <servlet-class>org.restlet.ext.spring.SpringServerServlet</servlet-class>
+ <init-param>
+ <param-name>org.restlet.component</param-name>
+ <param-value>RestletComponent</param-value>
+ </init-param>
+</servlet>
+
+<servlet-mapping>
+ <servlet-name>RestletServlet</servlet-name>
+ <url-pattern>/rs/*</url-pattern>
+</servlet-mapping>
+---------------------------------------------------------------------------
+
+You will then be able to access the deployed route at
+http://localhost:8080/mywebapp/rs/demo/1234 where;
+
+localhost:8080 is the server and port of your servlet container +
+ mywebapp is the name of your deployed webapp +
+ Your browser will then show the following content;
+
+[source,java]
+----------------------------------
+"Request type : GET and ID : 1234"
+----------------------------------
+
+You will need to add dependency on the Spring extension to restlet which
+you can do in your Maven pom.xml file:
+
+[source,xml]
+-------------------------------------------------
+<dependency>
+ <groupId>org.restlet.jee</groupId>
+ <artifactId>org.restlet.ext.spring</artifactId>
+ <version>${restlet-version}</version>
+</dependency>
+-------------------------------------------------
+
+And you would need to add dependency on the restlet maven repository as
+well:
+
+[source,xml]
+--------------------------------------------------
+<repository>
+ <id>maven-restlet</id>
+ <name>Public online Restlet repository</name>
+ <url>http://maven.restlet.org</url>
+</repository>
+--------------------------------------------------
+
+[[Restlet-SeeAlso]]
+See Also
+^^^^^^^^
+
+* link:configuring-camel.html[Configuring Camel]
+* link:component.html[Component]
+* link:endpoint.html[Endpoint]
+* link:getting-started.html[Getting Started]
+
http://git-wip-us.apache.org/repos/asf/camel/blob/036ee6ba/docs/user-manual/en/SUMMARY.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/SUMMARY.md b/docs/user-manual/en/SUMMARY.md
index 2cf6ae4..cadf448 100644
--- a/docs/user-manual/en/SUMMARY.md
+++ b/docs/user-manual/en/SUMMARY.md
@@ -222,6 +222,7 @@
* [Quartz2](quartz2.adoc)
* [Quickfix](quickfix.adoc)
* [RabbitMQ](rabbitmq.adoc)
+ * [Restlet](restlet.adoc)
* [Scp](scp.adoc)
* [SJMS](sjms.adoc)
* [SJMS Batch](sjms-batch.adoc)
[3/4] camel git commit: Added camel-rmi docs to Gitbook
Posted by ac...@apache.org.
Added camel-rmi docs to Gitbook
Project: http://git-wip-us.apache.org/repos/asf/camel/repo
Commit: http://git-wip-us.apache.org/repos/asf/camel/commit/c29aafb2
Tree: http://git-wip-us.apache.org/repos/asf/camel/tree/c29aafb2
Diff: http://git-wip-us.apache.org/repos/asf/camel/diff/c29aafb2
Branch: refs/heads/master
Commit: c29aafb25b28f658c77b77c7f219ddc642408b0d
Parents: 036ee6b
Author: Andrea Cosentino <an...@gmail.com>
Authored: Thu May 19 10:39:18 2016 +0200
Committer: Andrea Cosentino <an...@gmail.com>
Committed: Thu May 19 10:39:18 2016 +0200
----------------------------------------------------------------------
components/camel-rmi/src/main/docs/rmi.adoc | 123 +++++++++++++++++++++++
docs/user-manual/en/SUMMARY.md | 1 +
2 files changed, 124 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/camel/blob/c29aafb2/components/camel-rmi/src/main/docs/rmi.adoc
----------------------------------------------------------------------
diff --git a/components/camel-rmi/src/main/docs/rmi.adoc b/components/camel-rmi/src/main/docs/rmi.adoc
new file mode 100644
index 0000000..3e67331
--- /dev/null
+++ b/components/camel-rmi/src/main/docs/rmi.adoc
@@ -0,0 +1,123 @@
+[[RMI-RMIComponent]]
+RMI Component
+~~~~~~~~~~~~~
+
+The *rmi:* component binds link:exchange.html[Exchange]s to the RMI
+protocol (JRMP).
+
+Since this binding is just using RMI, normal RMI rules still apply
+regarding what methods can be invoked. This component supports only
+Exchanges that carry a method invocation from an interface that extends
+the http://java.sun.com/j2se/1.3/docs/api/java/rmi/Remote.html[Remote]
+interface. All parameters in the method should be either
+http://java.sun.com/j2se/1.5.0/docs/api/java/io/Serializable.html[Serializable]
+or `Remote` objects.
+
+Maven users will need to add the following dependency to their `pom.xml`
+for this component:
+
+[source,xml]
+------------------------------------------------------------
+<dependency>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-rmi</artifactId>
+ <version>x.x.x</version>
+ <!-- use the same version as your Camel core version -->
+</dependency>
+------------------------------------------------------------
+
+[[RMI-URIformat]]
+URI format
+^^^^^^^^^^
+
+[source,java]
+------------------------------------------------------------------
+rmi://rmi-regisitry-host:rmi-registry-port/registry-path[?options]
+------------------------------------------------------------------
+
+For example:
+
+[source,java]
+------------------------------------
+rmi://localhost:1099/path/to/service
+------------------------------------
+
+You can append query options to the URI in the following format,
+`?option=value&option=value&...`
+
+[[RMI-Options]]
+Options
+^^^^^^^
+
+
+// component options: START
+The RMI component has no options.
+// component options: END
+
+
+
+// endpoint options: START
+The RMI component supports 9 endpoint options which are listed below:
+
+{% raw %}
+[width="100%",cols="2s,1,1m,1m,5",options="header"]
+|=======================================================================
+| Name | Group | Default | Java Type | Description
+| hostname | common | localhost | String | Hostname of RMI server
+| name | common | | String | *Required* Name to use when binding to RMI server
+| port | common | 1099 | int | Port number of RMI server
+| method | common | | String | You can set the name of the method to invoke.
+| remoteInterfaces | common | | List | To specific the remote interfaces.
+| bridgeErrorHandler | consumer | false | boolean | Allows for bridging the consumer to the Camel routing Error Handler which mean any exceptions occurred while the consumer is trying to pickup incoming messages or the likes will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions that will be logged at WARN/ERROR level and ignored.
+| exceptionHandler | consumer (advanced) | | ExceptionHandler | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this options is not in use. By default the consumer will deal with exceptions that will be logged at WARN/ERROR level and ignored.
+| exchangePattern | advanced | InOnly | ExchangePattern | Sets the default exchange pattern when creating an exchange
+| synchronous | advanced | false | boolean | Sets whether synchronous processing should be strictly used or Camel is allowed to use asynchronous processing (if supported).
+|=======================================================================
+{% endraw %}
+// endpoint options: END
+
+
+[[RMI-Using]]
+Using
+^^^^^
+
+To call out to an existing RMI service registered in an RMI registry,
+create a route similar to the following:
+
+[source,java]
+------------------------------------------------
+from("pojo:foo").to("rmi://localhost:1099/foo");
+------------------------------------------------
+
+To bind an existing camel processor or service in an RMI registry,
+define an RMI endpoint as follows:
+
+[source,java]
+-------------------------------------------------------------------------
+RmiEndpoint endpoint= (RmiEndpoint) endpoint("rmi://localhost:1099/bar");
+endpoint.setRemoteInterfaces(ISay.class);
+from(endpoint).to("pojo:bar");
+-------------------------------------------------------------------------
+
+Note that when binding an RMI consumer endpoint, you must specify the
+`Remote` interfaces exposed.
+
+In XML DSL you can do as follows from *Camel 2.7* onwards:
+
+[source,xml]
+------------------------------------------------------------------------------------------------------------------------
+ <camel:route>
+ <from uri="rmi://localhost:37541/helloServiceBean?remoteInterfaces=org.apache.camel.example.osgi.HelloService"/>
+ <to uri="bean:helloServiceBean"/>
+ </camel:route>
+------------------------------------------------------------------------------------------------------------------------
+
+[[RMI-SeeAlso]]
+See Also
+^^^^^^^^
+
+* link:configuring-camel.html[Configuring Camel]
+* link:component.html[Component]
+* link:endpoint.html[Endpoint]
+* link:getting-started.html[Getting Started]
+
http://git-wip-us.apache.org/repos/asf/camel/blob/c29aafb2/docs/user-manual/en/SUMMARY.md
----------------------------------------------------------------------
diff --git a/docs/user-manual/en/SUMMARY.md b/docs/user-manual/en/SUMMARY.md
index cadf448..56c4b6b 100644
--- a/docs/user-manual/en/SUMMARY.md
+++ b/docs/user-manual/en/SUMMARY.md
@@ -223,6 +223,7 @@
* [Quickfix](quickfix.adoc)
* [RabbitMQ](rabbitmq.adoc)
* [Restlet](restlet.adoc)
+ * [RMI](rmi.adoc)
* [Scp](scp.adoc)
* [SJMS](sjms.adoc)
* [SJMS Batch](sjms-batch.adoc)