Apache Camel Component Reference
Configuration reference for Camel components
Copyright © 2011-2015 Red Hat, Inc. and/or its affiliates.
Abstract
Chapter 1. Components Overview
Abstract
1.1. List of Components
Table of components
Component | Endpoint URI | Artifact ID | Description |
---|---|---|---|
ActiveMQ | activemq:[queue:|topic:]DestinationName | activemq-core | For JMS Messaging with Apache ActiveMQ. |
AHC | ahc:http[s]://Hostname[:Port][/ResourceUri] | camel-ahc | Calls external HTTP servers using the Async Http Client library. |
AHC-WS | ahc-ws[s]://Hostname[:Port][/ResourceUri] | camel-ahc-ws | Calls external WebSocket servers using the Async Http Client library. |
AMQP | amqp:[queue:|topic:]DestinationName[?Options]] | camel-amqp | For messaging with the AMQP protocol. |
APNS | apns:notify[?Options] apns:consumer[?Options] | camel-apns | For sending notifications to Apple iOS devices. |
Atmosphere-WebSocket | atmosphere-websocket:///RelativePath[?Options] | camel-atmosphere-websocket | Accepts connections from external WebSocket clients using Atmosphere. |
Atom | atom://AtomUri[?Options] | camel-atom | Working with Apache Abdera for atom integration, such as consuming an atom feed. |
Avro | avro:http://Hostname[:Port][?Options] | camel-avro | Working with Apache Avro for data serialization. |
AWS-CW | aws-cw://Namespace[?Options] | camel-aws | For sending metrics to Amazon CloudWatch. |
AWS-DDB | aws-ddb://TableName[?Options] | camel-aws | For working with Amazon's DynamoDB (DDB). |
AWS-SDB | aws-sdb://DomainName[?Options] | camel-aws | For working with Amazon's SimpleDB (SDB). |
AWS-SES | aws-ses://From[?Options] | camel-aws | For working with Amazon's Simple Email Service (SES). |
AWS-S3 | aws-s3://BucketName[?Options] | camel-aws | For working with Amazon's Simple Storage Service (S3). |
AWS-SNS | aws-sns://TopicName[?Options] | camel-aws | For Messaging with Amazon's Simple Notification Service (SNS). |
AWS-SQS | aws-sqs://QueueName[?Options] | camel-aws | For Messaging with Amazon's Simple Queue Service (SQS). |
Bean | bean:BeanID[?methodName=Method] | camel-core | Uses the Bean Binding to bind message exchanges to beans in the Registry. Is also used for exposing and invoking POJO (Plain Old Java Objects). |
Bean Validation | bean-validator:Something[?Options] | camel-bean-validator | Validates the payload of a message using the Java Validation API (JSR 303 and JAXP Validation) and its reference implementation Hibernate Validator. |
Browse | browse: Name | camel-core | Provdes a simple BrowsableEndpoint which can be useful for testing, visualisation tools or debugging. The exchanges sent to the endpoint are all available to be browsed. |
Cache | cache://CacheName[?Options] | camel-cache | The cache component enables you to perform caching operations using EHCache as the Cache Implementation. |
Class | class:ClassName[?method=MethodName] | camel-core | Uses the Bean binding to bind message exchanges to beans in the registry. Is also used for exposing and invoking POJOs (Plain Old Java Objects). |
CMIS | cmis:CmisServerUrl[?Options] | camel-cmis | Uses the Apache Chemistry client API to interface with CMIS supporting CMS. |
Cometd | cometd://Hostname[:Port]/ChannelName[?Options] | camel-cometd | A transport for working with the jetty implementation of the cometd/bayeux protocol. |
Context | context:CamelContextId:LocalEndpointName | camel-context | Refers to an endpoint in a different CamelContext . |
ControlBus | controlbus:Command[?Options] | camel-core | ControlBus Enterprise Integration Pattern that allows you to send messages to endpoints for managing and monitoring your Camel applications. |
CouchDB | couchdb:http://Hostname[:Port] /Database[?Options]://Name[?Options] | camel-couchdb | Allows you to treat CouchDB instances as a producer or consumer of messages. |
Crypto | crypto:sign:Name[?Options] crypto:verify:Name[?Options] | camel-crypto | Sign and verify exchanges using the Signature Service of the Java Cryptographic Extension. |
CXF | cxf://Address[?Options] | camel-cxf | Working with Apache CXF for web services integration. |
CXF Bean | cxf:BeanName | camel-cxf | Proceess the exchange using a JAX WS or JAX RS annotated bean from the registry. |
CXFRS | cxfrs:bean:RsEndpoint[?Options] | camel-cxf | Provides integration with Apache CXF for connecting to JAX-RS services hosted in CXF. |
DataFormat | dataformat:Name:(marshal|unmarshal)[?Options] | camel-core | Enables you to marshal or unmarshal a message in one of the standard Camel data formats, by sending it to an endpoint. |
DataSet | dataset:Name[?Options] | camel-core | For load & soak testing the DataSet provides a way to create huge numbers of messages for sending to Components or asserting that they are consumed correctly. |
Direct | direct:EndpointID[?Options] | camel-core | Synchronous call (single-threaded) to another endpoint from same CamelContext. |
Direct-VM | direct-vm:EndpointID[?Options] | camel-core | Synchronous call (single-threaded) to another endpoint in another CamelContext running in the same JVM. |
Disruptor | disruptor:Name[?Options] disruptor-vm:Name[?Options] | camel-disruptor | Similar to a SEDA endpoint, but uses a Disruptor instead of a blocking queue. |
DNS | dns:Operation | camel-dns | Look up domain information and run DNS queries using DNSJava |
Dropbox | dropbox://[Operation][?Options] | camel-dropbox | Sends or receives messages from Dropbox remote folders. |
ElasticSearch | elasticsearch:ClusterName | camel-elasticsearch | For interfacing with an ElasticSearch server. |
EventAdmin | eventadmin:topic | camel-eventadmin | |
Exec | exec://Executable[?Options] | camel-exec | Execute system command. |
Fabric | fabric:ClusterID[:PublishedURI][?Options] | fabric-camel | Look up or publish a fabric endpoint. |
facebook://[Endpoint][?Options] | camel-facebook | Provides access to all of the Facebook APIs accessible using Facebook4J. | |
File2 | file://DirectoryName[?Options] | camel-core | Sending messages to a file or polling a file or directory. |
Flatpack | flatpack:[fixed|delim]: ConfigFile | camel-flatpack | Processing fixed width or delimited files or messages using the FlatPack library |
FOP | fop:OutputFormat | camel-fop | Renders the message into different output formats using Apache FOP. |
Freemarker | freemarker: TemplateResource | camel-freemarker | Generates a response using a Freemarker template. |
FTP2 | ftp://[Username@]Hostname[:Port]/Directoryname[?Options] | camel-ftp | Sending and receiving files over FTP. |
GAuth | gauth://Name[?Options] | camel-gae | Used by web applications to implement a Google-specific OAuth consumer |
GHTTP | ghttp:///Path[?Options] ghttp://Hostname[:Port]/Path[?Options] ghttps://Hostname[:Port]/Path[?Options] | camel-gae | Provides connectivity to the GAE URL fetch service and can also be used to receive messages from servlets. |
GLogin | glogin://Hostname[:Port][?Options] | camel-gae | Used by Camel applications outside Google App Engine (GAE) for programmatic login to GAE applications. |
GMail | gmail://Username@gmail.com[?Options] gmail://Username@googlemail.com[?Options] | camel-gae | Supports sending of emails via the GAE mail service. |
GTask | gtask://QueueName | camel-gae | Supports asynchronous message processing on GAE using the task queueing service as a message queue. |
Geocoder | geocoder:Address:Name[?Options] geocoder:latlng:Latitude,Longitude[?Options] | camel-geocoder | Looks up geocodes (latitude and longitude) for a given address, or performs reverse look-up. |
GoogleDrive | google-drive://EndpointPrefix/Endpoint[?Options] | camel-google-drive | Provides access to the Google Drive file storage service. |
Guava EventBus | guava-eventbus:BusName[?EventClass=ClassName] | camel-guava-eventbus | The Google Guava EventBus allows publish-subscribe-style communication between components without requiring the components to explicitly register with one another (and thus be aware of each other). This component provides integration bridge between Camel and Google Guava EventBus infrastructure. |
Hazelcast | hazelcast://StoreType:CacheName[?Options] | camel-hazelcast | Hazelcast is a data grid entirely implemented in Java (single JAR). This component supports map, multimap, seda, queue, set, atomic number and simple cluster. |
HBase | hbase://Table[?Options] | camel-hbase | For reading/writing from/to an HBase store (Hadoop database). |
HDFS | hdfs://Hostname[:Port][/Path][?Options] | camel-hdfs | Reads from and writes to a Hadoop Distributed File System (HDFS) using Hadoop 1.x. |
HDFS2 | hdfs2://Hostname[:Port][/Path][?Options] | camel-hdfs2 | Reads from and writes to a Hadoop Distributed File System (HDFS) using Hadoop 2.x. |
HL7 | mina:tcp://Host[:Port] | camel-hl7 | For working with the HL7 MLLP protocol and the HL7 model using the HAPI library. |
HTTP | http://Hostname[:Port][/ResourceUri] | camel-http | For calling out to external HTTP servers, using Apache HTTP Client 3.x. |
HTTP4 | http://Hostname[:Port][/ResourceUri] | camel-http4 | For calling out to external HTTP servers, using Apache HTTP Client 4.x. |
iBATIS | ibatis:OperationName[?Options] | camel-ibatis | Performs a query, poll, insert, update or delete in a relational database using Apache iBATIS. |
IMap | imap://[UserName@]Host[:Port][?Options] | camel-mail | Receiving email using IMap. |
IRC | irc:Host[:Port]/#Room | camel-irc | For IRC communication. |
JavaSpace | javaspace:jini://Host[?Options] | camel-javaspace | Sending and receiving messages through JavaSpace. |
JClouds | jclouds:[Blobstore|ComputService]:Provider | camel-jclouds | For interacting with cloud compute & blobstore service via JClouds. |
JCR | jcr://UserName:Password@Repository/path/to/node | camel-jcr | Storing a message in a JCR (JSR-170) compliant repository like Apache Jackrabbit. |
JDBC | jdbc:DataSourceName[?Options] | camel-jdbc | For performing JDBC queries and operations. |
Jetty | jetty:http://Host[:Port][/ResourceUri] | camel-jetty | For exposing services over HTTP. |
JGroups | jgroups:ClusterName[?Options] | camel-jgroups | Exchanges messages with JGroups clusters. |
Jing |
rng:LocalOrRemoteResource rnc:LocalOrRemoteResource | camel-jing | Validates the payload of a message using RelaxNG or RelaxNG compact syntax. |
JMS | jms:[temp:][queue:|topic:]DestinationName[?Options] | camel-jms | Working with JMS providers. |
JMX | jmx://Platform[?Options] | camel-jmx | For working with JMX notification listeners. |
JPA | jpa:[EntityClassName][?Options] | camel-jpa | For using a database as a queue via the JPA specification for working with OpenJPA, Hibernate or TopLink. |
Jsch | scp://Hostname/Destination | camel-jsch | Support for the scp protocol. |
JT400 | jt400://User:Pwd@System/PathToDTAQ | camel-jt400 | For integrating with data queues on an AS/400 (aka System i, IBM i, i5, ...) system. |
Kafka | kafka://Hostname[:Port][?Options] | camel-kafka | Sends or receives messages from an Apache Kafka message broker. |
Kestrel | kestrel://[AddressList/]Queuename[?Options] | camel-kestrel | For producing to or consuming from Kestrel queues. |
Krati | krati://[PathToDatastore/][?Options] | camel-krati | For producing to or consuming to Krati datastores. |
Language | language://LanguageName[:Script][?Options] | camel-core | Executes language scripts. |
LDAP | ldap:Host[:Port]?base=...[&scope=Scope] | camel-ldap | Performing searches on LDAP servers (Scope must be one of object|onelevel|subtree ). |
LevelDB | N/A | camel-leveldb | A very lightweight and embeddable key-value database. |
List | list:ListID | camel-core | Provides a simple BrowsableEndpoint which can be useful for testing, visualisation tools or debugging. The exchanges sent to the endpoint are all available to be browsed. |
Log | log:LoggingCategory[?level=LoggingLevel] | camel-core | Uses Jakarta Commons Logging to log the message exchange to some underlying logging system like log4j. |
Lucene | lucene:SearcherName:insert[?analyzer=Analyzer] lucene:SearcherName:query[?analyzer=Analyzer] | camel-lucene | Uses Apache Lucene to perform Java-based indexing and full text based searches using advanced analysis/tokenization capabilities. |
Master | REVISIT | ||
Metrics | metrics:[meter|counter|histogram|timer]:Metricname[?Options] | camel-metrics |
Enables you to collect various metrics directly from Camel routes using the Metrics Java library.
|
MINA | mina:tcp://Hostname[:Port][?Options] mina:udp://Hostname[:Port][?Options] mina:multicast://Hostname[:Port][?Options] mina:vm://Hostname[:Port][?Options] | camel-mina | Working with Apache MINA. |
MINA2 | mina2:tcp://Hostname[:Port][?Options] mina2:udp://Hostname[:Port][?Options] mina2:vm://Hostname[:Port][?Options] | camel-mina2 | Working with Apache MINA 2.x. |
Mock | mock:EndpointID | camel-core | For testing routes and mediation rules using mocks. |
MongoDB | mongodb:Connection[?Options] | camel-mongodb | Interacts with MongoDB databases and collections. Offers producer endpoints to perform CRUD-style operations and more against databases and collections, as well as consumer endpoints to listen on collections and dispatch objects to Camel routes. |
MQTT | mqtt:Name | camel-mqtt | Component for communicating with MQTT M2M message brokers |
MSV | msv:LocalOrRemoteResource | camel-msv | Validates the payload of a message using the MSV Library. |
Mustache | mustache:TemplateName[?Options] | camel-mustache | Enables you to process a message using a Mustache template. |
MVEL | mvel:TemplateName[?Options] | camel-mvel | Enables you to process a message using an MVEL template. |
MyBatis | mybatis:StatementName | camel-mybatis | Performs a query, poll, insert, update or delete in a relational database using MyBatis. |
Nagios | nagios://Host[:Port][?Options] | camel-nagios | Sending passive checks to Nagios using JSendNSCA. |
Netty | netty:tcp://localhost:99999[?Options] netty:udp://Remotehost:99999/[?Options] | camel-netty |
Enables you to work with TCP and UDP protocols, using the Java NIO based capabilities offered by Netty version 3.x.
|
Netty4 | netty4:tcp://localhost:99999[?Options] netty4:udp://Remotehost:99999/[?Options] | camel-netty4 |
Enables you to work with TCP and UDP protocols, using the Java NIO based capabilities offered by Netty version 4.x.
|
Netty HTTP | netty-http:http://Hostname[:Port][?Options] | camel-netty-http | An extension to the Netty component, facilitating the HTTP transport, using Netty version 3.x. |
Netty4 HTTP | netty4-http:http://Hostname[:Port][?Options] | camel-netty4-http | An extension to the Netty component, facilitating the HTTP transport, using Netty version 4.x. |
Olingo2 | olingo2://Endpoint/ResourcePath[?Options] | camel-olingo2 |
Communicates with OData 2.0 services using Apache Olingo 2.0.
|
Pax-Logging | paxlogging:Appender | camel-paxlogging |
Receives Pax Logging events in the context of an OSGi container.
|
POP | pop3://[UserName@]Host[:Port][?Options] | camel-mail | Receives email using POP3 and JavaMail. |
Printer | lpr://localhost[:Port]/default[?Options] lpr://RemoteHost[:Port]/path/to/printer[?Options] | camel-printer | Provides a way to direct payloads on a route to a printer. |
Properties | properties://Key[?Options] | camel-properties | Facilitates using property placeholders directly in endpoint URI definitions. |
Quartz | quartz://[GroupName/]TimerName[?Options] quartz://GroupName/TimerName/CronExpression | camel-quartz | Provides a scheduled delivery of messages using the Quartz scheduler. |
Quartz2 | quartz2://[GroupName/]TimerName[?Options] quartz2://GroupName/TimerName/CronExpression | camel-quartz2 | Provides a scheduled delivery of messages using the Quartz Scheduler 2.x. |
Quickfix | quickfix-server:ConfigFile quickfix-client:ConfigFile | camel-quickfix | Implementation of the QuickFix for Java engine which allow to send/receive FIX messages. |
RabbitMQ | rabbitmq://Hostname[:Port]/ExchangeName[?Options] | camel-rabbitmq | Enables you to produce and consume messages from a RabbitMQ instance. |
Ref | ref:EndpointID | camel-core | Component for lookup of existing endpoints bound in the Registry. |
Restlet | restlet:RestletUrl[?Options] | camel-restlet | Component for consuming and producing Restful resources using Restlet. |
RMI | rmi://RmiRegistryHost:RmiRegistryPort/RegistryPath | camel-rmi | Working with RMI. |
Routebox | routebox:routeboxName[?Options] | camel-routebox | |
RSS | rss:Uri | camel-rss | Working with ROME for RSS integration, such as consuming an RSS feed. |
RNC | rnc:LocalOrRemoteResource | camel-jing | Validates the payload of a message using RelaxNG Compact Syntax. |
RNG | rng:LocalOrRemoteResource | camel-jing | Validates the payload of a message using RelaxNG. |
Salesforce | salesforce:Topic[?Options] | camel-salesforce | Enables producer and consumer endpoints to communicate with Salesforce using Java DTOs. |
SAP | sap:[destination:DestinationName|server:ServerName]rfcName[?Options] | camel-sap | Enables outbound and inbound communication to and from SAP systems using synchronous remote function calls, sRFC. |
Chapter 124, SAP NetWeaver | sap-netweaver:https://Hostname[:Port]/Path[?Options] | camel-sap-netweaver | Integrates with the SAP NetWeaver Gateway using HTTP transports. |
Schematron | schematron://Path[?Options] | camel-schematron | Validates XML documents using Schematron. |
SEDA | seda:EndpointID | camel-core | Used to deliver messages to a java.util.concurrent.BlockingQueue, useful when creating SEDA style processing pipelines within the same CamelContext. |
SERVLET | servlet://RelativePath[?Options] | camel-servlet | Provides HTTP based endpoints for consuming HTTP requests that arrive at a HTTP endpoint and this endpoint is bound to a published Servlet. |
ServletListener | N/A | camel-servletlistener | Used for bootstrapping Camel applications in Web applications. |
SFTP | sftp://[Username@]Hostname[:Port]/Directoryname[?Options] | camel-ftp | Sending and receiving files over SFTP. |
Sip | sip://User@Hostname[:Port][?Options] sips://User@Hostname[:Port][?Options] | camel-sip | Publish/subscribe communication capability using the telecom SIP protocol. RFC3903 - Session Initiation Protocol (SIP) Extension for Event |
SJMS | sjms:[queue:|topic:]destinationName[?Options] | camel-sjms | A JMS client for Camel that employs best practices for JMS client creation and configuration. |
SMPP | smpp://UserInfo@Host[:Port][?Options] | camel-smpp | To send and receive SMS using Short Messaging Service Center using the JSMPP library. |
SMTP | smtp://[UserName@]Host[:Port][?Options] | camel-mail | Sending email using SMTP and JavaMail. |
SNMP | snmp://Hostname[:Port][?Options] | camel-snmp | Gives you the ability to poll SNMP capable devices or receive traps. |
Solr | solr://Hostname[:Port]/Solr[?Options] | camel-solr | Uses the Solrj client API to interface with an Apache Lucene Solr server. |
Splunk | splunk://Endpoint[?Options] | camel-splunk | Enables you to publish events and search for events in Splunk. |
Spring Batch | spring-batch:Job[?Options] | camel-spring-batch | To bridge Camel and Spring Batch. |
Spring Event | spring-event://dummy | camel-spring | Publishes or consumes Spring ApplicationEvents objects in a Spring context. |
Spring Integration | spring-integration:DefaultChannelName[?Options] | camel-spring-integration | The bridge component of Camel and Spring Integration. |
Spring LDAP | spring-ldap:SpringLdapTemplate[?Options] | camel-spring-ldap | Provides a Camel wrapper for Spring LDAP. |
Spring Redis | spring-redis://Hostname[:Port][?Options] | camel-spring-redis | Enables sending and receiving messages from Redis, which is an advanced key-value store, where keys can contain strings, hashes, lists, sets and sorted sets. |
Spring Web Services | spring-ws:[MappingType:]Address[?Options] | camel-spring-ws | Client-side support for accessing web services, and server-side support for creating your own contract-first web services using Spring Web Services. |
SQL | sql:SqlQueryString[?Options] | camel-sql | Performing SQL queries using JDBC. |
SSH | ssh:[Username[:Password]@]Host[:Port][?Options] | camel-ssh | For sending commands to a SSH server. |
StAX | stax:ContentHandlerClassName | camel-stax | Process messages through a SAX ContentHandler. |
Stomp | stomp:queue:Destination[?Options] | camel-stomp | For sending messages to or receiving messages from a Stomp compliant broker, such as Apache ActiveMQ. |
Stream | stream:[in|out|err|header][?Options] | camel-stream | Read or write to an input/output/error/file stream rather like Unix pipes. |
String Template | string-template:TemplateURI[?Options] | camel-stringtemplate | Generates a response using a String Template. |
Stub | stub:SomeOtherCamelUri | camel-core | Allows you to stub out some physical middleware endpoint for easier testing or debugging. |
Test | test:RouterEndpointUri | camel-spring | Creates a Mock endpoint which expects to receive all the message bodies that could be polled from the given underlying endpoint. |
Timer | timer:EndpointID[?Options] | camel-core | A timer endpoint. |
twitter://[Endpoint][?Options] | camel-twitter | A Twitter endpoint. | |
UrlRewrite | N/A | camel-urlrewrite | Enables you to plug URL rewrite functionality into the HTTP, HTTP4, Jetty, or AHC components. |
Validation | validator:LocalOrRemoteResource | camel-spring | Validates the payload of a message using XML Schema and JAXP Validation. |
Velocity | velocity:TemplateURI[?Options] | camel-velocity | Generates a response using an Apache Velocity template. |
Vertx | vertx:ChannelName[?Options] | camel-vertx | For working with the Vertx Event Bus. |
VM | vm:EndpointID | camel-core | Used to deliver messages to a java.util.concurrent.BlockingQueue, useful when creating SEDA style processing pipelines within the same JVM. |
Weather | weather://DummyName[?Options] | camel-weather | Polls weather information from Open Weather Map: a site that provides free global weather and forecast information. |
Websocket | websocket://Hostname[:Port]/Path | camel-websocket | Communicating with Websocket clients. |
XML RPC | xmlrpc://ServerURI[?Options] | camel-xmlrpc | Provides a data format for XML, which allows serialization and deserialization of request messages and response message using Apache XmlRpc's bindary data format. |
XML Security | N/A | camel-xmlsecurity | Generate and validate XML signatures as described in the W3C standard XML Signature Syntax and Processing. |
XMPP | xmpp:Hostname[:Port][/Room] | camel-xmpp | Working with XMPP and Jabber. |
XQuery | xquery:TemplateURI | camel-saxon | Generates a response using an XQuery template. |
XSLT | xslt:TemplateURI[?Options] | camel-spring | Enables you to process a message using an XSLT template. |
Yammer | yammer:[function][?Options] | camel-yammer | Enables you to interact with the Yammer enterprise social network. |
Zookeeper | zookeeper://Hostname[:Port]/Path | camel-zookeeper | Working with ZooKeeper cluster(s). |
Chapter 2. ActiveMQ
ActiveMQ Component
JmsTemplate
for sending and a MessageListenerContainer
for consuming. All the options from the JMS component also apply for this component.
activemq.jar
or activemq-core.jar
on your classpath along with any Apache Camel dependencies such as camel-core.jar
, camel-spring.jar
and camel-jms.jar
.
URI format
activemq:[queue:|topic:]destinationName
FOO.BAR
, use:
activemq:FOO.BAR
queue:
prefix, if you prefer:
activemq:queue:FOO.BAR
topic:
prefix. For example, to connect to the topic, Stocks.Prices
, use:
activemq:topic:Stocks.Prices
Options
Configuring the Connection Factory
activeMQComponent()
method while specifying the brokerURL used to connect to ActiveMQ.
camelContext.addComponent("activemq", activeMQComponent("vm://localhost?broker.persistent=false"));
Configuring the Connection Factory using Spring XML
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd"> <camelContext xmlns="http://camel.apache.org/schema/spring"> </camelContext> <bean id="activemq" class="org.apache.activemq.camel.component.ActiveMQComponent"> <property name="brokerURL" value="tcp://somehost:61616"/> </bean> </beans>
Using connection pooling
<dependency> <groupId>org.apache.activemq</groupId> <artifactId>activemq-pool</artifactId> <version>5.3.2</version> </dependency>
<bean id="jmsConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory"> <property name="brokerURL" value="tcp://localhost:61616" /> </bean> <bean id="pooledConnectionFactory" class="org.apache.activemq.pool.PooledConnectionFactory" init-method="start" destroy-method="stop"> <property name="maxConnections" value="8" /> <property name="connectionFactory" ref="jmsConnectionFactory" /> </bean> <bean id="jmsConfig" class="org.apache.camel.component.jms.JmsConfiguration"> <property name="connectionFactory" ref="pooledConnectionFactory"/> <property name="concurrentConsumers" value="10"/> </bean> <bean id="activemq" class="org.apache.activemq.camel.component.ActiveMQComponent"> <property name="configuration" ref="jmsConfig"/> </bean>
PooledConnectionFactory
will then create a connection pool with up to 8 connections in use at the same time. Each connection can be shared by many sessions. There is an option named maxActive
you can use to configure the maximum number of sessions per connection; the default value is 500
. From ActiveMQ 5.7 onwards the option has been renamed to better reflect its purpose, being named as maxActiveSessionPerConnection
. Notice the concurrentConsumers
is set to a higher value than maxConnections
is. This is okay, as each consumer is using a session, and as a session can share the same connection, we are in the safe. In this example we can have 8 * 500 = 4000 active sessions at the same time.
Invoking MessageListener POJOs in a route
public class MyListener implements MessageListener { public void onMessage(Message jmsMessage) { // ... } }
from("file://foo/bar"). bean(MyListener.class);
MessageListener
POJO\!
Using ActiveMQ Destination Options
<camelContext xmlns="http://camel.apache.org/schema/spring"> <route> <from uri="file://src/test/data?noop=true"/> <to uri="activemq:queue:foo"/> </route> <route> <!-- use consumer.exclusive ActiveMQ destination option, notice we have to prefix with destination. --> <from uri="activemq:foo?destination.consumer.exclusive=true&estination.consumer.prefetchSize=50"/> <to uri="mock:results"/> </route> </camelContext>
Consuming Advisory Messages
<route> <from uri="activemq:topic:ActiveMQ.Advisory.Connection?mapJmsMessage=false" /> <convertBodyTo type="java.lang.String"/> <transform> <simple>${in.body} </simple> </transform> <to uri="file://data/activemq/?fileExist=Append&ileName=advisoryConnection-${date:now:yyyyMMdd}.txt" /> </route>
ActiveMQMessage {commandId = 0, responseRequired = false, messageId = ID:dell-charles-3258-1268399815140 -1:0:0:0:221, originalDestination = null, originalTransactionId = null, producerId = ID:dell-charles- 3258-1268399815140-1:0:0:0, destination = topic://ActiveMQ.Advisory.Connection, transactionId = null, expiration = 0, timestamp = 0, arrival = 0, brokerInTime = 1268403383468, brokerOutTime = 1268403383468, correlationId = null, replyTo = null, persistent = false, type = Advisory, priority = 0, groupID = null, groupSequence = 0, targetConsumerId = null, compressed = false, userID = null, content = null, marshalledProperties = org.apache.activemq.util.ByteSequence@17e2705, dataStructure = ConnectionInfo {commandId = 1, responseRequired = true, connectionId = ID:dell-charles-3258-1268399815140-2:50, clientId = ID:dell-charles-3258-1268399815140-14:0, userName = , password = *****, brokerPath = null, brokerMasterConnector = false, manageable = true, clientMaster = true}, redeliveryCounter = 0, size = 0, properties = {originBrokerName=master, originBrokerId=ID:dell-charles- 3258-1268399815140-0:0, originBrokerURL=vm://master}, readOnlyProperties = true, readOnlyBody = true, droppable = false}
Getting Component JAR
activemq-camel
<dependency> <groupId>org.apache.activemq</groupId> <artifactId>activemq-camel</artifactId> <version>5.6.0</version> </dependency>
Chapter 3. AHC
Async Http Client (AHC) Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-ahc</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
ahc:http://hostname[:port][/resourceUri][?options] ahc:https://hostname[:port][/resourceUri][?options]
?option=value&option=value&...
AhcEndpoint Options
Name | Default Value | Description |
---|---|---|
throwExceptionOnFailure
|
true
|
Option to disable throwing the AhcOperationFailedException in case of failed responses from the remote server. This allows you to get all responses regardless of the HTTP status code.
|
bridgeEndpoint
|
false
|
If the option is true, then the Exchange.HTTP_URI header is ignored, and use the endpoint's URI for request. You may also set the throwExcpetionOnFailure to be false to let the AhcProducer send all the fault response back. |
transferException
|
false
|
If enabled and an Exchange failed processing on the consumer side, and if the caused Exception was send back serialized in the response as a application/x-java-serialized-object content type (for example using Jetty or Servlet Camel components). On the producer side the exception will be deserialized and thrown as is, instead of the AhcOperationFailedException . The caused exception is required to be serialized.
|
client
|
null
|
To use a custom com.ning.http.client.AsyncHttpClient .
|
clientConfig
|
null
|
To configure the AsyncHttpClient to use a custom com.ning.http.client.AsyncHttpClientConfig .
|
clientConfig.x
|
null
|
To configure additional properties of the com.ning.http.client.AsyncHttpClientConfig instance used by the endpoint. Note that configuration options set using this parameter will be merged with those set using the clientConfig parameter or the instance set at the component level with properties set using this parameter taking priority.
|
clientConfig.realm.x
|
null
|
Camel 2.11: To configure realm properties of the com.ning.http.client.AsyncHttpClientConfig The options which can be used are the options from com.ning.http.client.Realm.RealmBuilder . eg to set scheme, you can configure "clientConfig.realm.scheme=DIGEST"
|
binding
|
null
|
To use a custom org.apache.camel.component.ahc.AhcBinding .
|
sslContextParameters
|
null
|
Camel 2.9: Reference to a org.apache.camel.util.jsse.SSLContextParameters in the CAMEL:Registry. This reference overrides any configured SSLContextParameters at the component level. See Using the JSSE Configuration Utility. Note that configuring this option will override any SSL/TLS configuration options provided through the clientConfig option at the endpoint or component level.
|
bufferSize
|
4096
|
Camel 2.10.3: The initial in-memory buffer size used when transferring data between Camel and AHC Client. |
AhcComponent Options
Name | Default Value | Description |
---|---|---|
client
|
null
|
To use a custom com.ning.http.client.AsyncHttpClient .
|
clientConfig
|
null
|
To configure the AsyncHttpClient s use a custom com.ning.http.client.AsyncHttpClientConfig .
|
binding
|
null
|
To use a custom org.apache.camel.component.ahc.AhcBinding .
|
sslContextParameters
|
null
|
Camel 2.9: To configure custom SSL/TLS configuration options at the component level. See Using the JSSE Configuration Utility for more details. Note that configuring this option will override any SSL/TLS configuration options provided through the clientConfig option at the endpoint or component level. |
AhcComponent
will propagate those options to AhcEndpoint
s being created. However the AhcEndpoint
can also configure/override a custom option. Options set on endpoints will always take precedence over options from the AhcComponent
.
Message Headers
Name | Type | Description |
---|---|---|
Exchange.HTTP_URI
|
String
|
URI to call. Will override existing URI set directly on the endpoint. |
Exchange.HTTP_PATH
|
String
|
Request URI's path, the header will be used to build the request URI with the HTTP_URI. If the path is start with "/", http producer will try to find the relative path based on the Exchange.HTTP_BASE_URI header or the exchange.getFromEndpoint().getEndpointUri();
|
Exchange.HTTP_QUERY
|
String
|
URI parameters. Will override existing URI parameters set directly on the endpoint. |
Exchange.HTTP_RESPONSE_CODE
|
int
|
The HTTP response code from the external server. Is 200 for OK. |
Exchange.HTTP_CHARACTER_ENCODING
|
String
|
Character encoding. |
Exchange.CONTENT_TYPE
|
String
|
The HTTP content type. Is set on both the IN and OUT message to provide a content type, such as text/html .
|
Exchange.CONTENT_ENCODING
|
String
|
The HTTP content encoding. Is set on both the IN and OUT message to provide a content encoding, such as gzip .
|
Message Body
Response code
- Response code is in the range 100..299, Camel regards it as a success response.
- Response code is in the range 300..399, Camel regards it as a redirection response and will throw a
AhcOperationFailedException
with the information. - Response code is 400+, Camel regards it as an external server failure and will throw a
AhcOperationFailedException
with the information. The option,throwExceptionOnFailure
, can be set tofalse
to prevent theAhcOperationFailedException
from being thrown for failed response codes. This allows you to get any response from the remote server.
AhcOperationFailedException
- The HTTP status code
- The HTTP status line (text of the status code)
- Redirect location, if server returned a redirect
- Response body as a
java.lang.String
, if server provided a body as response
Calling using GET or POST
GET
or POST
HTTP method should be used: 1. Use method provided in header. 2. GET
if query string is provided in header. 3. GET
if endpoint is configured with a query string. 4. POST
if there is data to send (body is not null). 5. GET
otherwise.
Configuring URI to call
oldhost
, using HTTP.
from("direct:start") .to("ahc:http://oldhost");
<camelContext xmlns="http://activemq.apache.org/camel/schema/spring"> <route> <from uri="direct:start"/> <to uri="ahc:http://oldhost"/> </route> </camelContext>
Exchange.HTTP_URI
, on the message.
from("direct:start") .setHeader(Exchange.HTTP_URI, constant("http://newhost")) .to("ahc:http://oldhost");
Configuring URI Parameters
Exchange.HTTP_QUERY
on the message.
from("direct:start") .to("ahc:http://oldhost?order=123&detail=short");
from("direct:start") .setHeader(Exchange.HTTP_QUERY, constant("order=123&detail=short")) .to("ahc:http://oldhost");
How to set the http method (GET/POST/PUT/DELETE/HEAD/OPTIONS/TRACE) to the HTTP producer
from("direct:start") .setHeader(Exchange.HTTP_METHOD, constant("POST")) .to("ahc:http://www.google.com") .to("mock:results");
<camelContext xmlns="http://activemq.apache.org/camel/schema/spring"> <route> <from uri="direct:start"/> <setHeader headerName="CamelHttpMethod"> <constant>POST</constant> </setHeader> <to uri="ahc:http://www.google.com"/> <to uri="mock:results"/> </route> </camelContext>
Configuring charset
POST
to send data you can configure the charset
using the Exchange
property:
exchange.setProperty(Exchange.CHARSET_NAME, "iso-8859-1");
URI Parameters from the endpoint URI
&
character as separator, just as you would in the web browser. Camel does no tricks here.
// we query for Camel at the Google page template.sendBody("ahc:http://www.google.com/search?q=Camel", null);
URI Parameters from the Message
Map headers = new HashMap(); headers.put(Exchange.HTTP_QUERY, "q=Camel&lr=lang_en"); // we query for Camel and English language at Google template.sendBody("ahc:http://www.google.com/search", null, headers);
?
and you can separate parameters as usual with the &
char.
Getting the Response Code
Exchange.HTTP_RESPONSE_CODE
.
Exchange exchange = template.send("ahc:http://www.google.com/search", new Processor() { public void process(Exchange exchange) throws Exception { exchange.getIn().setHeader(Exchange.HTTP_QUERY, constant("hl=en&q=activemq")); } }); Message out = exchange.getOut(); int responseCode = out.getHeader(Exchange.HTTP_RESPONSE_CODE, Integer.class);
Configuring AsyncHttpClient
AsyncHttpClient
client uses a AsyncHttpClientConfig
to configure the client. See the documentation at Async Http Client for more details.
AsyncHttpClientConfig
which we configure on the AhcComponent
.
// create a client config builder AsyncHttpClientConfig.Builder builder = new AsyncHttpClientConfig.Builder(); // use the builder to set the options we want, in this case we want to follow redirects and try // at most 3 retries to send a request to the host AsyncHttpClientConfig config = builder.setFollowRedirects(true).setMaxRequestRetry(3).build(); // lookup AhcComponent AhcComponent component = context.getComponent("ahc", AhcComponent.class); // and set our custom client config to be used component.setClientConfig(config);
AsyncHttpClientConfigBean
class provides getters and setters for the configuration options available in AsyncHttpClientConfig
. An instance of AsyncHttpClientConfigBean
may be passed directly to the AHC component or referenced in an endpoint URI using the clientConfig
URI parameter.
AsyncHttpClientConfig
. The properties specified in the endpoint URI are merged with those specified in the configuration referenced by the "clientConfig" URI parameter with those being set using the "clientConfig." parameter taking priority. The AsyncHttpClientConfig
instance referenced is always copied for each endpoint such that settings on one endpoint will remain independent of settings on any previously created endpoints. The example below shows how to configure the AHC component using the "clientConfig." type URI parameters.
from("direct:start") .to("ahc:http://localhost:8080/foo?clientConfig.maxRequestRetry=3&clientConfig.followRedirects=true")
SSL Support (HTTPS)
Using the JSSE Configuration Utility
Programmatic configuration of the component
KeyStoreParameters ksp = new KeyStoreParameters(); ksp.setResource("/users/home/server/keystore.jks"); ksp.setPassword("keystorePassword"); KeyManagersParameters kmp = new KeyManagersParameters(); kmp.setKeyStore(ksp); kmp.setKeyPassword("keyPassword"); SSLContextParameters scp = new SSLContextParameters(); scp.setKeyManagers(kmp); AhcComponent component = context.getComponent("ahc", AhcComponent.class); component.setSslContextParameters(scp));
Spring DSL based configuration of endpoint
... <camel:sslContextParameters id="sslContextParameters"> <camel:keyManagers keyPassword="keyPassword"> <camel:keyStore resource="/users/home/server/keystore.jks" password="keystorePassword"/> </camel:keyManagers> </camel:sslContextParameters>... ... <to uri="ahc:https://localhost/foo?sslContextParameters=#sslContextParameters"/> ...
Chapter 4. AHC-WS
Async Http Client (AHC) Websocket Client Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-ahc-ws</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI Format
ahc-ws://hostname[:port][/resourceUri][?options] ahc-wss://hostname[:port][/resourceUri][?options]
AHC-WS Options
Writing and Reading Data over Websocket
Configuring URI to Write or Read Data
from("direct:start") .to("ahc-ws://targethost");
<camelContext xmlns="http://camel.apache.org/schema/spring"> <route> <from uri="direct:start"/> <to uri="ahc-ws://targethost"/> </route> </camelContext>
from("ahc-ws://targethost") .to("direct:next");
<camelContext xmlns="http://camel.apache.org/schema/spring"> <route> <from uri="ahc-ws://targethost"/> <to uri="direct:next"/> </route> </camelContext>
Chapter 5. AMQP
AMQP
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-ampq</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
amqp:[queue:|topic:]destinationName[?options]
Chapter 6. APNS
Apns Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-apns</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
apns:notify[?options]
apns:consumer[?options]
Options
Producer
Property | Default | Description |
---|---|---|
tokens
|
Empty by default. Configure this property in case you want to statically declare tokens related to devices you want to notify. Tokens are separated by comma. |
Consumer
Property | Default | Description |
---|---|---|
delay
|
3600
|
Delay in seconds between each poll. |
initialDelay
|
10
|
Seconds before polling starts. |
timeUnit
|
SECONDS
|
Time Unit for polling. |
userFixedDelay
|
true
|
If true , use fixed delay between pools, otherwise fixed rate is used. See ScheduledExecutorService in JDK for details.
|
?option=value&option=value&...
Component
ApnsComponent
must be configured with a com.notnoop.apns.ApnsService
. The service can be created and configured using the org.apache.camel.component.apns.factory.ApnsServiceFactory
. See further below for an example. For further information, see the test source code.
Exchange data format
Message Headers
Property | Default | Description |
---|---|---|
CamelApnsTokens
|
Empty by default. | |
CamelApnsMessageType
|
STRING, PAYLOAD
|
If you choose PAYLOAD as the message type, the message will be considered an APNS payload and sent as is. If you choose STRING, the message will be converted to an APNS payload |
ApnsServiceFactory Builder Callback
ApnsServiceFactory
comes with an empty callback method that can be used to configure or replace the default ApnsServiceBuilder
instance. The method has the following format:
protected ApnsServiceBuilder configureServiceBuilder(ApnsServiceBuilder serviceBuilder);It is used in the following way:
ApnsServiceFactory proxiedApnsServiceFactory = new ApnsServiceFactory(){ @Override protected ApnsServiceBuilder configureServiceBuilder(ApnsServiceBuilder serviceBuilder) { return serviceBuilder.withSocksProxy("my.proxy.com", 6666); } };
Samples
Camel Xml route
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:camel="http://camel.apache.org/schema/spring" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd"> <!-- Replace by desired values --> <bean id="apnsServiceFactory" class="org.apache.camel.component.apns.factory.ApnsServiceFactory"> <!-- Optional configuration of feedback host and port --> <!-- <property name="feedbackHost" value="localhost" /> --> <!-- <property name="feedbackPort" value="7843" /> --> <!-- Optional configuration of gateway host and port --> <!-- <property name="gatewayHost" value="localhost" /> --> <!-- <property name="gatewayPort" value="7654" /> --> <!-- Declaration of certificate used --> <!-- from Camel 2.11 onwards you can use prefix: classpath:, file: to refer to load the certificate from classpath or file. Default it classpath --> <property name="certificatePath" value="certificate.p12" /> <property name="certificatePassword" value="MyCertPassword" /> <!-- Optional connection strategy - By Default: No need to configure --> <!-- Possible options: NON_BLOCKING, QUEUE, POOL or Nothing --> <!-- <property name="connectionStrategy" value="POOL" /> --> <!-- Optional pool size --> <!-- <property name="poolSize" value="15" /> --> <!-- Optional connection strategy - By Default: No need to configure --> <!-- Possible options: EVERY_HALF_HOUR, EVERY_NOTIFICATION or Nothing (Corresponds to NEVER javapns option) --> <!-- <property name="reconnectionPolicy" value="EVERY_HALF_HOUR" /> --> </bean> <bean id="apnsService" factory-bean="apnsServiceFactory" factory-method="getApnsService" /> <!-- Replace this declaration by wanted configuration --> <bean id="apns" class="org.apache.camel.component.apns.ApnsComponent"> <property name="apnsService" ref="apnsService" /> </bean> <camelContext id="camel-apns-test" xmlns="http://camel.apache.org/schema/spring"> <route id="apns-test"> <from uri="apns:consumer?initialDelay=10&elay=3600&imeUnit=SECONDS" /> <to uri="log:org.apache.camel.component.apns?showAll=true&ultiline=true" /> <to uri="mock:result" /> </route> </camelContext> </beans>
Camel Java route
Create camel context and declare apns component programmatically
protected CamelContext createCamelContext() throws Exception { CamelContext camelContext = super.createCamelContext(); ApnsServiceFactory apnsServiceFactory = new ApnsServiceFactory(); apnsServiceFactory.setCertificatePath("classpath:/certificate.p12"); apnsServiceFactory.setCertificatePassword("MyCertPassword"); ApnsService apnsService = apnsServiceFactory.getApnsService(camelContext); ApnsComponent apnsComponent = new ApnsComponent(apnsService); camelContext.addComponent("apns", apnsComponent); return camelContext; }
ApnsProducer - iOS target device dynamically configured via header: "CamelApnsTokens"
protected RouteBuilder createRouteBuilder() throws Exception { return new RouteBuilder() { public void configure() throws Exception { from("direct:test") .setHeader(ApnsConstants.HEADER_TOKENS, constant(IOS_DEVICE_TOKEN)) .to("apns:notify"); } } }
ApnsProducer - iOS target device statically configured via uri
protected RouteBuilder createRouteBuilder() throws Exception { return new RouteBuilder() { public void configure() throws Exception { from("direct:test"). to("apns:notify?tokens=" + IOS_DEVICE_TOKEN); } }; }
ApnsConsumer
from("apns:consumer?initialDelay=10&delay=3600&timeUnit=SECONDS") .to("log:com.apache.camel.component.apns?showAll=true&multiline=true") .to("mock:result");
See Also
Chapter 7. Atmosphere-Websocket
Atmosphere Websocket Servlet Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-atmosphere-websocket</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI Format
atmosphere-websocket:///relative path[?options]
Reading and Writing Data over Websocket
Configuring URI to Read or Write Data
from("atmosphere-websocket:///servicepath") .to("direct:next");
<camelContext xmlns="http://camel.apache.org/schema/spring"> <route> <from uri="atmosphere-websocket:///servicepath"/> <to uri="direct:next"/> </route> </camelContext>
from("direct:next") .to("atmosphere-websocket:///servicepath");
<camelContext xmlns="http://camel.apache.org/schema/spring"> <route> <from uri="direct:next"/> <to uri="atmosphere-websocket:///servicepath"/> </route> </camelContext>
Chapter 8. Atom
Atom Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-atom</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
atom://atomUri[?options]
Options
Property | Default | Description |
---|---|---|
splitEntries
|
true
|
If true Apache Camel will poll the feed and for the subsequent polls return each entry poll by poll. If the feed contains 7 entries then Apache Camel will return the first entry on the first poll, the 2nd entry on the next poll, until no more entries where as Apache Camel will do a new update on the feed. If false then Apache Camel will poll a fresh feed on every invocation.
|
filter
|
true
|
Is only used by the split entries to filter the entries to return. Apache Camel will default use the UpdateDateFilter that only return new entries from the feed. So the client consuming from the feed never receives the same entry more than once. The filter will return the entries ordered by the newest last.
|
lastUpdate
|
null
|
Is only used by the filter, as the starting timestamp for selection never entries (uses the entry.updated timestamp). Syntax format is: yyyy-MM-ddTHH:MM:ss . Example: 2007-12-24T17:45:59 .
|
throttleEntries
|
true
|
Camel 2.5: Sets whether all entries identified in a single feed poll should be delivered immediately. If true , only one entry is processed per consumer.delay . Only applicable when splitEntries is set to true .
|
feedHeader
|
true
|
Sets whether to add the Abdera Feed object as a header. |
sortEntries
|
false
|
If splitEntries is true , this sets whether to sort those entries by updated date.
|
consumer.delay
|
500
|
Delay in millis between each poll. |
consumer.initialDelay
|
1000
|
Millis before polling starts. |
consumer.userFixedDelay
|
false
|
If true , use fixed delay between pools, otherwise fixed rate is used. See ScheduledExecutorService in JDK for details.
|
?option=value&option=value&...
Exchange data format
Exchange
with the entries. Depending on the splitEntries
flag Apache Camel will either return one Entry
or a List<Entry>
.
Option | Value | Behavior |
---|---|---|
splitEntries
|
true
|
Only a single entry from the currently being processed feed is set: exchange.in.body(Entry)
|
splitEntries
|
false
|
The entire list of entries from the feed is set: exchange.in.body(List<Entry>)
|
Feed
object on the in header (see feedHeader
option to disable this):
Message Headers
Header | Description |
---|---|
CamelAtomFeed
|
Apache Camel 2.0: When consuming the org.apache.abdera.model.Feed object is set to this header.
|
Samples
from("atom://http://macstrac.blogspot.com/feeds/posts/default").to("seda:feeds");
@Override protected CamelContext createCamelContext() throws Exception { // First we register a blog service in our bean registry SimpleRegistry registry = new SimpleRegistry(); registry.put("blogService", new BlogService()); // Then we create the camel context with our bean registry context = new DefaultCamelContext(registry); // Then we add all the routes we need using the route builder DSL syntax context.addRoutes(createMyRoutes()); // And finally we must start Camel to let the magic routing begins context.start(); return context; } /** * This is the route builder where we create our routes using the Camel DSL syntax */ protected RouteBuilder createMyRoutes() throws Exception { return new RouteBuilder() { public void configure() throws Exception { // We pool the atom feeds from the source for further processing in the seda queue // we set the delay to 1 second for each pool. // Using splitEntries=true will during polling only fetch one Atom Entry at any given time. // As the feed.atom file contains 7 entries, using this will require 7 polls to fetch the entire // content. When Camel have reach the end of entries it will refresh the atom feed from URI source // and restart - but as Camel by default uses the UpdatedDateFilter it will only deliver new // blog entries to "seda:feeds". So only when James Strachan updates his blog with a new entry // Camel will create an exchange for the seda:feeds. from("atom:file:src/test/data/feed.atom?splitEntries=true&consumer.delay=1000").to("seda:feeds"); // From the feeds we filter each blot entry by using our blog service class from("seda:feeds").filter().method("blogService", "isGoodBlog").to("seda:goodBlogs"); // And the good blogs is moved to a mock queue as this sample is also used for unit testing // this is one of the strengths in Camel that you can also use the mock endpoint for your // unit tests from("seda:goodBlogs").to("mock:result"); } }; } /** * This is the actual junit test method that does the assertion that our routes is working * as expected */ @Test public void testFiltering() throws Exception { // create and start Camel context = createCamelContext(); context.start(); // Get the mock endpoint MockEndpoint mock = context.getEndpoint("mock:result", MockEndpoint.class); // There should be at least two good blog entries from the feed mock.expectedMinimumMessageCount(2); // Asserts that the above expectations is true, will throw assertions exception if it failed // Camel will default wait max 20 seconds for the assertions to be true, if the conditions // is true sooner Camel will continue mock.assertIsSatisfied(); // stop Camel after use context.stop(); } /** * Services for blogs */ public class BlogService { /** * Tests the blogs if its a good blog entry or not */ public boolean isGoodBlog(Exchange exchange) { Entry entry = exchange.getIn().getBody(Entry.class); String title = entry.getTitle(); // We like blogs about Camel boolean good = title.toLowerCase().contains("camel"); return good; } }
Chapter 9. avro
Avro Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-avro</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
Apache Avro Overview
{"namespace": "org.apache.camel.avro.generated", "protocol": "KeyValueProtocol", "types": [ {"name": "Key", "type": "record", "fields": [ {"name": "key", "type": "string"} ] }, {"name": "Value", "type": "record", "fields": [ {"name": "value", "type": "string"} ] } ], "messages": { "put": { "request": [{"name": "key", "type": "Key"}, {"name": "value", "type": "Value"} ], "response": "null" }, "get": { "request": [{"name": "key", "type": "Key"}], "response": "Value" } } }
package org.apache.camel.avro.reflection; public interface KeyValueProtocol { void put(String key, Value value); Value get(String key); } class Value { private String value; public String getValue() { return value; } public void setValue(String value) { this.value = value; } }
Using the Avro data format
<camelContext id="camel" xmlns="http://camel.apache.org/schema/spring"> <route> <from uri="direct:in"/> <marshal> <avro instanceClass="org.apache.camel.dataformat.avro.Message"/> </marshal> <to uri="log:out"/> </route> </camelContext>
<camelContext id="camel" xmlns="http://camel.apache.org/schema/spring"> <dataFormats> <avro id="avro" instanceClass="org.apache.camel.dataformat.avro.Message"/> </dataFormats> <route> <from uri="direct:in"/> <marshal ref="avro"/> <to uri="log:out"/> </route> </camelContext>
Using Avro RPC in Camel
avro:[transport]:[host]:[port][?options]
avro:[transport]:[host]:[port][/messageName][?options]
singleParameter
URI option to receive it direcly in the "in" message body without array wrapping.
Avro RPC URI Options
Name | Version | Description |
---|---|---|
protocolClassName
|
The class name of the avro protocol. | |
singleParameter
|
2.12 | If true, consumer parameter won't be wrapped into array. Will fail if protocol specifies more then 1 parameter for the message |
protocol
|
Avro procol object. Can be used instead of protocolClassName when complex protocol needs to be created. One cane used #name notation to refer beans from the Registry
|
|
reflectionProtocol
|
2.12 |
If protocol object provided is reflection protocol. Should be used only with protocol parameter because for protocolClassName protocol type will be autodetected
|
Avro RPC Headers
Name | Description |
---|---|
CamelAvroMessageName
|
The name of the message to send. In consumer overrides message name from URI (if any) |
Examples
<route> <from uri="direct:start"/> <to uri="avro:http:localhost:{{avroport}}?protocolClassName=org.apache.camel.avro.generated.KeyValueProtocol"/> <to uri="log:avro"/> </route>
CamelAvroMessageName
header. Since 2.12 you can use following syntax to call constant messages:
<route> <from uri="direct:start"/> <to uri="avro:http:localhost:{{avroport}}/put?protocolClassName=org.apache.camel.avro.generated.KeyValueProtocol"/> <to uri="log:avro"/> </route>
<route> <from uri="avro:netty:localhost:{{avroport}}?protocolClassName=org.apache.camel.avro.generated.KeyValueProtocol"/> <choice> <when> <el>${in.headers.CamelAvroMessageName == 'put'}</el> <process ref="putProcessor"/> </when> <when> <el>${in.headers.CamelAvroMessageName == 'get'}</el> <process ref="getProcessor"/> </when> </choice> </route>
<route> <from uri="avro:netty:localhost:{{avroport}}/put?protocolClassName=org.apache.camel.avro.generated.KeyValueProtocol"> <process ref="putProcessor"/> </route> <route> <from uri="avro:netty:localhost:{{avroport}}/get?protocolClassName=org.apache.camel.avro.generated.KeyValueProtocol&singleParameter=true"/> <process ref="getProcessor"/> </route>
singleParameter
is used and getProcessor
will receive Value class directly in body, while putProcessor
will receive an array of size 2 with String key and Value value filled as array contents.
Chapter 10. AWS
10.1. Introduction to the AWS Components
Camel Components for Amazon Web Services
AWS service | Camel component | Camel Version | Component description |
---|---|---|---|
Simple Queue Service (SQS) | AWS-SQS | 2.6 | Supports sending and receiving messages using SQS |
Simple Notification Service (SNS) | AWS-SNS | 2.8 | Supports sending messages using SNS |
Simple Storage Service (S3) | AWS-S3 | 2.8 | Supports storing and retrieving of objects using S3 |
Simple Email Service (SES) | AWS-SES | 2.8.4 | Supports sending emails using SES |
SimpleDB | AWS-SDB | 2.8.4 | Supports storing retrieving data to/from SDB |
DynamoDB | AWS-DDB | 2.10.0 | Supports storing retrieving data to/from DDB |
CloudWatch | AWS-CW | 2.10.3 | Supports sending metrics to CloudWatch |
Simple Workflow | AWS-SWF | 2.13.0 | Supports managing workflows with SWF |
10.2. AWS-CW
CW Component
URI Format
aws-cw://namespace[?options]
?options=value&option2=value&...
URI Options
Name | Default Value | Context | Description |
---|---|---|---|
amazonCwClient |
null
|
Producer |
Reference to a com.amazonaws.services.cloudwatch.AmazonCloudWatch in the Registry.
|
accessKey |
null
|
Producer | Amazon AWS Access Key |
secretKey |
null
|
Producer | Amazon AWS Secret Key |
name |
null
|
Producer | The metric name which is used if the message header 'CamelAwsCwMetricName' is not present. |
value |
1.0
|
Producer | The metric value which is used if the message header 'CamelAwsCwMetricValue' is not present. |
unit |
Count
|
Producer | The metric unit which is used if the message header 'CamelAwsCwMetricUnit' is not present. |
namespace |
null
|
Producer | The metric namespace which is used if the message header 'CamelAwsCwMetricNamespace' is not present. |
timestamp |
null
|
Producer | The metric timestamp which is used if the message header 'CamelAwsCwMetricTimestamp' is not present. |
amazonCwEndpoint |
null
|
Producer | The region with which the AWS-CW client wants to work with. |
Usage
Message headers evaluated by the CW producer
Header | Type | Description |
---|---|---|
CamelAwsCwMetricName
|
String
|
The Amazon CW metric name. |
CamelAwsCwMetricValue
|
Double
|
The Amazon CW metric value. |
CamelAwsCwMetricUnit
|
String
|
The Amazon CW metric unit. |
CamelAwsCwMetricNamespace
|
String
|
The Amazon CW metric namespace. |
CamelAwsCwMetricTimestamp
|
Date
|
The Amazon CW metric timestamp. |
CamelAwsCwMetricDimensionName
|
String
|
Camel 2.12: The Amazon CW metric dimension name. |
CamelAwsCwMetricDimensionValue
|
String
|
Camel 2.12: The Amazon CW metric dimension value. |
CamelAwsCwMetricDimensions
|
Map<String, String>
|
Camel 2.12: A map of dimension names and dimension values. |
Advanced AmazonCloudWatch configuration
AmazonCloudWatch
instance configuration you can create your own instance and refer to it from the URI:
from("direct:start") .to("aws-cw://namepsace?amazonCwClient=#client");
AWSCredentials awsCredentials = new BasicAWSCredentials("myAccessKey", "mySecretKey"); ClientConfiguration clientConfiguration = new ClientConfiguration(); clientConfiguration.setProxyHost("http://myProxyHost"); clientConfiguration.setProxyPort(8080); AmazonCloudWatch client = new AmazonCloudWatchClient(awsCredentials, clientConfiguration); registry.bind("client", client);
Dependencies
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-aws</artifactId> <version>${camel-version}</version> </dependency>
${camel-version}
must be replaced by the actual version of Camel (2.10 or higher).
10.3. AWS-DDB
DDB Component
URI Format
aws-ddb://domainName[?options]
URI Options
Name | Default Value | Context | Description |
---|---|---|---|
amazonDDBClient |
null
|
Producer |
Reference to a com.amazonaws.services.dynamodb.AmazonDynamoDB in the Registry.
|
accessKey |
null
|
Producer | Amazon AWS Access Key |
secretKey |
null
|
Producer | Amazon AWS Secret Key |
amazonDdbEndpoint |
null
|
Producer | The region with which the AWS-DDB client wants to work with. |
tableName |
null
|
Producer | The name of the table currently worked with. |
readCapacity |
0
|
Producer | The provisioned throughput to reserve for reading resources from your table |
writeCapacity |
0
|
Producer | The provisioned throughput to reserved for writing resources to your table |
consistentRead |
false
|
Producer | Determines whether or not strong consistency should be enforced when data is read. |
operation |
PutAttributes
|
Producer | Valid values are BatchGetItems, DeleteItem, DeleteTable, DescribeTable, GetItem, PutItem, Query, Scan, UpdateItem, UpdateTable. |
Usage
Message headers evaluated by the DDB producer
Header | Type | Description |
---|---|---|
CamelAwsDdbBatchItems
|
Map<String, KeysAndAttributes>
|
A map of the table name and corresponding items to get by primary key. |
CamelAwsDdbTableName
|
String
|
Table Name for this operation. |
CamelAwsDdbKey
|
Key
|
The primary key that uniquely identifies each item in a table. |
CamelAwsDdbReturnValues
|
String
|
Use this parameter if you want to get the attribute name-value pairs before or after they are modified(NONE, ALL_OLD, UPDATED_OLD, ALL_NEW, UPDATED_NEW). |
CamelAwsDdbUpdateCondition
|
Map<String, ExpectedAttributeValue>
|
Designates an attribute for a conditional modification. |
CamelAwsDdbAttributeNames
|
Collection<String>
|
If attribute names are not specified then all attributes will be returned. |
CamelAwsDdbConsistentRead
|
Boolean
|
If set to true, then a consistent read is issued, otherwise eventually consistent is used. |
CamelAwsDdbItem
|
Map<String, AttributeValue>
|
A map of the attributes for the item, and must include the primary key values that define the item. |
CamelAwsDdbExactCount
|
Boolean
|
If set to true, Amazon DynamoDB returns a total number of items that match the query parameters, instead of a list of the matching items and their attributes. |
CamelAwsDdbStartKey
|
Key
|
Primary key of the item from which to continue an earlier query. |
CamelAwsDdbHashKeyValue
|
AttributeValue
|
Value of the hash component of the composite primary key. |
CamelAwsDdbLimit
|
Integer
|
The maximum number of items to return. |
CamelAwsDdbScanRangeKeyCondition
|
Condition
|
A container for the attribute values and comparison operators to use for the query. |
CamelAwsDdbScanIndexForward
|
Boolean
|
Specifies forward or backward traversal of the index. |
CamelAwsDdbScanFilter
|
Map<String, Condition>
|
Evaluates the scan results and returns only the desired values. |
CamelAwsDdbUpdateValues
|
Map<String, AttributeValueUpdate>
|
Map of attribute name to the new value and action for the update. |
Message headers set during BatchGetItems operation
Header | Type | Description |
---|---|---|
CamelAwsDdbBatchResponse
|
Map<String,BatchResponse>
|
Table names and the respective item attributes from the tables. |
CamelAwsDdbUnprocessedKeys
|
Map<String,KeysAndAttributes>
|
Contains a map of tables and their respective keys that were not processed with the current response. |
Message headers set during DeleteItem operation
Header | Type | Description |
---|---|---|
CamelAwsDdbAttributes
|
Map<String, AttributeValue>
|
The list of attributes returned by the operation. |
Message headers set during DeleteTable operation
Header | Type | Description |
---|---|---|
CamelAwsDdbProvisionedThroughput
|
ProvisionedThroughputDescription
|
The value of the ProvisionedThroughput property for this table |
CamelAwsDdbCreationDate
|
Date
|
Creation DateTime of this table. |
CamelAwsDdbTableItemCount
|
Long
|
Item count for this table. |
CamelAwsDdbKeySchema
|
KeySchema
|
The KeySchema that identifies the primary key for this table. |
CamelAwsDdbTableName
|
String
|
The table name. |
CamelAwsDdbTableSize
|
Long
|
The table size in bytes. |
CamelAwsDdbTableStatus
|
String
|
The status of the table: CREATING, UPDATING, DELETING, ACTIVE |
Message headers set during DescribeTable operation
Header | Type | Description |
---|---|---|
CamelAwsDdbProvisionedThroughput
|
{{ProvisionedThroughputDescription} | The value of the ProvisionedThroughput property for this table |
CamelAwsDdbCreationDate
|
Date
|
Creation DateTime of this table. |
CamelAwsDdbTableItemCount
|
Long
|
Item count for this table. |
CamelAwsDdbKeySchema
|
{{KeySchema | The KeySchema that identifies the primary key for this table. |
CamelAwsDdbTableName
|
String
|
The table name. |
CamelAwsDdbTableSize
|
Long
|
The table size in bytes. |
CamelAwsDdbTableStatus
|
String
|
The status of the table: CREATING, UPDATING, DELETING, ACTIVE |
CamelAwsDdbReadCapacity
|
Long
|
ReadCapacityUnits property of this table. |
CamelAwsDdbWriteCapacity
|
Long
|
WriteCapacityUnits property of this table. |
Message headers set during GetItem operation
Header | Type | Description |
---|---|---|
CamelAwsDdbAttributes
|
Map<String, AttributeValue>
|
The list of attributes returned by the operation. |
Message headers set during PutItem operation
Header | Type | Description |
---|---|---|
CamelAwsDdbAttributes
|
Map<String, AttributeValue>
|
The list of attributes returned by the operation. |
Message headers set during Query operation
Header | Type | Description |
---|---|---|
CamelAwsDdbItems
|
List<java.util.Map<String,AttributeValue>>
|
The list of attributes returned by the operation. |
CamelAwsDdbLastEvaluatedKey
|
Key
|
Primary key of the item where the query operation stopped, inclusive of the previous result set. |
CamelAwsDdbConsumedCapacity
|
Double
|
The number of Capacity Units of the provisioned throughput of the table consumed during the operation. |
CamelAwsDdbCount
|
Integer
|
Number of items in the response. |
Message headers set during Scan operation
Header | Type | Description |
---|---|---|
CamelAwsDdbItems
|
List<java.util.Map<String,AttributeValue>>
|
The list of attributes returned by the operation. |
CamelAwsDdbLastEvaluatedKey
|
Key
|
Primary key of the item where the query operation stopped, inclusive of the previous result set. |
CamelAwsDdbConsumedCapacity
|
Double
|
The number of Capacity Units of the provisioned throughput of the table consumed during the operation. |
CamelAwsDdbCount
|
Integer
|
Number of items in the response. |
CamelAwsDdbScannedCount
|
Integer
|
Number of items in the complete scan before any filters are applied. |
Message headers set during UpdateItem operation
Header | Type | Description |
---|---|---|
CamelAwsDdbAttributes
|
Map<String, AttributeValue>
|
The list of attributes returned by the operation. |
Advanced AmazonDynamoDB configuration
AmazonDynamoDB
instance configuration you can create your own instance and refer to it from the URI:
from("direct:start") .to("aws-ddb://domainName?amazonDDBClient=#client");
AWSCredentials awsCredentials = new BasicAWSCredentials("myAccessKey", "mySecretKey"); ClientConfiguration clientConfiguration = new ClientConfiguration(); clientConfiguration.setProxyHost("http://myProxyHost"); clientConfiguration.setProxyPort(8080); AmazonDynamoDB client = new AmazonDynamoDBClient(awsCredentials, clientConfiguration); registry.bind("client", client);
Dependencies
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-aws</artifactId> <version>${camel-version}</version> </dependency>
${camel-version}
must be replaced by the actual version of Camel (2.10 or higher).
10.4. AWS-S3
S3 Component
URI Format
aws-s3://bucket-name[?options]
URI Options
Name | Default Value | Context | Description |
---|---|---|---|
amazonS3Client |
null
|
Shared |
Reference to a com.amazonaws.services.sqs.AmazonS3 in the Registry.
|
accessKey |
null
|
Shared | Amazon AWS Access Key |
secretKey |
null
|
Shared | Amazon AWS Secret Key |
amazonS3Endpoint |
null
|
Shared | The region with which the AWS-S3 client wants to work with. |
region |
null
|
Producer |
The region who the bucket is located. This option is used in the com.amazonaws.services.s3.model.CreateBucketRequest .
|
deleteAfterRead |
true
|
Consumer | Delete objects from S3 after it has been retrieved. |
deleteAfterWrite |
false
|
Producer | Camel 2.11.0 Delete file object after the S3 file has been uploaded |
maxMessagesPerPoll | 10 | Consumer |
The maximum number of objects which can be retrieved in one poll. Used in in the com.amazonaws.services.s3.model.ListObjectsRequest .
|
policy |
null
|
Shared |
*Camel 2.8.4*: The policy for this queue to set in the com.amazonaws.services.s3.AmazonS3#setBucketPolicy() method.
|
storageClass |
null
|
Producer |
*Camel 2.8.4*: The storage class to set in the com.amazonaws.services.s3.model.PutObjectRequest request.
|
prefix |
null
|
Consumer |
*Camel 2.10.1*: The prefix which is used in the com.amazonaws.services.s3.model.ListObjectsRequest to only consume objects we are interested in.
|
multiPartUpload |
false
|
Producer |
Camel 2.15.0: If true , Camel uploads the file in multi-part format, where the part size can be specified by the partSize option.
|
partSize |
25 * 1024 * 1024
|
Producer |
Camel 2.15.0: Specifies the partSize used in multi-part upload. Default is 25 MB.
|
Batch Consumer
Usage
Message headers evaluated by the S3 producer
Header | Type | Description |
---|---|---|
CamelAwsS3Key
|
String
|
The key under which this object will be stored. |
CamelAwsS3ContentLength
|
Long
|
The content length of this object. |
CamelAwsS3ContentType
|
String
|
The content type of this object. |
CamelAwsS3ContentControl
|
String
|
The content control of this object. |
CamelAwsS3ContentDisposition
|
String
|
The content disposition of this object. |
CamelAwsS3ContentEncoding
|
String
|
The content encoding of this object. |
CamelAwsS3ContentMD5
|
String
|
The md5 checksum of this object. |
CamelAwsS3LastModified
|
java.util.Date
|
The last modified timestamp of this object. |
CamelAwsS3StorageClass
|
String
|
*Camel 2.8.4:* The storage class of this object. |
CamelAwsS3CannedAcl
|
String
|
Camel 2.11.0: The canned acl that will be applied to the object. see com.amazonaws.services.s3.model.CannedAccessControlList for allowed values.
|
CamelAwsS3Acl
|
com.amazonaws.services.s3.model.AccessControlList
|
Camel 2.11.0: a well constructed Amazon S3 Access Control List object. see com.amazonaws.services.s3.model.AccessControlList for more details
|
Message headers set by the S3 producer
Header | Type | Description |
---|---|---|
CamelAwsS3ETag
|
String
|
The ETag value for the newly uploaded object. |
CamelAwsS3VersionId
|
String
|
The optional version ID of the newly uploaded object. |
Message headers set by the S3 consumer
Header | Type | Description |
---|---|---|
CamelAwsS3Key
|
String
|
The key under which this object is stored. |
CamelAwsS3BucketName
|
String
|
The name of the bucket in which this object is contained. |
CamelAwsS3ETag
|
String
|
The hex encoded 128-bit MD5 digest of the associated object according to RFC 1864. This data is used as an integrity check to verify that the data received by the caller is the same data that was sent by Amazon S3. |
CamelAwsS3LastModified
|
Date
|
The value of the Last-Modified header, indicating the date and time at which Amazon S3 last recorded a modification to the associated object. |
CamelAwsS3VersionId
|
String
|
The version ID of the associated Amazon S3 object if available. Version IDs are only assigned to objects when an object is uploaded to an Amazon S3 bucket that has object versioning enabled. |
CamelAwsS3ContentType
|
String
|
The Content-Type HTTP header, which indicates the type of content stored in the associated object. The value of this header is a standard MIME type. |
CamelAwsS3ContentMD5
|
String
|
The base64 encoded 128-bit MD5 digest of the associated object (content - not including headers) according to RFC 1864. This data is used as a message integrity check to verify that the data received by Amazon S3 is the same data that the caller sent. |
CamelAwsS3ContentLength
|
Long
|
The Content-Length HTTP header indicating the size of the associated object in bytes. |
CamelAwsS3ContentEncoding
|
String
|
The optional Content-Encoding HTTP header specifying what content encodings have been applied to the object and what decoding mechanisms must be applied in order to obtain the media-type referenced by the Content-Type field. |
CamelAwsS3ContentDisposition
|
String
|
The optional Content-Disposition HTTP header, which specifies presentational information such as the recommended filename for the object to be saved as. |
CamelAwsS3ContentControl
|
String
|
The optional Cache-Control HTTP header which allows the user to specify caching behavior along the HTTP request/reply chain. |
Advanced AmazonS3 configuration
AmazonS3
instance configuration, you can create your own instance:
AWSCredentials awsCredentials = new BasicAWSCredentials("myAccessKey", "mySecretKey"); ClientConfiguration clientConfiguration = new ClientConfiguration(); clientConfiguration.setProxyHost("http://myProxyHost"); clientConfiguration.setProxyPort(8080); AmazonS3 client = new AmazonS3Client(awsCredentials, clientConfiguration); registry.bind("client", client);
from("aws-s3://MyBucket?amazonS3Client=#client&delay=5000&maxMessagesPerPoll=5") .to("mock:result");
Dependencies
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-aws</artifactId> <version>${camel-version}</version> </dependency>
$\{camel-version\}
must be replaced by the actual version of Camel (2.8 or higher).
10.5. AWS-SDB
SDB Component
URI Format
aws-sdb://domainName[?options]
URI Options
Name | Default Value | Context | Description |
---|---|---|---|
amazonSDBClient |
null
|
Producer |
Reference to a com.amazonaws.services.simpledb.AmazonSimpleDB in the Registry.
|
accessKey |
null
|
Producer | Amazon AWS Access Key |
secretKey |
null
|
Producer | Amazon AWS Secret Key |
amazonSdbEndpoint |
null
|
Producer | The region with which the AWS-SDB client wants to work with. |
domainName |
null
|
Producer | The name of the domain currently worked with. |
maxNumberOfDomains |
100
|
Producer | The maximum number of domain names you want returned. The range is 1 * to 100. |
consistentRead |
false
|
Producer | Determines whether or not strong consistency should be enforced when data is read. |
operation |
PutAttributes
|
Producer | Valid values are BatchDeleteAttributes, BatchPutAttributes, DeleteAttributes, DeleteDomain, DomainMetadata, GetAttributes, ListDomains, PutAttributes, Select. |
Usage
Message headers evaluated by the SDB producer
Header | Type | Description |
---|---|---|
CamelAwsSdbAttributes
|
Collection<Attribute>
|
List of attributes to be acted upon. |
CamelAwsSdbAttributeNames
|
Collection<String>
|
The names of the attributes to be retrieved. |
CamelAwsSdbConsistentRead
|
Boolean
|
Determines whether or not strong consistency should be enforced when data is read. |
CamelAwsSdbDeletableItems
|
Collection<DeletableItem>
|
A list of items on which to perform the delete operation in a batch. |
CamelAwsSdbDomainName
|
String
|
The name of the domain currently worked with. |
CamelAwsSdbItemName
|
String
|
The unique key for this item |
CamelAwsSdbMaxNumberOfDomains
|
Integer
|
The maximum number of domain names you want returned. The range is 1 * to 100. |
CamelAwsSdbNextToken
|
String
|
A string specifying where to start the next list of domain/item names. |
CamelAwsSdbOperation
|
String
|
To override the operation from the URI options. |
CamelAwsSdbReplaceableAttributes
|
Collection<ReplaceableAttribute>
|
List of attributes to put in an Item. |
CamelAwsSdbReplaceableItems
|
Collection<ReplaceableItem>
|
A list of items to put in a Domain. |
CamelAwsSdbSelectExpression
|
String
|
The expression used to query the domain. |
CamelAwsSdbUpdateCondition
|
UpdateCondition
|
The update condition which, if specified, determines whether the specified attributes will be updated/deleted or not. |
Message headers set during DomainMetadata operation
Header | Type | Description |
---|---|---|
CamelAwsSdbTimestamp
|
Integer
|
The data and time when metadata was calculated, in Epoch (UNIX) seconds. |
CamelAwsSdbItemCount
|
Integer
|
The number of all items in the domain. |
CamelAwsSdbAttributeNameCount
|
Integer
|
The number of unique attribute names in the domain. |
CamelAwsSdbAttributeValueCount
|
Integer
|
The number of all attribute name/value pairs in the domain. |
CamelAwsSdbAttributeNameSize
|
Long
|
The total size of all unique attribute names in the domain, in bytes. |
CamelAwsSdbAttributeValueSize
|
Long
|
The total size of all attribute values in the domain, in bytes. |
CamelAwsSdbItemNameSize
|
Long
|
The total size of all item names in the domain, in bytes. |
Message headers set during GetAttributes operation
Header | Type | Description |
---|---|---|
CamelAwsSdbAttributes
|
List<Attribute>
|
The list of attributes returned by the operation. |
Message headers set during ListDomains operation
Header | Type | Description |
---|---|---|
CamelAwsSdbDomainNames
|
List<String>
|
A list of domain names that match the expression. |
CamelAwsSdbNextToken
|
String
|
An opaque token indicating that there are more domains than the specified MaxNumberOfDomains still available. |
Message headers set during Select operation
Header | Type | Description |
---|---|---|
CamelAwsSdbItems
|
List<Item>
|
A list of items that match the select expression. |
CamelAwsSdbNextToken
|
String
|
An opaque token indicating that more items than MaxNumberOfItems were matched, the response size exceeded 1 megabyte, or the execution time exceeded 5 seconds. |
Advanced AmazonSimpleDB configuration
AmazonSimpleDB
instance configuration you can create your own instance and refer to it from the URI:
from("direct:start") .to("aws-sdb://domainName?amazonSDBClient=#client");
AWSCredentials awsCredentials = new BasicAWSCredentials("myAccessKey", "mySecretKey"); ClientConfiguration clientConfiguration = new ClientConfiguration(); clientConfiguration.setProxyHost("http://myProxyHost"); clientConfiguration.setProxyPort(8080); AmazonSimpleDB client = new AmazonSimpleDBClient(awsCredentials, clientConfiguration); registry.bind("client", client);
Dependencies
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-aws</artifactId> <version>${camel-version}</version> </dependency>
${camel-version}
must be replaced by the actual version of Camel (2.8.4 or higher).
10.6. AWS-SES
SES Component
URI Format
aws-ses://from[?options]
URI Options
Name | Default Value | Context | Description |
---|---|---|---|
amazonSESClient |
null
|
Producer |
Reference to a com.amazonaws.services.simpleemail.AmazonSimpleEmailService in the Registry.
|
accessKey |
null
|
Producer | Amazon AWS Access Key |
secretKey |
null
|
Producer | Amazon AWS Secret Key |
amazonSESEndpoint |
null
|
Producer | The region with which the AWS-SES client wants to work with. |
subject |
null
|
Producer | The subject which is used if the message header 'CamelAwsSesSubject' is not present. |
to |
null
|
Producer | List of destination email address. Can be overriden with 'CamelAwsSesTo' header. |
returnPath |
null
|
Producer | The email address to which bounce notifications are to be forwarded, override it using 'CamelAwsSesReturnPath' header. |
replyToAddresses |
null
|
Producer | List of reply-to email address(es) for the message, override it using 'CamelAwsSesReplyToAddresses' header. |
Usage
Message headers evaluated by the SES producer
Header | Type | Description |
---|---|---|
CamelAwsSesFrom
|
String
|
The sender's email address. |
CamelAwsSesTo
|
List<String>
|
The destination(s) for this email. |
CamelAwsSesSubject
|
String
|
The subject of the message. |
CamelAwsSesReplyToAddresses
|
List<String>
|
The reply-to email address(es) for the message. |
CamelAwsSesReturnPath
|
String
|
The email address to which bounce notifications are to be forwarded. |
CamelAwsSesHtmlEmail
|
Boolean
|
Since Camel 2.12.3 The flag to show if email content is HTML.
|
Message headers set by the SES producer
Header | Type | Description |
---|---|---|
CamelAwsSesMessageId
|
String
|
The Amazon SES message ID. |
Advanced AmazonSimpleEmailService configuration
AmazonSimpleEmailService
instance configuration you can create your own instance and refer to it from the URI:
from("direct:start") .to("aws-ses://example@example.com?amazonSESClient=#client");
AWSCredentials awsCredentials = new BasicAWSCredentials("myAccessKey", "mySecretKey"); ClientConfiguration clientConfiguration = new ClientConfiguration(); clientConfiguration.setProxyHost("http://myProxyHost"); clientConfiguration.setProxyPort(8080); AmazonSimpleEmailService client = new AmazonSimpleEmailServiceClient(awsCredentials, clientConfiguration); registry.bind("client", client);
Dependencies
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-aws</artifactId> <version>${camel-version}</version> </dependency>
${camel-version}
must be replaced by the actual version of Camel (2.8.4 or higher).
10.7. AWS-SNS
SNS Component
URI Format
aws-sns://topicName[?options]
?options=value&option2=value&...
URI Options
Name | Default Value | Context | Description |
---|---|---|---|
amazonSNSClient |
null
|
Producer |
Reference to a com.amazonaws.services.sns.AmazonSNS in the Registry.
|
accessKey |
null
|
Producer | Amazon AWS Access Key |
secretKey |
null
|
Producer | Amazon AWS Secret Key |
subject |
null
|
Producer | The subject which is used if the message header 'CamelAwsSnsSubject' is not present. |
amazonSNSEndpoint |
null
|
Producer | The region with which the AWS-SNS client wants to work with. |
policy |
null
|
Producer |
Camel 2.8.4: The policy for this queue to set in the com.amazonaws.services.sns.model.SetTopicAttributesRequest .
|
Usage
Message headers evaluated by the SNS producer
Header | Type | Description |
---|---|---|
CamelAwsSnsSubject
|
String
|
The Amazon SNS message subject. If not set, the subject from the SnsConfiguration is used.
|
Message headers set by the SNS producer
Header | Type | Description |
---|---|---|
CamelAwsSnsMessageId
|
String
|
The Amazon SNS message ID. |
Advanced AmazonSNS configuration
AmazonSNS
instance configuration you can create your own instance and refer to it from the URI:
from("direct:start") .to("aws-sns://MyTopic?amazonSNSClient=#client");
AWSCredentials awsCredentials = new BasicAWSCredentials("myAccessKey", "mySecretKey"); ClientConfiguration clientConfiguration = new ClientConfiguration(); clientConfiguration.setProxyHost("http://myProxyHost"); clientConfiguration.setProxyPort(8080); AmazonSNS client = new AmazonSNSClient(awsCredentials, clientConfiguration); registry.bind("client", client);
Dependencies
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-aws</artifactId> <version>${camel-version}</version> </dependency>
$\{camel-version\}
must be replaced by the actual version of Camel (2.8 or higher).
10.8. AWS-SQS
SQS Component
URI Format
aws-sqs://queue-name[?options]
URI Options
Name | Default Value | Context | Description |
---|---|---|---|
amazonSQSClient |
null
|
Shared |
Reference to a com.amazonaws.services.sqs.AmazonSQS in the Registry.
|
accessKey |
null
|
Shared | Amazon AWS Access Key |
secretKey |
null
|
Shared | Amazon AWS Secret Key |
amazonSQSEndpoint |
null
|
Shared | The region with which the AWS-SQS client wants to work with. Only works if Camel creates the AWS-SQS client, i.e., if you explicitly set amazonSQSClient, then this setting will have no effect. You would have to set it on the client you create directly. |
attributeNames |
null
|
Consumer |
A list of attributes to set in the com.amazonaws.services.sqs.model.ReceiveMessageRequest .
|
concurrentConsumers |
1
|
Consumer | Camel 2.15.0 Allows you to use multiple threads to poll the SQS queue to increase throughput. |
defaultVisibilityTimeout |
null
|
Shared |
The visibility timeout (in seconds) to set in the com.amazonaws.services.sqs.model.CreateQueueRequest .
|
deleteAfterRead |
true
|
Consumer | Delete message from SQS after it has been read |
deleteIfFiltered |
true
|
Consumer | Camel 2.12.2,2.13.0 Whether or not to send the DeleteMessage to the SQS queue if an exchange fails to get through a filter. If 'false' and exchange does not make it through a Camel filter upstream in the route, then don't send DeleteMessage. |
maxMessagesPerPoll |
null
|
Consumer |
The maximum number of messages which can be received in one poll to set in the com.amazonaws.services.sqs.model.ReceiveMessageRequest .
|
visibilityTimeout |
null
|
Shared |
The duration (in seconds) that the received messages are hidden from subsequent retrieve requests after being retrieved by a ReceiveMessage request to set in the com.amazonaws.services.sqs.model.SetQueueAttributesRequest . This only make sense if its different from defaultVisibilityTimeout . It changes the queue visibility timeout attribute permanently.
|
messageVisibilityTimeout |
null
|
Consumer |
Camel 2.8: The duration (in seconds) that the received messages are hidden from subsequent retrieve requests after being retrieved by a ReceiveMessage request to set in the com.amazonaws.services.sqs.model.ReceiveMessageRequest . It does NOT change the queue visibility timeout attribute permanently.
|
extendMessageVisibility |
false
|
Consumer |
Camel 2.10: If enabled then a scheduled background task will keep extending the message visibility on SQS. This is needed if it taks a long time to process the message. If set to true defaultVisibilityTimeout must be set. See details at Amazon docs.
|
maximumMessageSize |
null
|
Shared |
Camel 2.8: The maximumMessageSize (in bytes) an SQS message can contain for this queue, to set in the com.amazonaws.services.sqs.model.SetQueueAttributesRequest .
|
messageRetentionPeriod |
null
|
Shared |
Camel 2.8: The messageRetentionPeriod (in seconds) a message will be retained by SQS for this queue, to set in the com.amazonaws.services.sqs.model.SetQueueAttributesRequest .
|
policy |
null
|
Shared |
Camel 2.8: The policy for this queue to set in the com.amazonaws.services.sqs.model.SetQueueAttributesRequest .
|
delaySeconds |
null
|
Producer | Camel 2.9.3: Delay sending messages for a number of seconds. |
waitTimeSeconds |
0
|
Producer | Camel 2.11: Duration in seconds (0 to 20) that the ReceiveMessage action call will wait until a message is in the queue to include in the response. |
receiveMessageWaitTimeSeconds |
0
|
Shared | Camel 2.11: If you do not specify WaitTimeSeconds in the request, the queue attribute ReceiveMessageWaitTimeSeconds is used to determine how long to wait. |
queueOwnerAWSAccountId |
null
|
Shared | Camel 2.12: Specify the queue owner aws account id when you need to connect the queue with different account owner. |
region
|
null
|
Shared
|
Camel 2.12.3: Specify the queue region which could be used with
queueOwnerAWSAccountId to build the service URL.
|
redrivePolicy
|
null
|
Shared
|
Camel 2.15.0: Specify the policy that sends a message to DeadLetter queue. See detail at Amazon docs.
|
Batch Consumer
Usage
Message headers set by the SQS producer
Header | Type | Description |
---|---|---|
CamelAwsSqsMD5OfBody
|
String
|
The MD5 checksum of the Amazon SQS message. |
CamelAwsSqsMessageId
|
String
|
The Amazon SQS message ID. |
CamelAwsSqsDelaySeconds
|
Integer
|
Since Camel 2.11, the delay seconds that the Amazon SQS message can be see by others. |
Message headers set by the SQS consumer
Header | Type | Description |
---|---|---|
CamelAwsSqsMD5OfBody
|
String
|
The MD5 checksum of the Amazon SQS message. |
CamelAwsSqsMessageId
|
String
|
The Amazon SQS message ID. |
CamelAwsSqsReceiptHandle
|
String
|
The Amazon SQS message receipt handle. |
CamelAwsSqsAttributes
|
Map<String, String>
|
The Amazon SQS message attributes. |
Advanced AmazonSQS configuration
AWSCredentials awsCredentials = new BasicAWSCredentials("myAccessKey", "mySecretKey"); ClientConfiguration clientConfiguration = new ClientConfiguration(); clientConfiguration.setProxyHost("http://myProxyHost"); clientConfiguration.setProxyPort(8080); AmazonSQS client = new AmazonSQSClient(awsCredentials, clientConfiguration); registry.bind("client", client);
from("aws-sqs://MyQueue?amazonSQSClient=#client&delay=5000&maxMessagesPerPoll=5") .to("mock:result");
Dependencies
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-aws</artifactId> <version>${camel-version}</version> </dependency>
$\{camel-version\}
must be replaced by the actual version of Camel (2.6 or higher).
JMS-style Selectors
visibilityTimeout
. When SQS dispatches a message, it will wait up to the visibility timeout before it will try to dispatch the message to a different consumer unless a DeleteMessage is received. By default, Camel will always send the DeleteMessage at the end of the route, unless the route ended in failure. To achieve appropriate filtering and not send the DeleteMessage even on successful completion of the route, use a Filter:
from("aws-sqs://MyQueue?amazonSQSClient=#client&defaultVisibilityTimeout=5000&deleteIfFiltered=false") .filter("${header.login} == true") .to("mock:result");
10.9. AWS-SWF
SWF Component
URI Format
aws-swf://<workflow|activity>[?options]
URI Options
Name
|
Default Value
|
Context
|
Description
|
---|---|---|---|
amazonSWClient
|
null
|
All |
A reference to a com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflowClient in the Registry.
|
accessKey
|
null
|
All
|
Amazon AWS Access Key.
|
secretKey
|
null
|
All
|
Amazon AWS Secret Key.
|
sWClient.XXX
|
null
|
All
|
Properties to set on AmazonSimpleWorkflowClient in use.
|
clientConfiguration.XXX
|
null
|
All
|
Properties to set on ClientConfiguration in use.
|
startWorkflowOptions.XXX
|
null
|
Workflow/Producer
|
Properties to set on useStartWorkflowOptions in use.
|
operation
|
START
|
Workflow/Producer
|
The operation to perform on the workflow. Supported operations are:
SIGNAL , CANCEL , TERMINATE , GET_STATE , START , DESCRIBE , GET_HISTORY .
|
domainName
|
null
|
All
|
The workflow domain to use.
|
activityList
|
null
|
Activity/Consumer
|
The list name to consume activities from.
|
workflowList
|
null
|
Workflow/Consumer
|
The list name to consume workflows from.
|
eventName
|
null
|
All | The workflow or activity event name to use. |
version
|
null
|
All | The workflow or activity event version to use. |
signalName
|
null
|
Workflow/Producer | The name of the signal to send to the workflow. |
childPolicy
|
null
|
Workflow/Producer | The policy to use on child workflows when terminating a workflow. |
terminationReason
|
null
|
Workflow/Producer | The reason for terminating a workflow. |
stateResultType
|
Object
|
Workflow/Producer | The type of the result when a workflow state is queried. |
terminationDetails
|
null
|
Workflow/Producer | Details for terminating a workflow. |
dataConverter
|
JsonDataConverter
|
All |
An instance of com.amazonaws.services.simpleworkflow.flow.DataConverter to use for serializing/deserializing the data.
|
activitySchedulingOptions
|
null
|
Activity/Producer |
An instance of ActivitySchedulingOptions used to specify different timeout options.
|
activityTypeExecutionOptions
|
null
|
Activity/Consumer |
An instance of ActivityTypeExecutionOptions .
|
activityTypeRegistrationOptions
|
null
|
Activity/Consumer |
An instance of ActivityTypeRegistrationOptions .
|
workflowTypeRegistrationOptions
|
null
|
Workflow/Consumer |
An instance of WorkflowTypeRegistrationOptions .
|
Usage
Message headers evaluated by the SWF Workflow Producer
Header
|
Type
|
Description
|
---|---|---|
CamelSWFOperation
|
String
|
The operation to perform on the workflow. Supported operations are: SIGNAL, CANCEL, TERMINATE, GET_STATE, START, DESCRIBE, GET_HISTORY.
|
CamelSWFWorkflowId
|
String
|
A workflow ID to use.
|
CamelAwsDdbKeyCamelSWFRunId
|
String
|
A worfklow run ID to use.
|
CamelSWFStateResultType
|
String
|
The type of the result when a workflow state is queried.
|
CamelSWFEventName
|
String
|
The workflow or activity event name to use.
|
CamelSWFVersion
|
String
|
The workflow or activity event version to use.
|
CamelSWFReason
|
String
|
The reason for terminating a workflow.
|
CamelSWFDetails
|
String
|
Details for terminating a workflow.
|
CamelSWFChildPolicy
|
String
|
The policy to use on child workflows when terminating a workflow.
|
Message headers set by the SWF Workflow Producer
Header
|
Type
|
Description
|
---|---|---|
CamelSWFWorkflowId
|
String
|
The worfklow ID used or newly generated.
|
CamelAwsDdbKeyCamelSWFRunId
|
String
|
The worfklow run ID used or generated.
|
Message headers set by the SWF Workflow Consumer
Header
|
Type
|
Description
|
---|---|---|
CamelSWFAction
|
String
|
Indicates what type is the current event: CamelSWFActionExecute, CamelSWFSignalReceivedAction or CamelSWFGetStateAction.
|
CamelSWFWorkflowReplaying
|
boolean
|
Indicates whether the current decision task is a replay or not.
|
CamelSWFWorkflowStartTime
|
long
|
The time of the start event for this decision task.
|
Message headers set by the SWF Activity Producer
Header
|
Type
|
Description
|
---|---|---|
CamelSWFEventName
|
String
|
The activity name to schedule.
|
CamelSWFVersion
|
String
|
The activity version to schedule.
|
Message headers set by the SWF Activity Consumer
Header
|
Type
|
Description
|
---|---|---|
CamelSWFTaskToken
|
String
|
The task token that is required to report task completion for manually completed tasks.
|
Advanced amazonSWClient configuration
#client
refers to a AmazonSimpleWorkflowClient in the Registry.
AWSCredentials awsCredentials = new BasicAWSCredentials("myAccessKey", "mySecretKey"); ClientConfiguration clientConfiguration = new ClientConfiguration(); clientConfiguration.setProxyHost("http://myProxyHost"); clientConfiguration.setProxyPort(8080); AmazonSimpleWorkflowClient client = new AmazonSimpleWorkflowClient(awsCredentials, clientConfiguration); registry.bind("client", client);
Dependencies
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-aws</artifactId> <version>${camel-version}</version> </dependency>
${camel-version
} must be replaced by the actual version of Camel (2.13 or higher).
Chapter 11. Bean
Bean Component
URI format
bean:beanID[?options]
Options
Name | Type | Default | Description |
---|---|---|---|
method
|
String
|
null
|
The method name from the bean that will be invoked. If not provided, Camel will try to determine the method itself. In case of ambiguity an exception will be thrown. See Bean Binding for more details. |
cache
|
boolean
|
false
|
If enabled, Apache Camel will cache the result of the first Registry look-up. Cache can be enabled if the bean in the Registry is defined as a singleton scope. |
?option=value&option=value&...
Using
spring.xml
; or if you don't use Spring, put the bean in JNDI.
// lets populate the context with the services we need // note that we could just use a spring.xml file to avoid this step JndiContext context = new JndiContext(); context.bind("bye", new SayService("Good Bye!")); CamelContext camelContext = new DefaultCamelContext(context);
// lets add simple route camelContext.addRoutes(new RouteBuilder() { public void configure() { from("direct:hello").to("bean:bye"); } });
createProxy()
methods on ProxyHelper to create a proxy that will generate BeanExchanges and send them to any endpoint:
Endpoint endpoint = camelContext.getEndpoint("direct:hello"); ISay proxy = ProxyHelper.createProxy(endpoint, ISay.class); String rc = proxy.say(); assertEquals("Good Bye!", rc);
<route> <from uri="direct:hello"> <to uri="bean:bye"/> </route>
Bean as endpoint
<camelContext xmlns="http://camel.apache.org/schema/spring"> <route> <from uri="direct:start"/> <to uri="myBean"/> <to uri="mock:results"/> </route> </camelContext> <bean id="myBean" class="org.apache.camel.spring.bind.ExampleBean"/>
myBean
, Apache Camel will use the Bean Binding to invoke the bean. The source for the bean is just a plain POJO:
public class ExampleBean { public String sayHello(String name) { return "Hello " + name + "!"; } }
sayHello
method, by converting the Exchange's In body to the String
type and storing the output of the method on the Exchange Out body.
Java DSL bean syntax
to("bean:beanName")
) you can use the following syntax:
// Send message to the bean endpoint // and invoke method resolved using Bean Binding. from("direct:start").beanRef("beanName"); // Send message to the bean endpoint // and invoke given method. from("direct:start").beanRef("beanName", "methodName");
// Send message to the given bean instance. from("direct:start").bean(new ExampleBean()); // Explicit selection of bean method to be invoked. from("direct:start").bean(new ExampleBean(), "methodName"); // Camel will create the instance of bean and cache it for you. from("direct:start").bean(ExampleBean.class);
Bean Binding
- Class component
Chapter 12. Bean Validator
Bean Validator Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-bean-validator</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
bean-validator:label[?options]
bean-validator://label[?options]
label
is an arbitrary text value describing the endpoint. You can append query options to the URI in the following format, ?option=value&option=value&...
URI Options
Option | Default | Description |
---|---|---|
group
|
javax.validation.groups.Default
|
The custom validation group to use. |
messageInterpolator
|
org.hibernate.validator.engine. ResourceBundleMessageInterpolator
|
Reference to a custom javax.validation.MessageInterpolator in the Registry.
|
traversableResolver
|
org.hibernate.validator.engine.resolver. DefaultTraversableResolver
|
Reference to a custom javax.validation.TraversableResolver in the Registry.
|
constraintValidatorFactory
|
org.hibernate.validator.engine. ConstraintValidatorFactoryImpl
|
Reference to a custom javax.validation.ConstraintValidatorFactory in the Registry.
|
OSGi deployment
ValidationProviderResolver
implementation, just as org.apache.camel.component.bean.validator.HibernateValidationProviderResolver
. The snippet below demonstrates this approach. Keep in mind that you can use HibernateValidationProviderResolver
starting from the Camel 2.13.0.
Example 12.1. Using HibernateValidationProviderResolver
from("direct:test") .to("bean-validator://ValidationProviderResolverTest?validationProviderResolver=#myValidationProviderResolver"); ... <bean id="myValidationProviderResolver" class="org.apache.camel.component.bean.validator.HibernateValidationProviderResolver"/>
ValidationProviderResolver
is defined and the validator component has been deployed into the OSGi environment, the HibernateValidationProviderResolver
will be automatically used.
Example
// Java public class Car { @NotNull private String manufacturer; @NotNull @Size(min = 5, max = 14, groups = OptionalChecks.class) private String licensePlate; // getter and setter }
public interface OptionalChecks { }
javax.validation.groups.Default
).
from("direct:start") .to("bean-validator://x") .to("mock:end")
OptionalChecks
, you have to define the route like this
from("direct:start") .to("bean-validator://x?group=OptionalChecks") .to("mock:end")
@GroupSequence({Default.class, OptionalChecks.class}) public interface AllChecks { }
from("direct:start") .to("bean-validator://x?group=AllChecks") .to("mock:end")
<bean id="myMessageInterpolator" class="my.ConstraintValidatorFactory" /> <bean id="myTraversableResolver" class="my.TraversableResolver" /> <bean id="myConstraintValidatorFactory" class="my.ConstraintValidatorFactory" /> from("direct:start") .to("bean-validator://x?group=AllChecks&messageInterpolator=#myMessageInterpolator&traversableResolver=#myTraversableResolver&constraintValidatorFactory=#myConstraintValidatorFactory") .to("mock:end")
META-INF/validation.xml
which could looks like this
<?xml version="1.0" encoding="UTF-8"?> <validation-config xmlns="http://jboss.org/xml/ns/javax/validation/configuration" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://jboss.org/xml/ns/javax/validation/configuration"> <default-provider>org.hibernate.validator.HibernateValidator</default-provider> <message-interpolator>org.hibernate.validator.engine.ResourceBundleMessageInterpolator</message-interpolator> <traversable-resolver>org.hibernate.validator.engine.resolver.DefaultTraversableResolver</traversable-resolver> <constraint-validator-factory>org.hibernate.validator.engine.ConstraintValidatorFactoryImpl</constraint-validator-factory> <constraint-mapping>/constraints-car.xml</constraint-mapping> </validation-config>
constraints-car.xml
file
<?xml version="1.0" encoding="UTF-8"?> <constraint-mappings xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://jboss.org/xml/ns/javax/validation/mapping validation-mapping-1.0.xsd" xmlns="http://jboss.org/xml/ns/javax/validation/mapping"> <default-package>org.apache.camel.component.bean.validator</default-package> <bean class="CarWithoutAnnotations" ignore-annotations="true"> <field name="manufacturer"> <constraint annotation="javax.validation.constraints.NotNull" /> </field> <field name="licensePlate"> <constraint annotation="javax.validation.constraints.NotNull" /> <constraint annotation="javax.validation.constraints.Size"> <groups> <value>org.apache.camel.component.bean.validator.OptionalChecks</value> </groups> <element name="min">5</element> <element name="max">14</element> </constraint> </field> </bean> </constraint-mappings>
Chapter 13. Beanstalk
Beanstalk component
Dependencies
pom.xml
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-beanstalk</artifactId> <version>${camel-version}</version> </dependency>
${camel-version
} must be replaced by the actual version of Camel (2.15.0 or higher).
URI format
beanstalk://[host[:port]][/tube][?options]
port
or both host
and port
: for the Beanstalk defaults to be used (“localhost” and 11300). If you omit tube
, Beanstalk component will use the tube with name “default”.
beanstalk://localhost:11300/tube1+tube2
Common URI options
Name
|
Default value
|
Description
|
---|---|---|
jobPriority | 1000 | Job priority. (0 is the highest, see Beanstalk protocol) |
jobDelay | 0 | Job delay in seconds. |
jobTimeToRun | 60 | Job time to run in seconds. (when 0, the beanstalkd daemon raises it to 1 automatically, see Beanstalk protocol) |
Producer UIR options
command
parameter which tells what to do with the job, it can be
Name
|
Default value
|
Description
|
---|---|---|
command | put |
|
Consumer UIR options
consumer.awaitJob
parameter, which equals true
by default (following Beanstalkd nature).
delete
on successful job completion and calls bury
on failure. You can choose which command to execute in the case of failure by specifying consumer.onFailure
parameter in the URI. It can take values of bury
, delete
or release
.
consumer.useBlockIO
which corresponds to the same parameter in JavaBeanstalkClient library. By default it is true
.
release
, as the failed job will immediately become available in the same tube and your consumer will try to acquire it again. You can release
and specify jobDelay though.
Name
|
Default value
|
Description
|
---|---|---|
onFailure | bury | Command to use when processing failed. You can choose among: bury, delete or release. |
useBlockIO | true | Whether to use blockIO. |
awaitJob | true | Whether to wait for job to complete before ack the job from beanstalk |
Consumer Headers
Property
|
Type
|
Description
|
---|---|---|
beanstalk.jobId | long | Job ID |
beanstalk.tube | string | the name of the tube that contains this job |
beanstalk.state | string | “ready” or “delayed” or “reserved” or “buried” (must be “reserved”) |
beanstalk.priority | long | the priority value set |
beanstalk.age | int | the time in seconds since the put command that created this job |
beanstalk.time-left | int | the number of seconds left until the server puts this job into the ready queue |
beanstalk.timeouts | int | the number of times this job has timed out during a reservation |
beanstalk.releases | int | the number of times a client has released this job from a reservation |
beanstalk.buries | int | the number of times this job has been buried |
beanstalk.kicks | int | the number of times this job has been kicked |
Examples
from("beanstalk:testTube"). log("Processing job #${property.beanstalk.jobId} with body ${in.body}"). process(new Processor() { @Override public void process(Exchange exchange) { // try to make integer value out of body exchange.getIn().setBody( Integer.valueOf(exchange.getIn().getBody(classOf[String])) ); } }). log("Parsed job #${property.beanstalk.jobId} to body ${in.body}");
from("timer:dig?period=30seconds"). setBody(constant(10)).log("Kick ${in.body} buried/delayed tasks"). to("beanstalk:testTube?command=kick");
Chapter 14. Box
Box Component
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-box</artifactId> <version>${camel-version}</version> </dependency>
URI format
box://endpoint-prefix/endpoint?[options]
- collaborations
- comments
- events
- files
- folders
- groups
- poll-events
- search
- shared-comments
- shared-files
- shared-folders
- shared-items
- users
Box Component
configuration
of type org.apache.camel.component.box.BoxConfiguration
. These options can also be specified in the endpoint URI.
Option
|
Type
|
Description
|
authSecureStorage
|
com.box.boxjavalibv2.authorization.IAuthSecureStorage
|
OAuth Secure Storage callback, can be used to provide and or save OAuth tokens. The callback may return null on first call to allow the component to login and authorize application and obtain an OAuth token, which can then be saved in the secure storage. For the component to be able to create a token automatically a user password must be provided.
|
boxConfig
|
com.box.boxjavalibv2.IBoxConfig
|
Custom Box SDK configuration, not required normally
|
clientId
|
String
|
Box application client ID
|
clientSecret
|
String
|
Box application client secret
|
connectionManagerBuilder
|
com.box.boxjavalibv2.BoxConnectionManagerBuilder
|
Custom Box connection manager builder, used to override default settings like max connections for underlying HttpClient.
|
httpParams
|
java.util.Map
|
Custom HTTP params for settings like proxy host
|
loginTimeout
|
int
|
amount of time the component will wait for a response from Box.com, default is 30 seconds
|
refreshListener
|
com.box.boxjavalibv2.authorization.OAuthRefreshListener
|
OAuth listener for token updates, if the Camel application needs to use the access token outside the route
|
revokeOnShutdown
|
boolean
|
Flag to revoke OAuth refresh token on route shutdown, default false. Will require a fresh refresh token on restart using either a custom IAuthSecureStorage or automatic component login by providing a user password
|
sharedLink
|
String
|
Box shared link for shared-* endpoints, can be a link for a shared comment, file or folder
|
sharedPassword
|
String
|
Password associated with the shared link, MUST be provided with sharedLink
|
userName
|
String
|
Box user name, MUST be provided
|
userPassword
|
String
|
Box user password, MUST be provided if authSecureStorage is not set, or returns null on first call
|
Producer Endpoints:
inBody
that in turn should contain the name of the endpoint option whose value will be contained in the Camel Exchange In message.
CamelBox.<option>
. Note that the inBody
option overrides message header, i.e. the endpoint option inBody=option
would override a CamelBox.option
header.
null
. Note that the null
value will only be used if other options do not satisfy matching endpoints.
Endpoint Prefix collaborations
collaborations
as follows:
box://collaborations/endpoint?[options]
Endpoint
|
Shorthand Alias
|
Options
|
Result Body Type
|
createCollaboration
|
create
|
collabRequest, folderId
|
com.box.boxjavalibv2.dao.BoxCollaboration
|
deleteCollaboration
|
delete
|
collabId, defaultRequest
|
|
getAllCollaborations
|
allCollaborations
|
getAllCollabsRequest
|
java.util.List
|
getCollaboration
|
collaboration
|
collabId, defaultRequest
|
com.box.boxjavalibv2.dao.BoxCollaboration
|
updateCollaboration
|
update
|
collabId, collabRequest
|
com.box.boxjavalibv2.dao.BoxCollaboration
|
URI Options for collaborations
Name
|
Type
|
collabId
|
String
|
collabRequest
|
com.box.boxjavalibv2.requests.requestobjects.BoxCollabRequestObject
|
defaultRequest
|
com.box.restclientv2.requestsbase.BoxDefaultRequestObject
|
folderId
|
String
|
getAllCollabsRequest
|
com.box.boxjavalibv2.requests.requestobjects.BoxGetAllCollabsRequestObject
|
Endpoint Prefix events
events
as follows:
box://events/endpoint?[options]
Endpoint
|
Shorthand Alias
|
Options
|
Result Body Type
|
getEventOptions
|
eventOptions
|
defaultRequest
|
com.box.boxjavalibv2.dao.BoxCollection
|
getEvents
|
events
|
eventRequest
|
com.box.boxjavalibv2.dao.BoxEventCollection
|
URI Options for events
Name
|
Type
|
defaultRequest
|
com.box.restclientv2.requestsbase.BoxDefaultRequestObject
|
eventRequest
|
com.box.boxjavalibv2.requests.requestobjects.BoxEventRequestObject
|
Endpoint Prefix groups
groups
as follows:
box://groups/endpoint?[options]
Endpoint
|
Shorthand Alias
|
Options
|
Result Body Type
|
createGroup
|
|
[groupRequest], [name]
|
com.box.boxjavalibv2.dao.BoxGroup
|
createMembership
|
|
[groupId, role, userId], [groupMembershipRequest]
|
com.box.boxjavalibv2.dao.BoxGroupMembership
|
deleteGroup
|
delete
|
defaultRequest, groupId
|
|
deleteMembership
|
delete
|
defaultRequest, membershipId
|
|
getAllCollaborations
|
allCollaborations
|
defaultRequest, groupId
|
com.box.boxjavalibv2.dao.BoxCollection
|
getAllGroups
|
allGroups
|
defaultRequest
|
com.box.boxjavalibv2.dao.BoxCollection
|
getMembership
|
membership
|
defaultRequest, membershipId
|
com.box.boxjavalibv2.dao.BoxGroupMembership
|
getMemberships
|
memberships
|
defaultRequest, groupId
|
com.box.boxjavalibv2.dao.BoxCollection
|
updateGroup
|
update
|
groupId, groupRequest
|
com.box.boxjavalibv2.dao.BoxGroup
|
updateMembership
|
update
|
[groupMembershipRequest], [role], membershipId
|
com.box.boxjavalibv2.dao.BoxGroupMembership
|
URI Options for groups
Name
|
Type
|
defaultRequest
|
com.box.restclientv2.requestsbase.BoxDefaultRequestObject
|
groupId
|
String
|
groupMembershipRequest
|
com.box.boxjavalibv2.requests.requestobjects.BoxGroupMembershipRequestObject
|
groupRequest
|
com.box.boxjavalibv2.requests.requestobjects.BoxGroupRequestObject
|
membershipId
|
String
|
name
|
String
|
role
|
String
|
userId
|
String
|
Endpoint Prefix search
search
as follows:
box://search/endpoint?[options]
Endpoint
|
Shorthand Alias
|
Options
|
Result Body Type
|
search
|
|
defaultRequest, searchQuery
|
com.box.boxjavalibv2.dao.BoxCollection
|
URI Options for search
Name
|
Type
|
defaultRequest
|
com.box.restclientv2.requestsbase.BoxDefaultRequestObject
|
searchQuery
|
String
|
Endpoint Prefix comments and shared-comments
shared-comments
as follows. The shared-comments prefix requires sharedLink and sharedPassword properties.
box://comments/endpoint?[options] box://shared-comments/endpoint?[options]
Endpoint
|
Shorthand Alias
|
Options
|
Result Body Type
|
addComment
|
|
[commentRequest], [commentedItemId, commentedItemType, message]
|
com.box.boxjavalibv2.dao.BoxComment
|
deleteComment
|
delete
|
commentId, defaultRequest
|
|
getComment
|
comment
|
commentId, defaultRequest
|
com.box.boxjavalibv2.dao.BoxComment
|
updateComment
|
update
|
commentId, commentRequest
|
com.box.boxjavalibv2.dao.BoxComment
|
URI Options for comments and shared-comments
Name
|
Type
|
commentId
|
String
|
commentRequest
|
com.box.boxjavalibv2.requests.requestobjects.BoxCommentRequestObject
|
commentedItemId
|
String
|
commentedItemType
|
com.box.boxjavalibv2.dao.IBoxType
|
defaultRequest
|
com.box.restclientv2.requestsbase.BoxDefaultRequestObject
|
message
|
String
|
Endpoint Prefix files and shared-files
files
or shared-files
as follows. The shared-files
prefix requires sharedLink and sharedPassword properties.
box://files/endpoint?[options] box://shared-files/endpoint?[options]
Endpoint
|
Shorthand Alias
|
Options
|
Result Body Type
|
copyFile
|
|
fileId, itemCopyRequest
|
com.box.boxjavalibv2.dao.BoxFile
|
createSharedLink
|
create
|
fileId, sharedLinkRequest
|
com.box.boxjavalibv2.dao.BoxFile
|
deleteFile
|
|
defaultRequest, fileId
|
|
downloadFile
|
download
|
[destination, listener], [listener, outputStreams], defaultRequest, fileId
|
java.io.InputStream
|
downloadThumbnail
|
download
|
extension, fileId, imageRequest
|
java.io.InputStream
|
getFile
|
file
|
defaultRequest, fileId
|
com.box.boxjavalibv2.dao.BoxFile
|
getFileComments
|
fileComments
|
defaultRequest, fileId
|
com.box.boxjavalibv2.dao.BoxCollection
|
getFileVersions
|
fileVersions
|
defaultRequest, fileId
|
java.util.List
|
getPreview
|
preview
|
extension, fileId, imageRequest
|
com.box.boxjavalibv2.dao.BoxPreview
|
getThumbnail
|
thumbnail
|
extension, fileId, imageRequest
|
com.box.boxjavalibv2.dao.BoxThumbnail
|
updateFileInfo
|
update
|
fileId, fileRequest
|
com.box.boxjavalibv2.dao.BoxFile
|
uploadFile
|
upload
|
fileUploadRequest
|
com.box.boxjavalibv2.dao.BoxFile
|
uploadNewVersion
|
upload
|
fileId, fileUploadRequest
|
com.box.boxjavalibv2.dao.BoxFile
|
URI Options for files and shared-files
Name
|
Type
|
defaultRequest
|
com.box.restclientv2.requestsbase.BoxDefaultRequestObject
|
destination
|
java.io.File
|
extension
|
String
|
fileId
|
String
|
fileRequest
|
com.box.boxjavalibv2.requests.requestobjects.BoxFileRequestObject
|
fileUploadRequest
|
com.box.restclientv2.requestsbase.BoxFileUploadRequestObject
|
imageRequest
|
com.box.boxjavalibv2.requests.requestobjects.BoxImageRequestObject
|
itemCopyRequest
|
com.box.boxjavalibv2.requests.requestobjects.BoxItemCopyRequestObject
|
listener
|
com.box.boxjavalibv2.filetransfer.IFileTransferListener
|
outputStreams
|
java.io.OutputStream[]
|
sharedLinkRequest
|
com.box.boxjavalibv2.requests.requestobjects.BoxSharedLinkRequestObject
|
Endpoint Prefix folders and shared-folders
folders
or shared-folders
as follows. The prefix shared-folders requires sharedLink and sharedPassword properties.
box://folders/endpoint?[options] box://shared-folders/endpoint?[options]
Endpoint
|
Shorthand Alias
|
Options
|
Result Body Type
|
copyFolder
|
|
folderId, itemCopyRequest
|
com.box.boxjavalibv2.dao.BoxFolder
|
createFolder
|
create
|
folderRequest
|
com.box.boxjavalibv2.dao.BoxFolder
|
createSharedLink
|
create
|
folderId, sharedLinkRequest
|
com.box.boxjavalibv2.dao.BoxFolder
|
deleteFolder
|
delete
|
folderDeleteRequest, folderId
|
|
getFolder
|
folder
|
defaultRequest, folderId
|
com.box.boxjavalibv2.dao.BoxFolder
|
getFolderCollaborations
|
folderCollaborations
|
defaultRequest, folderId
|
java.util.List
|
getFolderItems
|
folderItems
|
folderId, pagingRequest
|
com.box.boxjavalibv2.dao.BoxCollection
|
updateFolderInfo
|
update
|
folderId, folderRequest
|
com.box.boxjavalibv2.dao.BoxFolder
|
URI Options for folders or shared-folders
Name
|
Type
|
defaultRequest
|
com.box.restclientv2.requestsbase.BoxDefaultRequestObject
|
folderDeleteRequest
|
com.box.boxjavalibv2.requests.requestobjects.BoxFolderDeleteRequestObject
|
folderId
|
String
|
folderRequest
|
com.box.boxjavalibv2.requests.requestobjects.BoxFolderRequestObject
|
itemCopyRequest
|
com.box.boxjavalibv2.requests.requestobjects.BoxItemCopyRequestObject
|
pagingRequest
|
com.box.boxjavalibv2.requests.requestobjects.BoxPagingRequestObject
|
sharedLinkRequest
|
com.box.boxjavalibv2.requests.requestobjects.BoxSharedLinkRequestObject
|
Endpoint Prefix shared-items
shared-items
as follows:
box://shared-items/endpoint?[options]
Endpoint
|
Shorthand Alias
|
Options
|
Result Body Type
|
getSharedItem
|
sharedItem
|
defaultRequest
|
com.box.boxjavalibv2.dao.BoxItem
|
URI Options for shared-items
Name
|
Type
|
defaultRequest
|
com.box.restclientv2.requestsbase.BoxDefaultRequestObject
|
Endpoint Prefix users
users
as follows:
box://users/endpoint?[options]
Endpoint
|
Shorthand Alias
|
Options
|
Result Body Type
|
addEmailAlias
|
|
emailAliasRequest, userId
|
com.box.boxjavalibv2.dao.BoxEmailAlias
|
createEnterpriseUser
|
create
|
userRequest
|
com.box.boxjavalibv2.dao.BoxUser
|
deleteEmailAlias
|
|
defaultRequest, emailId, userId
|
|
deleteEnterpriseUser
|
|
userDeleteRequest, userId
|
|
getAllEnterpriseUser
|
allEnterpriseUser
|
defaultRequest, filterTerm
|
java.util.List
|
getCurrentUser
|
currentUser
|
defaultRequest
|
com.box.boxjavalibv2.dao.BoxUser
|
getEmailAliases
|
emailAliases
|
defaultRequest, userId
|
java.util.List
|
moveFolderToAnotherUser
|
|
folderId, simpleUserRequest, userId
|
com.box.boxjavalibv2.dao.BoxFolder
|
updateUserInformaiton
|
update
|
userId, userRequest
|
com.box.boxjavalibv2.dao.BoxUser
|
updateUserPrimaryLogin
|
update
|
userId, userUpdateLoginRequest
|
com.box.boxjavalibv2.dao.BoxUser
|
URI Options for users
Name
|
Type
|
defaultRequest
|
com.box.restclientv2.requestsbase.BoxDefaultRequestObject
|
emailAliasRequest
|
com.box.boxjavalibv2.requests.requestobjects.BoxEmailAliasRequestObject
|
emailId
|
String
|
filterTerm
|
String
|
folderId
|
String
|
simpleUserRequest
|
com.box.boxjavalibv2.requests.requestobjects.BoxSimpleUserRequestObject
|
userDeleteRequest
|
com.box.boxjavalibv2.requests.requestobjects.BoxUserDeleteRequestObject
|
userId
|
String
|
userRequest
|
com.box.boxjavalibv2.requests.requestobjects.BoxUserRequestObject
|
userUpdateLoginRequest
|
com.box.boxjavalibv2.requests.requestobjects.BoxUserUpdateLoginRequestObject
|
Consumer Endpoints:
box://poll-events/endpoint?[options]
Endpoint
|
Shorthand Alias
|
Options
|
Result Body Type
|
poll
|
|
limit, streamPosition, streamType
|
com.box.boxjavalibv2.dao.BoxEvent by default, or com.box.boxjavalibv2.dao.BoxEventCollection when consumer.splitResult=false
|
URI Options for poll-events
Name
|
Type
|
limit
|
Integer
|
streamPosition
|
Long
|
streamType
|
String
|
splitResult
|
boolean
|
Message header
Message body
Type Converter
Use cases
from("file:...") .to("box://files/upload/inBody=fileUploadRequest");
from("box://poll-events/poll?streamPosition=-1&streamType=all&limit=100") .to("bean:blah");
from("direct:foo") .setHeader("CamelBox.fileId", header("fileId")) .to("box://files/download") .to("file://...");
Chapter 15. Browse
Browse Component
URI format
browse:someName
Sample
browse:
component to be able to browse the Exchanges that are passing through:
from("activemq:order.in").to("browse:orderReceived").to("bean:processOrder");
private CamelContext context; public void inspectRecievedOrders() { BrowsableEndpoint browse = context.getEndpoint("browse:orderReceived", BrowsableEndpoint.class); List<Exchange> exchanges = browse.getExchanges(); ... // then we can inspect the list of received exchanges from Java for (Exchange exchange : exchanges) { String payload = exchange.getIn().getBody(); ... } }
Chapter 16. Cache
16.1. Cache Component
Available as of Camel 2.1
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-cache</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
cache://cacheName[?options]
?option=value&option=#beanRef&...
Options
Name | Default Value | Description |
---|---|---|
maxElementsInMemory
|
1000
|
The number of elements that may be stored in the defined cache |
memoryStoreEvictionPolicy
|
MemoryStoreEvictionPolicy.LFU
|
The number of elements that may be stored in the defined cache. Options include
|
overflowToDisk
|
true
|
Specifies whether cache may overflow to disk |
eternal
|
false
|
Sets whether elements are eternal. If eternal, timeouts are ignored and the element never expires.
|
timeToLiveSeconds
|
300
|
The maximum time between creation time and when an element expires. Is used only if the element is not eternal
|
timeToIdleSeconds
|
300
|
The maximum amount of time between accesses before an element expires |
diskPersistent
|
false
|
Whether the disk store persists between restarts of the Virtual Machine. |
diskExpiryThreadIntervalSeconds
|
120
|
The number of seconds between runs of the disk expiry thread. |
cacheManagerFactory
|
null
|
Camel 2.8: If you want to use a custom factory which instantiates and creates the EHCache net.sf.ehcache.CacheManager . Type: abstract org.apache.camel.component.cache.CacheManagerFactory
|
eventListenerRegistry
|
null
|
Camel 2.8: Sets a list of EHCache net.sf.ehcache.event.CacheEventListener for all new caches\- no need to define it per cache in EHCache xml config anymore. Type: org.apache.camel.component.cache.CacheEventListenerRegistry
|
cacheLoaderRegistry
|
null
|
Camel 2.8: Sets a list of org.apache.camel.component.cache.CacheLoaderWrapper that extends EHCache net.sf.ehcache.loader.CacheLoader for all new caches\- no need to define it per cache in EHCache xml config anymore. Type: org.apache.camel.component.cache.CacheLoaderRegistry
|
key
|
null
|
Camel 2.10: To configure using a cache key by default. If a key is provided in the message header, then the key from the header takes precedence. |
operation
|
null
|
Camel 2.10: To configure using an cache operation by default. If an operation in the message header, then the operation from the header takes precedence. |
objectCache
|
false
|
Camel 2.10: Whether to turn on allowing to store non serializable objects in the cache. If this option is enabled then overflow to disk cannot be enabled as well. |
configurationFile
|
|
Camel 2.13/2.12.3: To configure the location of the
ehcache.xml file to use, such as classpath:com/foo/mycache.xml to load from classpath. If no configuration is given, then the default settings from EHCache is used.
|
configuration
|
|
To use a custom
org.apache.camel.component.cache.CacheConfiguration configuration.
|
Cache component options
Name
|
Default Value
|
Description
|
---|---|---|
configuration
|
|
To use a custom
org.apache.camel.component.cache.CacheConfiguration configuration.
|
cacheManagerFactory
|
|
To use a custom
org.apache.camel.component.cache.CacheManagerFactory .
|
configurationFile
|
|
Camel 2.13/2.12.3: To configure the location of the
ehcache.xml file to use, such as classpath:com/foo/mycache.xml to load from classpath. If no configuration is given, then the default settings from EHCache is used.
|
Message Headers Camel 2.8+
Header | Description |
---|---|
CamelCacheOperation
|
The operation to be performed on the cache. The valid options are
|
CamelCacheKey
|
The cache key used to store the Message in the cache. The cache key is optional if the CamelCacheOperation is CamelCacheDeleteAll
|
CamelCache
and use mixed case. This makes them easier to identify and keep separate from other headers. The CacheConstants
variable names remain unchanged, just their values have been changed. Also, these headers are now removed from the exchange after the cache operation is performed.
CamelCacheAdd
and CamelCacheUpdate
operations support additional headers:
Header | Type | Description |
---|---|---|
CamelCacheTimeToLive
|
Integer
|
Camel 2.11: Time to live in seconds. |
CamelCacheTimeToIdle
|
Integer
|
Camel 2.11: Time to idle in seconds. |
CamelCacheEternal
|
Boolean
|
Camel 2.11: Whether the content is eternal. |
Cache Producer
- setting the Message Exchange Headers shown above.
- ensuring that the Message Exchange Body contains the message directed to the cache
Cache Consumer
- an exchange containing Message Exchange Headers and a Message Exchange Body containing the just added/updated payload is placed and sent.
- in case of a CamelCacheDeleteAll operation, the Message Exchange Header CamelCacheKey and the Message Exchange Body are not populated.
Cache Processors
- body
- token
- xpath level
Example 1: Configuring the cache
from("cache://MyApplicationCache" + "?maxElementsInMemory=1000" + "&memoryStoreEvictionPolicy=" + "MemoryStoreEvictionPolicy.LFU" + "&overflowToDisk=true" + "&eternal=true" + "&timeToLiveSeconds=300" + "&timeToIdleSeconds=true" + "&diskPersistent=true" + "&diskExpiryThreadIntervalSeconds=300")
Example 2: Adding keys to the cache
RouteBuilder builder = new RouteBuilder() { public void configure() { from("direct:start") .setHeader(CacheConstants.CACHE_OPERATION, constant(CacheConstants.CACHE_OPERATION_ADD)) .setHeader(CacheConstants.CACHE_KEY, constant("Ralph_Waldo_Emerson")) .to("cache://TestCache1") } };
Example 2: Updating existing keys in a cache
RouteBuilder builder = new RouteBuilder() { public void configure() { from("direct:start") .setHeader(CacheConstants.CACHE_OPERATION, constant(CacheConstants.CACHE_OPERATION_UPDATE)) .setHeader(CacheConstants.CACHE_KEY, constant("Ralph_Waldo_Emerson")) .to("cache://TestCache1") } };
Example 3: Deleting existing keys in a cache
RouteBuilder builder = new RouteBuilder() { public void configure() { from("direct:start") .setHeader(CacheConstants.CACHE_OPERATION, constant(CacheConstants.CACHE_DELETE)) .setHeader(CacheConstants.CACHE_KEY", constant("Ralph_Waldo_Emerson")) .to("cache://TestCache1") } };
Example 4: Deleting all existing keys in a cache
RouteBuilder builder = new RouteBuilder() { public void configure() { from("direct:start") .setHeader(CacheConstants.CACHE_OPERATION, constant(CacheConstants.CACHE_DELETEALL)) .to("cache://TestCache1"); } };
Example 5: Notifying any changes registering in a Cache to Processors and other Producers
RouteBuilder builder = new RouteBuilder() { public void configure() { from("cache://TestCache1") .process(new Processor() { public void process(Exchange exchange) throws Exception { String operation = (String) exchange.getIn().getHeader(CacheConstants.CACHE_OPERATION); String key = (String) exchange.getIn().getHeader(CacheConstants.CACHE_KEY); Object body = exchange.getIn().getBody(); // Do something } }) } };
Example 6: Using Processors to selectively replace payload with cache values
RouteBuilder builder = new RouteBuilder() { public void configure() { //Message Body Replacer from("cache://TestCache1") .filter(header(CacheConstants.CACHE_KEY).isEqualTo("greeting")) .process(new CacheBasedMessageBodyReplacer("cache://TestCache1","farewell")) .to("direct:next"); //Message Token replacer from("cache://TestCache1") .filter(header(CacheConstants.CACHE_KEY).isEqualTo("quote")) .process(new CacheBasedTokenReplacer("cache://TestCache1","novel","#novel#")) .process(new CacheBasedTokenReplacer("cache://TestCache1","author","#author#")) .process(new CacheBasedTokenReplacer("cache://TestCache1","number","#number#")) .to("direct:next"); //Message XPath replacer from("cache://TestCache1"). .filter(header(CacheConstants.CACHE_KEY).isEqualTo("XML_FRAGMENT")) .process(new CacheBasedXPathReplacer("cache://TestCache1","book1","/books/book1")) .process (new CacheBasedXPathReplacer("cache://TestCache1","book2","/books/book2")) .to("direct:next"); } };
Example 7: Getting an entry from the Cache
from("direct:start") // Prepare headers .setHeader(CacheConstants.CACHE_OPERATION, constant(CacheConstants.CACHE_OPERATION_GET)) .setHeader(CacheConstants.CACHE_KEY, constant("Ralph_Waldo_Emerson")). .to("cache://TestCache1"). // Check if entry was not found .choice().when(header(CacheConstants.CACHE_ELEMENT_WAS_FOUND).isNull()). // If not found, get the payload and put it to cache .to("cxf:bean:someHeavyweightOperation"). .setHeader(CacheConstants.CACHE_OPERATION, constant(CacheConstants.CACHE_OPERATION_ADD)) .setHeader(CacheConstants.CACHE_KEY, constant("Ralph_Waldo_Emerson")) .to("cache://TestCache1") .end() .to("direct:nextPhase");
Example 8: Checking for an entry in the Cache
from("direct:start") // Prepare headers .setHeader(CacheConstants.CACHE_OPERATION, constant(CacheConstants.CACHE_OPERATION_CHECK)) .setHeader(CacheConstants.CACHE_KEY, constant("Ralph_Waldo_Emerson")). .to("cache://TestCache1"). // Check if entry was not found .choice().when(header(CacheConstants.CACHE_ELEMENT_WAS_FOUND).isNull()). // If not found, get the payload and put it to cache .to("cxf:bean:someHeavyweightOperation"). .setHeader(CacheConstants.CACHE_OPERATION, constant(CacheConstants.CACHE_OPERATION_ADD)) .setHeader(CacheConstants.CACHE_KEY, constant("Ralph_Waldo_Emerson")) .to("cache://TestCache1") .end();
Management of EHCache
<bean id="ehCacheManagementService" class="net.sf.ehcache.management.ManagementService" init-method="init" lazy-init="false"> <constructor-arg> <bean class="net.sf.ehcache.CacheManager" factory-method="getInstance"/> </constructor-arg> <constructor-arg> <bean class="org.springframework.jmx.support.JmxUtils" factory-method="locateMBeanServer"/> </constructor-arg> <constructor-arg value="true"/> <constructor-arg value="true"/> <constructor-arg value="true"/> <constructor-arg value="true"/> </bean>
ManagementService.registerMBeans(CacheManager.getInstance(), mbeanServer, true, true, true, true);
Cache replication Camel 2.8+
- You can configure
ehcache.xml
manually, or - You can configure these three options:
cacheManagerFactory
eventListenerRegistry
cacheLoaderRegistry
ehcache.xml
is not a good idea.
CacheManager
and per CacheEndpoint
. Also it is the only way when cache names are not know at the development phase.
Example: JMS cache replication
16.2. cacheReplicationJMSExample
Example: JMS cache replication
CacheManagerFactory
.
public class TestingCacheManagerFactory extends CacheManagerFactory { [...] //This constructor is very useful when using Camel with Spring/Blueprint public TestingCacheManagerFactory(String xmlName, TopicConnection replicationTopicConnection, Topic replicationTopic, QueueConnection getQueueConnection, Queue getQueue) { this.xmlName = xmlName; this.replicationTopicConnection = replicationTopicConnection; this.replicationTopic = replicationTopic; this.getQueue = getQueue; this.getQueueConnection = getQueueConnection; } @Override protected synchronized CacheManager createCacheManagerInstance() { //Singleton if (cacheManager == null) { cacheManager = new WrappedCacheManager(getClass().getResourceAsStream(xmlName)); } return cacheManager; } //Wrapping Ehcache's CacheManager to be able to add JMSCacheManagerPeerProvider public class WrappedCacheManager extends CacheManager { public WrappedCacheManager(InputStream xmlConfig) { super(xmlConfig); JMSCacheManagerPeerProvider jmsCMPP = new JMSCacheManagerPeerProvider(this, replicationTopicConnection, replicationTopic, getQueueConnection, getQueue, AcknowledgementMode.AUTO_ACKNOWLEDGE, true); cacheManagerPeerProviders.put(jmsCMPP.getScheme(), jmsCMPP); jmsCMPP.init(); } } }
CacheLoaderWrapper
, the easiest one is:
public class WrappedJMSCacheLoader implements CacheLoaderWrapper { [...] //This constructor is very useful when using Camel with Spring/Blueprint public WrappedJMSCacheLoader(QueueConnection getQueueConnection, Queue getQueue, AcknowledgementMode acknowledgementMode, int timeoutMillis) { this.getQueueConnection = getQueueConnection; this.getQueue = getQueue; this.acknowledgementMode = acknowledgementMode; this.timeoutMillis = timeoutMillis; } @Override public void init(Ehcache cache) { jmsCacheLoader = new JMSCacheLoader(cache, defaultLoaderArgument, getQueueConnection, getQueue, acknowledgementMode, timeoutMillis); } @Override public CacheLoader clone(Ehcache arg0) throws CloneNotSupportedException { return jmsCacheLoader.clone(arg0); } @Override public void dispose() throws CacheException { jmsCacheLoader.dispose(); } [...] }
- cacheManagerFactory
- eventListenerRegistry
- cacheLoaderRegistry
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:camel="http://camel.apache.org/schema/spring" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd"> <bean id="queueConnection1" factory-bean="amqCF" factory-method="createQueueConnection" class="javax.jms.QueueConnection" /> <bean id="topicConnection1" factory-bean="amqCF" factory-method="createTopicConnection" class="javax.jms.TopicConnection" /> <bean id="queue1" class="org.apache.activemq.command.ActiveMQQueue"> <constructor-arg ref="getQueue" /> </bean> <bean id="topic1" class="org.apache.activemq.command.ActiveMQTopic"> <constructor-arg ref="getTopic" /> </bean> <bean id="jmsListener1" class="net.sf.ehcache.distribution.jms.JMSCacheReplicator"> <constructor-arg index="0" value="true" /> <constructor-arg index="1" value="true" /> <constructor-arg index="2" value="true" /> <constructor-arg index="3" value="true" /> <constructor-arg index="4" value="false" /> <constructor-arg index="5" value="0" /> </bean> <bean id="jmsLoader1" class="my.cache.replication.WrappedJMSCacheLoader"> <constructor-arg index="0" ref="queueConnection1" /> <constructor-arg index="1" ref="queue1" /> <constructor-arg index="2" value="AUTO_ACKNOWLEDGE" /> <constructor-arg index="3" value="30000" /> </bean> <bean id="cacheManagerFactory1" class="my.cache.replication.TestingCacheManagerFactory"> <constructor-arg index="0" value="ehcache_jms_test.xml" /> <constructor-arg index="1" ref="topicConnection1" /> <constructor-arg index="2" ref="topic1" /> <constructor-arg index="3" ref="queueConnection1" /> <constructor-arg index="4" ref="queue1" /> </bean> <bean id="eventListenerRegistry1" class="org.apache.camel.component.cache.CacheEventListenerRegistry"> <constructor-arg> <list> <ref bean="jmsListener1" /> </list> </constructor-arg> </bean> <bean id="cacheLoaderRegistry1" class="org.apache.camel.component.cache.CacheLoaderRegistry"> <constructor-arg> <list> <ref bean="jmsLoader1"/> </list> </constructor-arg> </bean> </beans>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:camel="http://camel.apache.org/schema/spring" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd"> <bean id="getQueue" class="java.lang.String"> <constructor-arg value="replicationGetQueue" /> </bean> <bean id="getTopic" class="java.lang.String"> <constructor-arg value="replicationTopic" /> </bean> <!-- Import the xml file explained at step three --> <import resource="JMSReplicationCache1.xml"/> <camelContext xmlns="http://camel.apache.org/schema/spring"> <camel:endpoint id="fooCache1" uri="cache:foo?cacheManagerFactory=#cacheManagerFactory1&ventListenerRegistry=#eventListenerRegistry1&acheLoaderRegistry=#cacheLoaderRegistry1"/> <camel:route> <camel:from uri="direct:addRoute"/> <camel:setHeader headerName="CamelCacheOperation"> <camel:constant>CamelCacheAdd</camel:constant> </camel:setHeader> <camel:setHeader headerName="CamelCacheKey"> <camel:constant>foo</camel:constant> </camel:setHeader> <camel:to ref="fooCache1"/> </camel:route> </camelContext> <bean id="amqCF" class="org.apache.activemq.ActiveMQConnectionFactory"> <property name="brokerURL" value="vm://localhost?broker.persistent=false"/> </bean> <bean id="activemq" class="org.apache.camel.component.jms.JmsComponent"> <property name="connectionFactory"> <ref bean="amqCF"/> </property> </bean> </beans>
Chapter 17. Cassandra
Camel Cassandra Component
pom.xml
:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-cassandraql</artifactId> <version>x.y.z</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
URI | Description |
---|---|
cql:localhost/keyspace
|
Single host, default port, usual for testing |
cql:host1,host2/keyspace
|
Multi host, default port |
cql:host1,host2:9042/keyspace
|
Multi host, custom port |
cql:host1,host2
|
Default port and keyspace |
cql:bean:sessionRef
|
Provided Session reference |
cql:bean:clusterRef/keyspace
|
Provided Cluster reference |
Endpoint Options
Option | Default | Description |
---|---|---|
clusterName
|
Cluster name
|
|
username and password
|
Session authentication
|
|
cql
|
CQL query. Can be overriden with a message header.
|
|
consistencyLevel
|
ANY , ONE , TWO , QUORUM , LOCAL_QUORUM ...
|
|
prepareStatements
|
true
|
Use prepared statement (default) or not |
resultSetConversionStrategy
|
ALL
|
How is ResultSet converted transformed into message body
ALL , ONE , LIMIT_10 , LIMIT_100 ...
|
Messages
Incoming Message
Object
or Object[]
or Collection<Object>
) which will be bound to the CQL statement as query parameters. If message body is null or empty, then CQL query will be executed without binding parameters.
CamelCqlQuery
(optional,String
orRegularStatement
): CQL query either as a plain String or built using theQueryBuilder
.
Outgoing Message
resultSetConversionStrategy
:
List<Row>
ifresultSetConversionStrategy
isALL
orLIMIT_[0-9]+
- Single
Row
ifresultSetConversionStrategy
isONE
- Anything else, if
resultSetConversionStrategy
is a custom implementation of theResultSetConversionStrategy
Repositories
Idempotent repository
NamedCassandraIdempotentRepository
stores messages keys in a Cassandra table like this:
CREATE TABLE CAMEL_IDEMPOTENT ( NAME varchar, -- Repository name KEY varchar, -- Message key PRIMARY KEY (NAME, KEY) ) WITH compaction = {'class':'LeveledCompactionStrategy'} AND gc_grace_seconds = 86400;
CassandraIdempotentRepository
does not have a NAME
column and can be extended to use a different data model.
Option | Default | Description |
---|---|---|
table
|
CAMEL_IDEMPOTENT
|
Table name |
pkColumns
|
NAME , KEY
|
Primary key columns |
name
|
Repository name, value used for NAME column
|
|
ttl
|
Key time to live | |
writeConsistencyLevel
|
Consistency level used to insert/delete key: ANY , ONE , TWO , QUORUM , LOCAL_QUORUM …
|
|
readConsistencyLevel
|
Consistency level used to read/check key: ONE , TWO , QUORUM , LOCAL_QUORUM …
|
Aggregation repository
NamedCassandraAggregationRepository
stores exchanges by correlation key in a Cassandra table like this:
CREATE TABLE CAMEL_AGGREGATION ( NAME varchar, -- Repository name KEY varchar, -- Correlation id EXCHANGE_ID varchar, -- Exchange id EXCHANGE blob, -- Serialized exchange PRIMARY KEY (NAME, KEY) ) WITH compaction = {'class':'LeveledCompactionStrategy'} AND gc_grace_seconds = 86400;
CassandraAggregationRepository
does not have a NAME
column and can be extended to use a different data model.
Option | Default | Description |
---|---|---|
table
|
CAMEL_AGGREGATION
|
Table name |
pkColumns
|
NAME ,KEY
|
Primary key columns |
exchangeIdColumn
|
EXCHANGE_ID
|
Exchange Id column |
exchangeColumn
|
EXCHANGE
|
Exchange content column |
name
|
Repository name, value used for NAME column
|
|
ttl
|
Exchange time to live | |
writeConsistencyLevel
|
Consistency level used to insert/delete exchange: ANY , ONE , TWO , QUORUM , LOCAL_QUORUM …
|
|
readConsistencyLevel
|
Consistency level used to read/check exchange: ONE , TWO , QUORUM , LOCAL_QUORUM …
|
Chapter 18. Chunk
Chunk Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-chunk</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
chunk:templateName[?options]
?option=value&option=value&...
Options
Option
|
Default
|
Description
|
---|---|---|
encoding
|
null
|
Character encoding of the resource content.
|
themesFolder
|
null
|
Alternative folder to scan for a template name.
|
themeSubfolder
|
null
|
Alternative subfolder to scan for a template name if themeFolder parameter is set.
|
themeLayer
|
null
|
A specific layer of a template file to use as template.
|
extension
|
null
|
Alternative extension to scan for a template name if themeFolder and themeSubfolder are set.
|
Chunk Context
Map
). The Exchange
is transferred as:
key
|
value
|
---|---|
exchange
|
The
Exchange itself.
|
exchange.properties
|
The
Exchange properties.
|
headers
|
The headers of the In message.
|
camelContext
|
The Camel Context.
|
request
|
The In message.
|
body
|
The In message body.
|
response
|
The Out message (only for InOut message exchange pattern).
|
Dynamic templates
Header
|
Type
|
Description
|
Support Version
|
---|---|---|---|
ChunkConstants.CHUNK_RESOURCE_URI
|
String
|
A URI for the template resource to use instead of the endpoint configured.
|
|
ChunkConstants.CHUNK_TEMPLATE
|
String
|
The template to use instead of the endpoint configured.
|
|
Samples
from("activemq:My.Queue"). to("chunk:template");
JMSReplyTo
header).
from("activemq:My.Queue"). to("chunk:template"). to("activemq:Another.Queue");
from("direct:in"). setHeader(ChunkConstants.CHUNK_RESOURCE_URI).constant("template"). to("chunk:dummy");
from("direct:in"). to("chunk:file_example?themeFolder=template&themeSubfolder=subfolder&extension=chunk");
The Email Sample
Dear {$headers.lastName}, {$headers.firstName} Thanks for the order of {$headers.item}. Regards Camel Riders Bookstore {$body}
Chapter 19. Class
Class Component
URI format
class:className[?options]
Options
Name | Type | Default | Description |
---|---|---|---|
method
|
String
|
null
|
The method name that bean will be invoked. If not provided, Apache Camel will try to pick the method itself. In case of ambiguity an exception is thrown. See Bean Binding for more details. |
multiParameterArray
|
boolean
|
false
|
How to treat the parameters which are passed from the message body; if it is true , the In message body should be an array of parameters.
|
?option=value&option=value&...
Using
MyFooBean
you have to do as follows:
from("direct:start").to("class:org.apache.camel.component.bean.MyFooBean").to("mock:result");
MyFooBean
, for example hello
:
from("direct:start").to("class:org.apache.camel.component.bean.MyFooBean?method=hello").to("mock:result");
Setting properties on the created instance
setPrefix
method:
from("direct:start") .to("class:org.apache.camel.component.bean.MyPrefixBean?prefix=Bye") .to("mock:result");
#
syntax to refer to properties to be looked up in the Registry.
from("direct:start") .to("class:org.apache.camel.component.bean.MyPrefixBean?cool=#foo") .to("mock:result");
foo
and invoke the setCool
method on the created instance of the MyPrefixBean
class.
Chapter 20. CMIS
CMIS Component
URI Format
cmis://cmisServerUrl[?options]
URI Options
Name | Default Value | Context | Description |
---|---|---|---|
queryMode |
false
|
Producer | If true, will execute the cmis query from the message body and return result, otherwise will create a node in the cmis repository |
query |
String
|
Consumer | The cmis query to execute against the repository. If not specified, the consumer will retrieve every node from the content repository by iterating the content tree recursively |
username |
null
|
Both | Username for the cmis repository |
password |
null
|
Both | Password for the cmis repository |
repositoryId |
null
|
Both | The Id of the repository to use. If not specified the first available repository is used |
pageSize |
100
|
Both | Number of nodes to retrieve per page |
readCount |
0
|
Both | Max number of nodes to read |
readContent |
false
|
Both | If set to true, the content of document node will be retrieved in addition to the properties |
Usage
Message headers evaluated by the producer
Header | Default Value | Description |
---|---|---|
CamelCMISFolderPath
|
/
|
The current folder to use during the execution. If not specified will use the root folder |
CamelCMISRetrieveContent
|
false
|
In queryMode this header will force the producer to retrieve the content of document nodes.
|
CamelCMISReadSize
|
0
|
Max number of nodes to read. |
cmis:path
|
null
|
If CamelCMISFolderPath is not set, will try to find out the path of the node from this cmis property and it is name
|
cmis:name
|
null
|
If CamelCMISFolderPath is not set, will try to find out the path of the node from this cmis property and it is path
|
cmis:objectTypeId
|
null
|
The type of the node |
cmis:contentStreamMimeType
|
null
|
The mimetype to set for a document |
Message headers set during querying Producer operation
Header | Type | Description |
---|---|---|
CamelCMISResultCount
|
Integer
|
Number of nodes returned from the query. |
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-cmis</artifactId> <version>${camel-version}</version> </dependency>
${camel-version}
must be replaced by the actual version of Camel (2.11 or higher).
Chapter 21. Cometd
Cometd Component
URI format
cometd://host:port/channelName[?options]
Examples
cometd://localhost:8080/service/mychannel cometds://localhost:8443/service/mychannel
cometds:
represents an SSL configured endpoint.
Options
Name | Default Value | Description |
---|---|---|
resourceBase
|
The root directory for the web resources or classpath. Use the protocol file: or classpath: depending if you want that the component loads the resource from file system or classpath. Classpath is required for OSGI deployment where the resources are packaged in the jar | |
baseResource
|
Camel 2.7: The root directory for the web resources or classpath. Use the protocol file: or classpath: depending if you want that the component loads the resource from file system or classpath. Classpath is required for OSGI deployment where the resources are packaged in the jar | |
timeout
|
240000
|
The server side poll timeout in milliseconds. This is how long the server will hold a reconnect request before responding. |
interval
|
0
|
The client side poll timeout in milliseconds. How long a client will wait between reconnects |
maxInterval
|
30000
|
The max client side poll timeout in milliseconds. A client will be removed if a connection is not received in this time. |
multiFrameInterval
|
1500
|
The client side poll timeout, if multiple connections are detected from the same browser. |
jsonCommented
|
true
|
If true , the server will accept JSON wrapped in a comment and will generate JSON wrapped in a comment. This is a defence against Ajax Hijacking.
|
logLevel
|
1
|
0 =none, 1 =info, 2 =debug.
|
sslContextParameters |
Camel 2.9: Reference to a org.apache.camel.util.jsse.SSLContextParameters in the Registry. This reference overrides any configured SSLContextParameters at the component level. See Using the JSSE Configuration Utility.
|
|
crossOriginFilterOn
|
false
|
Camel 2.10: If true , the server will support for cross-domain filtering
|
allowedOrigins
|
*
|
Camel 2.10: The origins domain that support to cross, if the crosssOriginFilterOn is true
|
filterPath
|
Camel 2.10: The filterPath will be used by the CrossOriginFilter, if the crosssOriginFilterOn is true
|
|
disconnectLocalSession
|
true
|
Camel 2.10.5/2.11.1: (Producer only): Whether to disconnect local sessions after publishing a message to its channel. Disconnecting local session is needed as they are not swept by default by CometD, and therefore you can run out of memory. |
?option=value&option=value&...
cometd://localhost:8080?resourceBase=file./webapp
. For classpath (when the web resources are packaged inside the Webapp folder) cometd://localhost:8080?resourceBase=classpath:webapp
.
Authentication
SecurityPolicy
and Extension
's to the CometdComponent
which allows you to use authentication as documented here
Setting up SSL for Cometd Component
Using the JSSE Configuration Utility
CometdComponent
class.
Programmatic configuration of the component
KeyStoreParameters ksp = new KeyStoreParameters(); ksp.setResource("/users/home/server/keystore.jks"); ksp.setPassword("keystorePassword"); KeyManagersParameters kmp = new KeyManagersParameters(); kmp.setKeyStore(ksp); kmp.setKeyPassword("keyPassword"); TrustManagersParameters tmp = new TrustManagersParameters(); tmp.setKeyStore(ksp); SSLContextParameters scp = new SSLContextParameters(); scp.setKeyManagers(kmp); scp.setTrustManagers(tmp); CometdComponent commetdComponent = getContext().getComponent("cometds", CometdComponent.class); commetdComponent.setSslContextParameters(scp);
Spring DSL based configuration of endpoint
... <camel:sslContextParameters id="sslContextParameters"> <camel:keyManagers keyPassword="keyPassword"> <camel:keyStore resource="/users/home/server/keystore.jks" password="keystorePassword"/> </camel:keyManagers> <camel:trustManagers> <camel:keyStore resource="/users/home/server/keystore.jks" password="keystorePassword"/> </camel:keyManagers> </camel:sslContextParameters> <bean id="cometd" class="org. apache. camel. component.cometd.CometdComponent"> <property name="sslContextParameters" ref="sslContextParameters"/> </bean> ... <to uri="cometds://127.0.0.1:443/service/test?baseResource=file:./target/test-classes/webapp&timeout=240000&interval=0&maxInterval=30000&multiFrameInterval=1500&jsonCommented=true&logLevel=2&sslContextParameters=#sslContextParameters"/>...
Chapter 22. Context
Context Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-context</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
context:camelContextId:localEndpointName[?options]
camelContextId:localEndpointName[?options]
- camelContextId is the ID you used to register the CamelContext into the Registry.
- localEndpointName can be a valid Camel URI evaluated within the black box CamelContext. Or it can be a logical name which is mapped to any local endpoints. For example if you locally have endpoints like direct:invoices and seda:purchaseOrders inside a CamelContext of id supplyChain, then you can just use the URIs supplyChain:invoices or supplyChain:purchaseOrders to omit the physical endpoint kind and use pure logical URIs.
?option=value&option=value&...
Example
Defining the context component
// lets create our black box as a camel context and a set of routes DefaultCamelContext blackBox = new DefaultCamelContext(registry); blackBox.setName("blackBox"); blackBox.addRoutes(new RouteBuilder() { @Override public void configure() throws Exception { // receive purchase orders, lets process it in some way then send an invoice // to our invoice endpoint from("direct:purchaseOrder"). setHeader("received").constant("true"). to("direct:invoice"); } }); blackBox.start(); registry.bind("accounts", blackBox);
<camelContext id="accounts" xmlns="http://camel.apache.org/schema/spring"> <route> <from uri="direct:purchaseOrder"/> ... <to uri="direct:invoice"/> </route> </camelContext>
Using the context component
<camelContext xmlns="http://camel.apache.org/schema/spring"> <route> <!-- consume from an ActiveMQ into the black box --> <from uri="activemq:Accounts.PurchaseOrders"/> <to uri="accounts:purchaseOrders"/> </route> <route> <!-- lets send invoices from the black box to a different ActiveMQ Queue --> <from uri="accounts:invoice"/> <to uri="activemq:UK.Accounts.Invoices"/> </route> </camelContext>
Naming endpoints
Chapter 23. ControlBus Component
ControlBus Component
controlbus:command[?options]
Commands
Command | Description |
---|---|
route
|
To control routes using the routeId and action parameter.
|
language
|
Allows you to specify a Language to use for evaluating the message body. If there is any result from the evaluation, then the result is put in the message body. |
Options
Name | Default Value | Description |
---|---|---|
routeId
|
null
|
To specify a route by its id .
|
action
|
null
|
To denote an action that can be either: start , stop , or status . To either start or stop a route, or to get the status of the route as output in the message body. You can use suspend and resume from Camel 2.11.1 onwards to either suspend or resume a route. And from Camel 2.11.1 onwards you can use stats to get performance statics returned in XML format; the routeId option can be used to define which route to get the performance stats for, if routeId is not defined, then you get statistics for the entire CamelContext.
|
async
|
false
|
Whether to execute the control bus task asynchronously. Important: If this option is enabled, then any result from the task is not set on the Exchange. This is only possible if executing tasks synchronously. |
loggingLevel
|
INFO
|
Logging level used for logging when task is done, or if any exceptions occurred during processing the task. |
?option=value&option=value&...
Samples
Using route command
template.sendBody("controlbus:route?routeId=foo&action=start", null);
String status = template.requestBody("controlbus:route?routeId=foo&action=status", null, String.class);
Getting performance statistics
String xml = template.requestBody("controlbus:route?routeId=foo&action=stats", null, String.class);
dumpRouteStatsAsXml
operation on the ManagedRouteMBean
.
String xml = template.requestBody("controlbus:route?action=stats", null, String.class);
Using Simple language
"controlbus:language:simple"
endpoint containing the following message:
template.sendBody("controlbus:language:simple", "${camelContext.stopRoute('myRoute')}");
String status = template.requestBody("controlbus:language:simple", "${camelContext.getRouteStatus('myRoute')}", String.class);
route
command to control lifecycle of routes. The language
command allows you to execute a language script that has stronger powers such as Groovy or to some extend the Simple language.
template.sendBody("controlbus:language:simple?async=true", "${camelContext.stop()}");
async=true
to stop Camel asynchronously as otherwise we would be trying to stop Camel while it was in-flight processing the message we sent to the control bus component.
- ControlBus EIP
- JMX Component
- Using JMX with Camel
Chapter 24. CouchDB
Camel CouchDB component
- As a consumer, monitors couch changesets for inserts, updates and deletes and publishes these as messages into camel routes.
- As a producer, can save or update documents into couch.
- Can support as many endpoints as required, eg for multiple databases across multiple instances.
- Ability to have events trigger for only deletes, only inserts/updates or all (default).
- Headers set for sequenceId, document revision, document id, and HTTP method type.
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-couchdb</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
couchdb:http://hostname[:port]/database?[options]
Options
Property | Default | Description |
---|---|---|
deletes
|
true
|
document deletes are published as events |
updates
|
true
|
document inserts/updates are published as events |
heartbeat
|
30000
|
how often to send an empty message to keep socket alive in millis |
createDatabase
|
true
|
create the database if it does not already exist |
username
|
null
|
username in case of authenticated databases |
password
|
null
|
password for authenticated databases |
Headers
Property | Value |
---|---|
CouchDbDatabase
|
the database the message came from |
CouchDbSeq
|
the couchdb changeset sequence number of the update / delete message |
CouchDbId
|
the couchdb document id |
CouchDbRev
|
the couchdb document revision |
CouchDbMethod
|
the method (delete / update) |
Message Body
Samples
from("couchdb:http://localhost:9999").process(someProcessor);
from("couchdb:http://localhost:9999?updates=false").process(someProcessor);
from("someProducingEndpoint").process(someProcessor).to("couchdb:http://localhost:9999")
Chapter 25. Crypto (Digital Signatures)
Crypto component for Digital Signatures
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-crypto</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
Introduction
- Bruce Schneier's Applied Cryptography
- Beginning Cryptography with Java by David Hook
- The ever insightful, Wikipedia Digital_signatures
URI format
crypto:sign:name[?options] crypto:verify:name[?options]
crypto:sign
creates the signature and stores it in the Header keyed by the constantExchange.SIGNATURE
, i.e."CamelDigitalSignature"
.crypto:verify
will read in the contents of this header and do the verification calculation.
PrivateKey
and verify a PublicKey
(or a Certificate
containing one). Using the JCE is is very simple to generate these key pairs but it is usually most secure to use a KeyStore to house and share your keys. The DSL is very flexible about how keys are supplied and provides a number of mechanisms.
crypto:sign
endpoint is typically defined in one route and the complimentary crypto:verify
in another, though for simplicity in the examples they appear one after the other. It goes without saying that both sign and verify should be configured identically.
Options
Name | Type | Default | Description |
---|---|---|---|
algorithm
|
String
|
DSA
|
The name of the JCE Signature algorithm that will be used. |
alias
|
String
|
null
|
An alias name that will be used to select a key from the keystore. |
bufferSize
|
Integer
|
2048
|
the size of the buffer used in the signature process. |
certificate
|
Certificate
|
null
|
A Certificate used to verify the signature of the exchange's payload. Either this or a Public Key is required. |
keystore
|
KeyStore
|
null
|
A reference to a JCE Keystore that stores keys and certificates used to sign and verify. |
provider
|
String
|
null
|
The name of the JCE Security Provider that should be used. |
privateKey
|
PrivatKey
|
null
|
The private key used to sign the exchange's payload. |
publicKey
|
PublicKey
|
null
|
The public key used to verify the signature of the exchange's payload. |
secureRandom
|
secureRandom
|
null
|
A reference to a SecureRandom object that wil lbe used to initialize the Signature service.
|
password
|
char[]
|
null
|
The password for the keystore. |
clearHeaders
|
String
|
true
|
Remove camel crypto headers from Message after a verify operation (value can be "true" /{{"false"}}).
|
1) Raw keys
from("direct:keypair").to("crypto:sign://basic?privateKey=#myPrivateKey", "crypto:verify://basic?publicKey=#myPublicKey", "mock:result");
<route> <from uri="direct:keypair"/> <to uri="crypto:sign://basic?privateKey=#myPrivateKey" /> <to uri="crypto:verify://basic?publicKey=#myPublicKey" /> <to uri="mock:result"/> </route>
2) KeyStores and Aliases.
from("direct:keystore").to("crypto:sign://keystore?keystore=#keystore&alias=bob&password=letmein", "crypto:verify://keystore?keystore=#keystore&alias=bob", "mock:result");
<route> <from uri="direct:keystore"/> <to uri="crypto:sign://keystore?keystore=#keystore&lias=bob&assword=letmein" /> <to uri="crypto:verify://keystore?keystore=#keystore&lias=bob" /> <to uri="mock:result"/> </route>
3) Changing JCE Provider and Algorithm
KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA"); keyGen.initialize(512, new SecureRandom()); keyPair = keyGen.generateKeyPair(); PrivateKey privateKey = keyPair.getPrivate(); PublicKey publicKey = keyPair.getPublic(); // we can set the keys explicitly on the endpoint instances. context.getEndpoint("crypto:sign://rsa?algorithm=MD5withRSA", DigitalSignatureEndpoint.class).setPrivateKey(privateKey); context.getEndpoint("crypto:verify://rsa?algorithm=MD5withRSA", DigitalSignatureEndpoint.class).setPublicKey(publicKey); from("direct:algorithm").to("crypto:sign://rsa?algorithm=MD5withRSA", "crypto:verify://rsa?algorithm=MD5withRSA", "mock:result");
from("direct:provider").to("crypto:sign://provider?privateKey=#myPrivateKey&provider=SUN", "crypto:verify://provider?publicKey=#myPublicKey&provider=SUN", "mock:result");
<route> <from uri="direct:algorithm"/> <to uri="crypto:sign://rsa?algorithm=MD5withRSA&rivateKey=#rsaPrivateKey" /> <to uri="crypto:verify://rsa?algorithm=MD5withRSA&ublicKey=#rsaPublicKey" /> <to uri="mock:result"/> </route>
<route> <from uri="direct:provider"/> <to uri="crypto:sign://provider?privateKey=#myPrivateKey&rovider=SUN" /> <to uri="crypto:verify://provider?publicKey=#myPublicKey&rovider=SUN" /> <to uri="mock:result"/> </route>
4) Changing the Signature Mesasge Header
from("direct:signature-header").to("crypto:sign://another?privateKey=#myPrivateKey&signatureHeader=AnotherDigitalSignature", "crypto:verify://another?publicKey=#myPublicKey&signatureHeader=AnotherDigitalSignature", "mock:result");
<route> <from uri="direct:signature-header"/> <to uri="crypto:sign://another?privateKey=#myPrivateKey&ignatureHeader=AnotherDigitalSignature" /> <to uri="crypto:verify://another?publicKey=#myPublicKey&ignatureHeader=AnotherDigitalSignature" /> <to uri="mock:result"/> </route>
5) Changing the buffersize
from("direct:buffersize").to("crypto:sign://buffer?privateKey=#myPrivateKey&buffersize=1024", "crypto:verify://buffer?publicKey=#myPublicKey&buffersize=1024", "mock:result");
<route> <from uri="direct:buffersize" /> <to uri="crypto:sign://buffer?privateKey=#myPrivateKey&uffersize=1024" /> <to uri="crypto:verify://buffer?publicKey=#myPublicKey&uffersize=1024" /> <to uri="mock:result"/> </route>
6) Supplying Keys dynamically.
Exchange.SIGNATURE_PRIVATE_KEY
,"CamelSignaturePrivateKey"
Exchange.SIGNATURE_PUBLIC_KEY_OR_CERT
,"CamelSignaturePublicKeyOrCert"
from("direct:headerkey-sign").to("crypto:sign://alias"); from("direct:headerkey-verify").to("crypto:verify://alias", "mock:result");
<route> <from uri="direct:headerkey-sign"/> <to uri="crypto:sign://headerkey" /> </route> <route> <from uri="direct:headerkey-verify"/> <to uri="crypto:verify://headerkey" /> <to uri="mock:result"/> </route>
Exchange.KEYSTORE_ALIAS
,"CamelSignatureKeyStoreAlias"
from("direct:alias-sign").to("crypto:sign://alias?keystore=#keystore"); from("direct:alias-verify").to("crypto:verify://alias?keystore=#keystore", "mock:result");
<route> <from uri="direct:alias-sign"/> <to uri="crypto:sign://alias?keystore=#keystore" /> </route> <route> <from uri="direct:alias-verify"/> <to uri="crypto:verify://alias?keystore=#keystore" /> <to uri="mock:result"/> </route>
Exchange unsigned = getMandatoryEndpoint("direct:alias-sign").createExchange(); unsigned.getIn().setBody(payload); unsigned.getIn().setHeader(DigitalSignatureConstants.KEYSTORE_ALIAS, "bob"); unsigned.getIn().setHeader(DigitalSignatureConstants.KEYSTORE_PASSWORD, "letmein".toCharArray()); template.send("direct:alias-sign", unsigned); Exchange signed = getMandatoryEndpoint("direct:alias-sign").createExchange(); signed.getIn().copyFrom(unsigned.getOut()); signed.getIn().setHeader(KEYSTORE_ALIAS, "bob"); template.send("direct:alias-verify", signed);
- Crypto is also available as a Data Format
Chapter 26. CXF
CXF Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-cxf</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
WHICH-JARS
text file.
URI format
cxf:bean:cxfEndpoint[?options]
cxf://someAddress[?options]
cxf:bean:cxfEndpoint?wsdlURL=wsdl/hello_world.wsdl&dataFormat=PAYLOAD
Options
Name | Required | Description |
---|---|---|
wsdlURL
|
No |
The location of the WSDL. WSDL is obtained from endpoint address by default. For example:
file://local/wsdl/hello.wsdl or wsdl/hello.wsdl
|
serviceClass
|
Yes |
The name of the SEI (Service Endpoint Interface) class. This class can have, but does not require, JSR181 annotations. Since 2.0, this option is only required by POJO mode. If the wsdlURL option is provided, serviceClass is not required for PAYLOAD and MESSAGE mode. When wsdlURL option is used without serviceClass, the serviceName and portName (endpointName for Spring configuration) options MUST be provided.
Since 2.0, it is possible to use
# notation to reference a serviceClass object instance from the registry..
Please be advised that the referenced object cannot be a Proxy (Spring AOP Proxy is OK) as it relies on
Object.getClass().getName() method for non Spring AOP Proxy.
Since 2.8, it is possible to omit both wsdlURL and serviceClass options for PAYLOAD and MESSAGE mode. When they are omitted, arbitrary XML elements can be put in CxfPayload's body in PAYLOAD mode to facilitate CXF Dispatch Mode.
For example:
org.apache.camel.Hello
|
serviceName
|
Only if more than one serviceName present in WSDL
|
The service name this service is implementing, it maps to the
wsdl:service@name . For example:
{http://org.apache.camel}ServiceName
|
endpointName
|
Only if more than one portName under the serviceName is present, and it is required for camel-cxf consumer since camel 2.2
|
The port name this service is implementing, it maps to the
wsdl:port@name . For example:
{http://org.apache.camel}PortName
|
dataFormat
|
No |
Which message data format the CXF endpoint supports. Possible values are: POJO (default), PAYLOAD , MESSAGE .
|
relayHeaders
|
No |
Please see the Description ofrelayHeaders option section for this option. Should a CXF endpoint relay headers along the route. Currently only available when dataFormat=POJO Default: true Example: true , false
|
wrapped
|
No |
Which kind of operation the CXF endpoint producer will invoke. Possible values are: true , false (default).
|
wrappedStyle
|
No |
Since 2.5.0 The WSDL style that describes how parameters are represented in the SOAP body. If the value is false , CXF will chose the document-literal unwrapped style, If the value is true , CXF will chose the document-literal wrapped style
|
setDefaultBus
|
No |
Specifies whether or not to use the default CXF bus for this endpoint. Possible values are: true , false (default).
|
bus
|
No |
Use
# notation to reference a bus object from the registry—for example, bus=#busName . The referenced object must be an instance of org.apache.cxf.Bus .
By default, uses the default bus created by CXF Bus Factory.
|
cxfBinding
|
No |
Use
# notation to reference a CXF binding object from the registry—for example, cxfBinding=#bindingName . The referenced object must be an instance of org.apache.camel.component.cxf.CxfBinding .
|
headerFilterStrategy
|
No |
Use # notation to reference a header filter strategy object from the registry—for example, headerFilterStrategy=#strategyName . The referenced object must be an instance of org.apache.camel.spi.HeaderFilterStrategy .
|
loggingFeatureEnabled
|
No |
New in 2.3, this option enables CXF Logging Feature which writes inbound and outbound SOAP messages to log. Possible values are: true , false (default).
|
defaultOperationName
|
No |
New in 2.4, this option will set the default
operationName that will be used by the CxfProducer that invokes the remote service. For example:
defaultOperationName =greetMe
|
defaultOperationNamespace
|
No |
New in 2.4, this option will set the default operationNamespace that will be used by the CxfProducer which invokes the remote service. For example:
defaultOperationNamespace = http://apache.org/hello_world_soap_http
|
synchronous
|
No |
New in 2.5, this option will let CXF endpoint decide to use sync or async API to do the underlying work. The default value is false , which means camel-cxf endpoint will try to use async API by default.
|
publishedEndpointUrl
|
No |
New in 2.5, this option overrides the endpoint URL that appears in the published WSDL that is accessed using the service address URL plus
?wsdl . For example:
publshedEndpointUrl=http://example.com/service
|
properties.propName
|
No |
Camel 2.8: Allows you to set custom CXF properties in the endpoint URI. For example, setting properties.mtom-enabled=true to enable MTOM. To make sure that CXF does not switch the thread when starting the invocation, you can set properties.org.apache.cxf.interceptor.OneWayProcessorInterceptor.USE_ORIGINAL_THREAD=true .
|
allowStreaming
|
No | New in 2.8.2. This option controls whether the CXF component, when running in PAYLOAD mode (see below), will DOM parse the incoming messages into DOM Elements or keep the payload as a javax.xml.transform.Source object that would allow streaming in some cases. |
skipFaultLogging
|
No | New in 2.11. This option controls whether the PhaseInterceptorChain skips logging the Fault that it catches. |
cxfEndpointConfigurer
|
No
|
New in Camel 2.11. This option could apply the implementation of
org.apache.camel.component.cxf.CxfEndpointConfigurer which supports to configure the CXF endpoint in programmatic way. Since Camel 2.15.0, user can configure the CXF server and client by implementing configure{Server|Client} method of CxfEndpointConfigurer .
|
username
|
No
|
New in Camel 2.12.3 This option is used to set the basic authentication information of username for the CXF client.
|
password
|
No
|
New in Camel 2.12.3 This option is used to set the basic authentication information of password for the CXF client.
|
continuationTimeout
|
No
|
New in Camel 2.14.0 This option is used to set the CXF continuation timeout which could be used in CxfConsumer by default when the CXF server is using Jetty or Servlet transport. (Before Camel 2.14.0, CxfConsumer just set the continuation timeout to be 0, which means the continuation suspend operation never timeout.)
Default: 30000 Example: continuation=80000
|
serviceName
and portName
are QNames, so if you provide them be sure to prefix them with their {namespace}
as shown in the examples above.
The descriptions of the dataformats
DataFormat | Description |
---|---|
POJO
|
POJOs (plain old Java objects) are the Java parameters to the method being invoked on the target server. Both Protocol and Logical JAX-WS handlers are supported. |
PAYLOAD
|
PAYLOAD is the message payload (the contents of the soap:body ) after message configuration in the CXF endpoint is applied. Only Protocol JAX-WS handler is supported. Logical JAX-WS handler is not supported.
|
MESSAGE
|
MESSAGE is the raw message that is received from the transport layer. It is not suppose to touch or change Stream, some of the CXF interceptors will be removed if you are using this kind of DataFormat so you can't see any soap headers after the camel-cxf consumer and JAX-WS handler is not supported.
|
CXF_MESSAGE
|
New in Camel 2.8.2, CXF_MESSAGE allows for invoking the full capabilities of CXF interceptors by converting the message from the transport layer into a raw SOAP message
|
CamelCXFDataFormat
. The exchange key constant is defined in org.apache.camel.component.cxf.CxfConstants.DATA_FORMAT_PROPERTY
.
Configuring the CXF Endpoints with Apache Aries Blueprint.
<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:cm="http://aries.apache.org/blueprint/xmlns/blueprint-cm/v1.0.0" xmlns:camel-cxf="http://camel.apache.org/schema/blueprint/cxf" xmlns:cxfcore="http://cxf.apache.org/blueprint/core" xsi:schemaLocation="http://www.osgi.org/xmlns/blueprint/v1.0.0 http://www.osgi.org/xmlns/blueprint/v1.0.0/blueprint.xsd"> <camel-cxf:cxfEndpoint id="routerEndpoint" address="http://localhost:9001/router" serviceClass="org.apache.servicemix.examples.cxf.HelloWorld"> <camel-cxf:properties> <entry key="dataFormat" value="MESSAGE"/> </camel-cxf:properties> </camel-cxf:cxfEndpoint> <camel-cxf:cxfEndpoint id="serviceEndpoint" address="http://localhost:9000/SoapContext/SoapPort" serviceClass="org.apache.servicemix.examples.cxf.HelloWorld"> </camel-cxf:cxfEndpoint> <camelContext xmlns="http://camel.apache.org/schema/blueprint"> <route> <from uri="routerEndpoint"/> <to uri="log:request"/> </route> </camelContext> </blueprint>
<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:cm="http://aries.apache.org/blueprint/xmlns/blueprint-cm/v1.0.0" xmlns:jaxws="http://cxf.apache.org/blueprint/jaxws" xmlns:cxf="http://cxf.apache.org/blueprint/core" xmlns:camel="http://camel.apache.org/schema/blueprint" xmlns:camelcxf="http://camel.apache.org/schema/blueprint/cxf" xsi:schemaLocation=" http://www.osgi.org/xmlns/blueprint/v1.0.0 http://www.osgi.org/xmlns/blueprint/v1.0.0/blueprint.xsd http://cxf.apache.org/blueprint/jaxws http://cxf.apache.org/schemas/blueprint/jaxws.xsd http://cxf.apache.org/blueprint/core http://cxf.apache.org/schemas/blueprint/core.xsd "> <camelcxf:cxfEndpoint id="reportIncident" address="/camel-example-cxf-blueprint/webservices/incident" wsdlURL="META-INF/wsdl/report_incident.wsdl" serviceClass="org.apache.camel.example.reportincident.ReportIncidentEndpoint"> </camelcxf:cxfEndpoint> <bean id="reportIncidentRoutes" class="org.apache.camel.example.reportincident.ReportIncidentRoutes" /> <camelContext xmlns="http://camel.apache.org/schema/blueprint"> <routeBuilder ref="reportIncidentRoutes"/> </camelContext> </blueprint>
How to enable CXF's LoggingOutInterceptor in MESSAGE mode
LoggingOutInterceptor
outputs outbound message that goes on the wire to logging system (java.util.logging
). Since the LoggingOutInterceptor
is in PRE_STREAM
phase (but PRE_STREAM
phase is removed in MESSAGE
mode), you have to configure LoggingOutInterceptor
to be run during the WRITE
phase. The following is an example.
<bean id="loggingOutInterceptor" class="org.apache.cxf.interceptor.LoggingOutInterceptor"> <!-- it really should have been user-prestream but CXF does have such phase! --> <constructor-arg value="target/write"/> </bean> <cxf:cxfEndpoint id="serviceEndpoint" address="http://localhost:9002/helloworld" serviceClass="org.apache.camel.component.cxf.HelloService"> <cxf:outInterceptors> <ref bean="loggingOutInterceptor"/> </cxf:outInterceptors> <cxf:properties> <entry key="dataFormat" value="MESSAGE"/> </cxf:properties> </cxf:cxfEndpoint>
Description of relayHeaders option
relayHeaders
should be set to true
, which is the default value.
Available only in POJO mode
relayHeaders=true
setting expresses an intent to relay the headers. The actual decision on whether a given header is relayed is delegated to a pluggable instance that implements the MessageHeadersRelay
interface. A concrete implementation of MessageHeadersRelay
will be consulted to decide if a header needs to be relayed or not. There is already an implementation of SoapMessageHeadersRelay
which binds itself to well-known SOAP name spaces. Currently only out-of-band headers are filtered, and in-band headers will always be relayed when relayHeaders=true
. If there is a header on the wire, whose name space is unknown to the runtime, then a fall back DefaultMessageHeadersRelay
will be used, which simply allows all headers to be relayed.
relayHeaders=false
setting asserts that all headers, in-band and out-of-band, will be dropped.
MessageHeadersRelay
implementations overriding or adding additional ones to the list of relays. In order to override a preloaded relay instance just make sure that your MessageHeadersRelay
implementation services the same name spaces as the one you looking to override. Also note, that the overriding relay has to service all of the name spaces as the one you looking to override, or else a runtime exception on route start up will be thrown as this would introduce an ambiguity in name spaces to relay instance mappings.
<cxf:cxfEndpoint ...> <cxf:properties> <entry key="org.apache.camel.cxf.message.headers.relays"> <list> <ref bean="customHeadersRelay"/> </list> </entry> </cxf:properties> </cxf:cxfEndpoint> <bean id="customHeadersRelay" class="org.apache.camel.component.cxf.soap.headers.CustomHeadersRelay"/>
Changes since Release 2.0
POJO
andPAYLOAD
modes are supported. InPOJO
mode, only out-of-band message headers are available for filtering as the in-band headers have been processed and removed from the header list by CXF. The in-band headers are incorporated into theMessageContentList
inPOJO
mode. Thecamel-cxf
component does make any attempt to remove the in-band headers from theMessageContentList
If filtering of in-band headers is required, please usePAYLOAD
mode or plug in a (pretty straightforward) CXF interceptor/JAXWS Handler to the CXF endpoint.- The Message Header Relay mechanism has been merged into
CxfHeaderFilterStrategy
. TherelayHeaders
option, its semantics, and default value remain the same, but it is a property ofCxfHeaderFilterStrategy
. Here is an example of configuring it.<bean id="dropAllMessageHeadersStrategy" class="org.apache.camel.component.cxf.common.header.CxfHeaderFilterStrategy"> <!-- Set relayHeaders to false to drop all SOAP headers --> <property name="relayHeaders" value="false"/> </bean>
Then, your endpoint can reference theCxfHeaderFilterStrategy
.<route> <from uri="cxf:bean:routerNoRelayEndpoint?headerFilterStrategy=#dropAllMessageHeadersStrategy"/> <to uri="cxf:bean:serviceNoRelayEndpoint?headerFilterStrategy=#dropAllMessageHeadersStrategy"/> </route>
- The
MessageHeadersRelay
interface has changed slightly and has been renamed toMessageHeaderFilter
. It is a property ofCxfHeaderFilterStrategy
. Here is an example of configuring user defined Message Header Filters:<bean id="customMessageFilterStrategy" class="org.apache.camel.component.cxf.common.header.CxfHeaderFilterStrategy"> <property name="messageHeaderFilters"> <list> <!-- SoapMessageHeaderFilter is the built in filter. It can be removed by omitting it. --> <bean class="org.apache.camel.component.cxf.common.header.SoapMessageHeaderFilter"/> <!-- Add custom filter here --> <bean class="org.apache.camel.component.cxf.soap.headers.CustomHeaderFilter"/> </list> </property> </bean>
- Other than
relayHeaders
, there are new properties that can be configured inCxfHeaderFilterStrategy
.
Name | Description | type | Required? | Default value |
---|---|---|---|---|
relayHeaders
|
All message headers will be processed by Message Header Filters |
boolean
|
No |
true (1.6.1 behavior)
|
relayAllMessageHeaders
|
All message headers will be propagated (without processing by Message Header Filters) |
boolean
|
No |
false (1.6.1 behavior)
|
allowFilterNamespaceClash
|
If two filters overlap in activation namespace, the property control how it should be handled. If the value is true , last one wins. If the value is false , it will throw an exception
|
boolean
|
No |
false (1.6.1 behavior)
|
Configure the CXF endpoints with Spring
camelContext
tags. When you are invoking the service endpoint, you can set the operationName
and operationNamespace
headers to explicitly state which operation you are calling.
http://camel.apache.org/schema/cxf
as the CXF endpoint's target namespace.
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:cxf="http://camel.apache.org/schema/cxf" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd http://camel.apache.org/schema/cxf http://camel.apache.org/schema/cxf/camel-cxf.xsd http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd "> ...
http://activemq.apache.org/camel/schema/cxfEndpoint
namespace was changed to http://camel.apache.org/schema/cxf
.
schemaLocation
attribute specified on the root beans element. This allows CXF to validate the file and is required. Also note the namespace declarations at the end of the <cxf:cxfEndpoint/>
tag--these are required because the combined {namespace}localName
syntax is presently not supported for this tag's attribute values.
cxf:cxfEndpoint
element supports many additional attributes:
Name | Value |
---|---|
PortName
|
The endpoint name this service is implementing, it maps to the wsdl:port@name . In the format of ns:PORT_NAME where ns is a namespace prefix valid at this scope.
|
serviceName
|
The service name this service is implementing, it maps to the wsdl:service@name . In the format of ns:SERVICE_NAME where ns is a namespace prefix valid at this scope.
|
wsdlURL
|
The location of the WSDL. Can be on the classpath, file system, or be hosted remotely. |
bindingId
|
The bindingId for the service model to use.
|
address
|
The service publish address. |
bus
|
The bus name that will be used in the JAX-WS endpoint. |
serviceClass
|
The class name of the SEI (Service Endpoint Interface) class which could have JSR181 annotation or not. |
Name | Value |
---|---|
cxf:inInterceptors
|
The incoming interceptors for this endpoint. A list of <bean> or <ref> .
|
cxf:inFaultInterceptors
|
The incoming fault interceptors for this endpoint. A list of <bean> or <ref> .
|
cxf:outInterceptors
|
The outgoing interceptors for this endpoint. A list of <bean> or <ref> .
|
cxf:outFaultInterceptors
|
The outgoing fault interceptors for this endpoint. A list of <bean> or <ref> .
|
cxf:properties
|
A properties map which should be supplied to the JAX-WS endpoint. See below. |
cxf:handlers
|
A JAX-WS handler list which should be supplied to the JAX-WS endpoint. See below. |
cxf:dataBinding
|
You can specify the which DataBinding will be use in the endpoint. This can be supplied using the Spring <bean class="MyDataBinding"/> syntax.
|
cxf:binding
|
You can specify the BindingFactory for this endpoint to use. This can be supplied using the Spring <bean class="MyBindingFactory"/> syntax.
|
cxf:features
|
The features that hold the interceptors for this endpoint. A list of <bean> s or <ref> s
|
cxf:schemaLocations
|
The schema locations for endpoint to use. A list of <schemaLocation> s
|
cxf:serviceFactory
|
The service factory for this endpoint to use. This can be supplied using the Spring <bean class="MyServiceFactory"/> syntax
|
dataFormat
and setDefaultBus
properties from a Spring configuration file, as follows:
<cxf:cxfEndpoint id="testEndpoint" address="http://localhost:9000/router" serviceClass="org.apache.camel.component.cxf.HelloService" endpointName="s:PortName" serviceName="s:ServiceName" xmlns:s="http://www.example.com/test"> <cxf:properties> <entry key="dataFormat" value="MESSAGE"/> <entry key="setDefaultBus" value="true"/> </cxf:properties> </cxf:cxfEndpoint>
How to make the camel-cxf component use log4j instead of java.util.logging
java.util.logging
. If you want to change it to log4j
, proceed as follows. Create a file, in the classpath, named META-INF/cxf/org.apache.cxf.logger
. This file should contain the fully-qualified name of the class, org.apache.cxf.common.logging.Log4jLogger
, with no comments, on a single line.
How to let camel-cxf response message with xml start document
<?xml version="1.0" encoding="utf-8"?>
.
Error:sendSms: SoapFault exception: [Client] looks like we got no XML document in [...]
public class WriteXmlDeclarationInterceptor extends AbstractPhaseInterceptor<SoapMessage> { public WriteXmlDeclarationInterceptor() { super(Phase.PRE_STREAM); addBefore(StaxOutInterceptor.class.getName()); } public void handleMessage(SoapMessage message) throws Fault { message.put("org.apache.cxf.stax.force-start-document", Boolean.TRUE); } }
camel-cxf
endpont
<cxf:cxfEndpoint id="routerEndpoint" address="http://localhost:${CXFTestSupport.port2}/CXFGreeterRouterTest/CamelContext/RouterPort" serviceClass="org.apache.hello_world_soap_http.GreeterImpl" skipFaultLogging="true"> <cxf:outInterceptors> <!-- This interceptor will force the CXF server send the XML start document to client --> <bean class="org.apache.camel.component.cxf.WriteXmlDeclarationInterceptor"/> </cxf:outInterceptors> <cxf:properties> <!-- Set the publishedEndpointUrl which could override the service address from generated WSDL as you want --> <entry key="publishedEndpointUrl" value="http://www.simple.com/services/test" /> </cxf:properties> </cxf:cxfEndpoint>
// set up the response context which force start document Map<String, Object> map = new HashMap<String, Object>(); map.put("org.apache.cxf.stax.force-start-document", Boolean.TRUE); exchange.getOut().setHeader(Client.RESPONSE_CONTEXT, map);
How to consume a message from a camel-cxf endpoint in POJO data format
camel-cxf
endpoint consumer POJO
data format is based on the cxf invoker, so the message header has a property with the name of CxfConstants.OPERATION_NAME
and the message body is a list of the SEI method parameters.
public class PersonProcessor implements Processor { private static final transient Logger LOG = LoggerFactory.getLogger(PersonProcessor.class); @SuppressWarnings("unchecked") public void process(Exchange exchange) throws Exception { LOG.info("processing exchange in camel"); BindingOperationInfo boi = (BindingOperationInfo)exchange.getProperty(BindingOperationInfo.class.toString()); if (boi != null) { LOG.info("boi.isUnwrapped" + boi.isUnwrapped()); } // Get the parameters list which element is the holder. MessageContentsList msgList = (MessageContentsList)exchange.getIn().getBody(); Holder<String> personId = (Holder<String>)msgList.get(0); Holder<String> ssn = (Holder<String>)msgList.get(1); Holder<String> name = (Holder<String>)msgList.get(2); if (personId.value == null || personId.value.length() == 0) { LOG.info("person id 123, so throwing exception"); // Try to throw out the soap fault message org.apache.camel.wsdl_first.types.UnknownPersonFault personFault = new org.apache.camel.wsdl_first.types.UnknownPersonFault(); personFault.setPersonId(""); org.apache.camel.wsdl_first.UnknownPersonFault fault = new org.apache.camel.wsdl_first.UnknownPersonFault("Get the null value of person name", personFault); // Since camel has its own exception handler framework, we can't throw the exception to trigger it // We just set the fault message in the exchange for camel-cxf component handling and return exchange.getOut().setFault(true); exchange.getOut().setBody(fault); return; } name.value = "Bonjour"; ssn.value = "123"; LOG.info("setting Bonjour as the response"); // Set the response message, first element is the return value of the operation, // the others are the holders of method parameters exchange.getOut().setBody(new Object[] {null, personId, ssn, name}); } }
How to prepare the message for the camel-cxf endpoint in POJO data format
camel-cxf
endpoint producer is based on the cxf client API. First you need to specify the operation name in the message header, then add the method parameters to a list, and initialize the message with this parameter list. The response message's body is a messageContentsList
, you can get the result from that list.
CxfProducer
will try to use the defaultOperationName
from CxfEndpoint
. If there is no defaultOperationName
set on CxfEndpoint
, it will pick up the first operation name from the operation list.
message.getbody(Object[].class)
, as follows:
Exchange senderExchange = new DefaultExchange(context, ExchangePattern.InOut); final List<String> params = new ArrayList<String>(); // Prepare the request message for the camel-cxf procedure params.add(TEST_MESSAGE); senderExchange.getIn().setBody(params); senderExchange.getIn().setHeader(CxfConstants.OPERATION_NAME, ECHO_OPERATION); Exchange exchange = template.send("direct:EndpointA", senderExchange); org.apache.camel.Message out = exchange.getOut(); // The response message's body is an MessageContentsList which first element is the return value of the operation, // If there are some holder parameters, the holder parameter will be filled in the reset of List. // The result will be extract from the MessageContentsList with the String class type MessageContentsList result = (MessageContentsList)out.getBody(); LOG.info("Received output text: " + result.get(0)); Map<String, Object> responseContext = CastUtils.cast((Map<?, ?>)out.getHeader(Client.RESPONSE_CONTEXT)); assertNotNull(responseContext); assertEquals("We should get the response context here", "UTF-8", responseContext.get(org.apache.cxf.message.Message.ENCODING)); assertEquals("Reply body on Camel is wrong", "echo " + TEST_MESSAGE, result.get(0));
How to deal with the message for a camel-cxf endpoint in PAYLOAD data format
CxfMessage.getBody()
will return an org.apache.camel.component.cxf.CxfPayload
object, which has getters for SOAP message headers and Body elements. This change enables decoupling the native CXF message from the Apache Camel message.
protected RouteBuilder createRouteBuilder() { return new RouteBuilder() { public void configure() { from(SIMPLE_ENDPOINT_URI + "&dataFormat=PAYLOAD").to("log:info").process(new Processor() { @SuppressWarnings("unchecked") public void process(final Exchange exchange) throws Exception { CxfPayload<SoapHeader> requestPayload = exchange.getIn().getBody(CxfPayload.class); List<Source> inElements = requestPayload.getBodySources(); List<Source> outElements = new ArrayList<Source>(); // You can use a customer toStringConverter to turn a CxfPayLoad message into String as you want String request = exchange.getIn().getBody(String.class); XmlConverter converter = new XmlConverter(); String documentString = ECHO_RESPONSE; Element in = new XmlConverter().toDOMElement(inElements.get(0)); // Just check the element namespace if (!in.getNamespaceURI().equals(ELEMENT_NAMESPACE)) { throw new IllegalArgumentException("Wrong element namespace"); } if (in.getLocalName().equals("echoBoolean")) { documentString = ECHO_BOOLEAN_RESPONSE; checkRequest("ECHO_BOOLEAN_REQUEST", request); } else { documentString = ECHO_RESPONSE; checkRequest("ECHO_REQUEST", request); } Document outDocument = converter.toDOMDocument(documentString); outElements.add(new DOMSource(outDocument.getDocumentElement())); // set the payload header with null CxfPayload<SoapHeader> responsePayload = new CxfPayload<SoapHeader>(null, outElements, null); exchange.getOut().setBody(responsePayload); } }); } }; }
How to get and set SOAP headers in POJO mode
POJO
means that the data format is a list of Java objects when the CXF endpoint produces or consumes Camel exchanges. Even though Apache Camel exposes the message body as POJOs in this mode, the CXF component still provides access to read and write SOAP headers. However, since CXF interceptors remove in-band SOAP headers from the header list after they have been processed, only out-of-band SOAP headers are available in POJO mode.
<route> <from uri="cxf:bean:routerRelayEndpointWithInsertion"/> <process ref="InsertRequestOutHeaderProcessor" /> <to uri="cxf:bean:serviceRelayEndpointWithInsertion"/> <process ref="InsertResponseOutHeaderProcessor" /> </route>
org.apache.cxf.headers.Header.list
, which is a constant defined in CXF (org.apache.cxf.headers.Header.HEADER_LIST
). The header value is a List<>
of CXF SoapHeader
objects (org.apache.cxf.binding.soap.SoapHeader
). The following snippet is the InsertResponseOutHeaderProcessor
(that inserts a new SOAP header in the response message). The way to access SOAP headers in both InsertResponseOutHeaderProcessor
and InsertRequestOutHeaderProcessor
are actually the same. The only difference between the two processors is setting the direction of the inserted SOAP header.
public static class InsertResponseOutHeaderProcessor implements Processor { @SuppressWarnings("unchecked") public void process(Exchange exchange) throws Exception { // You should be able to get the header if exchange is routed from camel-cxf endpoint List<SoapHeader> soapHeaders = CastUtils.cast((List<?>)exchange.getIn().getHeader(Header.HEADER_LIST)); if (soapHeaders == null) { // we just create a new soap headers in case the header is null soapHeaders = new ArrayList<SoapHeader>(); } // Insert a new header String xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?><outofbandHeader " + "xmlns=\"http://cxf.apache.org/outofband/Header\" hdrAttribute=\"testHdrAttribute\" " + "xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\" soap:mustUnderstand=\"1\">" + "<name>New_testOobHeader</name><value>New_testOobHeaderValue</value></outofbandHeader>"; SoapHeader newHeader = new SoapHeader(soapHeaders.get(0).getName(), DOMUtils.readXml(new StringReader(xml)).getDocumentElement()); // make sure direction is OUT since it is a response message. newHeader.setDirection(Direction.DIRECTION_OUT); //newHeader.setMustUnderstand(false); soapHeaders.add(newHeader); } }
How to get and set SOAP headers in PAYLOAD mode
CxfPayload
object) in PAYLOAD
mode (see the section called “How to deal with the message for a camel-cxf endpoint in PAYLOAD data format”).
CxfPayload
object, you can invoke the CxfPayload.getHeaders()
method that returns a List
of DOM Elements (SOAP headers).
from(getRouterEndpointURI()).process(new Processor() { @SuppressWarnings("unchecked") public void process(Exchange exchange) throws Exception { CxfPayload<SoapHeader> payload = exchange.getIn().getBody(CxfPayload.class); List<Source> elements = payload.getBodySources(); assertNotNull("We should get the elements here", elements); assertEquals("Get the wrong elements size", 1, elements.size()); Element el = new XmlConverter().toDOMElement(elements.get(0)); elements.set(0, new DOMSource(el)); assertEquals("Get the wrong namespace URI", "http://camel.apache.org/pizza/types", el.getNamespaceURI()); List<SoapHeader> headers = payload.getHeaders(); assertNotNull("We should get the headers here", headers); assertEquals("Get the wrong headers size", headers.size(), 1); assertEquals("Get the wrong namespace URI", ((Element)(headers.get(0).getObject())).getNamespaceURI(), "http://camel.apache.org/pizza/types"); } }) .to(getServiceEndpointURI());
SOAP headers are not available in MESSAGE mode
MESSAGE
mode as SOAP processing is skipped.
How to throw a SOAP Fault from Apache Camel
Fault
from the camel context. Basically, you can use the throwFault
DSL to do that; it works for POJO
, PAYLOAD
and MESSAGE
data format. You can define the soap fault like this:
SOAP_FAULT = new SoapFault(EXCEPTION_MESSAGE, SoapFault.FAULT_CODE_CLIENT); Element detail = SOAP_FAULT.getOrCreateDetail(); Document doc = detail.getOwnerDocument(); Text tn = doc.createTextNode(DETAIL_TEXT); detail.appendChild(tn);
from(routerEndpointURI).setFaultBody(constant(SOAP_FAULT));
MESSAGE
data format, you could set the the SOAP Fault message in the message body and set the response code in the message header.
from(routerEndpointURI).process(new Processor() { public void process(Exchange exchange) throws Exception { Message out = exchange.getOut(); // Set the message body with the out.setBody(this.getClass().getResourceAsStream("SoapFaultMessage.xml")); // Set the response code here out.setHeader(org.apache.cxf.message.Message.RESPONSE_CODE, new Integer(500)); } });
Message.setFault(true)
, as follows:
from("direct:start").onException(SoapFault.class).maximumRedeliveries(0).handled(true) .process(new Processor() { public void process(Exchange exchange) throws Exception { SoapFault fault = exchange .getProperty(Exchange.EXCEPTION_CAUGHT, SoapFault.class); exchange.getOut().setFault(true); exchange.getOut().setBody(fault); } }).end().to(serviceURI);
How to propagate a CXF endpoint's request and response context
CxfExchange exchange = (CxfExchange)template.send(getJaxwsEndpointUri(), new Processor() { public void process(final Exchange exchange) { final List<String> params = new ArrayList<String>(); params.add(TEST_MESSAGE); // Set the request context to the inMessage Map<String, Object> requestContext = new HashMap<String, Object>(); requestContext.put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, JAXWS_SERVER_ADDRESS); exchange.getIn().setBody(params); exchange.getIn().setHeader(Client.REQUEST_CONTEXT , requestContext); exchange.getIn().setHeader(CxfConstants.OPERATION_NAME, GREET_ME_OPERATION); } }); org.apache.camel.Message out = exchange.getOut(); // The output is an object array, the first element of the array is the return value Object\[\] output = out.getBody(Object\[\].class); LOG.info("Received output text: " + output\[0\]); // Get the response context form outMessage Map<String, Object> responseContext = CastUtils.cast((Map)out.getHeader(Client.RESPONSE_CONTEXT)); assertNotNull(responseContext); assertEquals("Get the wrong wsdl opertion name", "{http://apache.org/hello_world_soap_http}greetMe", responseContext.get("javax.xml.ws.wsdl.operation").toString());
Attachment Support
DataHandler Message.getAttachment(String id)
<cxf:cxfEndpoint id="routerEndpoint" address="http://localhost:${CXFTestSupport.port1}/CxfMtomRouterPayloadModeTest/jaxws-mtom/hello" wsdlURL="mtom.wsdl" serviceName="ns:HelloService" endpointName="ns:HelloPort" xmlns:ns="http://apache.org/camel/cxf/mtom_feature"> <cxf:properties> <!-- enable mtom by setting this property to true --> <entry key="mtom-enabled" value="true"/> <!-- set the camel-cxf endpoint data fromat to PAYLOAD mode --> <entry key="dataFormat" value="PAYLOAD"/> </cxf:properties>
Exchange exchange = context.createProducerTemplate().send("direct:testEndpoint", new Processor() { public void process(Exchange exchange) throws Exception { exchange.setPattern(ExchangePattern.InOut); List<Source> elements = new ArrayList<Source>(); elements.add(new DOMSource(DOMUtils.readXml(new StringReader(MtomTestHelper.REQ_MESSAGE)).getDocumentElement())); CxfPayload<SoapHeader> body = new CxfPayload<SoapHeader>(new ArrayList<SoapHeader>(), elements, null); exchange.getIn().setBody(body); exchange.getIn().addAttachment(MtomTestHelper.REQ_PHOTO_CID, new DataHandler(new ByteArrayDataSource(MtomTestHelper.REQ_PHOTO_DATA, "application/octet-stream"))); exchange.getIn().addAttachment(MtomTestHelper.REQ_IMAGE_CID, new DataHandler(new ByteArrayDataSource(MtomTestHelper.requestJpeg, "image/jpeg"))); } }); // process response CxfPayload<SoapHeader> out = exchange.getOut().getBody(CxfPayload.class); Assert.assertEquals(1, out.getBody().size()); Map<String, String> ns = new HashMap<String, String>(); ns.put("ns", MtomTestHelper.SERVICE_TYPES_NS); ns.put("xop", MtomTestHelper.XOP_NS); XPathUtils xu = new XPathUtils(ns); Element oute = new XmlConverter().toDOMElement(out.getBody().get(0)); Element ele = (Element)xu.getValue("//ns:DetailResponse/ns:photo/xop:Include", oute, XPathConstants.NODE); String photoId = ele.getAttribute("href").substring(4); // skip "cid:" ele = (Element)xu.getValue("//ns:DetailResponse/ns:image/xop:Include", oute, XPathConstants.NODE); String imageId = ele.getAttribute("href").substring(4); // skip "cid:" DataHandler dr = exchange.getOut().getAttachment(photoId); Assert.assertEquals("application/octet-stream", dr.getContentType()); MtomTestHelper.assertEquals(MtomTestHelper.RESP_PHOTO_DATA, IOUtils.readBytesFromStream(dr.getInputStream())); dr = exchange.getOut().getAttachment(imageId); Assert.assertEquals("image/jpeg", dr.getContentType()); BufferedImage image = ImageIO.read(dr.getInputStream()); Assert.assertEquals(560, image.getWidth()); Assert.assertEquals(300, image.getHeight());
public static class MyProcessor implements Processor { @SuppressWarnings("unchecked") public void process(Exchange exchange) throws Exception { CxfPayload<SoapHeader> in = exchange.getIn().getBody(CxfPayload.class); // verify request assertEquals(1, in.getBody().size()); Map<String, String> ns = new HashMap<String, String>(); ns.put("ns", MtomTestHelper.SERVICE_TYPES_NS); ns.put("xop", MtomTestHelper.XOP_NS); XPathUtils xu = new XPathUtils(ns); Element body = new XmlConverter().toDOMElement(in.getBody().get(0)); Element ele = (Element)xu.getValue("//ns:Detail/ns:photo/xop:Include", body, XPathConstants.NODE); String photoId = ele.getAttribute("href").substring(4); // skip "cid:" assertEquals(MtomTestHelper.REQ_PHOTO_CID, photoId); ele = (Element)xu.getValue("//ns:Detail/ns:image/xop:Include", body, XPathConstants.NODE); String imageId = ele.getAttribute("href").substring(4); // skip "cid:" assertEquals(MtomTestHelper.REQ_IMAGE_CID, imageId); DataHandler dr = exchange.getIn().getAttachment(photoId); assertEquals("application/octet-stream", dr.getContentType()); MtomTestHelper.assertEquals(MtomTestHelper.REQ_PHOTO_DATA, IOUtils.readBytesFromStream(dr.getInputStream())); dr = exchange.getIn().getAttachment(imageId); assertEquals("image/jpeg", dr.getContentType()); MtomTestHelper.assertEquals(MtomTestHelper.requestJpeg, IOUtils.readBytesFromStream(dr.getInputStream())); // create response List<Source> elements = new ArrayList<Source>(); elements.add(new DOMSource(DOMUtils.readXml(new StringReader(MtomTestHelper.RESP_MESSAGE)).getDocumentElement())); CxfPayload<SoapHeader> sbody = new CxfPayload<SoapHeader>(new ArrayList<SoapHeader>(), elements, null); exchange.getOut().setBody(sbody); exchange.getOut().addAttachment(MtomTestHelper.RESP_PHOTO_CID, new DataHandler(new ByteArrayDataSource(MtomTestHelper.RESP_PHOTO_DATA, "application/octet-stream"))); exchange.getOut().addAttachment(MtomTestHelper.RESP_IMAGE_CID, new DataHandler(new ByteArrayDataSource(MtomTestHelper.responseJpeg, "image/jpeg"))); } }
SOAPMessage
to String
converter will provide the complete multi-part payload on the body. If you require just the SOAP XML as a String
, you can set the message body with message.getSOAPPart()
, and Camel convert can do the rest of work for you.
How to propagate stack trace information
dataFormat
to PAYLOAD
and set the faultStackTraceEnabled
property to true
in the cxfEndpoint
element, as follows:
<cxf:cxfEndpoint id="router" address="http://localhost:9002/TestMessage" wsdlURL="ship.wsdl" endpointName="s:TestSoapEndpoint" serviceName="s:TestService" xmlns:s="http://test"> <cxf:properties> <!-- enable sending the stack trace back to client; the default value is false--> <entry key="faultStackTraceEnabled" value="true" /> <entry key="dataFormat" value="PAYLOAD" /> </cxf:properties> </cxf:cxfEndpoint>
Caused by
). If you want to include the causing exception in the stack trace, set the exceptionMessageCauseEnabled
property to true
in the cxfEndpoint
element, as follows:
<cxf:cxfEndpoint id="router" address="http://localhost:9002/TestMessage"
wsdlURL="ship.wsdl"
endpointName="s:TestSoapEndpoint"
serviceName="s:TestService"
xmlns:s="http://test">
<cxf:properties>
<!-- enable to show the cause exception message and the default value is false -->
<entry key="exceptionMessageCauseEnabled" value="true" />
<!-- enable to send the stack trace back to client, the default value is false-->
<entry key="faultStackTraceEnabled" value="true" />
<entry key="dataFormat" value="PAYLOAD" />
</cxf:properties>
</cxf:cxfEndpoint>
exceptionMessageCauseEnabled
flag for testing and diagnostic purposes. It is normal practice for servers to conceal the original cause of an exception to make it harder for hostile users to probe the server.
Streaming Support in PAYLOAD mode
- Endpoint property: you can add "allowStreaming=false" as an endpoint property to turn the streaming on/off.
- Component property: the CxfComponent object also has an allowStreaming property that can set the default for endpoints created from that component.
- Global system property: you can add a system property of "org.apache.camel.component.cxf.streaming" to "false" to turn if off. That sets the global default, but setting the endpoint property above will override this value for that endpoint.
Using the generic CXF Dispatch mode
<cxf:cxfEndpoint id="testEndpoint" address="http://localhost:9000/SoapContext/SoapAnyPort"> <cxf:properties> <entry key="dataFormat" value="PAYLOAD"/> </cxf:properties> </cxf:cxfEndpoint>
Chapter 27. CXF Bean Component
CXF Bean Component (2.0 or later)
CxfBeanEndpoint
is a ProcessorEndpoint
so it has no consumers. It works similarly to a Bean component.
URI format
cxfbean:serviceBeanRef
serviceBeanRef
references a List
object, elements of the List
are the service bean objects accepted by the endpoint.
Options
Name | Description | Example | Required? | Default Value |
---|---|---|---|---|
bus
|
CXF bus reference specified by the # notation. The referenced object must be an instance of org.apache.cxf.Bus .
|
bus=#busName
|
No | Default bus created by CXF Bus Factory |
cxfBeanBinding
|
CXF bean binding specified by the # notation. The referenced object must be an instance of org.apache.camel.component.cxf.cxfbean.CxfBeanBinding .
|
cxfBinding=#bindingName
|
No |
DefaultCxfBeanBinding
|
headerFilterStrategy
|
Header filter strategy specified by the # notation. The referenced object must be an instance of org.apache.camel.spi.HeaderFilterStrategy .
|
headerFilterStrategy=#strategyName
|
No |
CxfHeaderFilterStrategy
|
populateFromClass
|
Since 2.3, the wsdlLocation annotated in the POJO is ignored (by default) unless this option is set to false. Prior to 2.3, the wsdlLocation annotated in the POJO is always honored and it is not possible to ignore.
|
true , false
|
No |
true
|
providers
|
Since 2.5, setting the providers for the CXFRS endpoint. |
providers=#providerRef1,#providerRef2
|
No |
null
|
setDefaultBus
|
Will set the default bus when CXF endpoint create a bus by itself. |
true , false
|
No |
false
|
Headers
Name | Description | Type | Required? | Default Value | In/Out | Examples |
---|---|---|---|---|---|---|
CamelHttpCharacterEncoding (before 2.0-m2: CamelCxfBeanCharacterEncoding )
|
Character encoding |
String
|
No | None | In | ISO-8859-1 |
CamelContentType (before 2.0-m2: CamelCxfBeanContentType )
|
Content type |
String
|
No | \**/*\* | In |
text/xml
|
CamelHttpBaseUri (2.0-m3 and before:
CamelCxfBeanRequestBasePath )
|
The value of this header will be set in the CXF message as the Message.BASE_PATH property. It is needed by CXF JAX-RS processing. Basically, it is the scheme, host and port portion of the request URI.
|
String
|
Yes | The Endpoint URI of the source endpoint in the Camel exchange | In | http://localhost:9000 |
CamelHttpPath (before 2.0-m2: CamelCxfBeanRequestPat{} h)
|
Request URI's path |
String
|
Yes | None | In |
consumer/123
|
CamelHttpMethod (before 2.0-m2: CamelCxfBeanVerb )
|
RESTful request verb |
String
|
Yes | None | In |
GET , PUT , POST , DELETE
|
CamelHttpResponseCode
|
HTTP response code |
Integer
|
No | None | Out | 200 |
A Working Sample
from
endpoint is a Jetty HTTP endpoint that is listening on port 9000. Notice that the matchOnUriPrefix
option must be set to true
because RESTful request URI will not match the endpoint's URI http://localhost:9000 exactly.
<route> <from uri="jetty:http://localhost:9000?matchOnUriPrefix=true" /> <to uri="cxfbean:customerServiceBean" /> <to uri="mock:endpointA" /> </route>
to
endpoint is a CXF Bean with bean name customerServiceBean
. The name will be looked up from the registry. Next, we make sure our service bean is available in Spring registry. We create a bean definition in the Spring configuration. In this example, we create a List of service beans (of one element). We could have created just a single bean without a List.
<util:list id="customerServiceBean"> <bean class="org.apache.camel.component.cxf.jaxrs.testbean.CustomerService" /> </util:list> <bean class="org.apache.camel.wsdl_first.PersonImpl" id="jaxwsBean" />
url = new URL("http://localhost:9000/customerservice/orders/223/products/323"); in = url.openStream(); assertEquals("{\"Product\":{\"description\":\"product 323\",\"id\":323}}", CxfUtils.getStringFromInputStream(in));
Chapter 28. CXFRS
CXFRS Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-cxf</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
cxfrs://address?options
cxfrs:bean:rsEndpoint
cxfrs:bean:cxfEndpoint?resourceClasses=org.apache.camel.rs.Example
Options
Name | Description | Example | Required? | default value |
---|---|---|---|---|
resourceClasses
|
The resource classes which you want to export as REST service. Multiple classes can be separated by a comma. |
resourceClasses=org.apache.camel.rs.Example1, org.apache.camel.rs.Exchange2
|
No | None |
httpClientAPI
|
New to Apache Camel 2.1 If true, the CxfRsProducer will use the HttpClientAPI to invoke the service |
httpClientAPI=true
|
No |
true
|
synchronous
|
New in 2.5, this option will let CxfRsConsumer decide to use sync or async API to do the underlying work. The default value is false which means it will try to use async API by default. |
synchronous=true
|
No |
false
|
throwExceptionOnFailure
|
New in 2.6, this option tells the CxfRsProducer to inspect return codes and will generate an Exception if the return code is larger than 207. |
throwExceptionOnFailure=true
|
No |
true
|
maxClientCacheSize
|
New in 2.6, you can set the In message header, CamelDestinationOverrideUrl , to dynamically override the target destination Web Service or REST Service defined in your routes. The implementation caches CXF clients or ClientFactoryBean in CxfProvider and CxfRsProvider . This option allows you to configure the maximum size of the cache.
|
maxClientCacheSize=5
|
No | 10 |
setDefaultBus
|
New in 2.9.0. Will set the default bus when CXF endpoint create a bus by itself |
setDefaultBus=true
|
No |
false
|
bus
|
New in 2.9.0. A default bus created by CXF Bus Factory. Use \# notation to reference a bus object from the registry. The referenced object must be an instance of org.apache.cxf.Bus .
|
bus=#busName
|
No | None |
bindingStyle
|
As of 2.11. Sets how requests and responses will be mapped to/from Camel. Two values are possible:
|
bindingStyle=SimpleConsumer
|
No | Default |
binding
|
Allows you to specify a custom
CxfRsBinding implementation to perform low-level processing of the raw CXF request and response objects. The implementation must be bound in the Camel registry, and you must use the hash (#) notation to refer to it.
|
binding=#myBinding
|
No
|
DefaultCxfRsBinding
|
providers
|
Since Camel 2.12.2 set custom JAX-RS providers list to the CxfRs endpoint.
|
providers=#MyProviders
|
No
|
None
|
schemaLocations
|
Since Camel 2.12.2 Sets the locations of the schemas which can be used to validate the incoming XML or JAXB-driven JSON.
|
schemaLocations=#MySchemaLocations
|
No
|
None
|
features
|
Since Camel 2.12.3 Set the feature list to the CxfRs endpoint.
|
features=#MyFeatures
|
No
|
None
|
properties
|
Since Camel 2.12.4 Set the properties to the CxfRs endpoint.
|
properties=#MyProperties
|
No
|
None
|
inInterceptors
|
Since Camel 2.12.4 Set the inInterceptors to the CxfRs endpoint.
|
inInterceptors=#MyInterceptors
|
No
|
None
|
outInterceptors
|
Since Camel 2.12.4 Set the outInterceptor to the CxfRs endpoint.
|
outInterceptors=#MyInterceptors
|
No
|
None
|
inFaultInterceptors
|
Since Camel 2.12.4 Set the inFaultInterceptors to the CxfRs endpoint.
|
inFaultInterceptors=#MyInterceptors
|
No
|
None
|
outFaultIntercetpros
|
Since Camel 2.12.4 Set the outFaultInterceptors to the CxfRs endpoint.
|
outFaultInterceptors=#MyInterceptors
|
No
|
None
|
continuationTimeout
|
Since Camel 2.14.0 This option is used to set the CXF continuation timeout which could be used in CxfConsumer by default when the CXF server is using Jetty or Servlet transport. (Before Camel 2.14.0, CxfConsumer just set the continuation timeout to be 0, which means the continuation suspend operation never timeout.)
|
continuationTimeout=800000
|
No
|
30000
|
ignoreDeleteMethodMessageBody
|
Since Camel 2.14.1 This option is used to tell
CxfRsProducer to ignore the message body of the DELETE method when using HTTP API.
|
ignoreDeleteMethodMessageBody=true
|
No
|
false
|
modelRef
|
Since Camel 2.14.2 This option is used to specify the model file which is useful for the resource class without annotation.
Since Camel 2.15 This option can point to a model file without specifying a service class for emulating document-only endpoints.
|
modelRef=classpath:/CustomerServiceModel.xml
|
No
|
None
|
performInvocation
|
Since Camel 2.15 When the option is true, camel will perform the invocation of the resource class instance and put the response object into the exchange for further processing.
|
performInvocation=true
|
No
|
false
|
propagateContexts
|
Since Camel 2.15 When
true , JAXRS UriInfo, HttpHeaders, Request and SecurityContext contexts will be available to custom CXFRS processors as typed Camel exchange properties. These contexts can be used to analyze the current requests using JAX-RS API.
|
|
|
|
How to configure the REST endpoint in Apache Camel
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:cxf="http://camel.apache.org/schema/cxf" xmlns:jaxrs="http://cxf.apache.org/jaxrs" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://camel.apache.org/schema/cxf http://camel.apache.org/schema/cxf/camel-cxf.xsd http://cxf.apache.org/jaxrs http://cxf.apache.org/schemas/jaxrs.xsd http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd "> <!-- Defined the real JAXRS back end service --> <jaxrs:server id="restService" address="http://localhost:9002/rest" staticSubresourceResolution="true"> <jaxrs:serviceBeans> <ref bean="customerService"/> </jaxrs:serviceBeans> </jaxrs:server> <!--bean id="jsonProvider" class="org.apache.cxf.jaxrs.provider.JSONProvider"/--> <bean id="customerService" class="org.apache.camel.component.cxf.jaxrs.testbean.CustomerService" /> <!-- Defined the server endpoint to create the cxf-rs consumer --> <cxf:rsServer id="rsServer" address="http://localhost:9000/route" serviceClass="org.apache.camel.component.cxf.jaxrs.testbean.CustomerService" loggingFeatureEnabled="true" loggingSizeLimit="20" skipFaultLogging="true"/> <!-- Defined the client endpoint to create the cxf-rs consumer --> <cxf:rsClient id="rsClient" address="http://localhost:9002/rest" serviceClass="org.apache.camel.component.cxf.jaxrs.testbean.CustomerService" loggingFeatureEnabled="true" skipFaultLogging="true"/> <!-- The camel route context --> <camelContext id="camel" xmlns="http://camel.apache.org/schema/spring"> <route> <from uri="cxfrs://bean://rsServer"/> <!-- We can remove this configure as the CXFRS producer is using the HttpAPI by default --> <setHeader headerName="CamelCxfRsUsingHttpAPI"> <constant>True</constant> </setHeader> <to uri="cxfrs://bean://rsClient"/> </route> </camelContext> </beans>
How to override the CXF producer address from message header
// set up the service address from the message header to override the setting of CXF endpoint exchange.getIn().setHeader(Exchange.DESTINATION_OVERRIDE_URL, constant(getServiceAddress()));
Consuming a REST Request - Simple Binding Style
Default
binding style is rather low-level, requiring the user to manually process the MessageContentsList
object coming into the route. Thus, it tightly couples the route logic with the method signature and parameter indices of the JAX-RS operation. Somewhat inelegant, difficult and error-prone.
SimpleConsumer
binding style performs the following mappings, in order to make the request data more accessible to you within the Camel Message:
- JAX-RS Parameters (@HeaderParam, @QueryParam, etc.) are injected as IN message headers. The header name matches the value of the annotation.
- The request entity (POJO or other type) becomes the IN message body. If a single entity cannot be identified in the JAX-RS method signature, it falls back to the original
MessageContentsList
. - Binary
@Multipart
body parts become IN message attachments, supportingDataHandler
,InputStream
,DataSource
and CXF'sAttachment
class. - Non-binary
@Multipart
body parts are mapped as IN message headers. The header name matches the Body Part name.
- If the message body type is different to
javax.ws.rs.core.Response
(user-built response), a newResponse
is created and the message body is set as the entity (so long it's not null). The response status code is taken from theExchange.HTTP_RESPONSE_CODE
header, or defaults to 200 OK if not present. - If the message body type is equal to
javax.ws.rs.core.Response
, it means that the user has built a custom response, and therefore it is respected and it becomes the final response. - In all cases, Camel headers permitted by custom or default
HeaderFilterStrategy
are added to the HTTP response.
Enabling the Simple Binding Style
bindingStyle
parameter in the consumer endpoint to value SimpleConsumer
:
from("cxfrs:bean:rsServer?bindingStyle=SimpleConsumer") .to("log:TEST?showAll=true");
Examples of request binding with different method signatures
public Response doAction(BusinessObject request);
Request payload is placed in IN message body, replacing the original MessageContentsList.
public Response doAction(BusinessObject request, @HeaderParam("abcd") String abcd, @QueryParam("defg") String defg);
Request payload placed in IN message body, replacing the original MessageContentsList. Both request params mapped as IN message headers with names abcd and defg.
public Response doAction(@HeaderParam("abcd") String abcd, @QueryParam("defg") String defg);
Both request params mapped as IN message headers with names abcd and defg. The original MessageContentsList is preserved, even though it only contains the 2 parameters.
public Response doAction(@Multipart(value="body1") BusinessObject request, @Multipart(value="body2") BusinessObject request2);
The first parameter is transferred as a header with name body1, and the second one is mapped as header body2. The original MessageContentsList is preserved as the IN message body.
public Response doAction(InputStream abcd);
The InputStream is unwrapped from the MessageContentsList and preserved as the IN message body.
public Response doAction(DataHandler abcd);
The DataHandler is unwrapped from the MessageContentsList and preserved as the IN message body.
More examples of the Simple Binding Style
@POST @Path("/customers/{type}") public Response newCustomer(Customer customer, @PathParam("type") String type, @QueryParam("active") @DefaultValue("true") boolean active) { return null; }
from("cxfrs:bean:rsServer?bindingStyle=SimpleConsumer") .recipientList(simple("direct:${header.operationName}")); from("direct:newCustomer") .log("Request: type=${header.type}, active=${header.active}, customerData=${body}");
POST /customers/gold?active=true Payload: <Customer> <fullName>Raul Kripalani</fullName> <country>Spain</country> <project>Apache Camel</project> </Customer>
Request: type=gold, active=true, customerData=<Customer.toString() representation>
Consuming a REST Request - Default Binding Style
camel-restlet
component, you don't need to specify the URI template within your endpoint, CXF takes care of the REST request URI to resource class method mapping according to the JSR-311 specification. All you need to do in Apache Camel is delegate this method request to a right processor or endpoint.
private static final String CXF_RS_ENDPOINT_URI = "cxfrs://http://localhost:" + CXT + "/rest?resourceClasses=org.apache.camel.component.cxf.jaxrs.testbean.CustomerServiceResource"; protected RouteBuilder createRouteBuilder() throws Exception { return new RouteBuilder() { public void configure() { errorHandler(new NoErrorHandlerBuilder()); from(CXF_RS_ENDPOINT_URI).process(new Processor() { public void process(Exchange exchange) throws Exception { Message inMessage = exchange.getIn(); // Get the operation name from in message String operationName = inMessage.getHeader(CxfConstants.OPERATION_NAME, String.class); if ("getCustomer".equals(operationName)) { String httpMethod = inMessage.getHeader(Exchange.HTTP_METHOD, String.class); assertEquals("Get a wrong http method", "GET", httpMethod); String path = inMessage.getHeader(Exchange.HTTP_PATH, String.class); // The parameter of the invocation is stored in the body of in message String id = inMessage.getBody(String.class); if ("/customerservice/customers/126".equals(path)) { Customer customer = new Customer(); customer.setId(Long.parseLong(id)); customer.setName("Willem"); // We just put the response Object into the out message body exchange.getOut().setBody(customer); } else { if ("/customerservice/customers/400".equals(path)) { // We return the remote client IP address this time org.apache.cxf.message.Message cxfMessage = inMessage.getHeader(CxfConstants.CAMEL_CXF_MESSAGE, org.apache.cxf.message.Message.class); ServletRequest request = (ServletRequest) cxfMessage.get("HTTP.REQUEST"); String remoteAddress = request.getRemoteAddr(); Response r = Response.status(200).entity("The remoteAddress is " + remoteAddress).build(); exchange.getOut().setBody(r); return; } if ("/customerservice/customers/123".equals(path)) { // send a customer response back Response r = Response.status(200).entity("customer response back!").build(); exchange.getOut().setBody(r); return; } if ("/customerservice/customers/456".equals(path)) { Response r = Response.status(404).entity("Can't found the customer with uri " + path).build(); throw new WebApplicationException(r); } else { throw new RuntimeCamelException("Can't found the customer with uri " + path); } } } if ("updateCustomer".equals(operationName)) { assertEquals("Get a wrong customer message header", "header1;header2", inMessage.getHeader("test")); String httpMethod = inMessage.getHeader(Exchange.HTTP_METHOD, String.class); assertEquals("Get a wrong http method", "PUT", httpMethod); Customer customer = inMessage.getBody(Customer.class); assertNotNull("The customer should not be null.", customer); // Now you can do what you want on the customer object assertEquals("Get a wrong customer name.", "Mary", customer.getName()); // set the response back exchange.getOut().setBody(Response.ok().build()); } } }); } }; }
@Path("/customerservice/") public interface CustomerServiceResource { @GET @Path("/customers/{id}/") Customer getCustomer(@PathParam("id") String id); @PUT @Path("/customers/") Response updateCustomer(Customer customer); }
performInvocation
option is enabled, the service implementation will be invoked first, the response will be set on the Camel exchange and the route execution will continue as usual. This can be useful for integrating the existing JAX-RS implementations into Camel routes and for post-processing JAX-RS Responses in custom processors.
How to invoke the REST service through camel-cxfrs producer ?
camel-cxfrs
producer is based on this proxy API. You just need to specify the operation name in the message header and prepare the parameter in the message body, the camel-cxfrs
producer will generate the right REST request for you.
Exchange exchange = template.send("direct://proxy", new Processor() { public void process(Exchange exchange) throws Exception { exchange.setPattern(ExchangePattern.InOut); Message inMessage = exchange.getIn(); setupDestinationURL(inMessage); // set the operation name inMessage.setHeader(CxfConstants.OPERATION_NAME, "getCustomer"); // using the proxy client API inMessage.setHeader(CxfConstants.CAMEL_CXF_RS_USING_HTTP_API, Boolean.FALSE); // set a customer header inMessage.setHeader("key", "value"); // set the parameters , if you just have one parameter // camel will put this object into an Object[] itself inMessage.setBody("123"); } }); // get the response message Customer response = (Customer) exchange.getOut().getBody(); assertNotNull("The response should not be null ", response); assertEquals("Get a wrong customer id ", String.valueOf(response.getId()), "123"); assertEquals("Get a wrong customer name", response.getName(), "John"); assertEquals("Get a wrong response code", 200, exchange.getOut().getHeader(Exchange.HTTP_RESPONSE_CODE)); assertEquals("Get a wrong header value", "value", exchange.getOut().getHeader("key"));
camel-cxfrs
producer. You need to specify the HTTP_PATH and Http method and let the the producer know to use the HTTP centric client by using the URI option httpClientAPI or set the message header with CxfConstants.CAMEL_CXF_RS_USING_HTTP_API
. You can turn the response object to the type class that you specify with CxfConstants.CAMEL_CXF_RS_RESPONSE_CLASS
.
Exchange exchange = template.send("direct://http", new Processor() { public void process(Exchange exchange) throws Exception { exchange.setPattern(ExchangePattern.InOut); Message inMessage = exchange.getIn(); setupDestinationURL(inMessage); // using the http central client API inMessage.setHeader(CxfConstants.CAMEL_CXF_RS_USING_HTTP_API, Boolean.TRUE); // set the Http method inMessage.setHeader(Exchange.HTTP_METHOD, "GET"); // set the relative path inMessage.setHeader(Exchange.HTTP_PATH, "/customerservice/customers/123"); // Specify the response class , cxfrs will use InputStream as the response object type inMessage.setHeader(CxfConstants.CAMEL_CXF_RS_RESPONSE_CLASS, Customer.class); // set a customer header inMessage.setHeader("key", "value"); // since we use the Get method, so we don't need to set the message body inMessage.setBody(null); } }); // get the response message Customer response = (Customer) exchange.getOut().getBody(); assertNotNull("The response should not be null ", response); assertEquals("Get a wrong customer id ", String.valueOf(response.getId()), "123"); assertEquals("Get a wrong customer name", response.getName(), "John"); assertEquals("Get a wrong response code", 200, exchange.getOut().getHeader(Exchange.HTTP_RESPONSE_CODE)); assertEquals("Get a wrong header value", "value", exchange.getOut().getHeader("key"));
Exchange exchange = template.send("cxfrs://http://localhost:" + getPort2() + "/" + getClass().getSimpleName() + "/testQuery?httpClientAPI=true&q1=12&q2=13"
CxfConstants.CAMEL_CXF_RS_QUERY_MAP
header to set the parameter map for it.
Map<String, String> queryMap = new LinkedHashMap<String, String>(); queryMap.put("q1", "new"); queryMap.put("q2", "world"); inMessage.setHeader(CxfConstants.CAMEL_CXF_RS_QUERY_MAP, queryMap);
Chapter 29. DataFormat Component
Data Format Component
URI format
dataformat:name:(marshal|unmarshal)[?options]
marshal
or unmarshal
. The options is used for configuring the Data Format in use. See the Data Format documentation for which options it support.
Samples
from("activemq:My.Queue"). to("dataformat:jaxb:unmarshal?contextPath=com.acme.model"). to("mqseries:Another.Queue");
<camelContext id="camel" xmlns="http://camel.apache.org/schema/spring"> <route> <from uri="activemq:My.Queue"/> <to uri="dataformat:jaxb:unmarshal?contextPath=com.acme.model"/> <to uri="mqseries:Another.Queue"/> </route> </camelContext>
Chapter 30. DataSet
DataSet Component
URI format
dataset:name[?options]
org.apache.camel.component.dataset.DataSet
, the org.apache.camel.component.dataset.DataSetSupport
class, that can be used as a base for implementing your own DataSet. Apache Camel also ships with a default implementation, the org.apache.camel.component.dataset.SimpleDataSet
that can be used for testing.
Options
Option | Default | Description |
---|---|---|
produceDelay
|
3 | Allows a delay in ms to be specified, which causes producers to pause in order to simulate slow producers. Uses a minimum of 3 ms delay unless you set this option to -1 to force no delay at all. |
consumeDelay
|
0 | Allows a delay in ms to be specified, which causes consumers to pause in order to simulate slow consumers. |
preloadSize
|
0 | Sets how many messages should be preloaded (sent) before the route completes its initialization. |
initialDelay
|
1000 | Camel 2.1: Time period in millis to wait before starting sending messages. |
minRate
|
0 | Wait until the DataSet contains at least this number of messages |
?option=value&option=value&...
Configuring DataSet
<bean id="myDataSet" class="com.mycompany.MyDataSet"> <property name="size" value="100"/> </bean>
Example
// send the dataset to a queue from("dataset:foo").to("activemq:SomeQueue"); // now lets test that the messages are consumed correctly from("activemq:SomeQueue").to("dataset:foo");
SimpleDataSet
as described below, configuring things like how big the data set is and what the messages look like etc.
Properties on SimpleDataSet
Property | Type | Default | Description |
---|---|---|---|
defaultBody
|
Object
|
<hello>world!</hello>
|
Specifies the default message body. For SimpleDataSet it is a constant payload; though if you want to create custom payloads per message, create your own derivation of DataSetSupport .
|
reportCount
|
long
|
-1
|
Specifies the number of messages to be received before reporting progress. Useful for showing progress of a large load test. If < 0, then size / 5, if is 0 then size , else set to reportCount value.
|
size
|
long
|
10
|
Specifies how many messages to send/consume. |
Chapter 31. Direct
Direct Component
URI format
direct:someName[?options]
Options
Name | Default Value | Description |
---|---|---|
block
|
false
|
Camel 2.11.1: If sending a message to a direct endpoint which has no active consumer, then we can tell the producer to block and wait for the consumer to become active. |
timeout
|
30000
|
Camel 2.11.1: The timeout value to use if block is enabled. |
?option=value&option=value&...
Samples
from("activemq:queue:order.in") .to("bean:orderServer?method=validate") .to("direct:processOrder"); from("direct:processOrder") .to("bean:orderService?method=process") .to("activemq:queue:order.out");
<route> <from uri="activemq:queue:order.in"/> <to uri="bean:orderService?method=validate"/> <to uri="direct:processOrder"/> </route> <route> <from uri="direct:processOrder"/> <to uri="bean:orderService?method=process"/> <to uri="activemq:queue:order.out"/> </route>
Chapter 32. Direct-VM
Direct VM Component
URI format
direct-vm:someName
Options
Name | Default Value | Description |
---|---|---|
block
|
false
|
Camel 2.11.1: If sending a message to a direct endpoint which has no active consumer, then we can tell the producer to block and wait for the consumer to become active. |
timeout
|
30000
|
Camel 2.11.1: The timeout value to use if block is enabled. |
Samples
from("activemq:queue:order.in") .to("bean:orderServer?method=validate") .to("direct-vm:processOrder");
from("direct-vm:processOrder") .to("bean:orderService?method=process") .to("activemq:queue:order.out");
<route> <from uri="activemq:queue:order.in"/> <to uri="bean:orderService?method=validate"/> <to uri="direct-vm:processOrder"/> </route> <route> <from uri="direct-vm:processOrder"/> <to uri="bean:orderService?method=process"/> <to uri="activemq:queue:order.out"/> </route>
Chapter 33. Disruptor
Disruptor Component
- The buffer used is always bounded in size (default 1024 exchanges).
- As a the buffer is always bouded, the default behaviour for the Disruptor is to block while the buffer is full instead of throwing an exception. This default behaviour may be configured on the component (see options).
- The Disruptor enpoints don't implement the BrowsableEndpoint interface. As such, the exchanges currently in the Disruptor can't be retrieved, only the amount of exchanges.
- The Disruptor requires its consumers (multicasted or otherwise) to be statically configured. Adding or removing consumers on the fly requires complete flushing of all pending exchanges in the Disruptor.
- As a result of the reconfiguration: Data sent over a Disruptor is directly processed and 'gone' if there is at least one consumer, late joiners only get new exchanges published after they've joined.
- The pollTimeout option is not supported by the Disruptor Component.
- When a producer blocks on a full Disruptor, it does not respond to thread interrupts.
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-disruptor</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
disruptor:someName[?options]
disruptor-vm:someName[?options]
?option=value&option=value&...
Options
Name | Default | Description |
---|---|---|
size | 1024 | The maximum capacity of the Disruptors ringbuffer. Will be effectively increased to the nearest power of two. Notice: Mind if you use this option, then its the first endpoint being created with the queue name, that determines the size. To make sure all endpoints use same size, then configure the size option on all of them, or the first endpoint being created. |
bufferSize | Component only: The maximum default size (capacity of the number of messages it can hold) of the Disruptors ringbuffer. This option is used if size is not in use. | |
queueSize | Component only: Additional option to specify the <em>bufferSize</em> to maintain maximum compatibility with the SEDA Component. | |
concurrentConsumers | 1 | Number of concurrent threads processing exchanges. |
waitForTaskToComplete | IfReplyExpected | Option to specify whether the caller should wait for the async task to complete or not before continuing. The following three options are supported: Always, Never or IfReplyExpected. The first two values are self-explanatory. The last value, IfReplyExpected, will only wait if the message is Request Reply based. See more information about Async messaging. |
timeout | 30000 | Timeout (in milliseconds) before a producer will stop waiting for an asynchronous task to complete. See waitForTaskToComplete and Async for more details. You can disable timeout by using 0 or a negative value. |
defaultMultipleConsumers | Component only: Allows to set the default allowance of multiple consumers for endpoints created by this comonent used when multipleConsumers is not provided. | |
multipleConsumers
|
false
|
Specifies whether multiple consumers are allowed. If enabled, you can use Disruptor for Publish-Subscribe messaging. That is, you can send a message to the SEDA queue and have each consumer receive a copy of the message. When enabled, this option should be specified on every consumer endpoint.
|
limitConcurrentConsumers | true | Whether to limit the number of concurrentConsumers to the maximum of 500. By default, an exception will be thrown if a Disruptor endpoint is configured with a greater number. You can disable that check by turning this option off. |
blockWhenFull | true | Whether a thread that sends messages to a full Disruptor will block until the ringbuffer's capacity is no longer exhausted. By default, the calling thread will block and wait until the message can be accepted. By disabling this option, an exception will be thrown stating that the queue is full. |
defaultBlockWhenFull | Component only: Allows to set the default producer behaviour when the ringbuffer is full for endpoints created by this comonent used when blockWhenFull is not provided. | |
waitStrategy | Blocking | Defines the strategy used by consumer threads to wait on new exchanges to be published. The options allowed are:Blocking, Sleeping, BusySpin and Yielding. Refer to the section below for more information on this subject |
defaultWaitStrategy | Component only: Allows to set the default wait strategy for endpoints created by this comonent used when waitStrategy is not provided. | |
producerType | Multi |
Defines the producers allowed on the Disruptor. The options allowed are: Multi to allow multiple producers and Single to enable certain optimizations only allowed when one concurrent producer (on one thread or otherwise synchronized) is active.
|
Wait strategies
Name | Description | Advice |
---|---|---|
Blocking | Blocking strategy that uses a lock and condition variable for Consumers waiting on a barrier. | This strategy can be used when throughput and low-latency are not as important as CPU resource. |
Sleeping | Sleeping strategy that initially spins, then uses a Thread.yield(), and eventually for the minimum number of nanos the OS and JVM will allow while the Consumers are waiting on a barrier. | This strategy is a good compromise between performance and CPU resource. Latency spikes can occur after quiet periods. |
BusySpin | Busy Spin strategy that uses a busy spin loop for Consumers waiting on a barrier. | This strategy will use CPU resource to avoid syscalls which can introduce latency jitter. It is best used when threads can be bound to specific CPU cores. |
Yielding | Yielding strategy that uses a Thread.yield() for Consumers waiting on a barrier after an initially spinning. | This strategy is a good compromise between performance and CPU resource without incurring significant latency spikes. |
Use of Request Reply
from("mina:tcp://0.0.0.0:9876?textline=true&sync=true").to("disruptor:input"); from("disruptor:input").to("bean:processInput").to("bean:createResponse");
Concurrent consumers
from("disruptor:stageName?concurrentConsumers=5").process(...)
Thread pools
from("disruptor:stageName").thread(5).process(...)
Sample
public void configure() throws Exception { from("direct:start") // send it to the disruptor that is async .to("disruptor:next") // return a constant response .transform(constant("OK")); from("disruptor:next").to("mock:result"); }
Object out = template.requestBody("direct:start", "Hello World"); assertEquals("OK", out);
Using multipleConsumers
<!-- define the consumers as spring beans --> <bean id="consumer1" class="org.apache.camel.spring.example.FooEventConsumer"/> <bean id="consumer2" class="org.apache.camel.spring.example.AnotherFooEventConsumer"/> <camelContext xmlns="http://camel.apache.org/schema/spring"> <!-- define a shared endpoint which the consumers can refer to instead of using url --> <endpoint id="foo" uri="disruptor:foo?multipleConsumers=true"/> </camelContext>
public class FooEventConsumer { @EndpointInject(uri = "mock:result") private ProducerTemplate destination; @Consume(ref = "foo") public void doSomething(String body) { destination.sendBody("foo" + body); } }
Extracting disruptor information
DisruptorEndpoint disruptor = context.getEndpoint("disruptor:xxxx"); int size = disruptor.getBufferSize();
Chapter 34. DNS
DNS
ip
- To resolve a domain by its IP address.
lookup
- To look up information about the domain.
dig
- To run DNS queries.
etc/jre.properties
file, to add sun.net.spi.nameservice
to the list of Java platform packages exported. The server will need restarting before this change takes effect.
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-dns</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
dns://operation
Options
Headers
Header | Type | Operations | Description |
---|---|---|---|
dns.domain
|
String
|
ip
|
The domain name. Mandatory. |
dns.name
|
String
|
lookup
|
The name to lookup. Mandatory. |
dns.type
|
- |
lookup , dig
|
The type of the lookup. Should match the values of org.xbill.dns.Type . Optional.
|
dns.class
|
- |
lookup , dig
|
he DNS class of the lookup. Should match the values of org.xbill.dns.DClass . Optional.
|
dns.query
|
String
|
dig
|
The query itself. Mandatory. |
dns.server
|
String
|
dig
|
The server in particular for the query. If none is given, the default one specified by the OS will be used. Optional. |
Examples
IP lookup
<route id="IPCheck"> <from uri="direct:start"/> <to uri="dns:ip"/> </route>
"dns.domain"
.
DNS lookup
<route id="IPCheck"> <from uri="direct:start"/> <to uri="dns:lookup"/> </route>
"dns.name"
.
DNS Dig
<route id="IPCheck"> <from uri="direct:start"/> <to uri="dns:dig"/> </route>
"dns.query"
.
Chapter 35. Docker
Docker Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-docker</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
docker://[operation]?[options]
Header Strategy
URI Option | Header Property |
---|---|
containerId | CamelDockerContainerId |
General Options
Option | Header | Description | Default Value |
---|---|---|---|
host | CamelDockerHost | Mandatory: Docker host | localhost |
port | CamelDockerPort | Mandatory:Docker port | 2375 |
username | CamelDockerUserName | User name to authenticate with | |
password | CamelDockerPassword | Password to authenticate with | |
CamelDockerEmail | Email address associated with the user | ||
secure | CamelDockerSecure | Use HTTPS communication | false |
requestTimeout | CamelDockerRequestTimeout | Request timeout for response (in seconds) | 30 |
certPath | CamelDockerCertPath | Location containing the SSL certificate chain |
Consumer Operations
Operation | Options | Description | Produces |
---|---|---|---|
events | initialRange | Monitor Docker events (Streaming) | Event |
Producer Operations
Misc Operation | Options | Description | Returns |
---|---|---|---|
auth | Check auth configuration | ||
info | System wide information | Info | |
ping | Ping the Docker server | ||
version | Show the docker version information | Version |
Image Operation | Options | Description | Body Content | Returns |
---|---|---|---|---|
image/list | filter, showAll | List images | List<Image> | |
image/create | repository | Create an image | InputStream | CreateImageResponse |
image/build | noCache, quiet, remove, tag | Build an image from Dockerfile via stdin | InputStream or File | InputStream |
image/pull | repository, registry, tag | Pull an image from the registry | InputStream | |
image/push | name | Push an image on the registry | InputStream | |
image/search | term | Search for images | List<SearchItem> | |
image/remove | imageId | Remove an image | ||
image/tag | imageId, repository, tag, force | Tag an image into a repository | ||
image/inspect | imageId | Inspect an image | InspectImageResponse |
Container Operation | Options | Description | Body Content | Returns |
---|---|---|---|---|
container/list | showSize, showAll, before, since, limit, List containers | initialRange | List<Container> | |
container/create | imageId, name, exposedPorts, workingDir, disableNetwork, hostname, user, tty, stdInOpen, stdInOnce, memoryLimit, memorySwap, cpuShares, attachStdIn, attachStdOut, attachStdErr, env, cmd, dns, image, volumes, volumesFrom | Create a container | CreateContainerResponse | |
container/start |
containerId, binds, links, lxcConf, portBindings, privileged, publishAllPorts, dns, dnsSearch, volumesFrom, networkMode, devices, restartPolicy, capAdd, capDrop
|
Start a container | ||
container/inspect | containerId | Inspect a container | InspectContainerResponse | |
container/wait | containerId | Wait a container | Integer | |
container/log | containerId, stdOut, stdErr, timestamps, followStream, tailAll, tail | Get container logs | InputStream | |
container/attach | containerId, stdOut, stdErr, timestamps, logs, followStream | Attach to a container | InputStream | |
container/stop | containerId, timeout | Stop a container | ||
container/restart | containerId, timeout | Restart a container | ||
container/diff | containerId | Inspect changes on a container | ChangeLog | |
container/kill | containerId, signal | Kill a container | ||
container/top | containerId, psArgs | List processes running in a container | TopContainerResponse | |
container/pause | containerId | Pause a container | ||
container/unpause | containerId | Unpause a container | ||
container/commit | containerId, repository, message, tag, attachStdIn, attachStdOut, attachStdErr, cmd, disableNetwork, pause, env, exposedPorts, hostname, memory, memorySwap, openStdIn, portSpecs, stdInOnce, tty, user, volumes, hostname | Create a new image from a container's changes | String | |
container/copyfile | containerId, resource, hostPath | Copy files or folders from a container | InputStream | |
container/remove | containerId, force, removeVolumes | Remove a container |
Examples
from("docker://events?host=192.168.59.103&port=2375").to("log:event");
from("docker://info?host=192.168.59.103&port=2375").to("log:info");
Chapter 36. Dozer
Dozer Component
- The ability to manage Dozer mapping configuration on a per-endpoint basis vs. global configuration via the converter registry.
- A Dozer endpoint can be configured to marshal/unmarshal input and output data using Camel data formats to support a single, any-to-any transformation endpoint
- The Dozer component allows for fine-grained integration and extension of Dozer to support additional functionality (e.g. mapping literal values, using expressions for mappings, etc.).
pom.xml
:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-dozer</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
dozer:endpointId[?options]
from("direct:orderInput"). to("dozer:transformOrder?mappingFile=orderMapping.xml&targetModel=example.XYZOrder"). to("direct:orderOutput");
Options
Name
|
Default
|
Description
|
---|---|---|
mappingFile
|
dozerBeanMapping.xml
|
The location of a Dozer configuration file. The file is loaded from the classpath by default, but you can use
file: , classpath: , or http: to load the configuration from a specific location.
|
unmarshalId
|
none
|
The id of a dataFormat defined within the Camel Context to use for unmarshalling the mapping input from a non-Java type. |
marshalId
|
none
|
The id of a dataFormat defined within the Camel Context to use for marshalling the mapping output to a non-Java type. |
sourceModel
|
none
|
Fully-qualified class name for the source type used in the mapping. If specified, the input to the mapping is converted to the specified type before being mapped with Dozer. |
targetModel
|
none
|
Fully-qualified class name for the target type used in the mapping. This option is required. |
mappingConfiguration
|
none | The name of a DozerBeanMapperConfiguration bean in the Camel registry which should be used for configuring the Dozer mapping. This is an alternative to the mappingFile option that can be used for fine-grained control over how Dozer is configured. Remember to use a "#" prefix in the value to indicate that the bean is in the Camel registry (e.g. "#myDozerConfig"). |
Using Data Formats with Dozer
<dataFormats> <json library="Jackson" id="myjson"/> <jaxb contextPath="org.example" id="myjaxb"/> </dataFormats>
<endpoint uri="dozer:xml2json?marshalId=myjson&unmarshalId=myjaxb&targetModel=org.example.Order"/>
Configuring Dozer
org.apache.camel.converter.dozer.DozerBeanMapperConfiguration
.
<bean id="mapper" class="org.apache.camel.converter.dozer.DozerBeanMapperConfiguration"> <property name="mappingFiles"> <list> <value>mapping1.xml</value> <value>mapping2.xml</value> </list> </property> </bean>
Mapping Extensions
Variable Mappings
<mappings xmlns="http://dozer.sourceforge.net" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://dozer.sourceforge.net http://dozer.sourceforge.net/schema/beanmapping.xsd"> <configuration> <variables> <variable name="CUST_ID">ACME-SALES</variable> </variables> </configuration> <mapping> <class-a>org.apache.camel.component.dozer.VariableMapper</class-a> <class-b>org.example.Order</class-b> <field custom-converter-id="_variableMapping" custom-converter-param="${CUST_ID}"> <a>literal</a> <b>custId</b> </field> </mapping> </mappings>
Custom Mappings
- You can have multiple converter methods in a single class with custom mappings.
- There is no requirement to implement a Dozer-specific interface with custom mappings.
[class-name][,method-name]
public class CustomMapper { // All customer ids must be wrapped in "[ ]" public Object mapCustomer(String customerId) { return "[" + customerId + "]"; } }
<mappings xmlns="http://dozer.sourceforge.net" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://dozer.sourceforge.net http://dozer.sourceforge.net/schema/beanmapping.xsd"> <mapping> <class-a>org.example.A</class-a> <class-b>org.example.B</class-b> <field custom-converter-id="_customMapping" custom-converter-param="org.example.CustomMapper,mapCustomer"> <a>header.customerNum</a> <b>custId</b> </field> </mapping> </mappings>
Expression Mappings
[language]:[expression]
<mappings xmlns="http://dozer.sourceforge.net" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://dozer.sourceforge.net http://dozer.sourceforge.net/schema/beanmapping.xsd"> <mapping> <class-a>org.apache.camel.component.dozer.ExpressionMapper</class-a> <class-b>org.example.B</class-b> <field custom-converter-id="_expressionMapping" custom-converter-param="simple:\${header.customerNumber}"> <a>expression</a> <b>custId</b> </field> </mapping> </mappings>
Chapter 37. Dropbox
Camel Dropbox component
- As a consumer, download files and search files by queries
- As a producer, download files, move files between remote directories, delete files/dir, upload files and search files by queries
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-dropbox</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
dropbox://[operation]?[options]
Operation
Operation
|
Description
|
---|---|
del
|
deletes files or directories on Dropbox
|
get
|
download files from Dropbox
|
move
|
move files from folders on Dropbox
|
put
|
upload files on Dropbox
|
search
|
search files on Dropbox based on string queries
|
Options
Property
|
Mandatory
|
Description
|
---|---|---|
accessToken
|
true
|
The access token to make API requests for a specific Dropbox user
|
clientIdentifier
|
true
|
Name of the app registered to make API requests
|
Del operation
Property
|
Mandatory
|
Description
|
---|---|---|
remotePath
|
true
|
Folder or file to delete on Dropbox
|
Samples
Result Message Headers
Property
|
Value
|
---|---|
DELETED_PATH
|
name of the path deleted on dropbox
|
Result Message Body
Object type
|
Description
|
---|---|
String
|
name of the path deleted on dropbox
|
Get (download) operation
Property
|
Mandatory
|
Description
|
---|---|---|
remotePath
|
true
|
Folder or file to download from Dropbox
|
Samples
Result Message Headers
Property
|
Value
|
---|---|
DOWNLOADED_FILE
|
in case of single file download, path of the remote file downloaded
|
DOWNLOADED_FILES
|
in case of multiple files download, path of the remote files downloaded
|
Result Message Body
Object type
|
Description
|
---|---|
ByteArrayOutputStream
|
in case of single file download, stream representing the file downloaded
|
Map<String, ByteArrayOutputStream>
|
in case of multiple files download, a map with as key the path of the remote file downloaded and as value the stream representing the file downloaded
|
Move operation
Property
|
Mandatory
|
Description
|
---|---|---|
remotePath
|
true
|
Original file or folder to move
|
newRemotePath
|
true
|
Destination file or folder
|
Samples
Result Message Headers
Property
|
Value
|
---|---|
MOVED_PATH
|
name of the path moved on dropbox
|
Result Message Body
Object type
|
Description
|
---|---|
String
|
name of the path moved on dropbox
|
Put (upload) operation
Property
|
Mandatory
|
Description
|
---|---|---|
uploadMode
|
true
|
add or force this option specifies how a file should be saved on dropbox: in case of "add" the new file will be renamed if a file with the same name already exists on dropbox. in case of "force" if a file with the same name already exists on dropbox, this will be overwritten.
|
localPath
|
true
|
Folder or file to upload on Dropbox from the local filesystem .
|
remotePath
|
false
|
Folder destination on Dropbox. If the property is not set, the component will upload the file on a remote path equal to the local path.
|
Samples
Result Message Headers
Property
|
Value
|
---|---|
UPLOADED_FILE
|
in case of single file upload, path of the remote path uploaded
|
UPLOADED_FILES
|
in case of multiple files upload, string with the remote paths uploaded
|
Result Message Body
Object type
|
Description
|
---|---|
String
|
in case of single file upload, result of the upload operation, OK or KO
|
Map<String, DropboxResultCode>
|
in case of multiple files upload, a map with as key the path of the remote file uploaded and as value the result of the upload operation, OK or KO
|
Search operation
Property
|
Mandatory
|
Description
|
---|---|---|
remotePath
|
true
|
Folder on Dropbox where to search in.
|
query
|
false
|
A space-separated list of substrings to search for. A file matches only if it contains all the substrings. If this option is not set, all files will be matched.
|
Samples
Result Message Headers
Property
|
Value
|
---|---|
FOUNDED_FILES
|
list of file path founded
|
Result Message Body
Object type
|
Description
|
---|---|
List<DbxEntry>
|
list of file path founded. For more information on this object refer to Dropbox documentation, http://dropbox.github.io/dropbox-sdk-java/api-docs/v1.7.x/com/dropbox/core/DbxEntry.html
|
Chapter 38. ElasticSearch
ElasticSearch Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-elasticsearch</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
elasticsearch://clusterName?[options]
local
. See the client guide for more details.
Endpoint Options
name | description |
---|---|
operation | required, indicates the operation to perform |
indexName |
the name of the index to act against
|
ip |
the TransportClient remote host ip to use Camel 2.12
|
Message Operations
operation
and a value set to one of the following. Some operations also require other parameters or the message body to be set.
operation | message body | description |
---|---|---|
INDEX
|
Map , String , byte[] or XContentBuilder content to index
|
Adds content to an index and returns the content's indexId in the body.
|
GET_BY_ID
|
Index ID of content to retrieve |
Retrieves the specified index and returns a GetResult object in the body.
|
DELETE
|
Index ID of content to delete |
Deletes the specified indexId and returns a DeleteResult object in the body.
|
BULK_INDEX
|
A List or Collection of any type that is already accepted (
XContentBuilder , Map , byte[] , or String )
|
Camel 2.14, Adds content to an index and return a List of the id of the successfully indexed documents in the body.
|
BULK
|
A List or Collection of any type that is already accepted (
XContentBuilder , Map , byte[] , or String )
|
Camel 2.15, Adds content to an index and returns the BulkResponse object in the body.
|
Index Example
from("direct:index") .to("elasticsearch://local?operation=INDEX&indexName=twitter&indexType=tweet");
<route> <from uri="direct:index" /> <to uri="elasticsearch://local?operation=INDEX&indexName=twitter&indexType=tweet"/> </route>
Map<String, String> map = new HashMap<String, String>(); map.put("content", "test"); String indexId = template.requestBody("direct:index", map, String.class);
For more information, see these resources
Chapter 39. EventAdmin
EventAdmin component
eventadmin
component can be used in an OSGi environment to receive OSGi EventAdmin events and process them.
Dependencies
pom.xml
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-eventadmin</artifactId> <version>${camel-version}</version> </dependency>
${camel-version}
must be replaced by the actual version of Camel (2.6.0 or higher).
URI format
eventadmin:topic[?options]
topic
is the name of the topic to listen too.
URI options
Name | Default value | Description |
---|---|---|
send
|
false
|
Whether to use 'send' or 'synchronous' deliver. Default false (async delivery) |
Message headers
Name | Type | Message | Description |
---|
Message body
in
message body will be set to the received Event.
Example usage
<route> <from uri="eventadmin:*"/> <to uri="stream:out"/> </route>
Chapter 40. Exec
Exec component
exec
component can be used to execute system commands.
Dependencies
pom.xml
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-exec</artifactId> <version>${camel-version}</version> </dependency>
${camel-version}
must be replaced by the actual version of Apache Camel (2.3.0 or higher).
URI format
exec://executable[?options]
executable
is the name, or file path, of the system command that will be executed. If executable name is used (e.g. exec:java
), the executable must in the system path.
URI options
Name | Default value | Description |
---|---|---|
args
|
null
|
The arguments of the executable. The arguments may be one or many whitespace-separated tokens, that can be quoted with
" , e.g. args="arg 1" arg2 will use two arguments arg 1 and arg2 . To include the quotes use "" , e.g. args=""arg 1"" arg2 will use the arguments "arg 1" and arg2 .
|
workingDir
|
null
|
The directory in which the command should be executed. If null , the working directory of the current process will be used.
|
timeout
|
Long.MAX_VALUE
|
The timeout, in milliseconds, after which the executable should be terminated. If execution has has not finished within the timeout, the component will send a termination request. |
outFile
|
null
|
The name of a file, created by the executable, that should be considered as its output. If no outFile is set, the standard output (stdout) of the executable will be considered as output.
|
binding
|
a DefaultExecBinding instance
|
A reference to a org.apache.commons.exec.ExecBinding in the Registry.
|
commandExecutor
|
a DefaultCommandExecutor instance
|
A reference to a org.apache.commons.exec.ExecCommandExecutor in the Registry, that customizes the command execution. The default command executor utilizes the commons-exec library. It adds a shutdown hook for every executed command.
|
useStderrOnEmptyStdout
|
false
|
A boolean indicating that when stdout is empty, this component will populate the Camel Message Body with stderr . This behavior is disabled (false ) by default.
|
Message headers
org.apache.camel.component.exec.ExecBinding
.
Name | Type | Message | Description |
---|---|---|---|
ExecBinding.EXEC_COMMAND_EXECUTABLE
|
String
|
in
|
The name of the system command that will be executed. Overrides the executable in the URI.
|
ExecBinding.EXEC_COMMAND_ARGS
|
java.util.List<String>
|
in
|
The arguments of the executable. The arguments are used literally, no quoting is applied. Overrides existing args in the URI.
|
ExecBinding.EXEC_COMMAND_ARGS
|
String
|
in
|
Camel 2.5: The arguments of the executable as a Single string where each argument is whitespace separated (see args in URI option). The arguments are used literally, no quoting is applied. Overrides existing args in the URI.
|
ExecBinding.EXEC_COMMAND_OUT_FILE
|
String
|
in
|
The name of a file, created by the executable, that should be considered as output of the executable. Overrides existing outFile in the URI.
|
ExecBinding.EXEC_COMMAND_TIMEOUT
|
long
|
in
|
The timeout, in milliseconds, after which the executable should be terminated. Overrides any existing timeout in the URI.
|
ExecBinding.EXEC_COMMAND_WORKING_DIR
|
String
|
in
|
The directory in which the command should be executed. Overrides any existing workingDir in the URI.
|
ExecBinding.EXEC_EXIT_VALUE
|
int
|
out
|
The value of this header is the exit value of the executable. Non-zero exit values typically indicate abnormal termination. Note that the exit value is OS-dependent. |
ExecBinding.EXEC_STDERR
|
java.io.InputStream
|
out
|
The value of this header points to the standard error stream (stderr) of the executable. If no stderr is written, the value is null .
|
ExecBinding.EXEC_USE_STDERR_ON_EMPTY_STDOUT
|
boolean
|
in
|
Indicates that when stdout is empty, this component will populate the Camel Message Body with stderr . This behavior is disabled (false ) by default.
|
Message body
Exec
component receives an in
message body that is convertible to java.io.InputStream
, it is used to feed input to the executable via its stdin. After execution, the message body is the result of the execution, that is, an org.apache.camel.components.exec.ExecResult
instance containing the stdout, stderr, exit value, and out file. This component supports the following ExecResult
type converters for convenience:
From | To |
---|---|
ExecResult
|
java.io.InputStream
|
ExecResult
|
String
|
ExecResult
|
byte []
|
ExecResult
|
org.w3c.dom.Document
|
Executing word count (Linux)
wc
(word count, Linux) to count the words in file /usr/share/dict/words
. The word count (output) is written in the standart output stream of wc
.
from("direct:exec") .to("exec:wc?args=--words /usr/share/dict/words") .process(new Processor() { public void process(Exchange exchange) throws Exception { // By default, the body is ExecResult instance assertIsInstanceOf(ExecResult.class, exchange.getIn().getBody()); // Use the Camel Exec String type converter to convert the ExecResult to String // In this case, the stdout is considered as output String wordCountOutput = exchange.getIn().getBody(String.class); // do something with the word count } });
Executing java
java
with 2 arguments: -server
and -version
, provided that java
is in the system path.
from("direct:exec") .to("exec:java?args=-server -version")
java
in c:/temp
with 3 arguments: -server
, -version
and the sytem property user.name
.
from("direct:exec") .to("exec:c:/program files/jdk/bin/java?args=-server -version -Duser.name=Camel&workingDir=c:/temp")
Executing Ant scripts
CamelExecBuildFile.xml
, provided that ant.bat
is in the system path, and that CamelExecBuildFile.xml
is in the current directory.
from("direct:exec") .to("exec:ant.bat?args=-f CamelExecBuildFile.xml")
ant.bat
command redirects its output to CamelExecOutFile.txt
with -l
. The file CamelExecOutFile.txt
is used as the out file with outFile=CamelExecOutFile.txt
. The example assumes that ant.bat
is in the system path, and that CamelExecBuildFile.xml
is in the current directory.
from("direct:exec") .to("exec:ant.bat?args=-f CamelExecBuildFile.xml -l CamelExecOutFile.txt&outFile=CamelExecOutFile.txt") .process(new Processor() { public void process(Exchange exchange) throws Exception { InputStream outFile = exchange.getIn().getBody(InputStream.class); assertIsInstanceOf(InputStream.class, outFile); // do something with the out file here } });
Executing echo (Windows)
echo
and dir
can be executed only with the command interpreter of the operating system. This example shows how to execute such a command - echo
- in Windows.
from("direct:exec").to("exec:cmd?args=/C echo echoString")
Chapter 41. Fabric Component
Abstract
Dependencies
fabric-camel
feature is installed. If necessary, you can install it using the following console command:
karaf@root> features:install fabric-camel
fabric-camel
feature is installed by including it in your feature definition. For example:
<?xml version="1.0" encoding="UTF-8"?> <features> <feature name="fabric-component-example"> <feature>fabric-camel</feature> <bundle>URIforMyBundle</bundle> <!-- Specify any other required bundles or features --> ... </feature> </features>
URI format
fabric:ClusterID[:PublishedURI[?Options]]
fabric:ClusterID:PublishedURI[?Options]
PublishedURI
, is published in the fabric registry and associated with the ClusterId
cluster. The options, Options
, are used when creating the producer endpoint instance, but the options are not published with the PublishedURI
in the fabric registry.
fabric:ClusterID
ClusterId
, in the fabric registry to discover the URI to connect to.
URI options
- Server-only options—options that are applicable only to the server are applied to the server endpoint (consumer endpoint) at run time.
- Client-only options—options that are applicable only to the client are applied to the client endpoint (producer endpoint) at run time.
- Common options—options common to the client and the server are applied to both.
Use cases for fabric endpoints
Location discovery
Figure 41.1. Location Discovery through Fabric
jetty:http://0.0.0.0:9090
. When this route is started, it automatically registers the Jetty URI in the fabric registry, under the cluster ID, foo
.
fabric:foo
. Now, when the client route starts, it automatically looks up the ID, foo
, in the fabric registry and retrieves the associated Jetty endpoint URI. The client then creates a producer endpoint using the discovered Jetty URI and connects to the corresponding server port.
Load-balancing cluster
Figure 41.2. Load Balancing through Fabric
jetty:http://0.0.0.0:9090
and jetty:http://0.0.0.0:9191
. Because these published URIs are both prefixed by fabric:foo:
, both of the Jetty URIs are registered under the same cluster ID, foo
, in the fabric registry.
foo
, in the fabric registry. Because the foo
ID is associated with multiple endpoint URIs, fabric implements a random load balancing algorithm to choose one of the available URIs. The client then creates a producer endpoint, using the chosen URI.
Auto-reconnect feature
Publishing an endpoint URI
PublishedURI
, in the fabric registry, define a fabric endpoint with the publisher syntax, FabricScheme:ClusterID:PublishedURI
. Note that this syntax can only be used in a consumer endpoint (that is, an endpoint that appears in a from
DSL command).
cluster
. The route is a simply HTTP server that returns the constant message, Response from Zookeeper agent
, in the body of the HTTP response.
Example 41.1. Publishing a URI
<?xml version="1.0" encoding="UTF-8"?> <blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.osgi.org/xmlns/blueprint/v1.0.0 http://www.osgi.org/xmlns/blueprint/v1.0.0/blueprint.xsd"> <bean id="fabric-camel" class="io.fabric8.camel.FabricComponent"/> <camelContext id="camel" trace="false" xmlns="http://camel.apache.org/schema/blueprint"> <route id="fabric-server"> <from uri="fabric-camel:cluster:jetty:http://0.0.0.0:9090/fabric"/> <log message="Request received : ${body}"/> <setHeader headerName="karaf.name"> <simple>${sys.karaf.name}</simple> </setHeader> <transform> <simple>Response from Zookeeper agent</simple> </transform> </route> </camelContext> </blueprint>
- The Fabric component uses the
CuratorFramework
object to connect to the ZooKeeper server (Fabric registry), where the reference to theCuratorFramework
object is provided automatically. - The
from
DSL command defines the fabric URI,fabric-camel:cluster:jetty:http://0.0.0.0:9090/fabric
. At run time, this causes two things to happen:- The specified
jetty
URI is published to the fabric registry under the cluster ID,cluster
. - The Jetty endpoint is activated and used as the consumer endpoint of the route (just as if it had been specified without the
fabric-camel:cluster:
prefix).
src/main/resources/OSGI-INF/blueprint
directory of a Maven project.
Looking up an endpoint URI
FabricScheme:ClusterID
. This syntax is used in a producer endpoint (for example, an endpoint that appears in a to
DSL command).
cluster
, in the fabric registry.
Example 41.2. Looking up a URI
<?xml version="1.0" encoding="UTF-8"?> <blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.osgi.org/xmlns/blueprint/v1.0.0 http://www.osgi.org/xmlns/blueprint/v1.0.0/blueprint.xsd"> <bean id="fabric-camel" class="io.fabric8.camel.FabricComponent"/> <camelContext id="camel" trace="false" xmlns="http://camel.apache.org/schema/blueprint"> <route id="fabric-client"> <from uri="timer://foo?fixedRate=true&period=10000"/> <setBody> <simple>Hello from Zookeeper server</simple> </setBody> <to uri="fabric-camel:cluster"/> <log message=">>> ${body} : ${header.karaf.name}"/> </route> </camelContext> <reference interface="org.apache.camel.spi.ComponentResolver" filter="(component=jetty)"/> </blueprint>
src/main/resources/OSGI-INF/blueprint
directory of a Maven project.
Load-balancing example
Example 41.3. Server Template for a Load-Balancing Cluster
<?xml version="1.0" encoding="UTF-8"?> <blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:cm="http://aries.apache.org/blueprint/xmlns/blueprint-cm/v1.0.0" xsi:schemaLocation=" http://www.osgi.org/xmlns/blueprint/v1.0.0 http://www.osgi.org/xmlns/blueprint/v1.0.0/blueprint.xsd"> <!-- osgi blueprint property placeholder --> <cm:property-placeholder id="myConfig" persistent-id="io.fabric8.examples.camel.loadbalancing.server"/> <bean id="fabric-camel" class="io.fabric8.camel.FabricComponent"/> <camelContext id="camel" trace="false" xmlns="http://camel.apache.org/schema/blueprint"> <!-- using Camel properties component and refer to the blueprint property placeholder by its id --> <propertyPlaceholder id="properties" location="blueprint:myConfig" prefixToken="[[" suffixToken="]]"/> <route id="fabric-server"> <from uri="fabric-camel:cluster:jetty:http://0.0.0.0:[[portNumber]]/fabric"/> <log message="Request received : ${body}"/> <setHeader headerName="karaf.name"> <simple>${sys.karaf.name}</simple> </setHeader> <transform> <simple>Response from Zookeeper agent</simple> </transform> </route> </camelContext> </blueprint>
io.fabric8.examples.camel.loadbalancing.server
persistent ID. A persistent ID in the OSGi Config Admin service identifies a collection of related property settings. After initializing the property placeholder, you can access any property values from the persistent ID using the syntax, [[PropName]]
.
[[portNumber]]
, at run time. At deploy time, you can specify the value of the portName
property. For example, if using a custom feature, you could specify the property in the feature definition (see Add OSGi configurations to the feature). Alternatively, you can specify configuration properties when defining deployment profiles in the Fuse Management Console.
OSGi bundle plug-in configuration
Import-Package
bundle header must be configured to import the following Java packages:
io.fabric8.zookeeper
Example 41.4. Maven Bundle Plug-In Configuration
<project ... > ... <build> <defaultGoal>install</defaultGoal> <plugins> ... <plugin> <groupId>org.apache.felix</groupId> <artifactId>maven-bundle-plugin</artifactId> <extensions>true</extensions> <configuration> <instructions> <Bundle-SymbolicName>${project.groupId}.${project.artifactId}</Bundle-SymbolicName> <Import-Package> io.fabric8.zookeeper, * </Import-Package> </instructions> </configuration> </plugin> </plugins> </build> ... </project>
Chapter 42. Facebook
Facebook Component
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-facebook</artifactId> <version>${camel-version}</version> </dependency>
URI format
facebook://[endpoint]?[options]
FacebookComponent
Option | Description |
---|---|
oAuthAppId | The application Id |
oAuthAppSecret | The application Secret |
oAuthAccessToken | The user access token |
Option | Description | Default Value |
---|---|---|
oAuthAuthorizationURL | OAuth authorization URL | https://www.facebook.com/dialog/oauth |
oAuthPermissions | Default OAuth permissions. Comma separeted permission names. See https://developers.facebook.com/docs/reference/login/#permissions for the detail | null |
oAuthAccessTokenURL | OAuth access token URL | https://graph.facebook.com/oauth/access_token |
debugEnabled | Enables deubg output. Effective only with the embedded logger | false |
gzipEnabled | Use Facebook GZIP encoding | true |
httpConnectionTimeout | Http connection timeout in milliseconds | 20000 |
httpDefaultMaxPerRoute | HTTP maximum connections per route | 2 |
httpMaxTotalConnections | HTTP maximum total connections | 20 |
httpProxyHost | HTTP proxy server host name | null |
httpProxyPassword | HTTP proxy server password | null |
httpProxyPort | HTTP proxy server port | null |
httpProxyUser | HTTP proxy server user name | null |
httpReadTimeout | Http read timeout in milliseconds | 120000 |
httpRetryCount | Number of HTTP retries | 0 |
httpRetryIntervalSeconds | HTTP retry interval in seconds | 5 |
httpStreamingReadTimeout | HTTP streaming read timeout in milliseconds | 40000 |
jsonStoreEnabled | If set to true, raw JSON forms will be stored in DataObjectFactory | false |
mbeanEnabled | If set to true, Facebook4J mbean will be registerd | false |
prettyDebugEnabled | prettify JSON debug output if set to true | false |
restBaseURL | API base URL | https://graph.facebook.com/ |
useSSL | Use SSL | true |
videoBaseURL | Video API base URL | https://graph-video.facebook.com/ |
clientURL | Facebook4J API client URL | http://facebook4j.org/en/facebook4j-<ersion>xml |
clientVersion | Facebook4J client API version | 1.1.12 |
Producer Endpoints:
from("direct:test").to("facebook://activities?inBody=userId")...
Endpoint | Short Name | Options | Body Type |
Accounts | |||
getAccounts | accounts | [reading],[userId] | facebook4j.ResponseList<acebook4j.Account> |
Activities | |||
getActivities | activities | [reading],[userId] | facebook4j.ResponseList<acebook4j.Activity> |
Albums | |||
addAlbumPhoto | addAlbumPhoto | albumId,source,[message] | String |
commentAlbum | commentAlbum | albumId,message | String |
createAlbum | createAlbum | albumCreate,[userId] | String |
getAlbum | album | albumId,[reading] | facebook.Album |
getAlbumComments | albumComments | albumId,[reading] | facebook4j.ResponseList<acebook4j.Comment> |
getAlbumCoverPhoto | albumCoverPhoto | albumId | java.net.URL |
getAlbumLikes | albumLikes | albumId,[reading] | facebook4j.ResponseList<acebook4j.Like> |
getAlbumPhotos | albumPhotos | albumId,[reading] | facebook4j.ResponseList<acebook4j.Photos> |
getAlbums | albums | [reading],[userId] | facebook4j.ResponseList<acebook4j.Album> |
likeAlbum | likeAlbum | albumId | boolean |
unlikeAlbum | unlikeAlbum | albumId | boolean |
Checkins | |||
checkin | checkin | checkinCreate,[userId] | String |
commentCheckin | commentCheckin | checkinId,message | String |
getCheckin | checkin | checkinId,[reading] | facebook4j.Checkin |
getCheckinComments | checkinComments | checkinId,[reading] | facebook4j.ResponseList<acebook4j.Comment> |
getCheckinLikes | checkinLikes | checkinId,[reading] | facebook4j.ResponseList<acebook4j.Like> |
getCheckins | checkins | [reading],[userId] | facebook4j.ResponseList<acebook4j.Checkin> |
likeCheckin | likeCheckin | checkinId | boolean |
unlikeCheckin | unlikeCheckin | checkinId | boolean |
Comments | |||
deleteComment | deleteComment | commentId | boolean |
getComment | comment | commentId | facebook4j.Comment |
getCommentLikes | commentLikes | commentId,[reading] | facebook4j.ResponseList<acebook4j.Like> |
likeComment | likeComment | commentId | boolean |
unlikeComment | unlikeComment | commentId | boolean |
Domains | |||
getDomain | domain | domainId | facebook4j.Domain |
getDomainByName | domainByName | domainName | facebook4j.Domain |
getDomainsByName | domainsByName | domainNames | java.util.List<acebook4j.Domain> |
Events | |||
createEvent | createEvent | eventUpdate,[userId] | String |
deleteEvent | deleteEvent | eventId | boolean |
deleteEventPicture | deleteEventPicture | eventId | boolean |
editEvent | editEvent | eventId,eventUpdate | boolean |
getEvent | event | eventId,[reading] | facebook4j.Event |
getEventFeed | eventFeed | eventId,[reading] | facebook4j.ResponseList<acebook4j.Post> |
getEventPhotos | eventPhotos | eventId,[reading] | facebook4j.ResponseList<acebook4j.Photo> |
getEventPictureURL | eventPictureURL | eventId,[size] | java.net.URL |
getEvents | events | [reading],[userId] | facebook4j.ResponseList<acebook4j.Event> |
getEventVideos | eventVideos | eventId,[reading] | facebook4j.ResponseList<acebook4j.Video> |
getRSVPStatusAsInvited | rSVPStatusAsInvited | eventId,[userId] | facebook4j.ResponseList<acebook4j.RSVPStatus> |
getRSVPStatusAsNoreply | rSVPStatusAsNoreply | eventId,[userId] | facebook4j.ResponseList<acebook4j.RSVPStatus> |
getRSVPStatusInAttending | rSVPStatusInAttending | eventId,[userId] | facebook4j.ResponseList<acebook4j.RSVPStatus> |
getRSVPStatusInDeclined | rSVPStatusInDeclined | eventId,[userId] | facebook4j.ResponseList<acebook4j.RSVPStatus> |
getRSVPStatusInMaybe | rSVPStatusInMaybe | eventId,[userId] | facebook4j.ResponseList<acebook4j.RSVPStatus> |
inviteToEvent | inviteToEvent | eventId,[userId],[userIds] | boolean |
postEventFeed | postEventFeed | eventId,postUpdate | String |
postEventLink | postEventLink | eventId,link,[message] | String |
postEventPhoto | postEventPhoto | eventId,source,[message] | String |
postEventStatusMessage | postEventStatusMessage | eventId,message | String |
postEventVideo | postEventVideo | eventId,source,[title,description] | String |
rsvpEventAsAttending | rsvpEventAsAttending | eventId | boolean |
rsvpEventAsDeclined | rsvpEventAsDeclined | eventId | boolean |
rsvpEventAsMaybe | rsvpEventAsMaybe | eventId | boolean |
uninviteFromEvent | uninviteFromEvent | eventId,userId | boolean |
updateEventPicture | updateEventPicture | eventId,source | boolean |
Family | |||
getFamily | family | [reading],[userId] | facebook4j.ResponseList<acebook4j.Family> |
Favorites | |||
getBooks | books | [reading],[userId] | facebook4j.ResponseList<acebook4j.Book> |
getGames | games | [reading],[userId] | facebook4j.ResponseList<acebook4j.Game> |
getInterests | interests | [reading],[userId] | facebook4j.ResponseList<acebook4j.Interest> |
getMovies | movies | [reading],[userId] | facebook4j.ResponseList<acebook4j.Movie> |
getMusic | music | [reading],[userId] | facebook4j.ResponseList<acebook4j.Music> |
getTelevision | television | [reading],[userId] | facebook4j.ResponseList<acebook4j.Television> |
Facebook Query Language (FQL) | |||
executeFQL | executeFQL | query,[locale] | facebook4j.internal.org.json.JSONArray |
executeMultiFQL | executeMultiFQL | queries,[locale] | java.util.Map<tring,facebook4j.internal.org.json.JSONArray> |
Friends | |||
addFriendlistMember | addFriendlistMember | friendlistId,userId | boolean |
createFriendlist | createFriendlist | friendlistName,[userId] | String |
deleteFriendlist | deleteFriendlist | friendlistId | boolean |
getBelongsFriend | belongsFriend | friendId,[reading],[userId] | facebook4j.ResponseList<acebook4j.Friend> |
getFriendlist | friendlist | friendlistId,[reading] | facebook4j.FriendList |
getFriendlistMembers | friendlistMembers | friendlistId | facebook4j.ResponseList<acebook4j.Friend> |
getFriendlists | friendlists | [reading],[userId] | facebook4j.ResponseList<acebook4j.FriendList> |
getFriendRequests | friendRequests | [reading],[userId] | facebook4j.ResponseList<acebook4j.FriendRequest> |
getFriends | friends | [reading],[userId] | facebook4j.ResponseList<acebook4j.Friend> |
getMutualFriends | mutualFriends | [friendUserId],[reading],[userId1,userId2] | facebook4j.ResponseList<acebook4j.Friend> |
removeFriendlistMember | removeFriendlistMember | friendlistId,userId | boolean |
Games | |||
deleteAchievement | deleteAchievement | achievementURL,[userId] | boolean |
deleteScore | deleteScore | [userId] | boolean |
getAchievements | achievements | [reading],[userId] | facebook4j.ResponseList<acebook4j.Achievement> |
getScores | scores | [reading],[userId] | facebook4j.ResponseList<acebook4j.Score> |
postAchievement | postAchievement | achievementURL,[userId] | String |
postScore | postScore | scoreValue,[userId] | String |
Groups | |||
getGroup | group | groupId,[reading] | facebook4j.Group |
getGroupDocs | groupDocs | groupId,[reading] | facebook4j.ResponseList<acebook4j.GroupDoc> |
getGroupFeed | groupFeed | groupId,[reading] | facebook4j.ResponseList<acebook4j.Post> |
getGroupMembers | groupMembers | groupId,[reading] | facebook4j.ResponseList<acebook4j.GroupMember> |
getGroupPictureURL | groupPictureURL | groupId | java.net.URL |
getGroups | groups | [reading],[userId] | facebook4j.ResponseList<acebook4j.Group> |
postGroupFeed | postGroupFeed | groupId,postUpdate | String |
postGroupLink | postGroupLink | groupId,link,[message] | String |
postGroupStatusMessage | postGroupStatusMessage | groupId,message | String |
Insights | |||
getInsights | insights | objectId,metric,[reading] | facebook4j.ResponseList<acebook4j.Insight> |
Likes | |||
getUserLikes | userLikes | [reading],[userId] | facebook4j.ResponseList<acebook4j.Like> |
Links | |||
commentLink | commentLink | linkId,message | String |
getLink | link | linkId,[reading] | facebook4j.Link |
getLinkComments | linkComments | linkId,[reading] | facebook4j.ResponseList<acebook4j.Comment> |
getLinkLikes | linkLikes | linkId,[reading] | facebook4j.ResponseList<acebook4j.Like> |
likeLink | likeLink | linkId | boolean |
unlikeLink | unlikeLink | linkId | boolean |
Locations | |||
getLocations | locations | [reading],[userId] | facebook4j.ResponseList<acebook4j.Location> |
Messages | |||
getInbox | inbox | [reading],[userId] | facebook4j.InboxResponseList<acebook4j.Inbox> |
getMessage | message | messageId,[reading] | facebook4j.Message |
getOutbox | outbox | [reading],[userId] | facebook4j.ResponseList<acebook4j.Message> |
getUpdates | updates | [reading],[userId] | facebook4j.ResponseList<acebook4j.Message> |
Notes | |||
commentNote | commentNote | noteId,message | String |
createNote | createNote | subject,message,[userId] | String |
getNote | note | noteId,[reading] | facebook4j.Note |
getNoteComments | noteComments | noteId,[reading] | facebook4j.ResponseList<acebook4j.Comment> |
getNoteLikes | noteLikes | noteId,[reading] | facebook4j.ResponseList<acebook4j.Like> |
getNotes | notes | [reading],[userId] | facebook4j.ResponseList<acebook4j.Note> |
likeNote | likeNote | noteId | boolean |
unlikeNote | unlikeNote | noteId | boolean |
Notifications | |||
getNotifications | notifications | [includeRead],[reading],[userId] | facebook4j.ResponseList<acebook4j.Notification> |
markNotificationAsRead | markNotificationAsRead | notificationId | boolean |
Permissions | |||
getPermissions | permissions | [userId] | java.util.List<acebook4j.Permission> |
revokePermission | revokePermission | permissionName,[userId] | boolean |
Photos | |||
addTagToPhoto | addTagToPhoto | photoId,[toUserId],[toUserIds],[tagUpdate] | boolean |
commentPhoto | commentPhoto | photoId,message | String |
deletePhoto | deletePhoto | photoId | boolean |
getPhoto | photo | photoId,[reading] | facebook4j.Photo |
getPhotoComments | photoComments | photoId,[reading] | facebook4j.ResponseList<acebook4j.Comment> |
getPhotoLikes | photoLikes | photoId,[reading] | facebook4j.ResponseList<acebook4j.Like> |
getPhotos | photos | [reading],[userId] | facebook4j.ResponseList<acebook4j.Photo> |
getPhotoURL | photoURL | photoId | java.net.URL |
getTagsOnPhoto | tagsOnPhoto | photoId,[reading] | facebook4j.ResponseList<acebook4j.Tag> |
likePhoto | likePhoto | photoId | boolean |
postPhoto | postPhoto | source,[message],[place],[noStory],[userId] | String |
unlikePhoto | unlikePhoto | photoId | boolean |
updateTagOnPhoto | updateTagOnPhoto | photoId,[toUserId],[tagUpdate] | boolean |
Pokes | |||
getPokes | pokes | [reading],[userId] | facebook4j.ResponseList<acebook4j.Poke> |
Posts | |||
commentPost | commentPost | postId,message | String |
deletePost | deletePost | postId | boolean |
getFeed | feed | [reading],[userId] | facebook4j.ResponseList<acebook4j.Post> |
getHome | home | [reading] | facebook4j.ResponseList<acebook4j.Post> |
getLinks | links | [reading],[userId] | facebook4j.ResponseList<acebook4j.Link> |
getPost | post | postId,[reading] | facebook4j.Post |
getPostComments | postComments | postId,[reading] | facebook4j.ResponseList<acebook4j.Comment> |
getPostLikes | postLikes | postId,[reading] | facebook4j.ResponseList<acebook4j.Like> |
getPosts | posts | [reading],[userId] | facebook4j.ResponseList<acebook4j.Post> |
getStatuses | statuses | [reading],[userId] | facebook4j.ResponseList<acebook4j.Post> |
getTagged | tagged | [reading],[userId] | facebook4j.ResponseList<acebook4j.Post> |
likePost | likePost | postId | boolean |
postFeed | postFeed | postUpdate,[userId] | String |
postLink | postLink | link,[message],[userId] | String |
postStatusMessage | postStatusMessage | message,[userId] | String |
unlikePost | unlikePost | postId | boolean |
Questions | |||
addQuestionOption | addQuestionOption | questionId,optionDescription | String |
createQuestion | createQuestion | question,[options],[allowNewOptions],[userId] | String |
deleteQuestion | deleteQuestion | questionId | boolean |
getQuestion | question | questionId,[reading] | facebook4j.Question |
getQuestionOptions | questionOptions | questionId,[reading] | facebook4j.ResponseList<acebook4j.Question.Option> |
getQuestionOptionVotes | questionOptionVotes | questionId | facebook4j.ResponseList<acebook4j.QuestionVotes> |
getQuestions | questions | [reading],[userId] | facebook4j.ResponseList<acebook4j.Question> |
getSubscribedto | subscribedto | [reading],[userId] | facebook4j.ResponseList<acebook4j.Subscribedto> |
getSubscribers | subscribers | [reading],[userId] | facebook4j.ResponseList<acebook4j.Subscriber> |
Test Users | |||
createTestUser | createTestUser | appId,[name],[userLocale],[permissions] | facebook4j.TestUser |
deleteTestUser | deleteTestUser | testUserId | boolean |
getTestUsers | testUsers | appId | java.util.List<acebook4j.TestUser> |
makeFriendTestUser | makeFriendTestUser | testUser1,testUser2 | boolean |
Users | |||
getMe | me | [reading] | facebook4j.User |
getPictureURL | pictureURL | [size],[userId] | java.net.URL |
getUser | user | userId,[reading] | facebook4j.User |
getUsers | users | ids | java.util.List<acebook4j.User> |
Videos | |||
commentVideo | commentVideo | videoId,message | String |
getVideo | video | videoId,[reading] | facebook4j.Video |
getVideoComments | videoComments | videoId,[reading] | facebook4j.ResponseList<acebook4j.Comment> |
getVideoCover | videoCover | videoId | java.net.URL |
getVideoLikes | videoLikes | videoId,[reading] | facebook4j.ResponseList<acebook4j.Like> |
getVideos | videos | [reading],[userId] | facebook4j.ResponseList<acebook4j.Video> |
likeVideo | likeVideo | videoId | boolean |
postVideo | postVideo | source,[title,description],[userId] | String |
unlikeVideo | unlikeVideo | videoId | boolean |
Search | |||
search | search | query,[reading] | facebook4j.ResponseList<acebook4j.internal.org.json.JSONObject> |
searchCheckins | checkins | [reading] | facebook4j.ResponseList<acebook4j.Checkin> |
searchEvents | events | query,[reading] | facebook4j.ResponseList<acebook4j.Event> |
searchGroups | groups | query,[reading] | facebook4j.ResponseList<acebook4j.Group> |
searchLocations | locations | [center,distance],[reading],[placeId] | facebook4j.ResponseList<acebook4j.Location> |
searchPlaces | places | query,[reading],[center,distance] | facebook4j.ResponseList<acebook4j.Place> |
searchPosts | posts | query,[reading] | facebook4j.ResponseList<acebook4j.Post> |
searchUsers | users | query,[reading] | facebook4j.ResponseList<acebook4j.User> |
Consumer Endpoints:
- URI Options
Name | Type | Description |
---|---|---|
achievementURL | java.net.URL | The unique URL of the achievement |
albumCreate | facebook4j.AlbumCreate | The facebook Album to be created |
albumId | String | The album ID |
allowNewOptions | boolean | True if allows other users to add new options |
appId | String | The ID of the Facebook Application |
center | facebook4j.GeoLocation | Location latitude and longitude |
checkinCreate | facebook4j.CheckinCreate | The checkin to be created. Deprecated, instead create a Post with an attached location |
checkinId | String | The checkin ID |
commentId | String | The comment ID |
description | String | The description text |
distance | int | Distance in meters |
domainId | String | The domain ID |
domainName | String | The domain name |
domainNames | String[] | The domain names |
eventId | String | The event ID |
eventUpdate | facebook4j.EventUpdate | The event to be created or updated |
friendId | String | The friend ID |
friendUserId | String | The friend user ID |
friendlistId | String | The friend list ID |
friendlistName | String | The friend list Name |
groupId | String | The group ID |
ids | String[] | The ids of users |
includeRead | boolean | Enables notifications that the user has already read in addition to unread ones |
link | java.net.URL | Link URL |
linkId | String | The link ID |
locale | java.util.Locale | Desired FQL locale |
message | String | The message text |
messageId | String | The message ID |
metric | String | The metric name |
name | String | Test user name, must be of the form 'first last' |
noStory | boolean | If set to true, optionally suppresses the feed story that is automatically generated on a user's profile when they upload a photo using your application. |
noteId | String | The note ID |
notificationId | String | The notification ID |
objectId | String | The insight object ID |
optionDescription | String | The question's answer option description |
options | java.util.List<tring> | The question's answer options |
permissionName | String | The permission name |
permissions | String | Test user permissions in the format perm1,perm2,... |
photoId | String | The photo ID |
place | String | The Facebook ID of the place associated with the Photo |
placeId | String | The place ID |
postId | String | The post ID |
postUpdate | facebook4j.PostUpdate | The post to create or update |
queries | java.util.Map<tring> | FQL queries |
query | String | FQL query or search terms for search* endpoints |
question | String | The question text |
questionId | String | The question id |
reading | facebook4j.Reading | Optional reading parameters. See Reading Options(#reading) |
scoreValue | int | The numeric score with value |
size | facebook4j.PictureSize | The picture size, one of large, normal, small or square |
source | facebook4j.Media | The media content from either a java.io.File or java.io.Inputstream |
subject | String | The note of the subject |
tagUpdate | facebook4j.TagUpdate | Photo tag information |
testUser1 | facebook4j.TestUser | Test user |
testUser2 | facebook4j.TestUser | Test user |
testUserId | String | The ID of the test user |
title | String | The title text |
toUserId | String | The ID of the user to tag |
toUserIds | java.util.List<tring> | The IDs of the users to tag |
userId | String | The Facebook user ID |
userId1 | String | The ID of a user |
userId2 | String | The ID of a user |
userIds | String[] | The IDs of users to invite to event |
userLocale | String | The test user locale |
videoId | String | The video ID |
Reading Options
Option | Description |
---|---|
reading.fields | Field names to retrieve, in the format field1,field2,... |
reading.limit | Limit for number of items to return for list results, e.g. a limit of 10 returns items 1 through 10 |
reading.offset | Starting offset for list results, e.g. a limit of 10, and offset of 10 returns items 11 through 20 |
reading.until | A Unix timestamp or strtotime data value that points to the end of the range of time-based data |
reading.since | A Unix timestamp or strtotime data value that points to the start of the range of time-based data |
reading.locale | Retrieve localized content in a particular locale, specified as a String with the format language[,country][,variant] |
reading.with | Retrieve information about objects that have location information attached, set it to true |
reading.metadata | Use Facebook Graph API Introspection to retrieve object metadata, set it to true |
reading.filter | User's stream filter key. See Facebook stream_filter |
Message header
Message body
Use cases
from("direct:foo") .to("facebook://postFeed/inBody=postUpdate);
from("facebook://home?consumer.delay=5000") .to("bean:blah");
from("direct:foo") .setHeader("CamelFacebook.query", header("bar")) .to("facebook://posts");
Chapter 43. File2
File Component - Apache Camel 2.0 onwards
URI format
file:directoryName[?options]
file://directoryName[?options]
?option=value&option=value&...
fileName=thefilename
. Also, the starting directory must not contain dynamic expressions with ${ } placeholders. Again use the fileName
option to specify the dynamic part of the filename.
readLock
options and the doneFileOption
option that you can use. See also the section the section called “Consuming files from folders where others drop files directly”.
URI Options
Name | Default Value | Description |
---|---|---|
autoCreate
|
true
|
Automatically create missing directories in the file's pathname. For the file consumer, that means creating the starting directory. For the file producer, it means the directory where the files should be written. |
bufferSize
|
128kb | Write buffer sized in bytes. |
fileName
|
null
|
Use Expression such as File Language to dynamically set the filename. For consumers, it's used as a filename filter. For producers, it's used to evaluate the filename to write. If an expression is set, it take precedence over the CamelFileName header. (Note: The header itself can also be an Expression). The expression options support both String and Expression types. If the expression is a String type, it is always evaluated using the File Language. If the expression is an Expression type, the specified Expression type is used - this allows you, for instance, to use OGNL expressions. For the consumer, you can use it to filter filenames, so you can for instance consume today's file using the File Language syntax: mydata-${date:now:yyyyMMdd}.txt . From Camel 2.11 onwards the producers support the CamelOverruleFileName header which takes precedence over any existing CamelFileName header; the CamelOverruleFileName is a header that is used only once, and makes it easier as this avoids to temporary store CamelFileName and have to restore it afterwards.
|
flatten
|
false
|
Flatten is used to flatten the file name path to strip any leading paths, so it's just the file name. This allows you to consume recursively into sub-directories, but when you eg write the files to another directory they will be written in a single directory. Setting this to true on the producer enforces that any file name recived in CamelFileName header will be stripped for any leading paths.
|
charset
|
null
|
Camel 2.5: this option is used to specify the encoding of the file, and camel will set the Exchange property with Exchange.CHARSET_NAME with the value of this option. |
copyAndDeleteOnRenameFail
|
true
|
Camel 2.9: whether to fallback and do a copy and delete file, in case the file could not be renamed directly. This option is not available for the FTP component. |
renameUsingCopy
|
false
|
Camel 2.13.1: Perform rename operations using a copy and delete strategy. This is primarily used in environments where the regular rename operation is unreliable (e.g. across different file systems or networks). This option takes precedence over the
copyAndDeleteOnRenameFail parameter that will automatically fall back to the copy and delete strategy, but only after additional delays.
|
Consumer only
Name | Default Value | Description |
---|---|---|
initialDelay
|
1000
|
Milliseconds before polling the file/directory starts. |
delay
|
500
|
Milliseconds before the next poll of the file/directory. |
useFixedDelay
|
true
|
Set to true to use fixed delay between pools, otherwise fixed rate is used. See ScheduledExecutorService in JDK for details.
|
runLoggingLevel
|
TRACE
|
Camel 2.8: The consumer logs a start/complete log line when it polls. This option allows you to configure the logging level for that. |
recursive
|
false
|
If a directory, will look for files in all the sub-directories as well. |
delete
|
false
|
If true , the file will be deleted after it is processed successfully.
|
noop
|
false
|
If true , the file is not moved or deleted in any way. This option is good for readonly data, or for ETL type requirements. If noop=true , Apache Camel will set idempotent=true as well, to avoid consuming the same files over and over again.
|
preMove
|
null
|
Use Expression such as File Language to dynamically set the filename when moving it before processing. For example to move in-progress files into the order directory set this value to order .
|
move
|
.camel
|
Use Expression such as File Language to dynamically set the filename when moving it after processing. To move files into a .done subdirectory just enter .done .
|
moveFailed
|
null
|
Use Expression such as File Language to dynamically set the filename when moving failed files after processing. To move files into a error subdirectory just enter error . Note: When moving the files to another location it can/will handle the error when you move it to another location so Apache Camel cannot pick up the file again.
|
include
|
null
|
Is used to include files, if filename matches the regex pattern. |
exclude
|
null
|
Is used to exclude files, if filename matches the regex pattern. |
antInclude
|
null
|
Camel 2.10: Ant style filter inclusion, for example antInclude=\* {}*/*{} .txt . Multiple inclusions may be specified in comma-delimited format. See below for more details about ant path filters.
|
antExclude
|
null
|
Camel 2.10: Ant style filter exclusion. If both antInclude and antExclude are used, antExclude takes precedence over antInclude . Multiple exclusions may be specified in comma-delimited format. See below for more details about ant path filters.
|
antFilterCaseSensitive
|
true
|
Camel 2.11: Ant style filter which is case sensitive or not. |
idempotent
|
false
|
Option to use the Idempotent Consumer EIP pattern to let Apache Camel skip already processed files. Will by default use a memory based LRUCache that holds 1000 entries. If noop=true then idempotent will be enabled as well to avoid consuming the same files over and over again.
|
idempotentKey
|
Expression
|
Camel 2.11: To use a custom idempotent key. By default the absolute path of the file is used. You can use the File Language, for example to use the file name and file size, you can do: idempotentKey=$-$ . |
idempotentRepository
|
null
|
Pluggable repository as a org.apache.camel.processor.idempotent.MessageIdRepository class. Will by default use MemoryMessageIdRepository if none is specified and idempotent is true .
|
inProgressRepository
|
memory
|
Pluggable in-progress repository as a org.apache.camel.processor.idempotent.MessageIdRepository class. The in-progress repository is used to account the current in progress files being consumed. By default a memory based repository is used. |
filter
|
null
|
Pluggable filter as a org.apache.camel.component.file.GenericFileFilter class. Will skip files if filter returns false in its accept() method. Apache Camel also ships with an ANT path matcher filter in the camel-spring component. More details in section below.
|
sorter
|
null
|
Pluggable sorter as a java.util.Comparator<org.apache.camel.component.file.GenericFile> class. |
sortBy
|
null
|
Built-in sort using the File Language. Supports nested sorts, so you can have a sort by file name and as a 2nd group sort by modified date. See sorting section below for details. |
readLock
|
markerFile
|
Used by consumer, to only poll the files if it has exclusive read-lock on the file (i.e. the file is not in-progress or being written). Apache Camel will wait until the file lock is granted.
The
readLock option supports the following built-in strategies:
|
readLockTimeout
|
0 (for FTP, 2000 )
|
Optional timeout in milliseconds for the read-lock, if supported by the read-lock. If the read-lock could not be granted and the timeout triggered, then Apache Camel will skip the file. At next poll Apache Camel, will try the file again, and this time maybe the read-lock could be granted. Currently fileLock , changed and rename support the timeout.
|
readLockCheckInterval
|
1000 (for FTP, 5000 )
|
Camel 2.6: Interval in millis for the read-lock, if supported by the read lock. This interval is used for sleeping between attempts to acquire the read lock. For example when using the changed read lock, you can set a higher interval period to cater for slow writes. The default of 1 sec. may be too fast if the producer is very slow writing the file.
|
readLockMinLength
|
1
|
Camel 2.10.1: This option applied only for readLock=changed . This option allows you to configure a minimum file length. By default Camel expects the file to contain data, and thus the default value is 1. You can set this option to zero, to allow consuming zero-length files.
|
readLockLoggingLevel
|
WARN
|
Camel 2.12: Logging level used when a read lock could not be acquired. By default a WARN is logged. You can change this level, for example to OFF to not have any logging. This option is only applicable for readLock of types: changed , fileLock , rename .
|
readLockMarkerFile
|
true
|
Camel 2.14: Whether to use marker file with the changed, rename, or exclusive read lock types. By default a marker file is used as well to guard against other processes picking up the same files. This behavior can be turned off by setting this option to false. For example if you do not want to write marker files to the file systems by the Camel application.
|
directoryMustExist
|
Camel 2.5: Similar to
startingDirectoryMustExist but this applies during polling recursive sub directories.
|
|
doneFileName
|
null
|
Camel 2.6: If provided, Camel will only consume files if a done file exists. This option configures what file name to use. Either you can specify a fixed name. Or you can use dynamic placeholders. The done file is always expected in the same folder as the original file. See using done file and writing done file sections for examples. |
exclusiveReadLockStrategy
|
null
|
Pluggable read-lock as a org.apache.camel.component.file.GenericFileExclusiveReadLockStrategy implementation.
|
maxMessagesPerPoll
|
0
|
An integer that defines the maximum number of messages to gather per poll. By default, no maximum is set. Can be used to set a limit of e.g. 1000 to avoid having the server read thousands of files as it starts up. Set a value of 0 or negative to disabled it. |
eagerMaxMessagesPerPoll
|
true
|
Camel 2.9.3: Allows for controlling whether the limit from
maxMessagesPerPoll is eager or not. If eager then the limit is during the scanning of files. Where as false would scan all files, and then perform sorting. Setting this option to false allows for sorting all files first, and then limit the poll. Mind that this requires a higher memory usage as all file details are in memory to perform the sorting.
|
minDepth
|
0 |
Camel 2.8: The minimum depth to start processing when recursively processing a directory. Using minDepth=1 means the base directory. Using minDepth=2 means the first sub directory. This option is not supported by FTP consumer.
|
maxDepth
|
Integer.MAX_VALUE
|
Camel 2.8: The maximum depth to traverse when recursively processing a directory. This option is not supported by FTP consumer. |
processStrategy
|
null
|
A pluggable org.apache.camel.component.file.GenericFileProcessStrategy allowing you to implement your own readLock option or similar. Can also be used when special conditions must be met before a file can be consumed, such as a special ready file exists. If this option is set then the readLock option does not apply.
|
startingDirectoryMustExist
|
false
|
Whether the starting directory must exist. Mind that the autoCreate option is default enabled, which means the starting directory is normally auto-created if it doesn't exist. You can disable autoCreate and enable this to ensure the starting directory must exist. Will throw an exception, if the directory doesn't exist.
|
pollStrategy
|
null
|
A pluggable
org.apache.camel.spi.PollingConsumerPollStrategy allowing you to provide your custom implementation to control error handling usually occurred during the poll operation before an Exchange have been created and being routed in Camel. In other words, the error occurred while the polling was gathering information, for instance access to a file network failed so Camel cannot access it to scan for files. The default implementation will log the caused exception at WARN level and ignore it.
|
sendEmptyMessageWhenIdle
|
false
|
Camel 2.9: If the polling consumer did not poll any files, you can enable this option to send an empty message (no body) instead.
|
consumer.bridgeErrorHandler
|
false
|
Camel 2.10: Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while trying to pick up files, or the like, 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 by default will be logged at WARN /ERROR level and ignored. See further below on this page fore more details, at section How to use the Camel error handler to deal with exceptions triggered outside the routing engine.
|
scheduledExecutorService
|
null
|
Camel 2.10: Allows for configuring a custom/shared thread pool to use for the consumer. By default each consumer has its own single threaded thread pool. This option allows you to share a thread pool among multiple file consumers.
|
scheduler
|
null
|
Camel 2.12: To use a custom scheduler to trigger the consumer to run. See more details at Polling Consumer, for example there is a Quartz2, and Spring based scheduler that supports CRON expressions. |
backoffMultiplier
|
0
|
Camel 2.12: To let the scheduled polling consumer backoff if there has been a number of subsequent idles/errors in a row. The multiplier is then the number of polls that will be skipped before the next actual attempt is happening again. When this option is in use then backoffIdleThreshold and/or backoffErrorThreshold must also be configured. See more details at Polling Consumer.
|
backoffIdleThreshold
|
0
|
Camel 2.12: The number of subsequent idle polls that should happen before the backoffMultipler should kick-in.
|
backoffErrorThreshold
|
0
|
Camel 2.12: The number of subsequent error polls (failed due some error) that should happen before the backoffMultipler should kick-in.
|
Default behavior for file consumer
- By default the file is locked for the duration of the processing.
- After the route has completed, files are moved into the
.camel
subdirectory, so that they appear to be deleted. - The File Consumer will always skip any file whose name starts with a dot, such as
.
,.camel
,.m2
or.groovy
. - Only files (not directories) are matched for valid filename, if options such as:
includeNamePrefix
,includeNamePostfix
,excludeNamePrefix
,excludeNamePostfix
,regexPattern
are used.
Producer only
Name | Default Value | Description |
---|---|---|
fileExist
|
Override
|
What to do if a file already exists with the same name. The following values can be specified: Override, Append, Fail, Ignore, Move, and TryRename (Camel 2.11.1). Override , which is the default, replaces the existing file. Append adds content to the existing file. Fail throws a GenericFileOperationException , indicating that there is already an existing file. Ignore silently ignores the problem and does not override the existing file, but assumes everything is okay. The Move option requires Camel 2.10.1 onwards, and the corresponding moveExisting option to be configured as well. The option eagerDeleteTargetFile can be used to control what to do if an moving the file, and there exists already an existing file, otherwise causing the move operation to fail. The Move option will move any existing files, before writing the target file. TryRename Camel 2.11.1 is only applicable if tempFileName option is in use. This allows to try renaming the file from the temporary name to the actual name, without doing any exists check. This check may be faster on some file systems and especially FTP servers.
|
tempPrefix
|
null
|
This option is used to write the file using a temporary name and then, after the write is complete, rename it to the real name. Can be used to identify files being written and also avoid consumers (not using exclusive read locks) reading in progress files. Is often used by FTP when uploading big files. |
tempFileName
|
null
|
Camel 2.1: The same as tempPrefix option but offering a more fine grained control on the naming of the temporary filename as it uses the File Language.
|
keepLastModified
|
false
|
Camel 2.2: Will keep the last modified timestamp from the source file (if any). Will use the Exchange.FILE_LAST_MODIFIED header to located the timestamp. This header can contain either a java.util.Date or long with the timestamp. If the timestamp exists and the option is enabled it will set this timestamp on the written file. Note: This option only applies to the file producer. You cannot use this option with any of the ftp producers.
|
eagerDeleteTargetFile
|
true
|
Camel 2.3: Whether or not to eagerly delete any existing target file. This option only applies when you use fileExists=Override and the tempFileName option as well. You can use this to disable (set it to false) deleting the target file before the temp file is written. For example you may write big files and want the target file to exists during the temp file is being written. This ensure the target file is only deleted until the very last moment, just before the temp file is being renamed to the target filename. From Camel 2.10.1 on this option is also used to control whether to delete any existing files when fileExist=Move is enabled, and an existing file exists. If the option copyAndDeleteOnRenameFail is false , an exception will be thrown if an existing file existed; if it's true , the existing file is deleted before the move operation.
|
doneFileName
|
null
|
Camel 2.6: If provided, then Camel will write a 2nd done file when the original file has been written. The done file will be empty. This option configures what file name to use. Either you can specify a fixed name. Or you can use dynamic placeholders. The done file will always be written in the same folder as the original file. See writing done file section for examples. |
allowNullBody
|
false
|
Camel 2.10.1: Used to specify if a null body is allowed during file writing. If set to true then an empty file will be created, when set to false, and attempting to send a null body to the file component, a GenericFileWriteException of 'Cannot write null body to file.' will be thrown. If the `fileExist` option is set to 'Override', then the file will be truncated, and if set to `append` the file will remain unchanged. |
forceWrites
|
true
|
Camel 2.10.5/2.11: Whether to force syncing writes to the file system. You can turn this off if you do not want this level of guarantee, for example if writing to logs / audit logs etc; this would yield better performance. |
Default behavior for file producer
- By default it will override any existing file, if one exist with the same name. In Apache Camel 1.x the
Append
is the default for the file producer. We have changed this toOverride
in Apache Camel 2.0 as this is also the default file operation usingjava.io.File
. And also the default for the FTP library we use in the camel-ftp component.
Move and Delete operations
Exchange
the file is still located in the inbox folder.
from("file://inbox?move=.done").to("bean:handleOrder");
inbox
folder, the file consumer notices this and creates a new FileExchange
that is routed to the handleOrder
bean. The bean then processes the File
object. At this point in time the file is still located in the inbox
folder. After the bean completes, and thus the route is completed, the file consumer will perform the move operation and move the file to the .done
sub-folder.
move=../backup/copy-of-${file:name}
.camel
sub-folder relative to the directory where the file was consumed.
from("file://inobox?delete=true").to("bean:handleOrder");
from("file://inbox?preMove=inprogress").to("bean:handleOrder");
from("file://inbox?preMove=inprogress&move=.done").to("bean:handleOrder");
inprogress
folder when being processed and after it's processed, it's moved to the .done
folder.
Fine grained control over Move and PreMove option
move=.done
Apache Camel will convert this into: ${file:parent}/.done/${file:onlyname}
. This is only done if Apache Camel detects that you have not provided a ${ }
in the option value yourself. So when you enter an expression containing ${ }
, the expression is interpreted as a File Language expression.
move=backup/${date:now:yyyyMMdd}/${file:name}
About moveFailed
moveFailed
option allows you to move files that could not be processed succesfully to another location such as a error folder of your choice. For example to move the files in an error folder with a timestamp you can use moveFailed=/error/${file:name.noext}-${date:now:yyyyMMddHHmmssSSS}.${file:name.ext}
.
Message Headers
File producer only
Header | Description |
---|---|
CamelFileName
|
Specifies the name of the file to write (relative to the endpoint directory). The name can be a String ; a String with a File Language or Simple expression; or an Expression object. If it's null then Apache Camel will auto-generate a filename based on the message unique ID.
|
CamelFileNameProduced
|
The actual absolute filepath (path + name) for the output file that was written. This header is set by Camel and its purpose is providing end-users with the name of the file that was written. |
CamelOverruleFileName
|
Camel 2.11: Is used for overruling CamelFileName header and use the value instead (but only once, as the producer will remove this header after writing the file). The value can be only be a String. Notice that if the option fileName has been configured, then this is still being evaluated.
|
File consumer only
Header | Description |
---|---|
CamelFileName
|
Name of the consumed file as a relative file path with offset from the starting directory configured on the endpoint. |
CamelFileNameOnly
|
Only the file name (the name with no leading paths). |
CamelFileAbsolute
|
A boolean option specifying whether the consumed file denotes an absolute path or not. Should normally be false for relative paths. Absolute paths should normally not be used but we added to the move option to allow moving files to absolute paths. But can be used elsewhere as well.
|
CamelFileAbsolutePath
|
The absolute path to the file. For relative files this path holds the relative path instead. |
CamelFilePath
|
The file path. For relative files this is the starting directory + the relative filename. For absolute files this is the absolute path. |
CamelFileRelativePath
|
The relative path. |
CamelFileParent
|
The parent path. |
CamelFileLength
|
A long value containing the file size.
|
CamelFileLastModified
|
A long value containing the last modified timestamp of the file.
|
Batch Consumer
Exchange Properties, file consumer only
BatchConsumer
it supports batching the files it polls. By batching it means that Apache Camel will add some properties to the Exchange so you know the number of files polled the current index in that order.
Property | Description |
---|---|
CamelBatchSize
|
The total number of files that was polled in this batch. |
CamelBatchIndex
|
The current index of the batch. Starts from 0. |
CamelBatchComplete
|
A boolean value indicating the last Exchange in the batch. Is only true for the last entry.
|
Common gotchas with folder and filenames
ID-MACHINENAME-2443-1211718892437-1-0
. If such a filename is not desired, then you must provide a filename in the CamelFileName
message header. The constant, Exchange.FILE_NAME
, can also be used.
from("direct:report").to("file:target/reports");
report.txt
as the filename you have to do:
from("direct:report").setHeader(Exchange.FILE_NAME, constant("report.txt")).to( "file:target/reports");
CamelFileName
:
from("direct:report").setHeader("CamelFileName", constant("report.txt")).to( "file:target/reports");
from("direct:report").to("file:target/reports/?fileName=report.txt");
Filename Expression
CamelFileName
header. See the File Language for syntax and samples.
Consuming files from folders where others drop files directly
readLock
options to see what suits your use cases. The best approach is however to write to another folder and after the write move the file in the drop folder. However if you write files directly to the drop folder then the option changed
could better detect whether a file is currently being written/copied as it uses a file changed algorithm to see whether the file size / modification changes over a period of time. The other read lock options rely on Java File API that sadly is not always very good at detecting this. You may also want to look at the doneFileName
option, which uses a marker file (done) to signal when a file is done and ready to be consumed.
Using done files
doneFileName
option on the endpoint.
from("file:bar?doneFileName=done");
doneFileName
option. Currently Camel supports the following two dynamic tokens: file:name
and file:name.noext
which must be enclosed in ${ }. The consumer only supports the static part of the done file name as either prefix or suffix (not both).
from("file:bar?doneFileName=${file:name}.done");
hello.txt
- is the file to be consumedhello.txt.done
- is the associated done file
from("file:bar?doneFileName=ready-${file:name}");
hello.txt
- is the file to be consumedready-hello.txt
- is the associated done file
Writing done files
doneFileName
option on the file producer endpoint.
.to("file:bar?doneFileName=done");
done
in the same directory as the target file.
doneFileName
option. Currently Camel supports the following two dynamic tokens: file:name
and file:name.noext
which must be enclosed in ${ }
.
.to("file:bar?doneFileName=done-${file:name}");
done-foo.txt
if the target file was foo.txt
in the same directory as the target file.
.to("file:bar?doneFileName=${file:name}.done");
foo.txt.done
if the target file was foo.txt
in the same directory as the target file.
.to("file:bar?doneFileName=${file:name.noext}.done");
foo.done
if the target file was foo.txt
in the same directory as the target file.
Read from a directory and write to another directory
from("file://inputdir/?delete=true").to("file://outputdir")
Read from a directory and write to another directory using a overrule dynamic name
from("file://inputdir/?delete=true").to("file://outputdir?overruleFile=copy-of-${file:name}")
outputdir
and delete the file in the inputdir
.
Reading recursively from a directory and writing to another
from("file://inputdir/?recursive=true&delete=true").to("file://outputdir")
outputdir
and delete the file in the inputdir
. Will scan recursively into sub-directories. Will lay out the files in the same directory structure in the outputdir
as the inputdir
, including any sub-directories.
inputdir/foo.txt inputdir/sub/bar.txt
outputdir/foo.txt outputdir/sub/bar.txt
Using flatten
flatten=true
option on the file producer side:
from("file://inputdir/?recursive=true&delete=true").to("file://outputdir?flatten=true")
outputdir/foo.txt outputdir/bar.txt
Reading from a directory and the default move operation
.camel
subdirectory in the directory the file was consumed from.
from("file://inputdir/?recursive=true&delete=true").to("file://outputdir")
inputdir/foo.txt inputdir/sub/bar.txt
inputdir/.camel/foo.txt inputdir/sub/.camel/bar.txt outputdir/foo.txt outputdir/sub/bar.txt
Read from a directory and process the message in java
from("file://inputdir/").process(new Processor() { public void process(Exchange exchange) throws Exception { Object body = exchange.getIn().getBody(); // do some business logic with the input body } });
File
object that points to the file that was just dropped into the inputdir
directory.
Read files from a directory and send the content to a jms queue
from("file://inputdir/").convertBodyTo(String.class).to("jms:test.queue")
FileMessage
which contains a File
object as the body. If you send this directly to the JMS component the JMS message will only contain the File
object but not the content. By converting the File
to a String
, the message will contain the file contents, which is probably what you want.
<route> <from uri="file://inputdir/"/> <convertBodyTo type="java.lang.String"/> <to uri="jms:test.queue"/> </route>
Writing to files
public void testToFile() throws Exception { MockEndpoint mock = getMockEndpoint("mock:result"); mock.expectedMessageCount(1); mock.expectedFileExists("target/test-reports/report.txt"); template.sendBody("direct:reports", "This is a great report"); assertMockEndpointsSatisfied(); } protected JndiRegistry createRegistry() throws Exception { // bind our processor in the registry with the given id JndiRegistry reg = super.createRegistry(); reg.bind("processReport", new ProcessReport()); return reg; } protected RouteBuilder createRouteBuilder() throws Exception { return new RouteBuilder() { public void configure() throws Exception { // the reports from the seda queue is processed by our processor // before they are written to files in the target/reports directory from("direct:reports").processRef("processReport").to("file://target/test-reports", "mock:result"); } }; } private static class ProcessReport implements Processor { public void process(Exchange exchange) throws Exception { String body = exchange.getIn().getBody(String.class); // do some business logic here // set the output to the file exchange.getOut().setBody(body); // set the output filename using java code logic, notice that this is done by setting // a special header property of the out exchange exchange.getOut().setHeader(Exchange.FILE_NAME, "report.txt"); } }
Write to subdirectory using Exchange.FILE_NAME
<route> <from uri="bean:myBean"/> <to uri="file:/rootDirectory"/> </route>
myBean
set the header Exchange.FILE_NAME
to values such as:
Exchange.FILE_NAME = hello.txt => /rootDirectory/hello.txt Exchange.FILE_NAME = foo/bye.txt => /rootDirectory/foo/bye.txt
Writing file through the temporary directory relative to the final destination
/var/myapp/filesInProgress
directory and after data transfer is done, they will be atomically moved to the /var/myapp/finalDirectory
directory.
from("direct:start"). to("file:///var/myapp/finalDirectory?tempPrefix=/../filesInProgress/");
Using expression for filenames
from("file://inbox?move=backup/${date:now:yyyyMMdd}/${file:name}").to("...");
Avoiding reading the same file more than once (idempotent consumer)
idempotent=true
option.
from("file://inbox?idempotent=true").to("...");
<route> <from uri="file://inbox?idempotent=true&dempotentKey=${file:name}-${file:size}"/> <to uri="bean:processInbox"/> </route>
idempotentRepository
option using the #
sign in the value to indicate it's a referring to a bean in the Registry with the specified id
.
<!-- define our store as a plain spring bean --> <bean id="myStore" class="com.mycompany.MyIdempotentStore"/> <route> <from uri="file://inbox?idempotent=true&dempotentRepository=#myStore"/> <to uri="bean:processInbox"/> </route>
DEBUG
level if it skips a file because it has been consumed before:
DEBUG FileConsumer is idempotent and the file has been consumed before. Will skip this file: target\idempotent\report.txt
Using a file based idempotent repository
org.apache.camel.processor.idempotent.FileIdempotentRepository
instead of the in-memory based that is used as default. This repository uses a 1st level cache to avoid reading the file repository. It will only use the file repository to store the content of the 1st level cache. Thereby the repository can survive server restarts. It will load the content of the file into the 1st level cache upon startup. The file structure is very simple as it stores the key in separate lines in the file. By default, the file store has a size limit of 1mb and when the file grows larger, Apache Camel will truncate the file store and rebuild the content by flushing the 1st level cache into a fresh empty file.
idempotentRepository
using \#
sign to indicate Registry lookup:
<!-- this is our file based idempotent store configured to use the .filestore.dat as file --> <bean id="fileStore" class="org.apache.camel.processor.idempotent.FileIdempotentRepository"> <!-- the filename for the store --> <property name="fileStore" value="target/fileidempotent/.filestore.dat"/> <!-- the max filesize in bytes for the file. Apache Camel will trunk and flush the cache if the file gets bigger --> <property name="maxFileStoreSize" value="512000"/> <!-- the number of elements in our store --> <property name="cacheSize" value="250"/> </bean> <camelContext xmlns="http://camel.apache.org/schema/spring"> <route> <from uri="file://target/fileidempotent/?idempotent=true&dempotentRepository=#fileStore&ove=done/${file:name}"/> <to uri="mock:result"/> </route> </camelContext>
Using a JPA based idempotent repository
META-INF/persistence.xml
where we need to use the class org.apache.camel.processor.idempotent.jpa.MessageProcessed
as model.
<persistence-unit name="idempotentDb" transaction-type="RESOURCE_LOCAL"> <class>org.apache.camel.processor.idempotent.jpa.MessageProcessed</class> <properties> <property name="openjpa.ConnectionURL" value="jdbc:derby:target/idempotentTest;create=true"/> <property name="openjpa.ConnectionDriverName" value="org.apache.derby.jdbc.EmbeddedDriver"/> <property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema"/> <property name="openjpa.Log" value="DefaultLevel=WARN, Tool=INFO"/> </properties> </persistence-unit>
jpaTemplate
in the spring XML file:
<!-- this is standard spring JPA configuration --> <bean id="jpaTemplate" class="org.springframework.orm.jpa.JpaTemplate"> <property name="entityManagerFactory" ref="entityManagerFactory"/> </bean> <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean"> <!-- we use idempotentDB as the persitence unit name defined in the persistence.xml file --> <property name="persistenceUnitName" value="idempotentDb"/> </bean>
<!-- we define our jpa based idempotent repository we want to use in the file consumer --> <bean id="jpaStore" class="org.apache.camel.processor.idempotent.jpa.JpaMessageIdRepository"> <!-- Here we refer to the spring jpaTemplate --> <constructor-arg index="0" ref="jpaTemplate"/> <!-- This 2nd parameter is the name (= a cateogry name). You can have different repositories with different names --> <constructor-arg index="1" value="FileConsumer"/> </bean>
idempotentRepository
option and the #
syntax:
<route> <from uri="file://inbox?idempotent=true&dempotentRepository=#jpaStore"/> <to uri="bean:processInbox"/> </route>
Filter using org.apache.camel.component.file.GenericFileFilter
skip
in the filename:
public class MyFileFilter implements GenericFileFilter { public boolean accept(GenericFile pathname) { // we dont accept any files starting with skip in the name return !pathname.getFileName().startsWith("skip"); } }
#
notation) that we have defined in the spring XML file:
<!-- define our filter as a plain spring bean --> <bean id="myFilter" class="com.mycompany.MyFileFilter"/> <route> <from uri="file://inbox?filter=#myFilter"/> <to uri="bean:processInbox"/> </route>
Filtering using ANT path matcher
?
matches one character*
matches zero or more characters**
matches zero or more directories in a path
<camelContext xmlns="http://camel.apache.org/schema/spring"> <template id="camelTemplate"/> <!-- use myFilter as filter to allow setting ANT paths for which files to scan for --> <endpoint id="myFileEndpoint" uri="file://target/antpathmatcher?recursive=true&ilter=#myAntFilter"/> <route> <from ref="myFileEndpoint"/> <to uri="mock:result"/> </route> </camelContext> <!-- we use the antpath file filter to use ant paths for includes and exlucde --> <bean id="myAntFilter" class="org.apache.camel.component.file.AntPathMatcherGenericFileFilter"> <!-- include and file in the subfolder that has day in the name --> <property name="includes" value="**/subfolder/**/*day*"/> <!-- exclude all files with bad in name or .xml files. Use comma to seperate multiple excludes --> <property name="excludes" value="**/*bad*,**/*.xml"/> </bean>
Sorting using Comparator
java.util.Comparator
in Java. You can then configure the endpoint with such a comparator and have Apache Camel sort the files before being processed.
public class MyFileSorter implements Comparator<GenericFile> { public int compare(GenericFile o1, GenericFile o2) { return o1.getFileName().compareToIgnoreCase(o2.getFileName()); } }
mySorter
) we have defined in the spring XML file:
<!-- define our sorter as a plain spring bean --> <bean id="mySorter" class="com.mycompany.MyFileSorter"/> <route> <from uri="file://inbox?sorter=#mySorter"/> <to uri="bean:processInbox"/> </route>
Sorting using sortBy
sortBy
option is configured as follows:
sortBy=group 1;group 2;group 3;...
sortBy=file:name
reverse:
to the group, so the sorting is now Z..A:
sortBy=reverse:file:name
sortBy=file:length
ignoreCase:
for string comparison, so if you want to use file name sorting but to ignore the case then we do:
sortBy=ignoreCase:file:name
sortBy=reverse:ignoreCase:file:name
sortBy=file:modified
sortBy=file:modified;file:name
sortBy=date:file:yyyyMMdd;file:name
sortBy=date:file:yyyyMMdd;reverse:file:name
Using GenericFileProcessStrategy
processStrategy
can be used to use a custom GenericFileProcessStrategy
that allows you to implement your own begin, commit and rollback logic. For instance lets assume a system writes a file in a folder you should consume. But you should not start consuming the file before another ready file have been written as well.
GenericFileProcessStrategy
we can implement this as:
- In the
begin()
method we can test whether the special ready file exists. The begin method returns aboolean
to indicate if we can consume the file or not. - in the
commit()
method we can move the actual file and also delete the ready file.
consumer.bridgeErrorHandler
consumer.bridgeErrorHandler
, then interceptors, OnCompletion does not apply. The Exchange is processed directly by the Camel Error Handler, and does not allow prior actions such as interceptors, onCompletion to take action.
Debug logging
Chapter 44. Flatpack
Flatpack Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-flatpack</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
flatpack:[delim|fixed]:flatPackConfig.pzmap.xml[?options]
flatpack:someName[?options]
?option=value&option=value&...
URI Options
Name | Default Value | Description |
---|---|---|
delimiter
|
,
|
The default character delimiter for delimited files. |
textQualifier
|
"
|
The text qualifier for delimited files. |
ignoreFirstRecord
|
true
|
Whether the first line is ignored for delimited files (for the column headers). |
splitRows
|
true
|
As of Apache Camel 1.5, the component can either process each row one by one or the entire content at once. |
allowShortLines
|
false
|
*Camel 2.9.3:* Allows for lines to be shorter than expected and ignores the extra characters. |
ignoreExtraColumns
|
false
|
*Camel 2.9.3:* Allows for lines to be longer than expected and ignores the extra characters. |
Examples
flatpack:fixed:foo.pzmap.xml
creates a fixed-width endpoint using thefoo.pzmap.xml
file configuration.flatpack:delim:bar.pzmap.xml
creates a delimited endpoint using thebar.pzmap.xml
file configuration.flatpack:foo
creates a delimited endpoint calledfoo
with no file configuration.
Message Headers
Header | Description |
---|---|
camelFlatpackCounter
|
The current row index. For splitRows=false the counter is the total number of rows.
|
Message Body
org.apache.camel.component.flatpack.DataSetList
object that has converters for java.util.Map
or java.util.List
. Usually you want the Map
if you process one row at a time (splitRows=true
). Use List
for the entire content (splitRows=false
), where each element in the list is a Map
. Each Map
contains the key for the column name and its corresponding value.
Map row = exchange.getIn().getBody(Map.class); String firstName = row.get("FIRSTNAME");
List
(even for splitRows=true
). The same example:
List data = exchange.getIn().getBody(List.class); Map row = (Map)data.get(0); String firstName = row.get("FIRSTNAME");
Header and Trailer records
header
for the header record (must be lowercase)trailer
for the trailer record (must be lowercase)
<RECORD id="header" startPosition="1" endPosition="3" indicator="HBT"> <COLUMN name="INDICATOR" length="3"/> <COLUMN name="DATE" length="8"/> </RECORD> <COLUMN name="FIRSTNAME" length="35" /> <COLUMN name="LASTNAME" length="35" /> <COLUMN name="ADDRESS" length="100" /> <COLUMN name="CITY" length="100" /> <COLUMN name="STATE" length="2" /> <COLUMN name="ZIP" length="5" /> <RECORD id="trailer" startPosition="1" endPosition="3" indicator="FBT"> <COLUMN name="INDICATOR" length="3"/> <COLUMN name="STATUS" length="7"/> </RECORD>
Using the endpoint
<camelContext xmlns="http://activemq.apache.org/camel/schema/spring"> <route> <from uri="file://someDirectory"/> <to uri="flatpack:foo"/> </route> <route> <from uri="flatpack:foo"/> ... </route> </camelContext>
Map
for easy Bean Integration
Chapter 45. FOP
FOP Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-fop</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
fop://outputFormat?[options]
Output Formats
Name | Output Format | Description |
---|---|---|
application/pdf
|
Portable Document Format | |
PS |
application/postscript
|
Adobe Postscript |
PCL |
application/x-pcl
|
Printer Control Language |
PNG |
image/png
|
PNG images |
JPEG |
image/jpeg
|
JPEG images |
SVG |
image/svg+xml
|
Scalable Vector Graphics |
XML |
application/X-fop-areatree
|
Area tree representation |
MIF |
application/mif
|
FrameMaker's MIF |
RTF |
application/rtf
|
Rich Text Format |
TXT |
text/plain
|
Text |
Endpoint Options
name | default value | description |
---|---|---|
outputFormat
|
See table above. | |
userConfigURL
|
none |
The location of a configuration file with the following structure. From Camel 2.12 onwards the file is loaded from the classpath by default. You can use file: , or classpath: as prefix to load the resource from file or classpath. In previous releases the file is always loaded from file system.
|
fopFactory
|
Allows you to use a custom configured or custom implementation of org.apache.fop.apps.FopFactory .
|
Message Operations
name | default value | description |
---|---|---|
CamelFop.Output.Format
|
Overrides the output format for that message | |
CamelFop.Encrypt.userPassword
|
PDF user password | |
CamelFop.Encrypt.ownerPassword
|
PDF owner passoword | |
CamelFop.Encrypt.allowPrint
|
true
|
Allows printing the PDF |
CamelFop.Encrypt.allowCopyContent
|
true
|
Allows copying content of the PDF |
CamelFop.Encrypt.allowEditContent
|
true
|
Allows editing content of the PDF |
CamelFop.Encrypt.allowEditAnnotations
|
true
|
Allows editing annotation of the PDF |
CamelFop.Render.producer
|
Apache FOP | Metadata element for the system/software that produces the document |
CamelFop.Render.creator
|
Metadata element for the user that created the document | |
CamelFop.Render.creationDate
|
Creation Date | |
CamelFop.Render.author
|
Author of the content of the document | |
CamelFop.Render.title
|
Title of the document | |
CamelFop.Render.subject
|
Subject of the document | |
CamelFop.Render.keywords
|
Set of keywords applicable to this document |
Example
from("file:source/data/xml") .to("xslt:xslt/template.xsl") .to("fop:application/pdf") .to("file:target/data");
Chapter 46. FreeMarker
FreeMarker
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-freemarker</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
freemarker:templateName[?options]
file://folder/myfile.ftl
).
?option=value&option=value&...
Options
Option | Default | Description |
---|---|---|
contentCache
|
true
|
Cache for the resource content when it's loaded. Note: as of Camel 2.9 cached resource content can be cleared via JMX using the endpoint's clearContentCache operation.
|
encoding
|
null
|
Character encoding of the resource content. |
templateUpdateDelay
|
5
|
*Camel 2.9:* Number of seconds the loaded template resource will remain in the cache. |
FreeMarker Context
Map
). The Exchange
is transferred as:
Key | Value |
---|---|
exchange
|
The Exchange itself.
|
exchange.properties
|
The Exchange properties.
|
headers
|
The headers of the In message. |
camelContext
|
The Camel Context. |
request
|
The In message. |
body
|
The In message body. |
response
|
The Out message (only for InOut message exchange pattern). |
CamelFreemarkerDataModel
, like this:
Map<String, Object> variableMap = new HashMap<String, Object>(); variableMap.put("headers", headersMap); variableMap.put("body", "Monday"); variableMap.put("exchange", exchange); exchange.getIn().setHeader("CamelFreemarkerDataModel", variableMap);
Hot reloading
contentCache=false
, then Apache Camel will not cache the resource and hot reloading is thus enabled. This scenario can be used in development.
Dynamic templates
Header | Type | Description | Support Version |
---|---|---|---|
FreemarkerConstants.FREEMARKER_RESOURCE
|
org.springframework.core.io.Resource
|
The template resource | <= 1.6.2, <= 2.1 |
FreemarkerConstants.FREEMARKER_RESOURCE_URI
|
String
|
A URI for the template resource to use instead of the endpoint configured. | >= 2.1 |
FreemarkerConstants.FREEMARKER_TEMPLATE
|
String
|
The template to use instead of the endpoint configured. | >= 2.1 |
Samples
from("activemq:My.Queue"). to("freemarker:com/acme/MyResponse.ftl");
JMSReplyTo
header).
from("activemq:My.Queue"). to(ExchangePattern.InOut,"freemarker:com/acme/MyResponse.ftl"). to("activemq:Another.Queue");
.ftl
template should be hot reloaded):
from("activemq:My.Queue"). to(ExchangePattern.InOut,"freemarker:com/acme/MyResponse.ftl?contentCache=false"). to("activemq:Another.Queue");
from("activemq:My.Queue"). to(ExchangePattern.InOut,"freemarker:file://myfolder/MyResponse.ftl?contentCache=false"). to("activemq:Another.Queue");
from("direct:in"). setHeader(FreemarkerConstants.FREEMARKER_RESOURCE_URI).constant("path/to/my/template.ftl"). to("freemarker:dummy");
The Email Sample
Dear ${headers.lastName}, ${headers.firstName} Thanks for the order of ${headers.item}. Regards Camel Riders Bookstore ${body}
private Exchange createLetter() { Exchange exchange = context.getEndpoint("direct:a").createExchange(); Message msg = exchange.getIn(); msg.setHeader("firstName", "Claus"); msg.setHeader("lastName", "Ibsen"); msg.setHeader("item", "Camel in Action"); msg.setBody("PS: Next beer is on me, James"); return exchange; } @Test public void testFreemarkerLetter() throws Exception { MockEndpoint mock = getMockEndpoint("mock:result"); mock.expectedMessageCount(1); mock.expectedBodiesReceived("Dear Ibsen, Claus\n\nThanks for the order of Camel in Action." + "\n\nRegards Camel Riders Bookstore\nPS: Next beer is on me, James"); template.send("direct:a", createLetter()); mock.assertIsSatisfied(); } protected RouteBuilder createRouteBuilder() throws Exception { return new RouteBuilder() { public void configure() throws Exception { from("direct:a") .to("freemarker:org/apache/camel/component/freemarker/letter.ftl") .to("mock:result"); } }; }
Chapter 47. FTP2
FTP/SFTP Component
URI format
ftp://[username@]hostname[:port]/directoryname[?options] sftp://[username@]hostname[:port]/directoryname[?options] ftps://[username@]hostname[:port]/directoryname[?options]
anonymous
login is attempted using no password. If no port number is provided, Apache Camel will provide default values according to the protocol (ftp = 21, sftp = 22, ftps = 21).
?option=value&option=value&...
URI Options
Name | Default Value | Description |
---|---|---|
username
|
null
|
Specifies the username to use to log in to the remote file systen. |
password
|
null
|
Specifies the password to use to log in to the remote file system. |
binary
|
false
|
Specifies the file transfer mode, BINARY or ASCII. Default is ASCII (false ).
|
disconnect
|
false
|
Camel 2.2: Whether or not to disconnect from remote FTP server right after use. Can be used for both consumer and producer. Disconnect will only disconnect the current connection to the FTP server. If you have a consumer which you want to stop, then you need to stop the consumer/route instead. |
localWorkDirectory
|
null
|
When consuming, a local work directory can be used to store the remote file content directly in local files, to avoid loading the content into memory. This is beneficial, if you consume a very big remote file and thus can conserve memory. See below for more details. |
passiveMode
|
false
|
FTP only: Specifies whether to use passive mode connections. Default is active mode {false ).
|
securityProtocol
|
TLS
|
FTPS only: Sets the underlying security protocol. The following values are defined:
TLS : Transport Layer Security SSL : Secure Sockets Layer
|
disableSecureDataChannelDefaults
|
false
|
Camel 2.4: FTPS only: Whether or not to disable using default values for execPbsz and execProt when using secure data transfer. You can set this option to true if you want to be in absolute full control what the options execPbsz and execProt should be used.
|
download
|
true
|
Camel 2.11: Whether the FTP consumer should download the file. If this option is set to false , then the message body will be null , but the consumer will still trigger a Camel Exchange that has details about the file such as file name, file size, etc. It's just that the file will not be downloaded.
|
streamDownload | false | Camel 2.11: hether the consumer should download the entire file up front, the default behavior, or if it should pass an InputStream ead from the remote resource rather than an in-memory array as the in body of the amel Exchange. his option is ignored if download s false r is localWorkDirectory is provided. his option is useful for working with large remote files. |
execProt
|
null
|
Camel 2.4: FTPS only: Will by default use option
P if secure data channel defaults hasn't been disabled. Possible values are: C : Clear S : Safe (SSL protocol only) E : Confidential (SSL protocol only) P : Private
|
execPbsz
|
null
|
Camel 2.4: FTPS only: This option specifies the buffer size of the secure data channel. If option useSecureDataChannel has been enabled and this option has not been explicit set, then value 0 is used.
|
isImplicit
|
false
|
FTPS only: Sets the security mode(implicit/explicit). Default is explicit (false ).
|
knownHostsFile
|
null
|
SFTP only: Sets the known_hosts file, so that the SFTP endpoint can do host key verification.
|
knownHostsUri
|
null
|
SFTP only:Camel 2.11.1: Sets the known_hosts file (loaded from classpath by default), so that the SFTP endpoint can do host key verification.
|
keyPair
|
null
|
SFTP only:Camel 2.12.0: Sets the Java KeyPair for SSH public key authentication, it supports DSA or RSA keys. |
privateKeyFile
|
null
|
SFTP only: Set the private key file to that the SFTP endpoint can do private key verification. |
privateKeyUri
|
null
|
SFTP only:Camel 2.11.1: Set the private key file (loaded from classpath by default) to that the SFTP endpoint can do private key verification. |
privateKey
|
null
|
SFTP only:Camel 2.11.1: Set the private key as byte[] to that the SFTP endpoint can do private key verification. |
privateKeyFilePassphrase
|
null
|
SFTP only: Set the private key file passphrase to that the SFTP endpoint can do private key verification. |
privateKeyPassphrase
|
null
|
SFTP only:Camel 2.11.1: Set the private key file passphrase to that the SFTP endpoint can do private key verification. |
preferredAuthentications
|
null
|
SFTP only:Camel 2.10.7, 2.11.2,2.12.0: set the preferred authentications which SFTP endpoint will used. Some example include:password,publickey. If not specified the default list from JSCH will be used. |
ciphers
|
null
|
Camel 2.8.2, 2.9: SFTP only Set a comma separated list of ciphers that will be used in order of preference. Possible cipher names are defined by JCraft JSCH. Some examples include: aes128-ctr,aes128-cbc,3des-ctr,3des-cbc,blowfish-cbc,aes192-cbc,aes256-cbc. If not specified the default list from JSCH will be used. |
fastExistsCheck
|
false
|
Camel 2.8.2, 2.9: If set this option to be true, camel-ftp will use the list file directly to check if the file exists. Since some FTP server may not support to list the file directly, if the option is false, camel-ftp will use the old way to list the directory and check if the file exists. Note from Camel 2.10.1 onwards this option also influences readLock=changed to control whether it performs a fast check to update file information or not. This can be used to speed up the process if the FTP server has a lot of files.
|
strictHostKeyChecking
|
no
|
SFTP only:Camel 2.2: Sets whether to use strict host key checking. Possible values are: no , yes and ask . ask does not make sense to use as Camel cannot answer the question for you as its meant for human intervention. Note: The default in Camel 2.1 and below was ask .
|
maximumReconnectAttempts
|
3 | Specifies the maximum reconnect attempts Apache Camel performs when it tries to connect to the remote FTP server. Use 0 to disable this behavior. |
reconnectDelay
|
1000 | Delay in millis Apache Camel will wait before performing a reconnect attempt. |
connectTimeout
|
10000
|
Camel 2.4: Is the connect timeout in millis. This corresponds to using ftpClient.connectTimeout for the FTP/FTPS. For SFTP this option is also used when attempting to connect.
|
soTimeout
|
null
|
FTP and FTPS Only:Camel 2.4: Is the SocketOptions.SO_TIMEOUT value in millis. Note SFTP will automatic use the connectTimeout as the soTimeout .
|
timeout
|
30000
|
FTP and FTPS Only:Camel 2.4: Is the data timeout in millis. This corresponds to using ftpClient.dataTimeout for the FTP/FTPS. For SFTP there is no data timeout.
|
throwExceptionOnConnectFailed
|
false
|
Camel 2.5: Whether or not to thrown an exception if a successful connection and login could not be establish. This allows a custom pollStrategy to deal with the exception, for example to stop the consumer or the likes.
|
siteCommand
|
null
|
FTP and FTPS Only:Camel 2.5: To execute site commands after successful login. Multiple site commands can be separated using a new line character (\n). Use help site to see which site commands your FTP server supports.
|
stepwise
|
true
|
When consuming directories, specifies whether or not to use stepwise mode for traversing the directory tree. Stepwise means that it will CD one directory at a time. For more details, see the section called “Stepwise changing directories”. |
separator
|
Auto
|
Camel 2.6: Dictates what path separator char to use when uploading files. Auto means use the path provided without altering it. UNIX means use UNIX style path separators. Windows means use Windows style path separators.
|
chmod
|
null
|
*SFTP Producer Only:* Camel 2.9: Allows you to set chmod on the stored file. For example chmod=640 .
|
compression
|
0 | *SFTP Only:* Camel 2.8.3/2.9: To use compression. Specify a level from 1 to 10. Important: You must manually add the needed JSCH zlib JAR to the classpath for compression support. |
ftpClient
|
null
|
FTP and FTPS Only:Camel 2.1: Allows you to use a custom org.apache.commons.net.ftp.FTPClient instance.
|
ftpClientConfig
|
null
|
FTP and FTPS Only:Camel 2.1: Allows you to use a custom org.apache.commons.net.ftp.FTPClientConfig instance.
|
serverAliveInterval
|
0
|
SFTP Only:Camel 2.8 Allows you to set the serverAliveInterval of the sftp session |
serverAliveCountMax
|
1
|
SFTP Only:Camel 2.8 Allows you to set the serverAliveCountMax of the sftp session |
ftpClient.trustStore.file
|
null
|
FTPS Only: Sets the trust store file, so that the FTPS client can look up for trusted certificates. |
ftpClient.trustStore.type
|
JKS
|
FTPS Only: Sets the trust store type. |
ftpClient.trustStore.algorithm
|
SunX509
|
FTPS Only: Sets the trust store algorithm. |
ftpClient.trustStore.password
|
null
|
FTPS Only: Sets the trust store password. |
ftpClient.keyStore.file
|
null
|
FTPS Only: Sets the key store file, so that the FTPS client can look up for the private certificate. |
ftpClient.keyStore.type
|
JKS
|
FTPS Only: Sets the key store type. |
ftpClient.keyStore.algorithm
|
SunX509
|
FTPS Only: Sets the key store algorithm. |
ftpClient.keyStore.password
|
null
|
FTPS Only: Sets the key store password. |
ftpClient.keyStore.keyPassword
|
null
|
FTPS Only: Sets the private key password. |
sslContextParameters
|
null
|
FTPS Only:Camel 2.9: Reference to a org.apache.camel.util.jsse.SSLContextParameters in the Registry. This reference overrides any configured SSL related options on ftpClient as well as the securityProtocol (SSL, TLS, etc.) set on FtpsConfiguration. See Using the JSSE Configuration Utility.
|
proxy
|
null
|
SFTP Only:Camel 2.10.7, 2.11.1: Reference to a com.jcraft.jsch.Proxy in the Registry. This proxy is used to consume/send messages from the target SFTP host.
|
useList
|
true
|
FTP/FTPS Only:Camel 2.12.1: Whether the consumer should use FTP LIST command to retrieve directory listing to see which files exists. If this option is set to false , then stepwise=false must be configured, and also fileName must be configured to a fixed name, so the consumer knows the name of the file to retrieve. When doing this only that single file can be retrieved. See further below for more details.
|
ignoreFileNotFoundOrPermissionError
|
false
|
Camel 2.12.1: Whether the consumer should ignore when a file was attempted to be retrieved but did not exist (for some reason), or failure due insufficient file permission error. |
ftpClient.
properties related to SSL with the FTPS component, the trust store accept all certificates. If you only want trust selective certificates, you have to configure the trust store with the ftpClient.trustStore.xxx
options or by configuring a custom ftpClient
.
sslContextParameters
, the trust store is managed by the configuration of the provided SSLContextParameters instance.
ftpClient
and ftpClientConfig
from the URI directly by using the ftpClient.
or ftpClientConfig.
prefix.
setDataTimeout
on the FTPClient
to 30 seconds you can do:
from("ftp://foo@myserver?password=secret&ftpClient.dataTimeout=30000") .to("bean:foo");
from("ftp://foo@myserver?password=secret&ftpClient.dataTimeout=30000&ftpClientConfig.serverLanguageCode=fr") .to("bean:foo");
ftpClient
or ftpClientConfig
to use by letting Camel lookup in the Registry for it.
<bean id="myConfig" class="org.apache.commons.net.ftp.FTPClientConfig"> <property name="lenientFutureDates" value="true"/> <property name="serverLanguageCode" value="fr"/> </bean>
from("ftp://foo@myserver?password=secret&ftpClientConfig=#myConfig").to("bean:foo");
More URI options
Examples
ftp://someone@someftpserver.com/public/upload/images/holiday2008?password=secret&binary=true ftp://someoneelse@someotherftpserver.co.uk:12049/reports/2008/password=secret&binary=false ftp://publicftpserver.com/download
Default when consuming files
delete=true
to delete the files, or use move=.done
to move the files into a hidden done sub directory.
.camel
sub directory. The reason Camel does not do this by default for the FTP consumer is that it may lack permissions by default to be able to move or delete files.
limitations
Message Headers
Header | Description |
---|---|
CamelFileName
|
Specifies the output file name (relative to the endpoint directory) to be used for the output message when sending to the endpoint. If this is not present and no expression either, then a generated message ID is used as the filename instead. |
CamelFileNameProduced
|
The actual absolute filepath (path + name) for the output file that was written. This header is set by Apache Camel and its purpose is providing end-users the name of the file that was written. |
CamelFileBatchIndex
|
Current index out of total number of files being consumed in this batch. |
CamelFileBatchSize
|
Total number of files being consumed in this batch. |
CamelFileHost
|
The remote hostname. |
CamelFileLocalWorkPath
|
Path to the local work file, if local work directory is used. |
Message
with the following headers:
Header | Description |
---|---|
CamelFtpReplyCode
|
Camel 2.11.1: The FTP client reply code (the type is a integer) |
CamelFtpReplyString
|
Camel 2.11.1: The FTP client reply string |
About timeouts
connectTimeout
option for both of them to set a timeout in milliseconds to establish a network connection. An individual soTimeout
can also be set on the FTP/FTPS, which corresponds to using ftpClient.soTimeout
. Notice SFTP will automatically use connectTimeout
as its soTimeout
. The timeout
option only applies for FTP/FTSP as the data timeout, which corresponds to the ftpClient.dataTimeout
value. All timeout values are in milliseconds.
Using Local Work Directory
FileOutputStream
.
.inprogress
as extension while the file is being downloaded. Afterwards, the file is renamed to remove the .inprogress
suffix. And finally, when the Exchange is complete the local file is deleted.
from("ftp://someone@someserver.com?password=secret&localWorkDirectory=/tmp").to("file://inbox");
java.io.File
handle is then used as the Exchange body. The file producer leverages this fact and can work directly on the work file java.io.File
handle and perform a java.io.File.rename
to the target filename. As Apache Camel knows it's a local work file, it can optimize and use a rename instead of a file copy, as the work file is meant to be deleted anyway.
Stepwise changing directories
- stepwise
- not stepwise
/
.
/ /one /one/two /one/two/sub-a /one/two/sub-b
sub-a
(a.txt
) and sub-b
(b.txt
) folder.
Using stepwise=true (default mode)
TYPE A 200 Type set to A PWD 257 "/" is current directory. CWD one 250 CWD successful. "/one" is current directory. CWD two 250 CWD successful. "/one/two" is current directory. SYST 215 UNIX emulated by FileZilla PORT 127,0,0,1,17,94 200 Port command successful LIST 150 Opening data channel for directory list. 226 Transfer OK CWD sub-a 250 CWD successful. "/one/two/sub-a" is current directory. PORT 127,0,0,1,17,95 200 Port command successful LIST 150 Opening data channel for directory list. 226 Transfer OK CDUP 200 CDUP successful. "/one/two" is current directory. CWD sub-b 250 CWD successful. "/one/two/sub-b" is current directory. PORT 127,0,0,1,17,96 200 Port command successful LIST 150 Opening data channel for directory list. 226 Transfer OK CDUP 200 CDUP successful. "/one/two" is current directory. CWD / 250 CWD successful. "/" is current directory. PWD 257 "/" is current directory. CWD one 250 CWD successful. "/one" is current directory. CWD two 250 CWD successful. "/one/two" is current directory. PORT 127,0,0,1,17,97 200 Port command successful RETR foo.txt 150 Opening data channel for file transfer. 226 Transfer OK CWD / 250 CWD successful. "/" is current directory. PWD 257 "/" is current directory. CWD one 250 CWD successful. "/one" is current directory. CWD two 250 CWD successful. "/one/two" is current directory. CWD sub-a 250 CWD successful. "/one/two/sub-a" is current directory. PORT 127,0,0,1,17,98 200 Port command successful RETR a.txt 150 Opening data channel for file transfer. 226 Transfer OK CWD / 250 CWD successful. "/" is current directory. PWD 257 "/" is current directory. CWD one 250 CWD successful. "/one" is current directory. CWD two 250 CWD successful. "/one/two" is current directory. CWD sub-b 250 CWD successful. "/one/two/sub-b" is current directory. PORT 127,0,0,1,17,99 200 Port command successful RETR b.txt 150 Opening data channel for file transfer. 226 Transfer OK CWD / 250 CWD successful. "/" is current directory. QUIT 221 Goodbye disconnected.
Using stepwise=false
230 Logged on TYPE A 200 Type set to A SYST 215 UNIX emulated by FileZilla PORT 127,0,0,1,4,122 200 Port command successful LIST one/two 150 Opening data channel for directory list 226 Transfer OK PORT 127,0,0,1,4,123 200 Port command successful LIST one/two/sub-a 150 Opening data channel for directory list 226 Transfer OK PORT 127,0,0,1,4,124 200 Port command successful LIST one/two/sub-b 150 Opening data channel for directory list 226 Transfer OK PORT 127,0,0,1,4,125 200 Port command successful RETR one/two/foo.txt 150 Opening data channel for file transfer. 226 Transfer OK PORT 127,0,0,1,4,126 200 Port command successful RETR one/two/sub-a/a.txt 150 Opening data channel for file transfer. 226 Transfer OK PORT 127,0,0,1,4,127 200 Port command successful RETR one/two/sub-b/b.txt 150 Opening data channel for file transfer. 226 Transfer OK QUIT 221 Goodbye disconnected.
Samples
protected RouteBuilder createRouteBuilder() throws Exception { return new RouteBuilder() { public void configure() throws Exception { // we use a delay of 60 minutes (eg. once pr. hour we poll the FTP server long delay = 60 * 60 * 1000L; // from the given FTP server we poll (= download) all the files // from the public/reports folder as BINARY types and store this as files // in a local directory. Apache Camel will use the filenames from the FTPServer // notice that the FTPConsumer properties must be prefixed with "consumer." in the URL // the delay parameter is from the FileConsumer component so we should use consumer.delay as // the URI parameter name. The FTP Component is an extension of the File Component. from("ftp://tiger:scott@localhost/public/reports?binary=true&consumer.delay=" + delay). to("file://target/test-reports"); } }; }
<route> <from uri="ftp://scott@localhost/public/reports?password=tiger&inary=true&elay=60000"/> <to uri="file://target/test-reports"/> </route>
Consuming a remote FTP server triggered by a route
from("seda:start") // define the file name so that only a single file is polled and deleted once retrieved .pollEnrich("ftp://admin@localhost:21/getme?password=admin&binary=false&fileName=myFile.txt&delete=true") .to("mock:result");
Consuming a remote FTPS server (implicit SSL) and client authentication
from("ftps://admin@localhost:2222/public/camel?password=admin&securityProtocol=SSL&isImplicit=true &ftpClient.keyStore.file=./src/test/resources/server.jks &ftpClient.keyStore.password=password&ftpClient.keyStore.keyPassword=password") .to("bean:foo");
Consuming a remote FTPS server (explicit TLS) and a custom trust store configuration
from("ftps://admin@localhost:2222/public/camel?password=admin&ftpClient.trustStore.file=./src/test/resources/server.jks&ftpClient.trustStore.password=password") .to("bean:foo");
Filter using org.apache.camel.component.file.GenericFileFilter
org.apache.camel.component.file.GenericFileFilter
interface in Java. You can then configure the endpoint with the filter to skip certain files.
report
.
public class MyFileFilter<T> implements GenericFileFilter<T> { public boolean accept(GenericFile<T> file) { // we only want report files return file.getFileName().startsWith("report"); } }
#
notation) that we have defined in the spring XML file:
<!-- define our sorter as a plain spring bean --> <bean id="myFilter" class="com.mycompany.MyFileFilter"/> <route> <from uri="ftp://someuser@someftpserver.com?password=secret&filter=#myFilter"/> <to uri="bean:processInbox"/> </route>
Filtering using ANT path matcher
?
matches one character*
matches zero or more characters**
matches zero or more directories in a path
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"/> <camelContext xmlns="http://camel.apache.org/schema/spring"> <template id="camelTemplate"/> <!-- use myFilter as filter to allow setting ANT paths for which files to scan for --> <endpoint id="myFTPEndpoint" uri="ftp://admin@localhost:${SpringFileAntPathMatcherRemoteFileFilterTest.ftpPort}/antpath?password=admin&ecursive=true&elay=10000&nitialDelay=2000&ilter=#myAntFilter"/> <route> <from ref="myFTPEndpoint"/> <to uri="mock:result"/> </route> </camelContext> <!-- we use the AntPathMatcherRemoteFileFilter to use ant paths for includes and exclude --> <bean id="myAntFilter" class="org.apache.camel.component.file.AntPathMatcherGenericFileFilter"> <!-- include any files in the sub-folder that have day in the name --> <property name="includes" value="**/subfolder/**/*day*"/> <!-- exclude all files with bad in name or .xml files. Use comma to seperate multiple excludes --> <property name="excludes" value="**/*bad*,**/*.xml"/> </bean>
Using a proxy with SFTP
<!-- define our sorter as a plain spring bean --> <bean id="proxy" class="com.jcraft.jsch.ProxyHTTP"> <constructor-arg value="localhost"/> <constructor-arg value="7777"/> </bean> <route> <from uri="sftp://localhost:9999/root?username=admin&password=admin&proxy=#proxy"/> <to uri="bean:processFile"/> </route>
com.jcraft.jsch.Proxy
to discover all options.
Setting preferred SFTP authentication method
sftp
component, use preferredAuthentications
option. If for example you would like Camel to attempt to authenticate with private/public SSH key and fallback to user/password authentication in the case when no public key is available, use the following route configuration:
from("sftp://localhost:9999/root?username=admin&password=admin&preferredAuthentications=publickey,password") .to("bean:processFile");
Consuming a single file using a fixed name
fileName=myFileName.txt
to tell Camel the name of the file to download. By default the consumer will still do a FTP LIST command to do a directory listing and then filter these files based on the fileName
option. Though in this use-case it may be desirable to turn off the directory listing by setting useList=false
. For example the user account used to login to the FTP server may not have permission to do a FTP LIST command. So you can turn off this with useList=false
, and then provide the fixed name of the file to download with fileName=myFileName.txt
, then the FTP consumer can still download the file. If the file for some reason does not exist, then Camel will by default throw an exception, you can turn this off and ignore this by setting ignoreFileNotFoundOrPermissionError=true
.
from("ftp://admin@localhost:21/nolist/?password=admin&stepwise=false&useList=false&ignoreFileNotFoundOrPermissionError=true&fileName=report.txt&delete=true") .to("activemq:queue:report");
ConsumerTemplate
. For example to download a single file (if it exists) and grab the file content as a String type:
String data = template.retrieveBodyNoWait("ftp://admin@localhost:21/nolist/?password=admin&stepwise=false&useList=false&ignoreFileNotFoundOrPermissionError=true&fileName=report.txt&delete=true", String.class);
Debug logging
Chapter 48. GAE
48.1. Introduction to the GAE Components
Apache Camel Components for Google App Engine
- A good starting point for using Apache Camel on GAE is the Tutorial for Camel on Google App Engine
- The OAuth tutorial demonstrates how to implement OAuth in web applications.
camel-gae
project and provide connectivity to GAE's cloud computing services. They make the GAE cloud computing environment accessible to applications via Apache Camel interfaces. Following this pattern for other cloud computing environments could make it easier to port Apache Camel applications from one cloud computing provider to another. The following table lists the cloud computing services provided by Google App Engine and the supporting Apache Camel components. The documentation of each component can be found by following the link in the Camel Component column.
GAE service | Camel component | Component description |
---|---|---|
URL fetch service | ghttp | Provides connectivity to the GAE URL fetch service but can also be used to receive messages from servlets. |
Task queueing service | gtask | Supports asynchronous message processing on GAE by using the task queueing service as message queue. |
Mail service | gmail | Supports sending of emails via the GAE mail service. Receiving mails is not supported yet but will be added later. |
Memcache service | Not supported yet. | |
XMPP service | Not supported yet. | |
Images service | Not supported yet. | |
Datastore service | Not supported yet. | |
Accounts service | gauth glogin | These components interact with the Google Accounts API for authentication and authorization. Google Accounts is not specific to Google App Engine but is often used by GAE applications for implementing security. The gauth component is used by web applications to implement a Google-specific OAuth consumer. This component can also be used to OAuth-enable non-GAE web applications. The glogin component is used by Java clients (outside GAE) for programmatic login to GAE applications. For instructions how to protect GAE applications against unauthorized access refer to the Security for page. |
Camel context
SpringCamelContext
on Google App Engine differs between Camel 2.1 and higher versions. The problem is that usage of the Camel-specific Spring configuration XML schema from the http://camel.apache.org/schema/spring
namespace requires JAXB and Camel 2.1 depends on a Google App Engine SDK version that doesn't support JAXB yet. This limitation has been removed since Camel 2.2.
javax.management
package isn't on the App Engine JRE whitelist.
Apache Camel 2.1
camel-gae
2.1 comes with the following CamelContext
implementations.
org.apache.camel.component.gae.context.GaeDefaultCamelContext
(extendsorg.apache.camel.impl.DefaultCamelContext
)org.apache.camel.component.gae.context.GaeSpringCamelContext
(extendsorg.apache.camel.spring.SpringCamelContext
)
GaeSpringCamelContext
additionally provides setter methods adding route builders as shown in the next example.
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd"> <bean id="camelContext" class="org.apache.camel.component.gae.context.GaeSpringCamelContext"> <property name="routeBuilder" ref="myRouteBuilder" /> </bean> <bean id="myRouteBuilder" class="org.example.MyRouteBuilder"> </bean> </beans>
routeBuilders
property of the GaeSpringCamelContext
for setting a list of route builders. Using this approach, a SpringCamelContext
can be configured on GAE without the need for JAXB.
Apache Camel 2.2
http://camel.apache.org/schema/spring
namespace for configuring a SpringCamelContext
but still need to disable JMX. Here's an example.
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:camel="http://camel.apache.org/schema/spring" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd"> <camel:camelContext id="camelContext"> <camel:jmxAgent id="agent" disabled="true" /> <camel:routeBuilder ref="myRouteBuilder"/> </camel:camelContext> <bean id="myRouteBuilder" class="org.example.MyRouteBuilder"> </bean> </beans>
The web.xml
CamelHttpTransportServlet
from camel-servlet
. The following example shows how to configure this servlet together with a Spring application context XML file.
<web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation=" http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5"> <servlet> <servlet-name>CamelServlet</servlet-name> <servlet-class>org.apache.camel.component.servlet.CamelHttpTransportServlet</servlet-class> <init-param> <param-name>contextConfigLocation</param-name> <param-value>appctx.xml</param-value> </init-param> </servlet> <!-- Mapping used for external requests --> <servlet-mapping> <servlet-name>CamelServlet</servlet-name> <url-pattern>/camel/*</url-pattern> </servlet-mapping> <!-- Mapping used for web hooks accessed by task queueing service. --> <servlet-mapping> <servlet-name>CamelServlet</servlet-name> <url-pattern>/worker/*</url-pattern> </servlet-mapping> </web-app>
contextConfigLocation
init parameter. The appctx.xml
file must be on the classpath. The servlet mapping makes the Apache Camel application accessible under http://<appname>.appspot.com/camel/...
when deployed to Google App Engine where <appname>
must be replaced by a real GAE application name. The second servlet mapping is used internally by the task queueing service for background processing via web hooks. This mapping is relevant for the gtask component and is explained there in more detail.
48.2. gauth
gauth Component
gauth
component is used by web applications to implement a Google-specific OAuth consumer. It will be later extended to support other OAuth providers as well. Although this component belongs to the Camel Components for Google App Engine (GAE), it can also be used to OAuth-enable non-GAE web applications. For a detailed description of Google's OAuth implementation refer to the Google OAuth API reference.
URI format
gauth://name[?options]
name
can be either authorize
or upgrade
. An authorize
endpoint is used to obtain an unauthorized request token from Google and to redirect the user to the authorization page. The upgrade
endpoint is used to process OAuth callbacks from Google and to upgrade an authorized request token to a long-lived access token. Refer to the usage section for an example.
Options
Name | Default Value | Required | Description |
---|---|---|---|
callback
|
null
|
true (can alternatively be set via GAuthAuthorizeBinding.GAUTH_CALLBACK message header)
|
URL where to redirect the user after having granted or denied access. |
scope
|
null
|
true (can alternatively be set via GAuthAuthorizeBinding.GAUTH_SCOPE message header)
|
URL identifying the service(s) to be accessed. Scopes are defined by each Google service; see the service's documentation for the correct value. To specify more than one scope, list each one separated with a comma. Example: http://www.google.com/calendar/feeds/ .
|
consumerKey
|
null
|
true (can alternatively be set on component-level). |
Domain identifying the web application. This is the domain used when registering the application with Google. Example: camelcloud.appspot.com . For a non-registered application use anonymous .
|
consumerSecret
|
null
|
one of consumerSecret or keyLoaderRef is required (can alternatively be set on component-level).
|
Consumer secret of the web application. The consumer secret is generated when when registering the application with Google. It is needed if the HMAC-SHA1 signature method shall be used. For a non-registered application use anonymous .
|
keyLoaderRef
|
null
|
one of consumerSecret or keyLoaderRef is required (can be alternatively set on component-level)
|
Reference to a private key loader in the registry. Part of camel-gae are two key loaders: GAuthPk8Loader for loading a private key from a PKCS#8 file and GAuthJksLoader to load a private key from a Java key store. It is needed if the RSA-SHA1 signature method shall be used. These classes are defined in the org.apache.camel.component.gae.auth package.
|
authorizeBindingRef
|
Reference to GAuthAuthorizeBinding
|
false |
Reference to a OutboundBinding<GAuthEndpoint, GoogleOAuthParameters, GoogleOAuthParameters> in the registry for customizing how an Exchange is bound to GoogleOAuthParameters . This binding is used for teh authorization phase. Most applications won't change the default value.
|
upgradeBindingRef
|
Reference to GAuthAuthorizeBinding
|
false |
Reference to a OutboundBinding<GAuthEndpoint, GoogleOAuthParameters, GoogleOAuthParameters> in the registry. for customizing how an Exchange is bound to GoogleOAuthParameters . This binding is used for teh token upgrade phase. Most applications won't change the default value.
|
Message headers
Name | Type | Endpoint | Message | Description |
---|---|---|---|---|
GAuthAuthorizeBinding.GAUTH_CALLBACK
|
String
|
gauth:authorize
|
in |
Overrides the callback option.
|
GAuthAuthorizeBinding.GAUTH_SCOPE
|
String
|
gauth:authorize
|
in |
Overrides the scope option.
|
GAuthUpgradeBinding.GAUTH_ACCESS_TOKEN
|
String
|
gauth:upgrade
|
out | Contains the long-lived access token. This token should be stored by the applications in context of a user. |
GAuthUpgradeBinding.GAUTH_ACCESS_TOKEN_SECRET
|
String
|
gauth:upgrade
|
out | Contains the access token secret. This token secret should be stored by the applications in context of a user. |
Message body
gauth
component doesn't read or write message bodies.
Component configuration
consumerKey
, consumerSecret
or keyLoader
are usually set to the same values on gauth:authorize
and gauth:upgrade
endpoints. The gauth
component allows to configure them on component-level. These settings are then inherited by gauth
endpoints and need not be set redundantly in the endpoint URIs. Here are some configuration examples.
<bean id="gauth" class="org.apache.camel.component.gae.auth.GAuthComponent"> <property name="consumerKey" value="example.appspot.com" /> <property name="consumerSecret" value="QAtA...HfQ" /> </bean>
<bean id="gauth" class="org.apache.camel.component.gae.auth.GAuthComponent"> <!-- Google will display a warning message on the authorization page --> <property name="consumerKey" value="anonymous" /> <property name="consumerSecret" value="anonymous" /> </bean>
<bean id="gauth" class="org.apache.camel.component.gae.auth.GAuthComponent"> <property name="consumerKey" value="ipfcloud.appspot.com" /> <property name="keyLoader" ref="jksLoader" /> <!--<property name="keyLoader" ref="pk8Loader" />--> </bean> <!-- Loads the private key from a Java key store --> <bean id="jksLoader" class="org.apache.camel.component.gae.auth.GAuthJksLoader"> <property name="keyStoreLocation" value="myKeytore.jks" /> <property name="keyAlias" value="myKey" /> <property name="keyPass" value="myKeyPassword" /> <property name="storePass" value="myStorePassword" /> </bean> <!-- Loads the private key from a PKCS#8 file --> <bean id="pk8Loader" class="org.apache.camel.component.gae.auth.GAuthPk8Loader"> <property name="keyStoreLocation" value="myKeyfile.pk8" /> </bean>
Usage
gauth.example.org
.
import java.net.URLEncoder; import org.apache.camel.builder.RouteBuilder; public class GAuthRouteBuilder extends RouteBuilder { @Override public void configure() throws Exception { // Calback URL to redirect user from Google Authorization back to the web application String encodedCallback = URLEncoder.encode("https://gauth.example.org:8443/handler", "UTF-8"); // Application will request for authorization to access a user's Google Calendar String encodedScope = URLEncoder.encode("http://www.google.com/calendar/feeds/", "UTF-8"); // Route 1: A GET request to http://gauth.example.org/authorize will trigger the the OAuth // sequence of interactions. The gauth:authorize endpoint obtains an unauthorized request // token from Google and then redirects the user (browser) to a Google authorization page. from("jetty:http://0.0.0.0:8080/authorize") .to("gauth:authorize?callback=" + encodedCallback + "&scope=" + encodedScope); // Route 2: Handle callback from Google. After the user granted access to Google Calendar // Google redirects the user to https://gauth.example.org:8443/handler (see callback) along // with an authorized request token. The gauth:access endpoint exchanges the authorized // request token against a long-lived access token. from("jetty:https://0.0.0.0:8443/handler") .to("gauth:upgrade") // The access token can be obtained from // exchange.getOut().getHeader(GAuthUpgradeBinding.GAUTH_ACCESS_TOKEN) // The access token secret can be obtained from // exchange.getOut().getHeader(GAuthUpgradeBinding.GAUTH_ACCESS_TOKEN_SECRET) .process(/* store the tokens in context of the current user ... */); } }
http://gauth.example.org/authorize
. The user is then redirected to a Google authorization page. After having granted access on this page, Google redirects the user to the web application which handles the callback and finally obtains a long-lived access token from Google.
servlet
component instead of the jetty
component.
- Application should store the access token in context of the current user. If the user logs in next time, the access token can directly be loaded from the database, for example, without doing the OAuth dance again.
- The access token is then used to get access to Google services, such as a Google Calendar API, on behalf of the user. Java applications will most likely use the GData Java library for that. See below for an example how to use the access token with the GData Java library to read a user's calendar feed.
- The user can revoke the access token at any time from his Google Accounts page. In this case, access to the corresponding Google service will throw an authorization exception. The web application should remove the stored access token and redirect the user again to the Google authorization page for creating another one.
<bean id="gauth" class="org.apache.camel.component.gae.auth.GAuthComponent"> <property name="consumerKey" value="anonymous" /> <property name="consumerSecret" value="anonymous" /> </bean>
consumerKey
and consumerSecret
settings.
GAE example
camelcloud.appspot.com
a configuration might look as follows. Here, the ghttp component is used to handle HTTP(S) requests instead of the jetty
component.
import java.net.URLEncoder; import org.apache.camel.builder.RouteBuilder; public class TutorialRouteBuilder extends RouteBuilder { @Override public void configure() throws Exception { String encodedCallback = URLEncoder.encode("https://camelcloud.appspot.com/handler", "UTF-8"); String encodedScope = URLEncoder.encode("http://www.google.com/calendar/feeds/", "UTF-8"); from("ghttp:///authorize") .to("gauth:authorize?callback=" + encodedCallback + "&scope=" + encodedScope); from("ghttp:///handler") .to("gauth:upgrade") .process(/* store the tokens in context of the current user ... */); } }
Access token usage
stdout
.
import com.google.gdata.client.authn.oauth.OAuthHmacSha1Signer; import com.google.gdata.client.authn.oauth.OAuthParameters; import com.google.gdata.client.calendar.CalendarService; import com.google.gdata.data.calendar.CalendarEntry; import com.google.gdata.data.calendar.CalendarFeed; import java.net.URL; public class AccessExample { public static void main(String... args) throws Exception { String accessToken = ... String accessTokenSecret = ... CalendarService myService = new CalendarService("exampleCo-exampleApp-1.0"); OAuthParameters params = new OAuthParameters(); params.setOAuthConsumerKey("anonymous"); params.setOAuthConsumerSecret("anonymous"); params.setOAuthToken(accessToken); params.setOAuthTokenSecret(accessTokenSecret); myService.setOAuthCredentials(params, new OAuthHmacSha1Signer()); URL feedUrl = new URL("http://www.google.com/calendar/feeds/default/"); CalendarFeed resultFeed = myService.getFeed(feedUrl, CalendarFeed.class); System.out.println("Your calendars:"); System.out.println(); for (int i = 0; i < resultFeed.getEntries().size(); i++) { CalendarEntry entry = resultFeed.getEntries().get(i); System.out.println(entry.getTitle().getPlainText()); } } }
48.3. ghttp
ghttp Component
ghttp
component contributes to the Camel Components for Google App Engine (GAE). It provides connectivity to the GAE URL fetch service but can also be used to receive messages from servlets (the only way to receive HTTP requests on GAE). This is achieved by extending the Servlet component. As a consequence, ghttp
URI formats and options sets differ on the consumer-side (from
) and producer-side (to
).
URI format
Format | Context | Comment |
---|---|---|
ghttp:///path[?options] |
Consumer | See also Servlet component |
ghttp://hostname[:port][/path][?options] ghttps://hostname[:port][/path][?options] |
Producer | See also Http component |
Options
Name | Default Value | Context | Description |
---|---|---|---|
bridgeEndpoint
|
true
|
Producer |
If set to true the Exchange.HTTP_URI header will be ignored. To override the default endpoint URI with the Exchange.HTTP_URI header set this option to false .
|
throwExceptionOnFailure
|
true
|
Producer |
Throw a org.apache.camel.component.gae.http if the response code is >= 400. To disable throwing an exception set this option to false .
|
inboundBindingRef
|
reference to GHttpBinding
|
Consumer |
Reference to an InboundBinding<GHttpEndpoint, HttpServletRequest, HttpServletResponse> in the Registry for customizing the binding of an Exchange to the Servlet API. The referenced binding is used as post-processor to org.apache.camel.component.http.HttpBinding .
|
outboundBindingRef
|
reference to GHttpBinding
|
Producer |
Reference to an OutboundBinding<GHttpEndpoint, HTTPRequest, HTTPResponse> in the Registry for customizing the binding of an Exchange to the URLFetchService .
|
Message headers
Name | Type | Description |
---|---|---|
Exchange.CONTENT_TYPE
|
String
|
The HTTP content type. Is set on both the in and out message to provide a content type, such as text/html .
|
Exchange.CONTENT_ENCODING
|
String
|
The HTTP content encoding. Is set on both the in and out message to provide a content encoding, such as gzip .
|
Exchange.HTTP_METHOD
|
String
|
The HTTP method to execute. One of GET , POST , PUT and DELETE . If not set, POST will be used if the message body is not null , GET otherwise.
|
Exchange.HTTP_QUERY
|
String
|
Overrides the query part of the endpoint URI or the the query part of Exchange.HTTP_URI (if defined). The query string must be in decoded form.
|
Exchange.HTTP_URI
|
String
|
Overrides the default endpoint URI if the bridgeEndpoint option is set to false . The URI string must be in decoded form.
|
Exchange.RESPONSE_CODE
|
int
|
The HTTP response code from URL fetch service responses. |
Message body
in
message body is converted to a byte[]
. The out
message body is made available as InputStream
. If the reponse size exceeds 1 megabyte a ResponseTooLargeException is thrown by the URL fetch service (see quotas and limits).
Receiving messages
ghttp
component, a CamelHttpTransportServlet
must be configured and mapped in the application's web.xml
(see the section called “The web.xml”). For example, to handle requests targeted at http://<appname>.appspot.com/camel/*
or http://localhost/camel/*
(when using a local development server) the following servlet mapping must be defined:
... <servlet> <servlet-name>CamelServlet</servlet-name> <servlet-class>org.apache.camel.component.servlet.CamelHttpTransportServlet</servlet-class> ... </servlet> ... <servlet-mapping> <servlet-name>CamelServlet</servlet-name> <url-pattern>/camel/*</url-pattern> </servlet-mapping> ...
from("ghttp:///greeting").transform().constant("Hello")
http://<appname>.appspot.com/camel/greeting
. In this example, the request body is ignored and the response body is set to Hello
. Requests targeted at http://<appname>.appspot.com/camel/greeting/*
are not processed by default. This requires setting the option matchOnUriPrefix
to true
.
from("ghttp:///greeting?matchOnUriPrefix=true").transform().constant("Hello")
Sending messages
ghttp
component uses the URL fetch service. For example, the Apache Camel homepage can the retrieved with the following endpoint definition on the producer-side.
from(...) ... .to("ghttp://camel.apache.org") ...
Exchange.HTTP_METHOD
message header or on the presence of an in-message body (GET
if null
, POST
otherwise). Retrieving the Camel homepage via a GAE application is as simple as
from("ghttp:///home") .to("ghttp://camel.apache.org")
GET
request to http://<appname>.appspot.com/camel/home
returns the Camel homepage. HTTPS-based communication with external services can be enabled with the ghttps
scheme.
from(...) ... .to("ghttps://svn.apache.org/repos/asf/camel/trunk/") ...
Dependencies
pom.xml
.
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-gae</artifactId> <version>${camel-version}</version> </dependency>
${camel-version}
must be replaced by the actual version of Apache Camel (2.1.0 or higher).
48.4. glogin
glogin Component
glogin
component is used by Apache Camel applications outside Google App Engine (GAE) for programmatic login to GAE applications. It is part of the Chapter 48, GAE. Security-enabled GAE applications normally redirect the user to a login page. After submitting username and password for authentication, the user is redirected back to the application. That works fine for applications where the client is a browser. For all other applications, the login process must be done programmatically. All the necessary steps for programmatic login are implemented by the glogin
component. These are
- Get an authentication token from Google Accounts via the ClientLogin API.
- Get an authorization cookie from Google App Engine's login API.
URI format
glogin://hostname[:port][?options]
hostname
is either the internet hostname of a GAE application (e.g. camelcloud.appspot.com
) or the name of the host where the development server is running (e.g. localhost
). The port
is only used when connecting to a development server (i.e. when devMode=true
, see options) and defaults to 8080
.
Options
Name | Default Value | Required | Description |
---|---|---|---|
clientName
|
apache-camel-2.x
|
false |
A client name with recommended (but not required) format <organization>\-<appname>\-<version> .
|
userName
|
null
|
true (can alternatively be set via GLoginBinding.GLOGIN_USER_NAME message header)
|
Login username (an email address). |
password
|
null
|
true (can alternatively be set via GLoginBinding.GLOGIN_PASSWORD message header)
|
Login password. |
devMode
|
false
|
false |
If set to true a login to a development server is attempted.
|
devAdmin
|
false
|
false |
If set to true a login to a development server in admin role is attempted.
|
Message headers
Name | Type | Message | Description |
---|---|---|---|
GLoginBinding.GLOGIN_HOST_NAME
|
String
|
in | Overrides the hostname defined in the endpoint URI. |
GLoginBinding.GLOGIN_USER_NAME
|
String
|
in |
Overrides the userName option.
|
GLoginBinding.GLOGIN_PASSWORD
|
String
|
in |
Overrides the password option.
|
GLoginBinding.GLOGIN_TOKEN
|
String
|
out | Contains the authentication token obtained from Google Accounts. Login to a development server does not set this header. |
GLoginBinding.GLOGIN_COOKIE
|
String
|
out | Contains the application-specific authorization cookie obtained from Google App Engine (or a development server). |
Message body
glogin
component doesn't read or write message bodies.
Usage
import org.apache.camel.Exchange; import org.apache.camel.Processor; import org.apache.camel.ProducerTemplate; import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import static org.apache.camel.component.gae.login.GLoginBinding.*; import static org.junit.Assert.*; public class GLoginTest { private ProducerTemplate template = ... @Test public void testDevLogin() { Exchange result = template.request("glogin://localhost:8888?userName=test@example.org&devMode=true", null); assertNotNull(result.getOut().getHeader(GLOGIN_COOKIE)); } @Test public void testRemoteLogin() { Exchange result = template.request("glogin://camelcloud.appspot.com", new Processor() { public void process(Exchange exchange) throws Exception { exchange.getIn().setHeader(GLOGIN_USER_NAME, "replaceme@gmail.com"); exchange.getIn().setHeader(GLOGIN_PASSWORD, "replaceme"); } }); assertNotNull(result.getOut().getHeader(GLOGIN_COOKIE)); } }
ahlogincookie=test@example.org:false:11223191102230730701;Path=/
ACSID=AJKiYcE...XxhH9P_jR_V3; expires=Sun, 07-Feb-2010 15:14:51 GMT; path=/
48.5. gmail
gmail Component
gmail
component contributes to the Camel Components for Google App Engine (GAE). It supports sending of emails via the GAE mail service. Receiving mails is not supported yet but will be added later. Currently, only Google accounts that are application administrators can send emails.
URI format
gmail://user@gmail.com[?options] gmail://user@googlemail.com[?options]
Options
Name | Default Value | Context | Description |
---|---|---|---|
to
|
null
|
Producer | To-receiver of the email. This can be a single receiver or a comma-separated list of receivers. |
cc
|
null
|
Producer | Cc-receiver of the email. This can be a single receiver or a comma-separated list of receivers. |
bcc
|
null
|
Producer | Bcc-receiver of the email. This can be a single receiver or a comma-separated list of receivers. |
subject
|
null
|
Producer | Subject of the email. |
outboundBindingRef
|
reference to GMailBinding
|
Producer |
Reference to an OutboundBinding<GMailEndpoint, MailService.Message, void> in the Registry for customizing the binding of an Exchange to the mail service.
|
Message headers
Name | Type | Context | Description |
---|---|---|---|
GMailBinding.GMAIL_SUBJECT
|
String
|
Producer |
Subject of the email. Overrides subject endpoint option.
|
GMailBinding.GMAIL_SENDER
|
String
|
Producer | Sender of the email. Overrides sender definition in endpoint URI. |
GMailBinding.GMAIL_TO
|
String
|
Producer |
To-receiver(s) of the email. Overrides to endpoint option.
|
GMailBinding.GMAIL_CC
|
String
|
Producer |
Cc-receiver(s) of the email. Overrides cc endpoint option.
|
GMailBinding.GMAIL_BCC
|
String
|
Producer |
Bcc-receiver(s) of the email. Overrides bcc endpoint option.
|
Message body
in
message body is converted to a String
.
Usage
... .setHeader(GMailBinding.GMAIL_SUBJECT, constant("Hello")) .setHeader(GMailBinding.GMAIL_TO, constant("account2@somewhere.com")) .to("gmail://account1@gmail.com");
Hello
from account1@gmail.com
to account2@somewhere.com
. The mail message body is taken from the in
message body. Please note that account1@gmail.com
must be an administrator account for the current GAE application.
Dependencies
pom.xml
.
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-gae</artifactId> <version>${camel-version}</version> </dependency>
$\{camel-version\
} must be replaced by the actual version of Apache Camel (2.1.0 or higher).
48.6. gsec
Security for Apache Camel GAE Applications
web.xml
file (see the section called “The web.xml”). This applies to Apache Camel applications as well. In the following example, the application is configured to only allow authenticated users (in any role) to access the application. Additionally, access to /worker/\*
URLs masy only be done by users in the admin role. By default, web hook URLs installed by the gtask component match the /worker/\*
pattern and should not be accessed by normal users. With this authorization constraint, only the task queuing service (which is always in the admin role) is allowed to access the web hooks. For implementing custom, non-declarative authorization logic, Apache Camel GAE applications should use the Google Accounts Java API.
Example 48.1. web.xml with authorization constraint
<web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation=" http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5"> <servlet> <servlet-name>CamelServlet</servlet-name> <servlet-class>org.apache.camel.component.servlet.CamelHttpTransportServlet</servlet-class> <init-param> <param-name>contextConfigLocation</param-name> <param-value>appctx.xml</param-value> </init-param> </servlet> <!-- Mapping used for external requests --> <servlet-mapping> <servlet-name>CamelServlet</servlet-name> <url-pattern>/camel/*</url-pattern> </servlet-mapping> <!-- Mapping used for web hooks accessed by task queueing service. --> <servlet-mapping> <servlet-name>CamelServlet</servlet-name> <url-pattern>/worker/*</url-pattern> </servlet-mapping> <!-- By default allow any user who is logged in to access the whole application. --> <security-constraint> <web-resource-collection> <url-pattern>/*</url-pattern> </web-resource-collection> <auth-constraint> <role-name>*</role-name> </auth-constraint> </security-constraint> <!-- Allow only admin users to access /worker/* URLs e.g. to prevent normal user to access gtask web hooks. --> <security-constraint> <web-resource-collection> <url-pattern>/worker/*</url-pattern> </web-resource-collection> <auth-constraint> <role-name>admin</role-name> </auth-constraint> </security-constraint> </web-app>
48.7. gtask
gtask Component
gtask
component contributes to the Camel Components for Google App Engine (GAE). It supports asynchronous message processing on GAE by using the task queueing service as message queue. For adding messages to a queue it uses the task queue API. For receiving messages from a queue it installs an HTTP callback handler. The handler is called by an HTTP POST callback (a web hook) initiated by the task queueing service. Whenever a new task is added to a queue a callback will be sent. The gtask
component abstracts from these details and supports endpoint URIs that make message queueing on GAE as easy as message queueing with JMS or SEDA.
URI format
gtask://queue-name
Options
Name | Default Value | Context | Description |
---|---|---|---|
workerRoot
|
worker
|
Producer |
The servlet mapping for callback handlers. By default, this component requires a callback servlet mapping of /worker/* . If another servlet mapping is used e.g. /myworker/* it must be set as option on the producer side: to("gtask:myqueue?workerRoot=myworker") .
|
inboundBindingRef
|
reference to GTaskBinding
|
Consumer |
Reference to an InboundBinding<GTaskEndpoint, HttpServletRequest, HttpServletResponse> in the Registry for customizing the binding of an Exchange to the Servlet API. The referenced binding is used as post-processor to org.apache.camel.component.http.HttpBinding .
|
outboundBindingRef
|
reference to GTaskBinding
|
Producer |
Reference to an OutboundBinding<GTaskEndpoint, TaskOptions, void> in the Registry for customizing the binding of an Exchange to the task queueing service.
|
Message headers
Name | Type | Context | Description |
---|---|---|---|
GTaskBinding.GTASK_QUEUE_NAME
|
String
|
Consumer | Name of the task queue. |
GTaskBinding.GTASK_TASK_NAME
|
String
|
Consumer | Name of the task (generated value). |
GTaskBinding.GTASK_RETRY_COUNT
|
int
|
Consumer | Number of callback retries. |
Message body
in
message body is converted to a byte[]
and is POSTed to the callback handler as content-type application/octet-stream
.
Usage
default
queue. This queue will be used in the following examples. Please note that when using task queues on the local development server, tasks must be executed manually from the developer console.
Default queue
... .to(gtask:default) // add message to default queue from(gtask:default) // receive message from default queue (via a web hook) ...
... <servlet> <servlet-name>CamelServlet</servlet-name> <servlet-class>org.apache.camel.component.servlet.CamelHttpTransportServlet</servlet-class> ... </servlet> ... <servlet-mapping> <servlet-name>CamelServlet</servlet-name> <url-pattern>/worker/*</url-pattern> </servlet-mapping> ...
Dependencies
pom.xml
.
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-gae</artifactId> <version>${camel-version}</version> </dependency>
${camel-version}
must be replaced by the actual version of Apache Camel (2.1.0 or higher).
Chapter 49. Geocoder
Geocoder Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-geocoder</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
geocoder:address:name[?options] geocoder:latlng:latitude,longitude[?options]
Options
Property | Default | Description |
---|---|---|
language
|
en
|
The language to use. |
headersOnly
|
false
|
Whether to only enrich the Exchange with headers, and leave the body as-is. |
clientId
|
To use google premium with this client id | |
clientKey
|
To use google premium with this client key |
?option=value&option=value&...
Exchange data format
com.google.code.geocoder.model.GeocodeResponse
type. And if the address is "current"
then the response is a String type with a JSON representation of the current location.
headersOnly
is set to true
then the message body is left as-is, and only headers will be added to the Exchange.
Message Headers
Header | Description |
---|---|
CamelGeoCoderStatus
|
Mandatory. Status code from the geocoder library. If status is GeocoderStatus.OK then additional headers is enriched
|
CamelGeoCoderAddress
|
The formatted address |
CamelGeoCoderLat
|
The latitude of the location. |
CamelGeoCoderLng
|
The longitude of the location. |
CamelGeoCoderLatlng
|
The latitude and longitude of the location. Separated by comma. |
CamelGeoCoderCity
|
The city long name. |
CamelGeoCoderRegionCode
|
The region code. |
CamelGeoCoderRegionName
|
The region name. |
CamelGeoCoderCountryLong
|
The country long name. |
CamelGeoCoderCountryShort
|
The country short name. |
Samples
from("direct:start") .to("geocoder:address:Paris, France")
CamelGeoCoderAddress
then that overrides the endpoint configuration, so to get the location of Copenhagen, Denmark we can send a message with a headers as shown:
template.sendBodyAndHeader("direct:start", "Hello", GeoCoderConstants.ADDRESS, "Copenhagen, Denmark");
from("direct:start") .to("geocoder:latlng:40.714224,-73.961452") .log("Location ${header.CamelGeocoderAddress} is at lat/lng: ${header.CamelGeocoderLatlng} and in country ${header.CamelGeoCoderCountryShort}")
Location 285 Bedford Avenue, Brooklyn, NY 11211, USA is at lat/lng: 40.71412890,-73.96140740 and in country US
from("direct:start") .to("geocoder:address:current")
Chapter 50. GitHub
GitHub component
- Concern for reliability/stability
- The types of payloads we're polling aren't typically large (plus, paging is available in the API)
- The need to support apps running somewhere not publicly accessible where a webhook would fail
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-github</artifactId> <version>${camel-version}</version> </dependency>
URI format
gihub://endpoint[?options]
Mandatory Options:
Option
|
Description
|
---|---|
username
|
GitHub username, required unless oauthToken is provided
|
password
|
GitHub password, required unless oauthToken is provided
|
oauthToken
|
GitHub OAuth token, required unless username & password are provided
|
repoOwner
|
GitHub repository owner (organization)
|
repoName | GitHub repository name |
Consumer Endpoints:
Endpoint
|
Context
|
Body Type
|
---|---|---|
pullRequest
|
polling
|
org.eclipse.egit.github.core.PullRequest
|
pullRequestComment
|
polling
|
org.eclipse.egit.github.core.Comment (comment on the general pull request discussion) or org.eclipse.egit.github.core.CommitComment (inline comment on a pull request diff)
|
tag
|
polling
|
org.eclipse.egit.github.core.RepositoryTag
|
commit
|
polling
|
org.eclipse.egit.github.core.RepositoryCommit
|
Producer Endpoints:
Endpoint
|
Body
| Message Headers |
---|---|---|
pullRequestComment
|
String (comment text)
|
|
closePullRequest
|
none
|
|
URI Options
Name
|
Default Value
|
Description
|
---|---|---|
delay
|
60
|
in seconds
|
Chapter 51. GoogleCalendar
GoogleCalendar component
Component Description
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-google-calendar</artifactId> <version>2.15-SNAPSHOT</version> </dependency>
URI Format
google-calendar://endpoint-prefix/endpoint?[options]
- acl
- calendars
- channels
- colors
- events
- freebusy
- list
- settings
GoogleCalendarComponent
configuration
of type org.apache.camel.component.google.calendar.GoogleCalendarConfiguration
.
Option | Type | |
---|---|---|
accessToken | String | OAuth 2 access token. This typically expires after an hour so refreshToken is recommended for long term usage. |
applicationName | String | Google calendar application name. Example would be "camel-google-calendar/1.0" |
clientId | String | Client ID of the calendar application |
clientSecret | String | Client secret of the calendar application |
refreshToken |
String
|
OAuth 2 refresh token. Using this, the Google Calendar component can obtain a new accessToken whenever the current one expires - a necessity if the application is long-lived. |
scopes | List<String> | Specifies the level of permissions you want a calendar application to have to a user account. See https://developers.google.com/google-apps/calendar/auth for more info. |
Producer Endpoints
inBody
that in turn should contain the name of the endpoint option whose value will be contained in the Camel Exchange In message.
CamelGoogleCalendar.<option>
. Note that the inBody
option overrides message header, i.e. the endpoint option inBody=option
would override a CamelGoogleCalendar.option
header.
1. Endpoint Prefix acl
acl
as follows:
google-calendar://acl/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
delete | calendarId, ruleId | ||
get | calendarId, ruleId | com.google.api.services.calendar.model.AclRule | |
insert | calendarId, content | com.google.api.services.calendar.model.AclRule | |
list | calendarId |
com.google.api.services.calendar.model.Acl
|
|
patch | calendarId, content, ruleId | com.google.api.services.calendar.model.AclRule | |
update | calendarId, content, ruleId | com.google.api.services.calendar.model.AclRule | |
watch | calendarId, contentChannel | com.google.api.services.calendar.model.Channel |
URI Options for acl
Name | Type |
---|---|
calendarId | String |
content | com.google.api.services.calendar.model.AclRule |
contentChannel | com.google.api.services.calendar.model.Channel |
ruleId | String |
2. Endpoint Prefix calendars
calendars
as follows:
google-calendar://calendars/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
clear | calendarId | ||
delete | calendarId | ||
get | calendarId |
com.google.api.services.calendar.Calendar
|
|
insert | content |
com.google.api.services.calendar.Calendar
|
|
patch | calendarId, content |
com.google.api.services.calendar.Calendar
|
|
update | calendarId, content |
com.google.api.services.calendar.Calendar
|
URI Options for calendars
Name | Type |
---|---|
calendarId | String |
content | com.google.api.services.calendar.model.Calendar |
3. Endpoint Prefix channels
channels
as follows:
google-calendar://channels/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
stop | contentChannel |
URI Options for channels
Name | Type |
---|---|
contentChannel | com.google.api.services.calendar.model.Channel |
4. Endpoint Prefix colors
colors
as follows:
google-calendar://colors/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
get |
com.google.api.services.calendar.model.Colors
|
URI Options for colors
Name | Type |
---|
5. Endpoint Prefix events
events
as follows:
google-calendar://events/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
calendarImport | calendarId, content | com.google.api.services.calendar.model.Event | |
delete | calendarId, eventId | ||
get | calendarId, eventId | com.google.api.services.calendar.model.Event | |
insert | calendarId, content | com.google.api.services.calendar.model.Event | |
instances | calendarId, eventId |
com.google.api.services.calendar.model.Events
|
|
list | calendarId |
com.google.api.services.calendar.model.Events
|
|
move | calendarId, destination, eventId | com.google.api.services.calendar.model.Event | |
patch | calendarId, content, eventId | com.google.api.services.calendar.model.Event | |
quickAdd | calendarId, text | com.google.api.services.calendar.model.Event | |
update | calendarId, content, eventId | com.google.api.services.calendar.model.Event | |
watch | calendarId, contentChannel | com.google.api.services.calendar.model.Channel |
URI Options for events
Name | Type |
---|---|
calendarId | String |
content | com.google.api.services.calendar.model.Event |
contentChannel | com.google.api.services.calendar.model.Channel |
destination | String |
eventId | String |
text | String |
6. Endpoint Prefix freebusy
freebusy
as follows:
google-calendar://freebusy/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
query | content | com.google.api.services.calendar.model.FreeBusyResponse |
URI Options for freebusy
Name | Type |
---|---|
content | com.google.api.services.calendar.model.FreeBusyRequest |
7. Endpoint Prefix list
list
as follows:
google-calendar://list/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
delete | calendarId | ||
get | calendarId |
com.google.api.services.calendar.model.CalendarListEntry
|
|
insert | content |
com.google.api.services.calendar.model.CalendarListEntry
|
|
list |
com.google.api.services.calendar.model.CalendarList
|
||
patch | calendarId, content |
com.google.api.services.calendar.model.CalendarListEntry
|
|
update | calendarId, content |
com.google.api.services.calendar.model.CalendarListEntry
|
|
watch | contentChannel | com.google.api.services.calendar.model.Channel |
URI Options for list
Name | Type |
---|---|
calendarId | String |
content | com.google.api.services.calendar.model.CalendarListEntry |
contentChannel | com.google.api.services.calendar.model.Channel |
8. Endpoint Prefix settings
settings
as follows:
google-calendar://settings/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
get | setting |
com.google.api.services.calendar.model.Setting
|
|
list |
com.google.api.services.calendar.model.Settings
|
||
watch | contentChannel | com.google.api.services.calendar.model.Channel |
URI Options for settings
Name | Type |
---|---|
contentChannel | com.google.api.services.calendar.model.Channel |
setting | String |
Consumer Endpoints
consumer.
prefix to schedule endpoint invocation. Consumer endpoints that return an array or collection will generate one exchange per element, and their routes will be executed once for each exchange.
Message Headers
CamelGoogleCalendar.
prefix.
Message Body
inBody
endpoint URI parameter. For endpoints that return an array or collection, a consumer endpoint will map every element to distinct messages.
Chapter 52. GoogleDrive
GoogleDrive Component
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-google-drive</artifactId> <version>2.14-SNAPSHOT</version> </dependency>
URI Format
google-drive://endpoint-prefix/endpoint?[options]
drive-about
drive-apps
drive-changes
drive-channels
drive-children
drive-comments
drive-files
drive-parents
drive-permissions
drive-properties
drive-realtime
drive-replies
drive-revisions
GoogleDriveComponent
configuration
of type org.apache.camel.component.google.drive.GoogleDriveConfiguration
.
Option | Type | Description |
---|---|---|
accessToken
|
String
|
OAuth 2 access token. This typically expires after an hour so refreshToken is recommended for long term usage.
|
applicationName
|
String
|
Google drive application name. Example would be camel-google-drive/1.0 .
|
clientId
|
String
|
Client ID of the drive application |
clientSecret
|
String
|
Client secret of the drive application |
refreshToken
|
String
|
OAuth 2 refresh token. Using this, the Google Drive component can obtain a new accessToken whenever the current one expires - a necessity if the application is long-lived.
|
scopes
|
List<String>
|
Specifies the level of permissions you want a drive application to have to a user account. See https://developers.google.com/drive/web/scopes for more info. |
Producer Endpoints
inBody
that in turn should contain the name of the endpoint option whose value will be contained in the Camel Exchange In message.
CamelGoogleDrive.<option>
. Note that the inBody
option overrides message header, i.e. the endpoint option inBody=option
would override a CamelGoogleDrive.option
header.
1. Endpoint Prefix drive-about
drive-about
as follows:
google-drive://drive-about/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
get
|
com.google.api.services.drive.model.About
|
URI Options for drive-about
Name | Type |
---|
2. Endpoint Prefix drive-apps
drive-apps
as follows:
google-drive://drive-apps/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
get
|
appId
|
com.google.api.services.drive.model.App
|
|
list
|
com.google.api.services.drive.model.AppList
|
URI Options for drive-apps
Name | Type |
---|---|
appId
|
String
|
3. Endpoint Prefix drive-changes
drive-changes
as follows:
google-drive://drive-changes/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
get
|
changeId
|
com.google.api.services.drive.model.Change
|
|
list
|
com.google.api.services.drive.model.ChangeList
|
||
watch
|
contentChannel
|
com.google.api.services.drive.model.Channel
|
URI Options for drive-changes
Name | Type |
---|---|
changeId
|
String
|
contentChannel
|
com.google.api.services.drive.model.Channel
|
4. Endpoint Prefix drive-channels
drive-channels
as follows:
google-drive://drive-channels/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
stop
|
contentChannel
|
URI Options for drive-channels
Name | Type |
---|---|
contentChannel
|
com.google.api.services.drive.model.Channel
|
5. Endpoint Prefix drive-children
drive-children
as follows:
google-drive://drive-children/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
delete
|
childId , folderId
|
||
get
|
childId , folderId
|
com.google.api.services.drive.model.ChildReference
|
|
insert
|
content , folderId
|
com.google.api.services.drive.model.ChildReference
|
|
list
|
folderId
|
com.google.api.services.drive.model.ChildList
|
URI Options for drive-children
Name | Type |
---|---|
childId
|
String
|
content
|
com.google.api.services.drive.model.ChildReference
|
folderId
|
String
|
6. Endpoint Prefix drive-comments
drive-comments
as follows:
google-drive://drive-comments/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
delete
|
commentId , fileId
|
||
get
|
commentId , fileId
|
com.google.api.services.drive.model.Comment
|
|
insert
|
content , fileId
|
com.google.api.services.drive.model.Comment
|
|
list
|
fileId
|
com.google.api.services.drive.model.CommentList
|
|
patch
|
commentId , content , fileId
|
com.google.api.services.drive.model.Comment
|
|
update
|
commentId , content , fileId
|
com.google.api.services.drive.model.Comment
|
URI Options for drive-comments
Name | Type |
---|---|
commentId
|
String
|
content
|
com.google.api.services.drive.model.Comment
|
fileId
|
String
|
7. Endpoint Prefix drive-files
drive-files
as follows:
google-drive://drive-files/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
copy
|
content , fileId
|
com.google.api.services.drive.model.File
|
|
delete
|
fileId
|
||
get
|
fileId
|
com.google.api.services.drive.model.File
|
|
insert
|
[mediaContent] , content
|
com.google.api.services.drive.model.File
|
|
list
|
com.google.api.services.drive.model.FileList
|
||
patch
|
content , fileId
|
com.google.api.services.drive.model.File
|
|
touch
|
fileId
|
com.google.api.services.drive.model.File
|
|
trash
|
fileId
|
com.google.api.services.drive.model.File
|
|
untrash
|
fileId
|
com.google.api.services.drive.model.File
|
|
update
|
[mediaContent] , content , fileId
|
com.google.api.services.drive.model.File
|
|
watch
|
contentChannel , fileId
|
com.google.api.services.drive.model.Channel
|
URI Options for drive-files
Name | Type |
---|---|
content
|
com.google.api.services.drive.model.File
|
contentChannel
|
com.google.api.services.drive.model.Channel
|
fileId
|
String
|
mediaContent
|
com.google.api.client.http.AbstractInputStreamContent
|
8. Endpoint Prefix drive-parents
drive-parents
as follows:
google-drive://drive-parents/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
delete
|
fileId , parentId
|
||
get
|
fileId , parentId
|
com.google.api.services.drive.model.ParentReference
|
|
insert
|
content , fileId
|
com.google.api.services.drive.model.ParentReference
|
|
list
|
fileId
|
com.google.api.services.drive.model.ParentList
|
URI Options for drive-parents
Name | Type |
---|---|
content
|
com.google.api.services.drive.model.ParentReference
|
fileId
|
String
|
parentId
|
String
|
9. Endpoint Prefix drive-permissions
drive-permissions
as follows:
google-drive://drive-permissions/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
delete
|
fileId , permissionId
|
||
get
|
fileId , permissionId
|
com.google.api.services.drive.model.Permission
|
|
getIdForEmail
|
email
|
com.google.api.services.drive.model.PermissionId
|
|
insert
|
content , fileId
|
com.google.api.services.drive.model.Permission
|
|
list
|
fileId
|
com.google.api.services.drive.model.PermissionList
|
|
patch
|
content , fileId , permissionId
|
com.google.api.services.drive.model.Permission
|
|
update
|
content , fileId , permissionId
|
com.google.api.services.drive.model.Permission
|
URI Options for drive-permissions
Name | Type |
---|---|
content
|
com.google.api.services.drive.model.Permission
|
email
|
String
|
fileId
|
String
|
permissionId
|
String
|
10. Endpoint Prefix drive-properties
drive-properties
as follows:
google-drive://drive-properties/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
delete
|
fileId , propertyKey
|
||
get
|
fileId , propertyKey
|
com.google.api.services.drive.model.Property
|
|
insert
|
content , fileId
|
com.google.api.services.drive.model.Property
|
|
list
|
fileId
|
com.google.api.services.drive.model.PropertyList
|
|
patch
|
content , fileId , propertyKey
|
com.google.api.services.drive.model.Property
|
|
update
|
content , fileId , propertyKey
|
com.google.api.services.drive.model.Property
|
URI Options for drive-properties
Name | Type |
---|---|
content
|
com.google.api.services.drive.model.Property
|
fileId
|
String
|
propertyKey
|
String
|
11. Endpoint Prefix drive-realtime
drive-realtime
as follows:
google-drive://drive-realtime/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
get
|
fileId
|
||
update
|
[mediaContent] , fileId
|
URI Options for drive-realtime
Name | Type |
---|---|
fileId
|
String
|
mediaContent
|
com.google.api.client.http.AbstractInputStreamContent
|
12. Endpoint Prefix drive-replies
drive-replies
as follows:
google-drive://drive-replies/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
delete
|
commentId , fileId , replyId
|
||
get
|
commentId , fileId , replyId
|
com.google.api.services.drive.model.CommentReply
|
|
insert
|
commentId , content , fileId
|
com.google.api.services.drive.model.CommentReply
|
|
list
|
commentId , fileId
|
com.google.api.services.drive.model.CommentReplyList
|
|
patch
|
commentId , content , fileId , replyId
|
com.google.api.services.drive.model.CommentReply
|
|
update
|
commentId , content , fileId , replyId
|
com.google.api.services.drive.model.CommentReply
|
URI Options for drive-replies
Name | Type |
---|---|
commentId
|
String
|
content
|
com.google.api.services.drive.model.CommentReply
|
fileId
|
String
|
replyId
|
String
|
13. Endpoint Prefix drive-revisions
drive-revisions
as follows:
google-drive://drive-revisions/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
delete
|
fileId , revisionId
|
||
get
|
fileId , revisionId
|
com.google.api.services.drive.model.Revision
|
|
list
|
fileId
|
com.google.api.services.drive.model.RevisionList
|
|
patch
|
content , fileId , revisionId
|
com.google.api.services.drive.model.Revision
|
|
update
|
content , fileId , revisionId
|
com.google.api.services.drive.model.Revision
|
URI Options for drive-revisions
Name | Type |
---|---|
content
|
com.google.api.services.drive.model.Revision
|
fileId
|
String
|
revisionId
|
String
|
Consumer Endpoints
consumer.
prefix to schedule endpoint invocation. Consumer endpoints that return an array or collection will generate one exchange per element, and their routes will be executed once for each exchange.
Message Headers
CamelGoogleDrive.
prefix.
Message Body
inBody
endpoint URI parameter. For endpoints that return an array or collection, a consumer endpoint will map every element to distinct messages.
Chapter 53. GoogleMail
GoogleMail component
Component Description
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-google-mail</artifactId> <version>2.15-SNAPSHOT</version> </dependency>
URI Format
google-mail://endpoint-prefix/endpoint?[options]
- attachments
- drafts
- history
- labels
- messages
- threads
- users
GoogleMailComponent
configuration
of type org.apache.camel.component.google.mail.GoogleMailConfiguration
.
Option | Type | |
---|---|---|
accessToken | String | OAuth 2 access token. This typically expires after an hour so refreshToken is recommended for long term usage. |
applicationName | String | Google drive application name. Example would be "camel-google-mail/1.0" |
clientId | String | Client ID of the drive application |
clientSecret | String | Client secret of the drive application |
refreshToken |
String
|
OAuth 2 refresh token. Using this, the Google Mail component can obtain a new accessToken whenever the current one expires - a necessity if the application is long-lived. |
scopes | List<String> | Specifies the level of permissions you want a drive application to have to a user account. See https://developers.google.com/gmail/api/auth/scopes for more info. |
Producer Endpoints
inBody
that in turn should contain the name of the endpoint option whose value will be contained in the Camel Exchange In message.
CamelGoogleMail.<option>
. Note that the inBody
option overrides message header, i.e. the endpoint option inBody=option
would override a CamelGoogleMail.option
header.
1. Endpoint Prefix attachments
attachments
as follows:
google-mail://attachments/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
get | id, messageId, userId | com.google.api.services.gmail.model.MessagePartBody |
URI Options for attachments
Name | Type |
---|---|
id | String |
messageId | String |
userId | String |
2. Endpoint Prefix drafts
drafts
as follows:
google-mail://drafts/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
create | [mediaContent], content, userId |
com.google.api.services.gmail.model.Draft
|
|
delete | id, userId | ||
get | id, userId |
com.google.api.services.gmail.model.Draft
|
|
list | userId |
com.google.api.services.gmail.model.ListDraftsResponse
|
|
send | [mediaContent], content, userId |
com.google.api.services.gmail.model.Message
|
|
update | [mediaContent], content, id, userId |
com.google.api.services.gmail.model.Draft
|
URI Options for drafts
Name | Type |
---|---|
content | com.google.api.services.gmail.model.Draft |
id | String |
mediaContent | com.google.api.client.http.AbstractInputStreamContent |
userId | String |
3. Endpoint Prefix history
history
as follows:
google-mail://history/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
list | userId |
com.google.api.services.gmail.model.ListHistoryResponse
|
URI Options for history
Name | Type |
---|---|
userId | String |
4. Endpoint Prefix labels
labels
as follows:
google-mail://labels/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
create | content, userId |
com.google.api.services.gmail.model.Label
|
|
delete | id, userId | ||
get | id, userId |
com.google.api.services.gmail.model.Label
|
|
list | userId |
com.google.api.services.gmail.model.ListLabelsResponse
|
|
patch | content, id, userId |
com.google.api.services.gmail.model.Label
|
|
update | content, id, userId |
com.google.api.services.gmail.model.Label
|
URI Options for labels
Name | Type |
---|---|
content | com.google.api.services.gmail.model.Label |
id | String |
userId | String |
5. Endpoint Prefix messages
messages
as follows:
google-mail://messages/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
delete | id, userId | ||
get | id, userId |
com.google.api.services.gmail.model.Message
|
|
gmailImport | [mediaContent], content, userId |
com.google.api.services.gmail.model.Message
|
|
insert | [mediaContent], content, userId |
com.google.api.services.gmail.model.Message
|
|
list | userId |
com.google.api.services.gmail.model.ListMessagesResponse
|
|
modify | id, modifyMessageRequest, userId |
com.google.api.services.gmail.model.Message
|
|
send | [mediaContent], content, userId |
com.google.api.services.gmail.model.Message
|
|
trash | id, userId |
|
|
untrash | id, userId |
|
URI Options for messages
Name | Type |
---|---|
content | com.google.api.services.gmail.model.Message |
id | String |
mediaContent | com.google.api.client.http.AbstractInputStreamContent |
modifyMessageRequest | com.google.api.services.gmail.model.ModifyMessageRequest |
userId | String |
6. Endpoint Prefix threads
threads
as follows:
google-mail://threads/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
delete | id, userId | ||
get | id, userId |
com.google.api.services.gmail.model.Thread
|
|
list | userId |
com.google.api.services.gmail.model.ListThreadsResponse
|
|
modify | content, id, userId |
com.google.api.services.gmail.model.Thread
|
|
trash | id, userId | ||
untrash | id, userId |
URI Options for threads
Name | Type |
---|---|
content | com.google.api.services.gmail.model.ModifyThreadRequest |
id | String |
userId | String |
7. Endpoint Prefix users
users
as follows:
google-mail://users/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
getProfile | userId | com.google.api.services.gmail.model.Profile |
URI Options for users
Name | Type |
---|---|
userId | String |
Consumer Endpoints
consumer.
prefix to schedule endpoint invocation. Consumer endpoints that return an array or collection will generate one exchange per element, and their routes will be executed once for each exchange.
Message Headers
CamelGoogleMail.
prefix.
Message Body
inBody
endpoint URI parameter. For endpoints that return an array or collection, a consumer endpoint will map every element to distinct messages.
Chapter 54. Guava EventBus
Guava EventBus Component
EventBus
can be transparently forwarded to the Camel routes. EventBus component allows also to route body of Camel exchanges to the Guava EventBus
.
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-guava-eventbus</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
guava-eventbus:busName[?options]
com.google.common.eventbus.EventBus
instance located in the Camel registry.
Options
Name | Default Value | Description |
---|---|---|
eventClass
|
null
|
Camel 2.10: If used on the consumer side of the route, will filter events received from the EventBus to the instances of the class and superclasses of eventClass . Null value of this option is equal to setting it to the java.lang.Object i.e. the consumer will capture all messages incoming to the event bus. This option cannot be used together with listenerInterface option.
|
listenerInterface
|
null
|
Camel 2.11: The interface with method(s) marked with the @Subscribe annotation. Dynamic proxy will be created over the interface so it could be registered as the EventBus listener. Particularly useful when creating multi-event listeners and for handling DeadEvent properly. This option cannot be used together with eventClass option.
|
Usage
guava-eventbus
component on the consumer side of the route will capture messages sent to the Guava EventBus
and forward them to the Camel route. Guava EventBus consumer processes incoming messages asynchronously.
SimpleRegistry registry = new SimpleRegistry(); EventBus eventBus = new EventBus(); registry.put("busName", eventBus); CamelContext camel = new DefaultCamelContext(registry); from("guava-eventbus:busName").to("seda:queue"); eventBus.post("Send me to the SEDA queue.");
guava-eventbus
component on the producer side of the route will forward body of the Camel exchanges to the Guava EventBus
instance.
SimpleRegistry registry = new SimpleRegistry(); EventBus eventBus = new EventBus(); registry.put("busName", eventBus); CamelContext camel = new DefaultCamelContext(registry); from("direct:start").to("guava-eventbus:busName"); ProducerTemplate producerTemplate = camel.createProducerTemplate(); producer.sendBody("direct:start", "Send me to the Guava EventBus."); eventBus.register(new Object(){ @Subscribe public void messageHander(String message) { System.out.println("Message received from the Camel: " + message); } });
DeadEvent considerations
@Subscribe
method. This limitation implies that endpoint with eventClass
option specified actually listens to all possible events (java.lang.Object
) and filter appropriate messages programmatically at runtime. The snipped below demonstrates an appropriate excerpt from the Camel code base.
@Subscribe public void eventReceived(Object event) { if (eventClass == null || eventClass.isAssignableFrom(event.getClass())) { doEventReceived(event); ...
EventBus
instance used by Camel will never generate com.google.common.eventbus.DeadEvent
notifications. If you want Camel to listen only to the precisely specified event (and therefore enable DeadEvent
support), use listenerInterface
endpoint option. Camel will create dynamic proxy over the interface you specify with the latter option and listen only to messages specified by the interface handler methods. The example of the listener interface with single method handling only SpecificEvent
instances is demonstrated below.
package com.example; public interface CustomListener { @Subscribe void eventReceived(SpecificEvent event); }
from("guava-eventbus:busName?listenerInterface=com.example.CustomListener").to("seda:queue");
Consuming multiple type of events
listenerInterface
endpoint option, as listener interface could provide multiple methods marked with the @Subscribe
annotation.
package com.example; public interface MultipleEventsListener { @Subscribe void someEventReceived(SomeEvent event); @Subscribe void anotherEventReceived(AnotherEvent event); }
from("guava-eventbus:busName?listenerInterface=com.example.MultipleEventsListener").to("seda:queue");
Chapter 55. HawtDB
HawtDB
- HawtDBAggregationRepository
Using HawtDBAggregationRepository
HawtDBAggregationRepository
is an AggregationRepository
which on the fly persists the aggregated messages. This ensures that you will not loose messages, as the default aggregator will use an in memory only AggregationRepository
.
Option | Type | Description |
---|---|---|
repositoryName
|
String |
A mandatory repository name. Allows you to use a shared HawtDBFile for multiple repositories.
|
persistentFileName
|
String | Filename for the persistent storage. If no file exists on startup a new file is created. |
bufferSize
|
int | The size of the memory segment buffer which is mapped to the file store. By default its 8mb. The value is in bytes. |
sync
|
boolean |
Whether or not the HawtDBFile should sync on write or not. Default is true . By sync on write ensures that its always waiting for all writes to be spooled to disk and thus will not loose updates. If you disable this option, then HawtDB will auto sync when it has batched up a number of writes.
|
pageSize
|
short | The size of memory pages. By default its 512 bytes. The value is in bytes. |
hawtDBFile
|
HawtDBFile |
Use an existing configured org.apache.camel.component.hawtdb.HawtDBFile instance.
|
returnOldExchange
|
boolean |
Whether the get operation should return the old existing Exchange if any existed. By default this option is false to optimize as we do not need the old exchange when aggregating.
|
useRecovery
|
boolean |
Whether or not recovery is enabled. This option is by default true . When enabled the Apache Camel section "Aggregator" in "Apache Camel Development Guide" automatic recover failed aggregated exchange and have them resubmitted.
|
recoveryInterval
|
long | If recovery is enabled then a background task is run every x'th time to scan for failed exchanges to recover and resubmit. By default this interval is 5000 millis. |
maximumRedeliveries
|
int |
Allows you to limit the maximum number of redelivery attempts for a recovered exchange. If enabled then the Exchange will be moved to the dead letter channel if all redelivery attempts failed. By default this option is disabled. If this option is used then the deadLetterUri option must also be provided.
|
deadLetterUri
|
String |
An endpoint uri for a Dead Letter Channel where exhausted recovered Exchanges will be moved. If this option is used then the maximumRedeliveries option must also be provided.
|
optimisticLocking
|
false
|
Camel 2.12: To turn on optimistic locking, which often would be needed in clustered environments where multiple Camel applications shared the same HawtDB based aggregation repository. |
repositoryName
option must be provided. Then either the persistentFileName
or the hawtDBFile
must be provided.
What is preserved when persisting
HawtDBAggregationRepository
will only preserve any Serializable
compatible data types. If a data type is not such a type its dropped and a WARN
is logged. And it only persists the Message
body and the Message
headers. The Exchange
properties are not persisted.
Recovery
HawtDBAggregationRepository
will by default recover any failed Exchange. It does this by having a background tasks that scans for failed Exchanges in the persistent store. You can use the checkInterval
option to set how often this task runs. The recovery works as transactional which ensures that Apache Camel will try to recover and redeliver the failed Exchange. Any Exchange which was found to be recovered will be restored from the persistent store and resubmitted and send out again.
Header | Type | Description |
---|---|---|
Exchange.REDELIVERED
|
Boolean | Is set to true to indicate the Exchange is being redelivered. |
Exchange.REDELIVERY_COUNTER
|
Integer | The redelivery attempt, starting from 1. |
confirm
method is invoked on the AggregationRepository
. This means if the same Exchange fails again it will be kept retried until it success.
maximumRedeliveries
to limit the maximum number of redelivery attempts for a given recovered Exchange. You must also set the deadLetterUri
option so Apache Camel knows where to send the Exchange when the maximumRedeliveries
was hit.
Using HawtDBAggregationRepository in Java DSL
target/data/hawtdb.dat
file.
public void configure() throws Exception { // create the hawtdb repo HawtDBAggregationRepository repo = new HawtDBAggregationRepository("repo1", "target/data/hawtdb.dat"); // here is the Camel route where we aggregate from("direct:start") .aggregate(header("id"), new MyAggregationStrategy()) // use our created hawtdb repo as aggregation repository .completionSize(5).aggregationRepository(repo) .to("mock:aggregated"); }
Using HawtDBAggregationRepository in Spring XML
<!-- a persistent aggregation repository using camel-hawtdb --> <bean id="repo" class="org.apache.camel.component.hawtdb.HawtDBAggregationRepository"> <!-- store the repo in the hawtdb.dat file --> <property name="persistentFileName" value="target/data/hawtdb.dat"/> <!-- and use repo2 as the repository name --> <property name="repositoryName" value="repo2"/> </bean> <!-- aggregate the messages using this strategy --> <bean id="myAggregatorStrategy" class="org.apache.camel.component.hawtdb.HawtDBSpringAggregateTest$MyAggregationStrategy"/> <!-- this is the camel routes --> <camelContext id="camel" xmlns="http://camel.apache.org/schema/spring"> <route> <from uri="direct:start"/> <!-- aggregate using our strategy and hawtdb repo, and complete when we have 5 messages aggregated --> <aggregate strategyRef="myAggregatorStrategy" aggregationRepositoryRef="repo" completionSize="5"> <!-- correlate by header with the key id --> <correlationExpression><header>id</header></correlationExpression> <!-- send aggregated messages to the mock endpoint --> <to uri="mock:aggregated"/> </aggregate> </route> </camelContext>
Dependencies
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-hawtdb</artifactId> <version>2.3.0</version> </dependency>
Chapter 56. Hazelcast Component
Hazelcast Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-hazelcast</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
hazelcast:[ map | multimap | queue | topic | seda | set | atomicvalue | instance | list]:cachename[?options]
Options
Name
|
Required
|
Description
|
hazelcastInstance
|
No
|
Camel 2.14: The hazelcast instance reference which can be used for hazelcast endpoint. If you don't specify the instance reference, camel use the default hazelcast instance from the camel-hazelcast instance.
|
hazelcastInstanceName
|
No
|
|
defaultOperation
|
-1
|
Camel 2.15: To specify a default operation to use, if no operation header has been provided.
|
Sections
Usage of Map
map cache producer - to("hazelcast:map:foo")
org.apache.camel.component.hazelcast.HazelcastConstants
.
Name | Type | Description |
---|---|---|
hazelcast.operation.type
|
String
|
valid values are: put, delete, get, update, query |
hazelcast.objectId
|
String
|
the object id to store / find your object inside the cache (not needed for the query operation) |
Name | Type | Description |
---|---|---|
CamelHazelcastOperationType
|
String
|
valid values are: put, delete, get, update, query Version 2.8 |
CamelHazelcastObjectId
|
String
|
the object id to store / find your object inside the cache (not needed for the query operation) Version 2.8 |
template.sendBodyAndHeader("direct:[put|get|update|delete|query]", "my-foo", HazelcastConstants.OBJECT_ID, "4711");
Sample for put:
from("direct:put") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.PUT_OPERATION)) .toF("hazelcast:%sfoo", HazelcastConstants.MAP_PREFIX);
<route> <from uri="direct:put" /> <!-- If using version 2.8 and above set headerName to "CamelHazelcastOperationType" --> <setHeader headerName="hazelcast.operation.type"> <constant>put</constant> </setHeader> <to uri="hazelcast:map:foo" /> </route>
Sample for get:
from("direct:get") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.GET_OPERATION)) .toF("hazelcast:%sfoo", HazelcastConstants.MAP_PREFIX) .to("seda:out");
<route> <from uri="direct:get" /> <!-- If using version 2.8 and above set headerName to "CamelHazelcastOperationType" --> <setHeader headerName="hazelcast.operation.type"> <constant>get</constant> </setHeader> <to uri="hazelcast:map:foo" /> <to uri="seda:out" /> </route>
Sample for update:
from("direct:update") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.UPDATE_OPERATION)) .toF("hazelcast:%sfoo", HazelcastConstants.MAP_PREFIX);
<route> <from uri="direct:update" /> <!-- If using version 2.8 and above set headerName to "CamelHazelcastOperationType" --> <setHeader headerName="hazelcast.operation.type"> <constant>update</constant> </setHeader> <to uri="hazelcast:map:foo" /> </route>
Sample for delete:
from("direct:delete") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.DELETE_OPERATION)) .toF("hazelcast:%sfoo", HazelcastConstants.MAP_PREFIX);
<route> <from uri="direct:delete" /> <!-- If using version 2.8 and above set headerName to "CamelHazelcastOperationType" --> <setHeader headerName="hazelcast.operation.type"> <constant>delete</constant> </setHeader> <to uri="hazelcast:map:foo" /> </route>
Sample for query
from("direct:query") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.QUERY_OPERATION)) .toF("hazelcast:%sfoo", HazelcastConstants.MAP_PREFIX) .to("seda:out");
<route> <from uri="direct:query" /> <!-- If using version 2.8 and above set headerName to "CamelHazelcastOperationType" --> <setHeader headerName="hazelcast.operation.type"> <constant>query</constant> </setHeader> <to uri="hazelcast:map:foo" /> <to uri="seda:out" /> </route>
String q1 = "bar > 1000"; template.sendBodyAndHeader("direct:query", null, HazelcastConstants.QUERY, q1);
map cache consumer - from("hazelcast:map:foo")
Name | Type | Description |
---|---|---|
hazelcast.listener.time
|
Long
|
time of the event in millis |
hazelcast.listener.type
|
String
|
the map consumer sets here "cachelistener" |
hazelcast.listener.action
|
String
|
type of event - here added, updated, envicted and removed |
hazelcast.objectId
|
String
|
the oid of the object |
hazelcast.cache.name
|
String
|
the name of the cache - e.g. "foo" |
hazelcast.cache.type
|
String
|
the type of the cache - here map |
Name | Type | Description |
---|---|---|
CamelHazelcastListenerTime
|
Long
|
time of the event in millis Version 2.8 |
CamelHazelcastListenerType
|
String
|
the map consumer sets here "cachelistener" Version 2.8 |
CamelHazelcastListenerAction
|
String
|
type of event - here added, updated, envicted and removed. Version 2.8 |
CamelHazelcastObjectId
|
String
|
the oid of the object Version 2.8 |
CamelHazelcastCacheName
|
String
|
the name of the cache - e.g. "foo" Version 2.8 |
CamelHazelcastCacheType
|
String
|
the type of the cache - here map Version 2.8 |
fromF("hazelcast:%sfoo", HazelcastConstants.MAP_PREFIX) .log("object...") .choice() .when(header(HazelcastConstants.LISTENER_ACTION).isEqualTo(HazelcastConstants.ADDED)) .log("...added") .to("mock:added") .when(header(HazelcastConstants.LISTENER_ACTION).isEqualTo(HazelcastConstants.ENVICTED)) .log("...envicted") .to("mock:envicted") .when(header(HazelcastConstants.LISTENER_ACTION).isEqualTo(HazelcastConstants.UPDATED)) .log("...updated") .to("mock:updated") .when(header(HazelcastConstants.LISTENER_ACTION).isEqualTo(HazelcastConstants.REMOVED)) .log("...removed") .to("mock:removed") .otherwise() .log("fail!");
Usage of Multi Map
multimap cache producer - to("hazelcast:multimap:foo")
Name | Type | Description |
---|---|---|
hazelcast.operation.type
|
String
|
valid values are: put, get, removevalue, delete |
hazelcast.objectId
|
String
|
the object id to store / find your object inside the cache |
Name | Type | Description |
---|---|---|
CamelHazelcastOperationType
|
String
|
valid values are: put, delete, get, update, query Available as of Apache Camel 2.8 |
CamelHazelcastObjectId
|
String
|
the object id to store / find your object inside the cache (not needed for the query operation) Version 2.8 |
template.sendBodyAndHeader("direct:[put|get|update|delete|query]", "my-foo", HazelcastConstants.OBJECT_ID, "4711");
Sample for put:
from("direct:put") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.PUT_OPERATION)) .toF("hazelcast:%sfoo", HazelcastConstants.MAP_PREFIX);
<route> <from uri="direct:put" /> <!-- If using version 2.8 and above set headerName to "CamelHazelcastOperationType" --> <setHeader headerName="hazelcast.operation.type"> <constant>put</constant> </setHeader> <to uri="hazelcast:map:foo" /> </route>
Sample for get:
from("direct:get") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.GET_OPERATION)) .toF("hazelcast:%sfoo", HazelcastConstants.MAP_PREFIX) .to("seda:out");
<route> <from uri="direct:get" /> <!-- If using version 2.8 and above set headerName to "CamelHazelcastOperationType" --> <setHeader headerName="hazelcast.operation.type"> <constant>get</constant> </setHeader> <to uri="hazelcast:map:foo" /> <to uri="seda:out" /> </route>
Sample for update:
from("direct:update") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.UPDATE_OPERATION)) .toF("hazelcast:%sfoo", HazelcastConstants.MAP_PREFIX);
<route> <from uri="direct:update" /> <!-- If using version 2.8 and above set headerName to "CamelHazelcastOperationType" --> <setHeader headerName="hazelcast.operation.type"> <constant>update</constant> </setHeader> <to uri="hazelcast:map:foo" /> </route>
Sample for delete:
from("direct:delete") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.DELETE_OPERATION)) .toF("hazelcast:%sfoo", HazelcastConstants.MAP_PREFIX);
<route> <from uri="direct:delete" /> <!-- If using version 2.8 and above set headerName to "CamelHazelcastOperationType" --> <setHeader headerName="hazelcast.operation.type"> <constant>delete</constant> </setHeader> <to uri="hazelcast:map:foo" /> </route>
Sample for query
from("direct:query") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.QUERY_OPERATION)) .toF("hazelcast:%sfoo", HazelcastConstants.MAP_PREFIX) .to("seda:out");
<route> <from uri="direct:query" /> <!-- If using version 2.8 and above set headerName to "CamelHazelcastOperationType" --> <setHeader headerName="hazelcast.operation.type"> <constant>query</constant> </setHeader> <to uri="hazelcast:map:foo" /> <to uri="seda:out" /> </route>
String q1 = "bar > 1000"; template.sendBodyAndHeader("direct:query", null, HazelcastConstants.QUERY, q1);
map cache consumer - from("hazelcast:map:foo")
Name | Type | Description |
---|---|---|
hazelcast.listener.time
|
Long
|
time of the event in millis |
hazelcast.listener.type
|
String
|
the map consumer sets here "cachelistener" |
hazelcast.listener.action
|
String
|
type of event - here added, updated, envicted and removed |
hazelcast.objectId
|
String
|
the oid of the object |
hazelcast.cache.name
|
String
|
the name of the cache - e.g. "foo" |
hazelcast.cache.type
|
String
|
the type of the cache - here map |
Name | Type | Description |
---|---|---|
CamelHazelcastListenerTime
|
Long
|
time of the event in millis Version 2.8 |
CamelHazelcastListenerType
|
String
|
the map consumer sets here "cachelistener" Version 2.8 |
CamelHazelcastListenerAction
|
String
|
type of event - here added, updated, envicted and removed. Version 2.8 |
CamelHazelcastObjectId
|
String
|
the oid of the object Version 2.8 |
CamelHazelcastCacheName
|
String
|
the name of the cache - e.g. "foo" Version 2.8 |
CamelHazelcastCacheType
|
String
|
the type of the cache - here map Version 2.8 |
fromF("hazelcast:%sfoo", HazelcastConstants.MAP_PREFIX) .log("object...") .choice() .when(header(HazelcastConstants.LISTENER_ACTION).isEqualTo(HazelcastConstants.ADDED)) .log("...added") .to("mock:added") .when(header(HazelcastConstants.LISTENER_ACTION).isEqualTo(HazelcastConstants.ENVICTED)) .log("...envicted") .to("mock:envicted") .when(header(HazelcastConstants.LISTENER_ACTION).isEqualTo(HazelcastConstants.UPDATED)) .log("...updated") .to("mock:updated") .when(header(HazelcastConstants.LISTENER_ACTION).isEqualTo(HazelcastConstants.REMOVED)) .log("...removed") .to("mock:removed") .otherwise() .log("fail!");
Usage of Multi Map
multimap cache producer - to("hazelcast:multimap:foo")
Name | Type | Description |
---|---|---|
hazelcast.operation.type
|
String
|
valid values are: put, get, removevalue, delete |
hazelcast.objectId
|
String
|
the object id to store / find your object inside the cache |
Name | Type | Description |
---|---|---|
CamelHazelcastOperationType
|
String
|
valid values are: put, get, removevalue, delete Version 2.8 |
CamelHazelcastObjectId
|
String
|
the object id to store / find your object inside the cache Version 2.8 |
Sample for put:
from("direct:put") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.PUT_OPERATION)) .to(String.format("hazelcast:%sbar", HazelcastConstants.MULTIMAP_PREFIX));
<route> <from uri="direct:put" /> <log message="put.."/> <!-- If using version 2.8 and above set headerName to "CamelHazelcastOperationType" --> <setHeader headerName="hazelcast.operation.type"> <constant>put</constant> </setHeader> <to uri="hazelcast:multimap:foo" /> </route>
Sample for removevalue:
from("direct:removevalue") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.REMOVEVALUE_OPERATION)) .toF("hazelcast:%sbar", HazelcastConstants.MULTIMAP_PREFIX);
<route> <from uri="direct:removevalue" /> <log message="removevalue..."/> <!-- If using version 2.8 and above set headerName to "CamelHazelcastOperationType" --> <setHeader headerName="hazelcast.operation.type"> <constant>removevalue</constant> </setHeader> <to uri="hazelcast:multimap:foo" /> </route>
} you have to put "my-foo" inside the message body to remove the "my-foo" value.
Sample for get:
from("direct:get") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.GET_OPERATION)) .toF("hazelcast:%sbar", HazelcastConstants.MULTIMAP_PREFIX) .to("seda:out");
<route> <from uri="direct:get" /> <log message="get.."/> <!-- If using version 2.8 and above set headerName to "CamelHazelcastOperationType" --> <setHeader headerName="hazelcast.operation.type"> <constant>get</constant> </setHeader> <to uri="hazelcast:multimap:foo" /> <to uri="seda:out" /> </route>
Sample for delete:
from("direct:delete") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.DELETE_OPERATION)) .toF("hazelcast:%sbar", HazelcastConstants.MULTIMAP_PREFIX);
<route> <from uri="direct:delete" /> <log message="delete.."/> <!-- If using version 2.8 and above set headerName to "CamelHazelcastOperationType" --> <setHeader headerName="hazelcast.operation.type"> <constant>delete</constant> </setHeader> <to uri="hazelcast:multimap:foo" /> </route>
template.sendBodyAndHeader("direct:[put|get|removevalue|delete]", "my-foo", HazelcastConstants.OBJECT_ID, "4711");
multimap cache consumer - from("hazelcast:multimap:foo")
fromF("hazelcast:%sbar", HazelcastConstants.MULTIMAP_PREFIX) .log("object...") .choice() .when(header(HazelcastConstants.LISTENER_ACTION).isEqualTo(HazelcastConstants.ADDED)) .log("...added") .to("mock:added") //.when(header(HazelcastConstants.LISTENER_ACTION).isEqualTo(HazelcastConstants.ENVICTED)) // .log("...envicted") // .to("mock:envicted") .when(header(HazelcastConstants.LISTENER_ACTION).isEqualTo(HazelcastConstants.REMOVED)) .log("...removed") .to("mock:removed") .otherwise() .log("fail!");
Name | Type | Description |
---|---|---|
hazelcast.listener.time
|
Long
|
time of the event in millis |
hazelcast.listener.type
|
String
|
the map consumer sets here "cachelistener" |
hazelcast.listener.action
|
String
|
type of event - here added and removed (and soon envicted) |
hazelcast.objectId
|
String
|
the oid of the object |
hazelcast.cache.name
|
String
|
the name of the cache - e.g. "foo" |
hazelcast.cache.type
|
String
|
the type of the cache - here multimap |
Name | Type | Description |
---|---|---|
CamelHazelcastListenerTime
|
Long
|
time of the event in millis Version 2.8 |
CamelHazelcastListenerType
|
String
|
the map consumer sets here "cachelistener" Version 2.8 |
CamelHazelcastListenerAction
|
String
|
type of event - here added and removed (and soon envicted) Version 2.8 |
CamelHazelcastObjectId
|
String
|
the oid of the object Version 2.8 |
CamelHazelcastCacheName
|
String
|
the name of the cache - e.g. "foo" Version 2.8 |
CamelHazelcastCacheType
|
String
|
the type of the cache - here multimap Version 2.8 |
Usage of Queue
Queue producer to("hazelcast:queue:foo")
Sample for add:
from("direct:add") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.ADD_OPERATION)) .toF("hazelcast:%sbar", HazelcastConstants.QUEUE_PREFIX);
Sample for put:
from("direct:put") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.PUT_OPERATION)) .toF("hazelcast:%sbar", HazelcastConstants.QUEUE_PREFIX);
Sample for poll:
from("direct:poll") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.POLL_OPERATION)) .toF("hazelcast:%sbar", HazelcastConstants.QUEUE_PREFIX);
Sample for peek:
from("direct:peek") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.PEEK_OPERATION)) .toF("hazelcast:%sbar", HazelcastConstants.QUEUE_PREFIX);
Sample for offer:
from("direct:offer") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.OFFER_OPERATION)) .toF("hazelcast:%sbar", HazelcastConstants.QUEUE_PREFIX);
Sample for removevalue:
from("direct:removevalue") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.REMOVEVALUE_OPERATION)) .toF("hazelcast:%sbar", HazelcastConstants.QUEUE_PREFIX);
Queue consumer from("hazelcast:queue:foo")
fromF("hazelcast:%smm", HazelcastConstants.QUEUE_PREFIX) .log("object...") .choice() .when(header(HazelcastConstants.LISTENER_ACTION).isEqualTo(HazelcastConstants.ADDED)) .log("...added") .to("mock:added") .when(header(HazelcastConstants.LISTENER_ACTION).isEqualTo(HazelcastConstants.REMOVED)) .log("...removed") .to("mock:removed") .otherwise() .log("fail!");
Usage of Topic
Topic producer – to(“hazelcast:topic:foo”)
Sample for publish
from("direct:add") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.PUBLISH_OPERATION)) .toF("hazelcast:%sbar", HazelcastConstants.PUBLISH_OPERATION);
Topic consumer – from(“hazelcast:topic:foo”)
fromF("hazelcast:%sfoo", HazelcastConstants.TOPIC_PREFIX) .choice() .when(header(HazelcastConstants.LISTENER_ACTION).isEqualTo(HazelcastConstants.RECEIVED)) .log("...message received") .otherwise() .log("...this should never have happened")
Usage of List
List producer to("hazelcast:list:foo")
Sample for add:
from("direct:add") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.ADD_OPERATION)) .toF("hazelcast:%sbar", HazelcastConstants.LIST_PREFIX);
Sample for get:
from("direct:get") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.GET_OPERATION)) .toF("hazelcast:%sbar", HazelcastConstants.LIST_PREFIX) .to("seda:out");
Sample for setvalue:
from("direct:set") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.SETVALUE_OPERATION)) .toF("hazelcast:%sbar", HazelcastConstants.LIST_PREFIX);
Sample for removevalue:
from("direct:removevalue") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.REMOVEVALUE_OPERATION)) .toF("hazelcast:%sbar", HazelcastConstants.LIST_PREFIX);
List consumer from("hazelcast:list:foo")
fromF("hazelcast:%smm", HazelcastConstants.LIST_PREFIX) .log("object...") .choice() .when(header(HazelcastConstants.LISTENER_ACTION).isEqualTo(HazelcastConstants.ADDED)) .log("...added") .to("mock:added") .when(header(HazelcastConstants.LISTENER_ACTION).isEqualTo(HazelcastConstants.REMOVED)) .log("...removed") .to("mock:removed") .otherwise() .log("fail!");
Usage of SEDA
SEDA producer to("hazelcast:seda:foo")
Name | default value | Description |
---|---|---|
transferExchange
|
false
|
Apache Camel 2.8.0: if set to true the whole Exchange will be transfered. If header or body contains not serializable objects, they will be skipped. |
from("direct:foo") .to("hazelcast:seda:foo");
<route> <from uri="direct:start" /> <to uri="hazelcast:seda:foo" /> </route>
SEDA consumer from("hazelcast:seda:foo")
Name | default value | Description |
---|---|---|
pollInterval
|
1000
|
Deprecated since Camel 2.15. Use pollTimeout instead.
|
pollTimeout
|
1000
|
The timeout used when consuming from the SEDA queue. 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. |
concurrentConsumers
|
1
|
To use concurrent consumers polling from the SEDA queue. |
transferExchange
|
false
|
Camel 2.8.0: if set to true the whole Exchange will be transfered. If header or body contains not serializable objects, they will be skipped. |
transacted
|
false
|
Camel 2.10.4: if set to true then the consumer runs in transaction mode, where the messages in the seda queue will only be removed if the transaction commits, which happens when the processing is complete. |
from("hazelcast:seda:foo") .to("mock:result");
<route> <from uri="hazelcast:seda:foo" /> <to uri="mock:result" /> </route>
Usage of Atomic Number
atomic number producer - to("hazelcast:atomicnumber:foo")
Name | Type | Description |
---|---|---|
hazelcast.operation.type
|
String
|
valid values are: setvalue, get, increase, decrease, destroy |
Name | Type | Description |
---|---|---|
CamelHazelcastOperationType
|
String
|
valid values are: setvalue, get, increase, decrease, destroy Available as of Apache Camel version 2.8 |
Sample for set:
from("direct:set") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.SETVALUE_OPERATION)) .toF("hazelcast:%sfoo", HazelcastConstants.ATOMICNUMBER_PREFIX);
<route> <from uri="direct:set" /> <!-- If using version 2.8 and above set headerName to "CamelHazelcastOperationType" --> <setHeader headerName="hazelcast.operation.type"> <constant>setvalue</constant> </setHeader> <to uri="hazelcast:atomicvalue:foo" /> </route>
template.sendBody("direct:set", 10);
Sample for get:
from("direct:get") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.GET_OPERATION)) .toF("hazelcast:%sfoo", HazelcastConstants.ATOMICNUMBER_PREFIX);
<route> <from uri="direct:get" /> <!-- If using version 2.8 and above set headerName to "CamelHazelcastOperationType" --> <setHeader headerName="hazelcast.operation.type"> <constant>get</constant> </setHeader> <to uri="hazelcast:atomicvalue:foo" /> </route>
long body = template.requestBody("direct:get", null, Long.class);
.
Sample for increment:
from("direct:increment") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.INCREMENT_OPERATION)) .toF("hazelcast:%sfoo", HazelcastConstants.ATOMICNUMBER_PREFIX);
<route> <from uri="direct:increment" /> <!-- If using version 2.8 and above set headerName to "CamelHazelcastOperationType" --> <setHeader headerName="hazelcast.operation.type"> <constant>increment</constant> </setHeader> <to uri="hazelcast:atomicvalue:foo" /> </route>
Sample for decrement:
from("direct:decrement") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.DECREMENT_OPERATION)) .toF("hazelcast:%sfoo", HazelcastConstants.ATOMICNUMBER_PREFIX);
<route> <from uri="direct:decrement" /> <!-- If using version 2.8 and above set headerName to "CamelHazelcastOperationType" --> <setHeader headerName="hazelcast.operation.type"> <constant>decrement</constant> </setHeader> <to uri="hazelcast:atomicvalue:foo" /> </route>
Sample for destroy
from("direct:destroy") .setHeader(HazelcastConstants.OPERATION, constant(HazelcastConstants.DESTROY_OPERATION)) .toF("hazelcast:%sfoo", HazelcastConstants.ATOMICNUMBER_PREFIX);
<route> <from uri="direct:destroy" /> <!-- If using version 2.8 and above set headerName to "CamelHazelcastOperationType" --> <setHeader headerName="hazelcast.operation.type"> <constant>destroy</constant> </setHeader> <to uri="hazelcast:atomicvalue:foo" /> </route>
Cluster support
instance consumer - from("hazelcast:instance:foo")
fromF("hazelcast:%sfoo", HazelcastConstants.INSTANCE_PREFIX) .log("instance...") .choice() .when(header(HazelcastConstants.LISTENER_ACTION).isEqualTo(HazelcastConstants.ADDED)) .log("...added") .to("mock:added") .otherwise() .log("...removed") .to("mock:removed");
Name | Type | Description |
---|---|---|
hazelcast.listener.time
|
Long
|
time of the event in millis |
hazelcast.listener.type
|
String
|
the map consumer sets here "instancelistener" |
hazelcast.listener.action
|
String
|
type of event - here added or removed |
hazelcast.instance.host
|
String
|
host name of the instance |
hazelcast.instance.port
|
Integer
|
port number of the instance |
Name | Type | Description |
---|---|---|
CamelHazelcastListenerTime
|
Long
|
time of the event in millis Version 2.8 |
CamelHazelcastListenerType
|
String
|
the map consumer sets here "instancelistener" Version 2.8 |
CamelHazelcastListenerActionn
|
String
|
type of event - here added or removed. Version 2.8 |
CamelHazelcastInstanceHost
|
String
|
host name of the instance Version 2.8 |
CamelHazelcastInstancePort
|
Integer
|
port number of the instance Version 2.8 |
Using hazelcast reference
By its name
<bean id="hazelcastLifecycle" class="com.hazelcast.core.LifecycleService" factory-bean="hazelcastInstance" factory-method="getLifecycleService" destroy-method="shutdown" /> <bean id="config" class="com.hazelcast.config.Config"> <constructor-arg type="java.lang.String" value="HZ.INSTANCE" /> </bean> <bean id="hazelcastInstance" class="com.hazelcast.core.Hazelcast" factory-method="newHazelcastInstance"> <constructor-arg type="com.hazelcast.config.Config" ref="config"/> </bean> <camelContext xmlns="http://camel.apache.org/schema/spring"> <route id="testHazelcastInstanceBeanRefPut"> <from uri="direct:testHazelcastInstanceBeanRefPut"/> <setHeader headerName="CamelHazelcastOperationType"> <constant>put</constant> </setHeader> <to uri="hazelcast:map:testmap?hazelcastInstanceName=HZ.INSTANCE"/> </route> <route id="testHazelcastInstanceBeanRefGet"> <from uri="direct:testHazelcastInstanceBeanRefGet" /> <setHeader headerName="CamelHazelcastOperationType"> <constant>get</constant> </setHeader> <to uri="hazelcast:map:testmap?hazelcastInstanceName=HZ.INSTANCE"/> <to uri="seda:out" /> </route> </camelContext>
By instance
<bean id="hazelcastInstance" class="com.hazelcast.core.Hazelcast" factory-method="newHazelcastInstance" /> <bean id="hazelcastLifecycle" class="com.hazelcast.core.LifecycleService" factory-bean="hazelcastInstance" factory-method="getLifecycleService" destroy-method="shutdown" /> <camelContext xmlns="http://camel.apache.org/schema/spring"> <route id="testHazelcastInstanceBeanRefPut"> <from uri="direct:testHazelcastInstanceBeanRefPut"/> <setHeader headerName="CamelHazelcastOperationType"> <constant>put</constant> </setHeader> <to uri="hazelcast:map:testmap?hazelcastInstance=#hazelcastInstance"/> </route> <route id="testHazelcastInstanceBeanRefGet"> <from uri="direct:testHazelcastInstanceBeanRefGet" /> <setHeader headerName="CamelHazelcastOperationType"> <constant>get</constant> </setHeader> <to uri="hazelcast:map:testmap?hazelcastInstance=#hazelcastInstance"/> <to uri="seda:out" /> </route> </camelContext>
Publishing hazelcast instance as an OSGI service
Bundle A create an instance and publishes it as an OSGI service
<bean id="config" class="com.hazelcast.config.FileSystemXmlConfig"> <argument type="java.lang.String" value="${hazelcast.config}"/> </bean> <bean id="hazelcastInstance" class="com.hazelcast.core.Hazelcast" factory-method="newHazelcastInstance"> <argument type="com.hazelcast.config.Config" ref="config"/> </bean> <!-- publishing the hazelcastInstance as a service --> <service ref="hazelcastInstance" interface="com.hazelcast.core.HazelcastInstance" />
Bundle B uses the instance
<!-- referencing the hazelcastInstance as a service --> <reference ref="hazelcastInstance" interface="com.hazelcast.core.HazelcastInstance" /> <camelContext xmlns="http://camel.apache.org/schema/blueprint"> <route id="testHazelcastInstanceBeanRefPut"> <from uri="direct:testHazelcastInstanceBeanRefPut"/> <setHeader headerName="CamelHazelcastOperationType"> <constant>put</constant> </setHeader> <to uri="hazelcast:map:testmap?hazelcastInstance=#hazelcastInstance"/> </route> <route id="testHazelcastInstanceBeanRefGet"> <from uri="direct:testHazelcastInstanceBeanRefGet" /> <setHeader headerName="CamelHazelcastOperationType"> <constant>get</constant> </setHeader> <to uri="hazelcast:map:testmap?hazelcastInstance=#hazelcastInstance"/> <to uri="seda:out" /> </route> </camelContext>
Chapter 57. HBase
HBase Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-hbase</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
Apache HBase Overview
Camel and HBase
- HBase groups columns into families, so just mapping a property to a column using a name convention is just not enough.
- HBase doesn't have the notion of type, which means that it stores everything as byte[] and doesn't know if the byte[] represents a String, a Number, a serialized Java object or just binary data.
Configuring the component
<bean id="hbase" class="org.apache.camel.component.hbase.HBaseComponent"> <property name="configuration" ref="config"/> </bean>
HBase Producer
hbase://table[?options]
- Put
- Get
- Delete
- Scan
Supported URI options on producer
Name | Default Value | Description |
---|---|---|
operation
|
CamelHBasePut
|
The HBase operation to perform. Supported values: CamelHBasePut , CamelHBaseGet , CamelHBaseDelete , and CamelHBaseScan .
|
maxResults
|
100
|
The maximum number of rows to scan.Supported operations: CamelHBaseScan .
|
mappingStrategyName
|
header
|
The strategy to use for mapping Camel messages to HBase columns. Supported values: header , or body .
|
mappingStrategyClassName
|
null
|
The class name of a custom mapping strategy implementation. |
filters
|
null
|
A list of filters. Supported operations: CamelHBaseScan .
|
Name | Default Value | Description |
---|---|---|
rowId
|
The id of the row. This has limited use as the row usually changes per Exchange. | |
rowType
|
String |
The type to covert row id to. Supported operations: CamelHBaseScan .
|
family
|
The column family. Supports a number suffix for referring to more than one columns | |
qualifier
|
The column qualifier. Supports a number suffix for referring to more than one columns | |
value
|
The value. Supports a number suffix for referring to more than one columns | |
valueType
|
String |
The value type. Supports a number suffix for referring to more than one columns. Supported operations: CamelHBaseGet , and CamelHBaseScan .
|
Put Operations.
<route> <from uri="direct:in"/> <!-- Set the HBase Row --> <setHeader headerName="CamelHBaseRowId"> <el>${in.body.id}</el> </setHeader> <!-- Set the HBase Value --> <setHeader headerName="CamelHBaseValue"> <el>${in.body.value}</el> </setHeader> <to uri="hbase:mytable?operation=CamelHBasePut&amily=myfamily&ualifier=myqualifier"/> </route>
RowId2
, RowId3
, RowId4
, and so on. Only the first header does not have the number 1
.
<route> <from uri="direct:in"/> <!-- Set the HBase Row 1st column --> <setHeader headerName="CamelHBaseRowId"> <el>${in.body.id}</el> </setHeader> <!-- Set the HBase Row 2nd column --> <setHeader headerName="CamelHBaseRowId2"> <el>${in.body.id}</el> </setHeader> <!-- Set the HBase Value for 1st column --> <setHeader headerName="CamelHBaseValue"> <el>${in.body.value}</el> </setHeader> <!-- Set the HBase Value for 2nd column --> <setHeader headerName="CamelHBaseValue2"> <el>${in.body.othervalue}</el> </setHeader> <to uri="hbase:mytable?operation=CamelHBasePut&amily=myfamily&ualifier=myqualifier&amily2=myfamily&ualifier2=myqualifier2"/> </route>
Get Operations.
<route> <from uri="direct:in"/> <!-- Set the HBase Row of the Get --> <setHeader headerName="CamelHBaseRowId"> <el>${in.body.id}</el> </setHeader> <to uri="hbase:mytable?operation=CamelHBaseGet&amily=myfamily&ualifier=myqualifier&alueType=java.lang.Long"/> <to uri="log:out"/> </route>
Delete Operations.
<route> <from uri="direct:in"/> <!-- Set the HBase Row of the Get --> <setHeader headerName="CamelHBaseRowId"> <el>${in.body.id}</el> </setHeader> <to uri="hbase:mytable?operation=CamelHBaseDelete"/> </route>
Scan Operations.
<route> <from uri="direct:in"/> <to uri="hbase:mytable?operation=CamelHBaseScan&amily=myfamily&ualifier=myqualifier&alueType=java.lang.Long&owType=java.lang.String"/> <to uri="log:out"/> </route>
ModelAwareColumnMatchingFilter
as shown below.
<route> <from uri="direct:scan"/> <!-- Set the Criteria --> <setHeader headerName="CamelHBaseFamily"> <constant>name</constant> </setHeader> <setHeader headerName="CamelHBaseQualifier"> <constant>first</constant> </setHeader> <setHeader headerName="CamelHBaseValue"> <el>in.body.firstName</el> </setHeader> <setHeader headerName="CamelHBaseFamily2"> <constant>name</constant> </setHeader> <setHeader headerName="CamelHBaseQualifier2"> <constant>last</constant> </setHeader> <setHeader headerName="CamelHBaseValue2"> <el>in.body.lastName</el> </setHeader> <!-- Set additional fields that you want to be return by skipping value --> <setHeader headerName="CamelHBaseFamily3"> <constant>address</constant> </setHeader> <setHeader headerName="CamelHBaseQualifier3"> <constant>country</constant> </setHeader> <to uri="hbase:mytable?operation=CamelHBaseScan&ilters=#myFilterList"/> </route> <bean id="myFilters" class="java.util.ArrayList"> <constructor-arg> <list> <bean class="org.apache.camel.component.hbase.filters.ModelAwareColumnMatchingFilter"/> </list> </constructor-arg> </bean>
HBase Consumer
hbase://table[?options]
hbase:mutable?family=name&qualifer=first&valueType=java.lang.String&family=address&qualifer=number&valueType2=java.lang.Integer&rowType=java.lang.Long
Supported URI options on consumer
Name | Default Value | Description |
---|---|---|
initialDelay
|
1000
|
Milliseconds before the first polling starts. |
delay
|
500
|
Milliseconds before the next poll. |
useFixedDelay
|
true
|
Controls if fixed delay or fixed rate is used. See ScheduledExecutorService in JDK for details. |
timeUnit |
TimeUnit.MILLISECONDS
|
time unit for initialDelay and delay options.
|
runLoggingLevel
|
TRACE
|
Camel 2.8: The consumer logs a start/complete log line when it polls. This option allows you to configure the logging level for that. |
operation
|
CamelHBasePut
|
The HBase operation to perform. Supported values: CamelHBasePut , CamelHBaseGet , CamelHBaseDelete , and CamelHBaseScan .
|
maxResults
|
100
|
The maximum number of rows to scan. Supported operations:CamelHBaseScan .
|
mappingStrategyName
|
header
|
The strategy to use for mapping Camel messages to HBase columns. Supported values: header , or body .
|
mappingStrategyClassName
|
null
|
The class name of a custom mapping strategy implementation. |
filters
|
null
|
A list of filters. Supported operations: CamelHBaseScan
|
Name | Default Value | Description |
---|---|---|
rowId
|
The id of the row. This has limited use as the row usually changes per Exchange. | |
rowType
|
String | The type to covert row id to. Supported operations: CamelHBaseScan |
family
|
The column family. *upports a number suffix for referring to more than one columns | |
qualifier
|
The column qualifier. *Supports a number suffix for referring to more than one columns | |
value
|
The value. Supports a number suffix for referring to more than one columns | |
rowModel
|
String | An instance of org.apache.camel.component.hbase.model.HBaseRow which describes how each row should be modeled |
HBase Idempotent repository
HBaseConfiguration configuration = HBaseConfiguration.create(); HBaseIdempotentRepository repository = new HBaseIdempotentRepository(configuration, tableName, family, qualifier); from("direct:in") .idempotentConsumer(header("messageId"), repository) .to("log:out);
HBase Mapping
HBase Header mapping Examples
Header | Value |
---|---|
CamelHBaseRowId | myrow |
CamelHBaseFamily | myfamily |
CamelHBaseQualifier | myqualifier |
CamelHBaseValue | myvalue |
Header | Value |
---|---|
CamelHBaseRowId | myrow |
CamelHBaseFamily | myfamily |
CamelHBaseQualifier | myqualifier |
CamelHBaseValue | myvalue |
CamelHBaseRowId2 | myrow2 |
CamelHBaseFamily2 | myfamily |
CamelHBaseQualifier2 | myqualifier |
CamelHBaseValue2 | myvalue2 |
Header | Value |
---|---|
CamelHBaseFamily | myfamily |
CamelHBaseQualifier | myqualifier |
CamelHBaseValueType | Long |
Body mapping Examples
hbase:mytable?mappingStrategy=body
HBaseData data = new HBaseData(); HBaseRow row = new HBaseRow(); row.setId("myRowId"); HBaseCell cell = new HBaseCell(); cell.setFamily("myfamily"); cell.setQualifier("myqualifier"); cell.setValue("myValue"); row.getCells().add(cell); data.addRows().add(row);
See also
Chapter 58. HDFS
HDFS Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-hdfs</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
hdfs://hostname[:port][/path][?options]
?option=value&option=value&...
The path is treated in the following way:
- as a consumer, if it's a file, it just reads the file, otherwise if it represents a directory it scans all the file under the path satisfying the configured pattern. All the files under that directory must be of the same type.
- as a producer, if at least one split strategy is defined, the path is considered a directory and under that directory the producer creates a different file per split named using the configured
UuidGenerator
.
chunkSize
option. If you want to read from HDFS and write to a regular file using the File component, you can set fileMode=Append
to concatenate the chunks.
Options
Name | Default Value | Description |
---|---|---|
overwrite
|
true
|
The file can be overwritten |
append
|
false
|
Append to existing file. Notice that not all HDFS file systems support the append option. |
bufferSize
|
4096
|
The buffer size used by HDFS |
replication
|
3
|
The HDFS replication factor |
blockSize
|
67108864
|
The size of the HDFS blocks |
fileType
|
NORMAL_FILE
|
It can be SEQUENCE_FILE, MAP_FILE, ARRAY_FILE, or BLOOMMAP_FILE, see Hadoop
|
fileSystemType
|
HDFS
|
It can be LOCAL for local filesystem |
keyType
|
NULL
|
The type for the key in case of sequence or map files. See below.
|
valueType
|
TEXT
|
The type for the key in case of sequence or map files. See below.
|
splitStrategy
|
A string describing the strategy on how to split the file based on different criteria. See below.
|
|
openedSuffix
|
opened
|
When a file is opened for reading/ writing the file is renamed with this suffix to avoid to read it during the writing phase.
|
readSuffix
|
read
|
Once the file has been read is renamed with this suffix to avoid to read it again.
|
initialDelay
|
0
|
For the consumer, how much to wait (milliseconds) before to start scanning the directory.
|
delay
|
0
|
The interval (milliseconds) between the directory scans.
|
pattern
|
*
|
The pattern used for scanning the directory
|
chunkSize
|
4096
|
When reading a normal file, this is split into chunks producing a message per chunk
|
connectOnStartup
|
true
|
Camel 2.9.3/2.10.1: Whether to connect to the HDFS file system on starting the producer/consumer. If false then the connection is created on-demand. Notice that HDFS may take up till 15 minutes to establish a connection, as it has hardcoded 45 x 20 sec redelivery. By setting this option to false allows your application to startup, and not block for up till 15 minutes.
|
owner
|
Camel 2.13/2.12.4: The file owner must match this owner for the consumer to pickup the file. Otherwise the file is skipped.
|
KeyType and ValueType
- NULL it means that the key or the value is absent
- BYTE for writing a byte, the java Byte class is mapped into a BYTE
- BYTES for writing a sequence of bytes. It maps the java ByteBuffer class
- INT for writing java integer
- FLOAT for writing java float
- LONG for writing java long
- DOUBLE for writing java double
- TEXT for writing java strings
Splitting Strategy
- If the split strategy option has been defined, the hdfs path will be used as a directory and files will be created using the configured
UuidGenerator
. - Every time a splitting condition is met, a new file is created. The
splitStrategy
option is defined as a string with the following syntax:splitStrategy=<ST>:<value>,<ST>:<value>,*
<ST>
can be:
- BYTES a new file is created, and the old is closed when the number of written bytes is more than <value>
- MESSAGES a new file is created, and the old is closed when the number of written messages is more than <value>
- IDLE a new file is created, and the old is closed when no writing happened in the last <value> milliseconds
HdfsConstants.HDFS_CLOSE
header to false
to use the BYTES/MESSAGES
configuration, otherwise the file will be closed with each message
hdfs://localhost/tmp/simple-file?splitStrategy=IDLE:1000,BYTES:5
hadoop fs ls /tmp/simplefile
you'll see that multiple files have been created.
Message Headers
Header
|
Description
|
---|---|
CamelFileName
|
Camel 2.13: Specifies the name of the file to write (relative to the endpoint path). The name can be a
String or an Expression object. Only relevant when not using a split strategy.
|
Controlling to close file stream
HdfsConstants.HDFS_CLOSE
(value = "CamelHdfsClose"
) to control this. Setting this value to a boolean allows you to explicit control whether the stream should be closed or not.
Using this component in OSGi
Chapter 59. HDFS2
HDFS2 Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-hdfs2</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
hdfs2://hostname[:port][/path][?options]
?option=value&option=value&...
The path is treated in the following way:
- as a consumer, if it's a file, it just reads the file, otherwise if it represents a directory it scans all the file under the path satisfying the configured pattern. All the files under that directory must be of the same type.
- as a producer, if at least one split strategy is defined, the path is considered a directory and under that directory the producer creates a different file per split named using the configured UuidGenerator.
chunkSize
option. If you want to read from HDFS and write to a regular file using the File component, you can set fileMode=Append
to concatenate the chunks.
Options
Name
|
Default Value
|
Description
|
---|---|---|
overwrite
|
true
|
The file can be overwritten
|
append
|
false
|
Append to existing file. Notice that not all HDFS file systems support the append option.
|
bufferSize
|
4096
|
The buffer size used by HDFS
|
replication
|
3
|
The HDFS replication factor
|
blockSize
|
67108864
|
The size of the HDFS blocks
|
fileType
|
NORMAL_FILE
|
It can be SEQUENCE_FILE, MAP_FILE, ARRAY_FILE, or BLOOMMAP_FILE, see Hadoop
|
fileSystemType
|
HDFS
|
It can be LOCAL for local filesystem
|
keyType
|
NULL
|
The type for the key in case of sequence or map files. See below.
|
valueType
|
TEXT
|
The type for the key in case of sequence or map files. See below.
|
splitStrategy
|
|
A string describing the strategy on how to split the file based on different criteria. See below.
|
openedSuffix
|
opened
|
When a file is opened for reading/writing the file is renamed with this suffix to avoid to read it during the writing phase.
|
readSuffix
|
read
|
Once the file has been read is renamed with this suffix to avoid to read it again.
|
initialDelay
|
0
|
For the consumer, how much to wait (milliseconds) before to start scanning the directory.
|
delay
|
0
|
The interval (milliseconds) between the directory scans.
|
pattern
|
*
|
The pattern used for scanning the directory
|
chunkSize
|
4096
|
When reading a normal file, this is split into chunks producing a message per chunk.
|
connectOnStartup
|
true
|
Camel 2.9.3/2.10.1: Whether to connect to the HDFS file system on starting the producer/consumer. If
false then the connection is created on-demand. Notice that HDFS may take up till 15 minutes to establish a connection, as it has hardcoded 45 x 20 sec redelivery. By setting this option to false allows your application to startup, and not block for up till 15 minutes.
|
owner
|
|
The file owner must match this owner for the consumer to pickup the file. Otherwise the file is skipped.
|
KeyType and ValueType
- NULL it means that the key or the value is absent
- BYTE for writing a byte, the java Byte class is mapped into a BYTE
- BYTES for writing a sequence of bytes. It maps the java ByteBuffer class
- INT for writing java integer
- FLOAT for writing java float
- LONG for writing java long
- DOUBLE for writing java double
- TEXT for writing java strings
Splitting Strategy
- If the split strategy option has been defined, the hdfs path will be used as a directory and files will be created using the configured UuidGenerator
- Every time a splitting condition is met, a new file is created. The splitStrategy option is defined as a string with the following syntax: splitStrategy=<ST>:<value>,<ST>:<value>,*
- BYTES a new file is created, and the old is closed when the number of written bytes is more than <value>
- MESSAGES a new file is created, and the old is closed when the number of written messages is more than <value>
- IDLE a new file is created, and the old is closed when no writing happened in the last <value> milliseconds
hdfs2://localhost/tmp/simple-file?splitStrategy=IDLE:1000,BYTES:5
hadoop fs -ls /tmp/simple-file
you'll see that multiple files have been created.
Message Headers
Producer only
Header
|
Description
|
---|---|
CamelFileName
|
Camel 2.13: Specifies the name of the file to write (relative to the endpoint path). The name can be a
String or an Expression object. Only relevant when not using a split strategy.
|
Controlling to close file stream
HdfsConstants.HDFS_CLOSE
(value = "CamelHdfsClose"
) to control this. Setting this value to a boolean allows you to explicit control whether the stream should be closed or not.
Using this component in OSGi
org.apache.hadoop.fs.FileSystem
implementations. Hadoop 2.x uses java.util.ServiceLoader
which looks for /META-INF/services/org.apache.hadoop.fs.FileSystem
files defining available filesystem types and implementations. These resources are not available when running inside OSGi.
camel-hdfs
component, the default configuration files need to be visible from the bundle class loader. A typical way to deal with it is to keep a copy of core-default.xml
(and e.g., hdfs-default.xml
) in your bundle root.
Using this component with manually defined routes
- Package
/META-INF/services/org.apache.hadoop.fs.FileSystem
resource with bundle that defines the routes. This resource should list all the required Hadoop 2.x filesystem implementations. - Provide boilerplate initialization code which populates internal, static cache inside
org.apache.hadoop.fs.FileSystem
class:
org.apache.hadoop.conf.Configuration conf = new org.apache.hadoop.conf.Configuration(); conf.setClass("fs.file.impl", org.apache.hadoop.fs.LocalFileSystem.class, FileSystem.class); conf.setClass("fs.hdfs.impl", org.apache.hadoop.hdfs.DistributedFileSystem.class, FileSystem.class); ... FileSystem.get("file:///", conf); FileSystem.get("hdfs://localhost:9000/", conf); ...
Using this component with Blueprint container
- Package
/META-INF/services/org.apache.hadoop.fs.FileSystem
resource with bundle that contains blueprint definition. - Add the following to the blueprint definition file:
<bean id="hdfsOsgiHelper" class="org.apache.camel.component.hdfs2.HdfsOsgiHelper"> <argument> <map> <entry key="file:///" value="org.apache.hadoop.fs.LocalFileSystem" /> <entry key="hdfs://localhost:9000/" value="org.apache.hadoop.hdfs.DistributedFileSystem" /> ... </map> </argument> </bean> <bean id="hdfs2" class="org.apache.camel.component.hdfs2.HdfsComponent" depends-on="hdfsOsgiHelper" />
Chapter 60. Hipchat
Hipchat component
You must have a valid Hipchat user account and get a personal access token that you can use to produce/consume messages.
|
URI Format
hipchat://[host][:port]?options
URI Options
Name
|
Default Value
|
Context
| Required | Producer/Consumer |
Description
|
---|---|---|---|---|---|
authToken
|
null
|
Shared
|
Yes | Both | Authorization token(personal access token) obtained from Hipchat |
protocol
|
http
|
Shared
|
No | Both |
Default protocol to connect to the Hipchat server
|
consumeUsers
|
null
|
Shared
|
No | Consumer |
Comma separated list of user @Mentions or emails whose messages to the owner of authToken must be consumed
|
host | api.hipchat.com | Shared | No | Both | The API host of the Hipchat to connect to |
port | 80 | Shared | No | Both | The port to connect to on the Hipchat host |
delay | 5000 | Shared | No | Consumer | The poll interval in millisec for consuming messages from consumeUsers provided. Please read about rate limits before decreasing this. |
Scheduled Poll Consumer
@Override public void configure() throws Exception { String hipchatEndpointUri = "hipchat://?authToken=XXXX&consumeUsers=@Joe,@John"; from(hipchatEndpointUri) .idempotentConsumer( simple("${in.header.HipchatMessageDate} ${in.header.HipchatFromUser}"), MemoryIdempotentRepository.memoryIdempotentRepository(200) ) .to("mock:result"); }
Message headers set by the Hipchat consumer
|
Hipchat Producer
@Override public void configure() throws Exception { String hipchatEndpointUri = "hipchat://?authToken=XXXX"; from("direct:start") .to(hipchatEndpointUri) .to("mock:result"); }
Message headers evaluated by the Hipchat producer
|
Message headers set by the Hipchat producer
|
Dependencies
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-hipchat</artifactId> <version>${camel-version}</version> </dependency>
${camel-version
} must be replaced by the actual version of Camel (2.15.0 or higher)
Chapter 61. HL7
HL7 Component
- HL7 MLLP codec for Mina
- HL7 MLLP codec forý Netty4 fromýCamel 2.15 onwards
- Type Converter from/to HAPI and String
- HL7 DataFormat using the HAPI library
- Even more ease-of-use as it's integrated well with the Chapter 93, MINA2 - Deprecated component.
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-hl7</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
HL7 MLLP protocol
camel-mina2
or camel-netty4
component is used with the HL7MLLPCodec (mina2) or HL7MLLPNettyDecoder/HL7MLLPNettyEncoder (Netty4).
Name | Default Value | Description |
---|---|---|
startByte
|
0x0b
|
The start byte spanning the HL7 payload. |
endByte1
|
0x1c
|
The first end byte spanning the HL7 payload. |
endByte2
|
0x0d
|
The 2nd end byte spanning the HL7 payload. |
charset
|
JVM Default | The encoding (a charset name) to use for the codec. If not provided, Camel will use the JVM default Charset. |
produceString
|
true
|
Camel 2.14.1: If true , the codec creates a string using the defined charset. If false , the codec sends a plain byte array into the route, so that the HL7 Data Format can determine the actual charset from the HL7 message content.
|
convertLFtoCR
|
false
|
Will convert \n to \r (0x0d , 13 decimal) as HL7 stipulates \r as segment terminators. The HAPI library requires the use of \r .
|
Exposing a HL7 listener using Mina
<endpoint id="hl7MinaListener" uri="mina2:tcp://localhost:8888?sync=true&codec=#hl7codec"/>
hl7codec
is just a Spring bean ID, so it could be named mygreatcodecforhl7
or whatever you like. The codec is also set up in the Spring XML file:
<bean id="hl7codec" class="org.apache.camel.component.hl7.HL7MLLPCodec"> <property name="charset" value="iso-8859-1"/> </bean>
from("hl7MinaListener").beanRef("patientLookupService");
<bean id="patientLookupService" class="com.mycompany.healthcare.service.PatientLookupService"/>
import ca.uhn.hl7v2.HL7Exception; import ca.uhn.hl7v2.model.Message; import ca.uhn.hl7v2.model.v24.segment.QRD; public class PatientLookupService { public Message lookupPatient(Message input) throws HL7Exception { QRD qrd = (QRD)input.get("QRD"); String patientId = qrd.getWhoSubjectFilter(0).getIDNumber().getValue(); // find patient data based on the patient id and create a HL7 model object with the response Message response = ... create and set response data return response }
Exposing an HL7 listener using Netty (available from Camel 2.15 onwards)
<endpoint id="hl7NettyListener" uri="netty4:tcp://localhost:8888?sync=true&encoder=#hl7encoder&decoder=#hl7decoder"/>
sync=true
indicates that this listener is synchronous and therefore will return a HL7 response to the caller. The HL7 codec is set up with encoder=#hl7encoder
and decoder=#hl7decoder
. Note that hl7encoder
and hl7decoder
are just bean IDs, so they could be named differently. The beans can be set in the Spring XML file:
<bean id="hl7decoder" class="org.apache.camel.component.hl7.HL7MLLPNettyDecoderFactory"/> <bean id="hl7encoder" class="org.apache.camel.component.hl7.HL7MLLPNettyEncoderFactory"/>
hl7NettyListener
endpoint can then be used in a route as a consumer, as this Java DSL example illustrates:
from("hl7NettyListener").beanRef("patientLookupService");
HL7 Model using java.lang.String or byte[]
String
as its data format. Camel uses its Type Converter to convert to/from strings to the HAPI HL7 model objects, but you can use the plain String
objects if you prefer, for instance if you wish to parse the data yourself.
byte[]
as its data format by setting the produceString
property to false
. The Type Converter is also capable of converting the byte[]
to/from HAPI HL7 model objects.
HL7v2 Model using HAPI
0101701234
.
MSH|^~\\&|MYSENDER|MYRECEIVER|MYAPPLICATION||200612211200||QRY^A19|1234|P|2.4 QRD|200612211200|R|I|GetPatient|||1^RD|0101701234|DEM||
ca.uhn.hl7v2.model.Message
object, for example to retrieve a patient ID:
Message msg = exchange.getIn().getBody(Message.class); QRD qrd = (QRD)msg.get("QRD"); String patientId = qrd.getWhoSubjectFilter(0).getIDNumber().getValue(); // 0101701234
byte[]
, String
or any other simple object formats. You can just use the HAPI HL7v2 model objects. If you know the message type in advance, you can be more type-safe:
QRY_A19 msg = exchange.getIn().getBody(QRY_A19.class); String patientId = msg.getQRD().getWhoSubjectFilter(0).getIDNumber().getValue();
HL7 DataFormat
marshal
= from Message to byte stream (can be used when responding using the HL7 MLLP codec)unmarshal
= from byte stream to Message (can be used when receiving streamed data from the HL7 MLLP
marshal
or unmarshal
operation in the route builder:
DataFormat hl7 = new HL7DataFormat(); ... from("direct:hl7in").marshal(hl7).to("jms:queue:hl7out");
DataFormat hl7 = new HL7DataFormat(); ... from("jms:queue:hl7out").unmarshal(hl7).to("patientLookupService");
marshal()
and read them again directly from the queue (i.e. without calling unmarshal()
).
unmarshal
does not automatically fix segment separators any more by converting \n
to \r
. If you need this conversion, org.apache.camel.component.hl7.HL7#convertLFToCR
provides a handy Expression
for this purpose.
marshal
and unmarshal
evaluate the charset
provided in the field MSH-18. If this field is empty, by default the charset contained in the corresponding Camel charset property/header is assumed. You can even change this default behaviour by overriding the guessCharsetName
method when inheriting from the HL7DataFormat
class.
HL7DataFormat
object:
from("direct:hl7in").marshal().hl7().to("jms:queue:hl7out"); from("jms:queue:hl7out").unmarshal().hl7().to("patientLookupService");
Message Headers
unmarshal
operation adds these fields from the MSH segment as headers on the Camel message:
Key | MSH field | Example |
---|---|---|
CamelHL7SendingApplication
|
MSH-3
|
MYSERVER
|
CamelHL7SendingFacility
|
MSH-4
|
MYSERVERAPP
|
CamelHL7ReceivingApplication
|
MSH-5
|
MYCLIENT
|
CamelHL7ReceivingFacility
|
MSH-6
|
MYCLIENTAPP
|
CamelHL7Timestamp
|
MSH-7
|
20071231235900
|
CamelHL7Security
|
MSH-8
|
null
|
CamelHL7MessageType
|
MSH-9-1
|
ADT
|
CamelHL7TriggerEvent
|
MSH-9-2
|
A01
|
CamelHL7MessageControl
|
MSH-10
|
1234
|
CamelHL7ProcessingId
|
MSH-11
|
P
|
CamelHL7VersionId
|
MSH-12
|
2.4
|
CamelHL7Context
|
-
|
Camel 2.14: contains the
HapiContext that was used to parse the message
|
CamelHL7Charset
|
MSH-18
|
Camel 2.14.1: Unicode UTF-8
|
CamelHL7Context
are String
types. If a header value is missing, its value is null
.
Options
Option | Default | Description |
---|---|---|
validate
|
true
|
Whether the HAPI Parser should validate the message using the default validation rules. It is recommended to use the parser or hapiContext option and initialize it with the desired HAPI ValidationContext. |
parser
|
ca.uhn.hl7v2.parser.GenericParser
|
Custom parser to be used. Must be of type ca.uhn.hl7v2.parser.Parser. Note that GenericParser also allows to parse XML-encoded HL7v2 messages |
hapiContext
|
ca.uhn.hl7v2.DefaultHapiContext
|
Camel 2.14: Custom HAPI context that can define a custom parser, custom ValidationContext etc. This gives you full control over the HL7 parsing and rendering process.
|
Dependencies
camel-hl7
only references the HAPI base library. Applications are responsible for including structure libraries themselves. For example, if an application works with HL7v2 message versions 2.4 and 2.5 then the following dependencies must be added:
<dependency> <groupId>ca.uhn.hapi</groupId> <artifactId>hapi-structures-v24</artifactId> <version>2.2</version> <!-- use the same version as your hapi-base version --> </dependency> <dependency> <groupId>ca.uhn.hapi</groupId> <artifactId>hapi-structures-v25</artifactId> <version>2.2</version> <!-- use the same version as your hapi-base version --> </dependency>
<dependency> <groupId>ca.uhn.hapi</groupId> <artifactId>hapi-osgi-base</artifactId> <version>2.2</version> </dependency>
Terser language
import static org.apache.camel.component.hl7.HL7.terser; ... // extract patient ID from field QRD-8 in the QRY_A19 message above and put into message header from("direct:test1") .setHeader("PATIENT_ID",terser("QRD-8(0)-1")) .to("mock:test1"); // continue processing if extracted field equals a message header from("direct:test2") .filter(terser("QRD-8(0)-1").isEqualTo(header("PATIENT_ID")) .to("mock:test2");
HL7 Validation predicate
import static org.apache.camel.component.hl7.HL7.messageConformsTo; import ca.uhn.hl7v2.validation.impl.DefaultValidation; ... // Use standard or define your own validation rules ValidationContext defaultContext = new DefaultValidation(); // Throws PredicateValidationException if message does not validate from("direct:test1").validate(messageConformsTo(defaultContext)).to("mock:test1");
HL7 Validation predicate using the HapiContext (Camel 2.14)
CamelHL7Context
header, and the validation rules of this context can be easily reused:
import static org.apache.camel.component.hl7.HL7.messageConformsTo; import static org.apache.camel.component.hl7.HL7.messageConforms ... HapiContext hapiContext = new DefaultHapiContext(); hapiContext.getParserConfiguration().setValidating(false); // don't validate during parsing // customize HapiContext some more ... e.g. enforce that PID-8 in ADT_A01 messages of version 2.4 is not empty ValidationRuleBuilder builder = new ValidationRuleBuilder() { @Override protected void configure() { forVersion(Version.V24) .message("ADT", "A01") .terser("PID-8", not(empty())); } }; hapiContext.setValidationRuleBuilder(builder); HL7DataFormat hl7 = new HL7DataFormat(); hl7.setHapiContext(hapiContext); from("direct:test1") .unmarshal(hl7) // uses the GenericParser returned from the HapiContext .validate(messageConforms()) // uses the validation rules returned from the HapiContext // equivalent with .validate(messageConformsTo(hapiContext)) // route continues from here
HL7 Acknowledgement expression
ack
expression lets us accomplish this very elegantly:
import static org.apache.camel.component.hl7.HL7.messageConformsTo; import static org.apache.camel.component.hl7.HL7.ack; import ca.uhn.hl7v2.validation.impl.DefaultValidation; ... // Use standard or define your own validation rules ValidationContext defaultContext = new DefaultValidation(); from("direct:test1") .onException(Exception.class) .handled(true) .transform(ack()) // auto-generates negative ack because of exception in Exchange .end() .validate(messageConformsTo(defaultContext)) // do something meaningful here ... // acknowledgement .transform(ack())
More Samples
String
HL7 request is sent to an HL7 listener that sends back a response:
String line1 = "MSH|^~\\&|MYSENDER|MYRECEIVER|MYAPPLICATION||200612211200||QRY^A19|1234|P|2.4"; String line2 = "QRD|200612211200|R|I|GetPatient|||1^RD|0101701234|DEM||"; StringBuilder in = new StringBuilder(); in.append(line1); in.append("\n"); in.append(line2); String out = (String)template.requestBody("mina2:tcp://127.0.0.1:8888?sync=true&codec=#hl7codec", in.toString());
public class MyHL7BusinessLogic { // This is a plain POJO that has NO imports whatsoever on Apache Camel. // its a plain POJO only importing the HAPI library so we can much easier work with the HL7 format. public Message handleA19(Message msg) throws Exception { // here you can have your business logic for A19 messages assertTrue(msg instanceof QRY_A19); // just return the same dummy response return createADR19Message(); } public Message handleA01(Message msg) throws Exception { // here you can have your business logic for A01 messages assertTrue(msg instanceof ADT_A01); // just return the same dummy response return createADT01Message(); } }
RouteBuilder
are as follows:
DataFormat hl7 = new HL7DataFormat(); // we setup or HL7 listener on port 8888 (using the hl7codec) and in sync mode so we can return a response from("mina2:tcp://127.0.0.1:8888?sync=true&codec=#hl7codec") // we use the HL7 data format to unmarshal from HL7 stream to the HAPI Message model // this ensures that the camel message has been enriched with hl7 specific headers to // make the routing much easier (see below) .unmarshal(hl7) // using choice as the content base router .choice() // where we choose that A19 queries invoke the handleA19 method on our hl7service bean .when(header("CamelHL7TriggerEvent").isEqualTo("A19")) .beanRef("hl7service", "handleA19") .to("mock:a19") // and A01 should invoke the handleA01 method on our hl7service bean .when(header("CamelHL7TriggerEvent").isEqualTo("A01")).to("mock:a01") .beanRef("hl7service", "handleA01") .to("mock:a19") // other types should go to mock:unknown .otherwise() .to("mock:unknown") // end choice block .end() // marshal response back .marshal(hl7);
Chapter 62. HTTP
HTTP Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-http</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
http:hostname[:port][/resourceUri][?param1=value1][¶m2=value2]
Examples
Java DSL | Spring DSL |
---|---|
from("direct:start") .to("http://myhost/mypath"); |
<from uri="direct:start"/> <to uri="http://oldhost"/> |
Java DSL |
---|
from("direct:start") .setHeader(Exchange.HTTP_URI, simple("http://myserver/orders/${header.orderId}")) .to("http://dummyhost"); |
Java DSL |
---|
from("direct:start") .to("http://oldhost?order=123&detail=short"); from("direct:start") .setHeader(Exchange.HTTP_QUERY, constant("order=123&detail=short")) .to("http://oldhost"); |
Java DSL | Spring DSL |
---|---|
from("direct:start") .setHeader(Exchange.HTTP_METHOD, constant("POST")) .to("http://www.google.com"); |
<from uri="direct:start"/> <setHeader headerName="CamelHttpMethod"> <constant>POST</constant> </setHeader> <to uri="http://www.google.com"/> <to uri="mock:results"/> |
HttpEndpoint Options
Name | Default Value | Description |
---|---|---|
throwExceptionOnFailure
|
true
|
Option to disable throwing the HttpOperationFailedException in case of failed responses from the remote server. This allows you to get all responses regardless of the HTTP status code.
|
bridgeEndpoint
|
false
|
If the option is true , HttpProducer will ignore the Exchange.HTTP_URI header, and use the endpoint's URI for request. You may also set the throwExceptionOnFailure to be false to let the HttpProducer send all the fault response back. Camel 2.3: If the option is true, HttpProducer and CamelServlet will skip the gzip processing if the content-encoding is "gzip".
|
disableStreamCache
|
false
|
DefaultHttpBinding will copy the request input stream into a stream cache and put it into message body if this option is false to support read it twice, otherwise DefaultHttpBinding will set the request input stream direct into the message body. |
httpBindingRef
|
null
|
Deprecated and will be removed in Camel 3.0: Reference to a org.apache.camel.component.http.HttpBinding in the Registry. Use the httpBinding option instead.
|
httpBinding
|
null
|
Reference to a org.apache.camel.component.http.HttpBinding in the Registry.
|
httpClientConfigurerRef
|
null
|
Deprecated and will be removed in Camel 3.0: Reference to a org.apache.camel.component.http.HttpClientConfigurer in the Registry. Use the httpClientConfigurer option instead.
|
httpClientConfigurer
|
null
|
Reference to a org.apache.camel.component.http.HttpClientConfigurer in the Registry.
|
httpClient.XXX
|
null
|
Setting options on the HttpClientParams. For instance httpClient.soTimeout=5000 will set the SO_TIMEOUT to 5 seconds.
|
clientConnectionManager
|
null
|
To use a custom org.apache.http.conn.ClientConnectionManager .
|
transferException
|
false
|
Camel 2.6: If enabled and an Exchange failed processing on the consumer side, and if the caused Exception was send back serialized in the response as a application/x-java-serialized-object content type (for example using Jetty or Servlet Camel components). On the producer side the exception will be deserialized and thrown as is, instead of the HttpOperationFailedException . The caused exception is required to be serialized.
|
headerFilterStrategy
|
null
|
Camel 2.11: Reference to a instance of org.apache.camel.spi.HeaderFilterStrategy in the Registry. It will be used to apply the custom headerFilterStrategy on the new create HttpEndpoint.
|
urlRewrite
|
null
|
Camel 2.11:Producer only Refers to a custom org.apache.camel.component.http.UrlRewrite which allows you to rewrite urls when you bridge/proxy endpoints. See more details at UrlRewrite and How to use Camel as a HTTP proxy between a client and server.
|
Authentication and Proxy
Name | Default Value | Description |
---|---|---|
authMethod
|
null
|
Authentication method, either as Basic , Digest or NTLM .
|
authMethodPriority
|
null
|
Priority of authentication methods. Is a list separated with comma. For example: Basic,Digest to exclude NTLM .
|
authUsername
|
null
|
Username for authentication |
authPassword
|
null
|
Password for authentication |
authDomain
|
null
|
Domain for NTML authentication |
authHost
|
null
|
Optional host for NTML authentication |
proxyHost
|
null
|
The proxy host name |
proxyPort
|
null
|
The proxy port number |
proxyAuthMethod
|
null
|
Authentication method for proxy, either as Basic , Digest or NTLM .
|
proxyAuthUsername
|
null
|
Username for proxy authentication |
proxyAuthPassword
|
null
|
Password for proxy authentication |
proxyAuthDomain
|
null
|
Domain for proxy NTML authentication |
proxyAuthHost
|
null
|
Optional host for proxy NTML authentication |
authMethod
or authProxyMethod
options. You can configure the proxy and authentication details on either the HttpComponent
or the HttpEndoint
. Values provided on the HttpEndpoint
will take precedence over HttpComponent
. Its most likely best to configure this on the HttpComponent
which allows you to do this once.
authMethodPriority
then it will fallback and use the select(ed) authMethod
as priority as well. So if you use authMethod.Basic
then the auhtMethodPriority
will be Basic
only.
HttpComponent Options
Name | Default Value | Description |
---|---|---|
httpBinding
|
null
|
To use a custom org.apache.camel.component.http.HttpBinding .
|
httpClientConfigurer
|
null
|
To use a custom org.apache.camel.component.http.HttpClientConfigurer .
|
httpConnectionManager
|
null
|
To use a custom org.apache.commons.httpclient.HttpConnectionManager .
|
httpConfiguration
|
null
|
To use a custom org.apache.camel.component.http.HttpConfiguration
|
Message Headers
Name | Type | Description |
---|---|---|
Exchange.HTTP_URI
|
String
|
URI to call. Will override existing URI set directly on the endpoint. |
Exchange.HTTP_METHOD
|
String
|
HTTP Method / Verb to use (GET/POST/PUT/DELETE/HEAD/OPTIONS/TRACE) |
Exchange.HTTP_PATH
|
String
|
Request URI's path, the header will be used to build the request URI with the HTTP_URI. Camel 2.3.0: If the path is start with "/", http producer will try to find the relative path based on the Exchange.HTTP_BASE_URI header or the exchange.getFromEndpoint().getEndpointUri(); |
Exchange.HTTP_QUERY
|
String
|
URI parameters. Will override existing URI parameters set directly on the endpoint. |
Exchange.HTTP_RESPONSE_CODE
|
int
|
The HTTP response code from the external server. Is 200 for OK. |
Exchange.HTTP_CHARACTER_ENCODING
|
String
|
Character encoding. |
Exchange.CONTENT_TYPE
|
String
|
The HTTP content type. Is set on both the IN and OUT message to provide a content type, such as text/html .
|
Exchange.CONTENT_ENCODING
|
String
|
The HTTP content encoding. Is set on both the IN and OUT message to provide a content encoding, such as gzip .
|
Exchange.HTTP_SERVLET_REQUEST
|
HttpServletRequest
|
The HttpServletRequest object.
|
Exchange.HTTP_SERVLET_RESPONSE
|
HttpServletResponse
|
The HttpServletResponse object.
|
Exchange.HTTP_PROTOCOL_VERSION
|
String
|
Camel 2.5: You can set the http protocol version with this header, eg. "HTTP/1.0". If you didn't specify the header, HttpProducer will use the default value "HTTP/1.1" |
Message Body
Response code
- Response code is in the range 100..299, Camel regards it as a success response.
- Response code is in the range 300..399, Camel regards it as a redirection response and will throw a
HttpOperationFailedException
with the information. - Response code is 400+, Camel regards it as an external server failure and will throw a
HttpOperationFailedException
with the information.throwExceptionOnFailureThe option,throwExceptionOnFailure
, can be set tofalse
to prevent theHttpOperationFailedException
from being thrown for failed response codes. This allows you to get any response from the remote server. There is a sample below demonstrating this.
HttpOperationFailedException
- The HTTP status code
- The HTTP status line (text of the status code)
- Redirect location, if server returned a redirect
- Response body as a
java.lang.String
, if server provided a body as response
Calling using GET or POST
GET
or POST
HTTP method should be used: 1. Use method provided in header. 2. GET
if query string is provided in header. 3. GET
if endpoint is configured with a query string. 4. POST
if there is data to send (body is not null). 5. GET
otherwise.
How to get access to HttpServletRequest and HttpServletResponse
HttpServletRequest request = exchange.getIn().getBody(HttpServletRequest.class); HttpServletRequest response = exchange.getIn().getBody(HttpServletResponse.class);
Using client timeout - SO_TIMEOUT
Configuring a Proxy
Java DSL |
---|
from("direct:start") .to("http://oldhost?proxyHost=www.myproxy.com&proxyPort=80"); |
proxyUsername
and proxyPassword
options.
Using proxy settings outside of URI
Java DSL | Spring DSL |
---|---|
context.getProperties().put("http.proxyHost", "172.168.18.9"); context.getProperties().put("http.proxyPort" "8080"); |
<camelContext> <properties> <property key="http.proxyHost" value="172.168.18.9"/> <property key="http.proxyPort" value="8080"/> </properties> </camelContext> |
Configuring charset
POST
to send data you can configure the charset
setProperty(Exchange.CHARSET_NAME, "iso-8859-1");
Sample with scheduled poll
message.html
:
from("timer://foo?fixedRate=true&delay=0&period=10000") .to("http://www.google.com") .setHeader(FileComponent.HEADER_FILE_NAME, "message.html").to("file:target/google");
Getting the Response Code
Exchange.HTTP_RESPONSE_CODE
.
Exchange exchange = template.send("http://www.google.com/search", new Processor() { public void process(Exchange exchange) throws Exception { exchange.getIn().setHeader(Exchange.HTTP_QUERY, constant("hl=en&q=activemq")); } }); Message out = exchange.getOut(); int responseCode = out.getHeader(Exchange.HTTP_RESPONSE_CODE, Integer.class);
Using throwExceptionOnFailure=false to get any response back
throwExceptionOnFailure
option to false
so we get any response in the AggregationStrategy
. As the code is based on a unit test that simulates a HTTP status code 404, there is some assertion code etc.
// We set throwExceptionOnFailure to false to let Camel return any response from the remove HTTP server without thrown // HttpOperationFailedException in case of failures. // This allows us to handle all responses in the aggregation strategy where we can check the HTTP response code // and decide what to do. As this is based on an unit test we assert the code is 404 from("direct:start").enrich("http://localhost:{{port}}/myserver?throwExceptionOnFailure=false&user=Camel", new AggregationStrategy() { public Exchange aggregate(Exchange original, Exchange resource) { // get the response code Integer code = resource.getIn().getHeader(Exchange.HTTP_RESPONSE_CODE, Integer.class); assertEquals(404, code.intValue()); return resource; } }).to("mock:result"); // this is our jetty server where we simulate the 404 from("jetty://http://localhost:{{port}}/myserver") .process(new Processor() { public void process(Exchange exchange) throws Exception { exchange.getOut().setBody("Page not found"); exchange.getOut().setHeader(Exchange.HTTP_RESPONSE_CODE, 404); } });
Disabling Cookies
httpClient.cookiePolicy=ignoreCookies
Advanced Usage
HttpComponent
where you can set various classes to give you custom behavior.
Setting MaxConnectionsPerHost
org.apache.commons.httpclient.HttpConnectionManager
where you can configure various global configuration for the given component. By global, we mean that any endpoint the component creates has the same shared HttpConnectionManager
. So, if we want to set a different value for the max connection per host, we need to define it on the HTTP component and not on the endpoint URI that we usually use. So here comes:
http
component in Spring XML. Yes, we use the same scheme name, http
, because otherwise Camel will auto-discover and create the component with default settings. What we need is to overrule this so we can set our options. In the sample below we set the max connection to 5 instead of the default of 2.
<bean id="http" class="org.apache.camel.component.http.HttpComponent"> <property name="camelContext" ref="camel"/> <property name="httpConnectionManager" ref="myHttpConnectionManager"/> </bean> <bean id="myHttpConnectionManager" class="org.apache.commons.httpclient.MultiThreadedHttpConnectionManager"> <property name="params" ref="myHttpConnectionManagerParams"/> </bean> <bean id="myHttpConnectionManagerParams" class="org.apache.commons.httpclient.params.HttpConnectionManagerParams"> <property name="defaultMaxConnectionsPerHost" value="5"/> </bean>
<camelContext id="camel" xmlns="http://camel.apache.org/schema/spring" trace="true"> <route> <from uri="direct:start"/> <to uri="http://www.google.com"/> <to uri="mock:result"/> </route> </camelContext>
Using preemptive authentication
httpClient.authenticationPreemptive=true
Accepting self signed certificates from remote server
Using the JSSE Configuration Utility
org.apache.camel.component.http.SSLContextParametersSecureProtocolSocketFactory
, of the HTTP client's protocol socket factory in order to support the use of the Camel JSSE Configuration utility. The following example demonstrates how to configure the protocol registry and use the registered protocol information in a route.
KeyStoreParameters ksp = new KeyStoreParameters(); ksp.setResource("/users/home/server/keystore.jks"); ksp.setPassword("keystorePassword"); KeyManagersParameters kmp = new KeyManagersParameters(); kmp.setKeyStore(ksp); kmp.setKeyPassword("keyPassword"); SSLContextParameters scp = new SSLContextParameters(); scp.setKeyManagers(kmp); ProtocolSocketFactory factory = new SSLContextParametersSecureProtocolSocketFactory(scp); Protocol.registerProtocol("https", new Protocol( "https", factory, 443)); from("direct:start") .to("https://mail.google.com/mail/").to("mock:results");
Configuring Apache HTTP Client Directly
org.apache.camel.component.http.HttpClientConfigurer
to do some configuration on the http client if you need full control of it.
HttpClientConfigurer
, for example:
Protocol authhttps = new Protocol("https", new AuthSSLProtocolSocketFactory( new URL("file:my.keystore"), "mypassword", new URL("file:my.truststore"), "mypassword"), 443); Protocol.registerProtocol("https", authhttps);
HttpClientConfigurer
, and registers https protocol providing a keystore or truststore per example above. Then, from your camel route builder class you can hook it up like so:
HttpComponent httpComponent = getContext().getComponent("http", HttpComponent.class); httpComponent.setHttpClientConfigurer(new MyHttpClientConfigurer());
HttpClientConfigurer
using the URI. For example:
<bean id="myHttpClientConfigurer" class="my.https.HttpClientConfigurer"> </bean> <to uri="https://myhostname.com:443/myURL?httpClientConfigurerRef=myHttpClientConfigurer"/>
Chapter 63. HTTP4
HTTP4 Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-http4</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
http4:hostname[:port][/resourceUri][?options]
?option=value&option=value&...
HttpComponent Options
Name | Default Value | Description |
---|---|---|
maxTotalConnections
|
200
|
The maximum number of connections. |
connectionsPerRoute
|
20
|
The maximum number of connections per route. |
cookieStore
|
null
|
Camel 2.11.2/2.12.0: To use a custom org.apache.http.client.CookieStore . By default the org.apache.http.impl.client.BasicCookieStore is used which is an in-memory only cookie store. Notice if bridgeEndpoint=true then the cookie store is forced to be a noop cookie store as cookies shouldn't be stored as we are just bridging (eg acting as a proxy).
|
httpClientConfigurer
|
null
|
Reference to a org.apache.camel.component.http.HttpClientConfigurer in the Registry.
|
clientConnectionManager
|
null
|
To use a custom org.apache.http.conn.ClientConnectionManager .
|
httpBinding
|
null
|
To use a custom org.apache.camel.component.http.HttpBinding .
|
httpContext
|
null
|
Camel 2.9.2: To use a custom org.apache.http.protocol.HttpContext when executing requests.
|
sslContextParameters
|
null
|
Camel 2.8: To use a custom org.apache.camel.util.jsse.SSLContextParameters . See Using the JSSE Configuration Utility.
|
x509HostnameVerifier
|
BrowserCompatHostnameVerifier
|
Camel 2.7: You can refer to a different org.apache.http.conn.ssl.X509HostnameVerifier instance in the Registry such as org.apache.http.conn.ssl.StrictHostnameVerifier or org.apache.http.conn.ssl.AllowAllHostnameVerifier .
|
connectionTimeToLive
|
-1
|
Camel 2.11.0: The time for connection to live, the time unit is millisecond, the default value is always keep alive. |
HttpEndpoint Options
Name | Default Value | Description |
---|---|---|
throwExceptionOnFailure
|
true
|
Option to disable throwing the HttpOperationFailedException in case of failed responses from the remote server. This allows you to get all responses regardless of the HTTP status code.
|
bridgeEndpoint
|
false
|
If true, HttpProducer will ignore the Exchange.HTTP_URI header, and use the endpoint's URI for request. You may also set the throwExcpetionOnFailure to be false to let the HttpProducer send all fault responses back. Also if set to true HttpProducer and CamelServlet will skip the gzip processing if the content-encoding is "gzip". |
clearExpiredCookies
|
true
|
Camel 2.11.2/2.12.0: Whether to clear expired cookies before sending the HTTP request. This ensures the cookies store does not keep growing by adding new cookies which is newer removed when they are expired. |
cookieStore
|
null
|
Camel 2.11.2/2.12.0: To use a custom org.apache.http.client.CookieStore . By default the org.apache.http.impl.client.BasicCookieStore is used which is an in-memory only cookie store. Notice if bridgeEndpoint=true then the cookie store is forced to be a noop cookie store as cookies shouldn't be stored as we are just bridging (eg acting as a proxy).
|
disableStreamCache
|
false
|
DefaultHttpBinding will copy the request input stream into a stream cache and put it into the message body if this option is false to support multiple reads, otherwise DefaultHttpBinding will set the request input stream directly in the message body. |
headerFilterStrategy
|
null
|
Camel 2.10.4: Reference to a instance of org.apache.camel.spi.HeaderFilterStrategy in the Registry. t will be used to apply the custom headerFilterStrategy on the new create HttpEndpoint.
|
httpBindingRef
|
null
|
Deprecated and will be removed in Camel 3.0: Reference to a org.apache.camel.component.http.HttpBinding in the Registry. Use the httpBinding option instead.
|
httpBinding
|
null
|
To use a custom org.apache.camel.component.http.HttpBinding .
|
httpClientConfigurerRef
|
null
|
Deprecated and will be removed in Camel 3.0: Reference to a org.apache.camel.component.http.HttpClientConfigurer in the Registry. Use the httpClientConfigurer option instead.
|
httpClientConfigurer
|
null
|
Reference to a org.apache.camel.component.http.HttpClientConfigurer in the Registry.
|
httpContextRef
|
null
|
Deprecated and will be removed in Camel 3.0:Camel 2.9.2: Reference to a custom org.apache.http.protocol.HttpContext in the Registry. Use the httpContext option instead.
|
httpContext
|
null
|
Camel 2.9.2: To use a custom org.apache.http.protocol.HttpContext when executing requests.
|
httpClient.XXX
|
null
|
Setting options on the BasicHttpParams. For instance
httpClient.soTimeout=5000 will set the SO_TIMEOUT to 5 seconds. Look on the setter methods of the following parameter beans for a complete reference: AuthParamBean, ClientParamBean, ConnConnectionParamBean, ConnRouteParamBean, CookieSpecParamBean, HttpConnectionParamBean and HttpProtocolParamBean
Since Camel 2.13.0:
httpClient is changed to configure the HttpClientBuilder and RequestConfig.Builder, please check out API document for a complete reference.
|
clientConnectionManager
|
null
|
To use a custom org.apache.http.conn.ClientConnectionManager .
|
transferException
|
false
|
If enabled and an Exchange failed processing on the consumer side, and if the caused Exception was send back serialized in the response as a application/x-java-serialized-object content type (for example using Jetty or SERVLET Camel components). On the producer side the exception will be deserialized and thrown as is, instead of the HttpOperationFailedException . The caused exception is required to be serialized.
|
sslContextParametersRef
|
null
|
Deprecated and will be removed in Camel 3.0:Camel 2.8: Reference to a org.apache.camel.util.jsse.SSLContextParameters in the Registry. Important: Only one instance of org.apache.camel.util.jsse.SSLContextParameters is supported per HttpComponent. If you need to use 2 or more different instances, you need to define a new HttpComponent per instance you need. See further below for more details. See Using the JSSE Configuration Utility. Use the sslContextParameters option instead.
|
sslContextParameters
|
null
|
Camel 2.11.1: Reference to a org.apache.camel.util.jsse.SSLContextParameters in the Registry. Important: Only one instance of org.apache.camel.util.jsse.SSLContextParameters is supported per HttpComponent. If you need to use 2 or more different instances, you need to define a new HttpComponent per instance you need. See further below for more details. See Using the JSSE Configuration Utility.
|
x509HostnameVerifier
|
BrowserCompatHostnameVerifier
|
Camel 2.7: You can refer to a different org.apache.http.conn.ssl.X509HostnameVerifier instance in the Registry such as org.apache.http.conn.ssl.StrictHostnameVerifier or org.apache.http.conn.ssl.AllowAllHostnameVerifier .
|
urlRewrite
|
null
|
Camel 2.11:Producer only Refers to a custom org.apache.camel.component.http4.UrlRewrite which allows you to rewrite urls when you bridge/proxy endpoints. See more details at UrlRewrite and How to use Camel as a HTTP proxy between a client and server.
|
maxTotalConnections
|
null
|
Camel 2.14: The maximum number of total connections that the connection manager has. If this option is not set, camel will use the component's setting instead.
|
connectionsPerRoute
|
null
|
Camel 2.14: The maximum number of connections per route. If this option is not set, camel will use the component's setting instead.
|
authenticationPreemptive
|
false
|
Camel 2.11.3/2.12.2: If this option is true, camel-http4 sends preemptive basic authentication to the server.
|
Setting Basic Authentication and Proxy
Name | Default Value | Description |
---|---|---|
username
|
null
|
Username for authentication. |
password
|
null
|
Password for authentication. |
domain
|
null
|
The domain name for authentication. |
host
|
null
|
The host name authentication. |
proxyHost
|
null
|
The proxy host name |
proxyPort
|
null
|
The proxy port number |
proxyUsername
|
null
|
Username for proxy authentication |
proxyPassword
|
null
|
Password for proxy authentication |
proxyDomain
|
null
|
The proxy domain name |
proxyNtHost
|
null
|
The proxy Nt host name |
Name | Default Value | Description |
authUsername
|
null
|
Username for authentication |
authPassword
|
null
|
Password for authentication |
authDomain
|
null
|
The domain name for authentication |
authHost
|
null
|
The host name authentication |
proxyAuthHost
|
null
|
The proxy host name |
proxyAuthPort
|
null
|
The proxy port number |
proxyAuthScheme
|
null
|
The proxy scheme, will fallback and use the scheme from the endpoint if not configured. |
proxyAuthUsername
|
null
|
Username for proxy authentication |
proxyAuthPassword
|
null
|
Password for proxy authentication |
proxyAuthDomain
|
null
|
The proxy domain name |
proxyAuthNtHost
|
null
|
The proxy Nt host name |
Message Headers
Name | Type | Description |
---|---|---|
Exchange.HTTP_URI
|
String
|
URI to call. Will override existing URI set directly on the endpoint. |
Exchange.HTTP_PATH
|
String
|
Request URI's path, the header will be used to build the request URI with the HTTP_URI. |
Exchange.HTTP_QUERY
|
String
|
URI parameters. Will override existing URI parameters set directly on the endpoint. |
Exchange.HTTP_RESPONSE_CODE
|
int
|
The HTTP response code from the external server. Is 200 for OK. |
Exchange.HTTP_CHARACTER_ENCODING
|
String
|
Character encoding. |
Exchange.CONTENT_TYPE
|
String
|
The HTTP content type. Is set on both the IN and OUT message to provide a content type, such as text/html .
|
Exchange.CONTENT_ENCODING
|
String
|
The HTTP content encoding. Is set on both the IN and OUT message to provide a content encoding, such as gzip .
|
Message Body
Response code
- Response code is in the range 100..299, Camel regards it as a success response.
- Response code is in the range 300..399, Camel regards it as a redirection response and will throw a
HttpOperationFailedException
with the information. - Response code is 400+, Camel regards it as an external server failure and will throw a
HttpOperationFailedException
with the information.throwExceptionOnFailureThe option,throwExceptionOnFailure
, can be set tofalse
to prevent theHttpOperationFailedException
from being thrown for failed response codes. This allows you to get any response from the remote server. There is a sample below demonstrating this.
HttpOperationFailedException
- The HTTP status code
- The HTTP status line (text of the status code)
- Redirect location, if server returned a redirect
- Response body as a
java.lang.String
, if server provided a body as response
Calling using GET or POST
GET
or POST
HTTP method should be used: 1. Use method provided in header. 2. GET
if query string is provided in header. 3. GET
if endpoint is configured with a query string. 4. POST
if there is data to send (body is not null). 5. GET
otherwise.
How to get access to HttpServletRequest and HttpServletResponse
HttpServletRequest request = exchange.getIn().getBody(HttpServletRequest.class); HttpServletRequest response = exchange.getIn().getBody(HttpServletResponse.class);
Configuring URI to call
oldhost
, using HTTP.
from("direct:start") .to("http4://oldhost");
<camelContext xmlns="http://activemq.apache.org/camel/schema/spring"> <route> <from uri="direct:start"/> <to uri="http4://oldhost"/> </route> </camelContext>
Exchange.HTTP_URI
, on the message.
from("direct:start") .setHeader(Exchange.HTTP_URI, constant("http://newhost")) .to("http4://oldhost");
Exchange.HTTP_URI
.
Configuring URI Parameters
Exchange.HTTP_QUERY
on the message.
from("direct:start") .to("http4://oldhost?order=123&detail=short");
from("direct:start") .setHeader(Exchange.HTTP_QUERY, constant("order=123&detail=short")) .to("http4://oldhost");
How to set the http method (GET/POST/PUT/DELETE/HEAD/OPTIONS/TRACE) to the HTTP producer
from("direct:start") .setHeader(Exchange.HTTP_METHOD, constant(org.apache.camel.component.http4.HttpMethods.POST)) .to("http4://www.google.com") .to("mock:results");
.setHeader("CamelHttpMethod", constant("POST"))
<camelContext xmlns="http://activemq.apache.org/camel/schema/spring"> <route> <from uri="direct:start"/> <setHeader headerName="CamelHttpMethod"> <constant>POST</constant> </setHeader> <to uri="http4://www.google.com"/> <to uri="mock:results"/> </route> </camelContext>
Using client timeout - SO_TIMEOUT
Configuring a Proxy
from("direct:start") .to("http4://oldhost?proxyAuthHost=www.myproxy.com&proxyAuthPort=80");
proxyAuthUsername
and proxyAuthPassword
options.
Using proxy settings outside of URI
context.getProperties().put("http.proxyHost", "172.168.18.9"); context.getProperties().put("http.proxyPort" "8080");
<camelContext> <properties> <property key="http.proxyHost" value="172.168.18.9"/> <property key="http.proxyPort" value="8080"/> </properties> </camelContext>
http.proxyScheme
property you can set to explicit configure the scheme to use.
Configuring charset
POST
to send data you can configure the charset
using the Exchange
property:
exchange.setProperty(Exchange.CHARSET_NAME, "ISO-8859-1");
Sample with scheduled poll
message.html
:
from("timer://foo?fixedRate=true&delay=0&period=10000") .to("http4://www.google.com") .setHeader(FileComponent.HEADER_FILE_NAME, "message.html") .to("file:target/google");
URI Parameters from the endpoint URI
&
character as separator, just as you would in the web browser. Camel does no tricks here.
// we query for Camel at the Google page template.sendBody("http4://www.google.com/search?q=Camel", null);
URI Parameters from the Message
Map headers = new HashMap(); headers.put(Exchange.HTTP_QUERY, "q=Camel&lr=lang_en"); // we query for Camel and English language at Google template.sendBody("http4://www.google.com/search", null, headers);
?
and you can separate parameters as usual with the &
char.
Getting the Response Code
Exchange.HTTP_RESPONSE_CODE
.
Exchange exchange = template.send("http4://www.google.com/search", new Processor() { public void process(Exchange exchange) throws Exception { exchange.getIn().setHeader(Exchange.HTTP_QUERY, constant("hl=en&q=activemq")); } }); Message out = exchange.getOut(); int responseCode = out.getHeader(Exchange.HTTP_RESPONSE_CODE, Integer.class);
Disabling Cookies
httpClient.cookiePolicy=ignoreCookies
Advanced Usage
HttpComponent
where you can set various classes to give you custom behavior.
Using the JSSE Configuration Utility
Programmatic configuration of the component
KeyStoreParameters ksp = new KeyStoreParameters(); ksp.setResource("/users/home/server/keystore.jks"); ksp.setPassword("keystorePassword"); KeyManagersParameters kmp = new KeyManagersParameters(); kmp.setKeyStore(ksp); kmp.setKeyPassword("keyPassword"); SSLContextParameters scp = new SSLContextParameters(); scp.setKeyManagers(kmp); HttpComponent httpComponent = getContext().getComponent("https4", HttpComponent.class); httpComponent.setSslContextParameters(scp);
Spring DSL based configuration of endpoint
... <camel:sslContextParameters id="sslContextParameters"> <camel:keyManagers keyPassword="keyPassword"> <camel:keyStore resource="/users/home/server/keystore.jks" password="keystorePassword"/> </camel:keyManagers> </camel:sslContextParameters>... ... <to uri="https4://127.0.0.1/mail/?sslContextParametersRef=sslContextParameters"/>...
Configuring Apache HTTP Client Directly
org.apache.camel.component.http4.HttpsServerTestSupport
unit test base class. You can also implement a custom org.apache.camel.component.http4.HttpClientConfigurer
to do some configuration on the http client if you need full control of it.
HttpClientConfigurer
, for example:
KeyStore keystore = ...; KeyStore truststore = ...; SchemeRegistry registry = new SchemeRegistry(); registry.register(new Scheme("https", 443, new SSLSocketFactory(keystore, "mypassword", truststore)));
HttpClientConfigurer
, and registers https protocol providing a keystore or truststore per example above. Then, from your camel route builder class you can hook it up like so:
HttpComponent httpComponent = getContext().getComponent("http4", HttpComponent.class); httpComponent.setHttpClientConfigurer(new MyHttpClientConfigurer());
HttpClientConfigurer
using the URI. For example:
<bean id="myHttpClientConfigurer" class="my.https.HttpClientConfigurer"> </bean> <to uri="https4://myhostname.com:443/myURL?httpClientConfigurer=myHttpClientConfigurer"/>
Using HTTPS to authenticate gotchas
org.apache.http.protocol.HttpContext
:
public class HttpContextFactory { private String httpHost = "localhost"; private String httpPort = 9001; private BasicHttpContext httpContext = new BasicHttpContext(); private BasicAuthCache authCache = new BasicAuthCache(); private BasicScheme basicAuth = new BasicScheme(); public HttpContext getObject() { authCache.put(new HttpHost(httpHost, httpPort), basicAuth); httpContext.setAttribute(ClientContext.AUTH_CACHE, authCache); return httpContext; } // getter and setter }
<bean id="myHttpContext" factory-bean="httpContextFactory" factory-method="getObject"/>
<to uri="https4://myhostname.com:443/myURL?httpContext=myHttpContext"/>
Using different SSLContextParameters
org.apache.camel.util.jsse.SSLContextParameters
per component. If you need to use 2 or more different instances, then you need to setup multiple HTTP4 components as shown below. Where we have 2 components, each using their own instance of sslContextParameters
property.
<bean id="http4-foo" class="org.apache.camel.component.http4.HttpComponent"> <property name="sslContextParameters" ref="sslContextParams1"/> <property name="x509HostnameVerifier" ref="hostnameVerifier"/> </bean> <bean id="http4-bar" class="org.apache.camel.component.http4.HttpComponent"> <property name="sslContextParameters" ref="sslContextParams2"/> <property name="x509HostnameVerifier" ref="hostnameVerifier"/> </bean>
Chapter 64. iBATIS
iBATIS
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-ibatis</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
ibatis:statementName[?options]
?option=value&option=value&...
SqlMapConfig.xml
. It uses Spring resource loading so you can define it using classpath
, file
or http
as prefix to load resources with those schemes. In Camel 2.2 you can configure this on the iBatisComponent with the setSqlMapConfig(String)
method.
Options
Option | Type | Default | Description |
---|---|---|---|
consumer.onConsume
|
String
|
null
|
Statements to run after consuming. Can be used, for example, to update rows after they have been consumed and processed in Apache Camel. See sample later. Multiple statements can be separated with comma. |
consumer.useIterator
|
boolean
|
true
|
If true each row returned when polling will be processed individually. If false the entire List of data is set as the IN body.
|
consumer.routeEmptyResultSet
|
boolean
|
false
|
Apache Camel 2.0: Sets whether empty result set should be routed or not. By default, empty result sets are not routed. |
statementType
|
StatementType
|
null
|
Apache Camel 1.6.1/2.0: Mandatory to specify for IbatisProducer to control which iBatis SqlMapClient method to invoke. The enum values are: QueryForObject , QueryForList , Insert , Update , Delete .
|
maxMessagesPerPoll
|
int
|
0
|
Apache Camel 2.0: An integer to define a maximum messages to gather per poll. By default, no maximum is set. Can be used to set a limit of e.g. 1000 to avoid when starting up the server that there are thousands of files. Set a value of 0 or negative to disabled it. |
isolation
|
String
|
TRANSACTION_REPEATABLE_READ
|
*Camel 2.9:* A String the defines the transaction isolation level of the will be used. Allowed values are TRANSACTION_NONE, TRANSACTION_READ_UNCOMMITTED, TRANSACTION_READ_COMMITTED, TRANSACTION_REPEATABLE_READ, TRANSACTION_SERIALIZABLE |
isolation
|
String
|
TRANSACTION_REPEATABLE_READ
|
*Camel 2.9:* A String the defines the transaction isolation level of the will be used. Allowed values are TRANSACTION_NONE, TRANSACTION_READ_UNCOMMITTED, TRANSACTION_READ_COMMITTED, TRANSACTION_REPEATABLE_READ, TRANSACTION_SERIALIZABLE |
Message Headers
Header | Type | Description |
---|---|---|
CamelIBatisStatementName
|
String
|
Apache Camel 2.0: The statementName used (for example: insertAccount). |
CamelIBatisResult
|
Object
|
Apache Camel 1.6.2/2.0: The response returned from iBatis in any of the operations. For instance an INSERT could return the auto-generated key, or number of rows etc.
|
Message Body
SELECT
statement. That means, for example, for INSERT
statements Apache Camel will not replace the body. This allows you to continue routing and keep the original body. The response from iBatis is always stored in the header with the key CamelIBatisResult
.
Samples
from("activemq:queue:newAccount"). to("ibatis:insertAccount?statementType=Insert");
statementType
, as we need to instruct Apache Camel which SqlMapClient
operation to invoke.
<!-- Insert example, using the Account parameter class --> <insert id="insertAccount" parameterClass="Account"> insert into ACCOUNT ( ACC_ID, ACC_FIRST_NAME, ACC_LAST_NAME, ACC_EMAIL ) values ( #id#, #firstName#, #lastName#, #emailAddress# ) </insert>
Using StatementType for better control of IBatis
SELEECT
, UPDATE
, DELETE
or INSERT
etc. This is now possible in Apache Camel 1.6.1/2.0. So for instance if we want to route to an iBatis endpoint in which the IN body contains parameters to a SELECT
statement we can do:
from("direct:start") .to("ibatis:selectAccountById?statementType=QueryForObject") .to("mock:result");
selectAccountById
and the IN body should contain the account id we want to retrieve, such as an Integer
type.
QueryForList
:
from("direct:start") .to("ibatis:selectAllAccounts?statementType=QueryForList") .to("mock:result");
UPDATE
, where we can send an Account
object as IN body to iBatis:
from("direct:start") .to("ibatis:updateAccount?statementType=Update") .to("mock:result");
Scheduled polling example
from("timer://pollTheDatabase?delay=30000").to("ibatis:selectAllAccounts?statementType=QueryForList").to("activemq:queue:allAccounts");
<!-- Select with no parameters using the result map for Account class. --> <select id="selectAllAccounts" resultMap="AccountResult"> select * from ACCOUNT </select>
Using onConsume
UPDATE
statements. Apache Camel supports executing multiple statements whose name should be separated by comma.
from("ibatis:selectUnprocessedAccounts?consumer.onConsume=consumeAccount").to("mock:results");
<select id="selectUnprocessedAccounts" resultMap="AccountResult"> select * from ACCOUNT where PROCESSED = false </select>
<update id="consumeAccount" parameterClass="Account"> update ACCOUNT set PROCESSED = true where ACC_ID = #id# </update>
Chapter 65. IRC
IRC Component
URI format
irc:nick@host[:port]/#room[?options]
irc:nick@host[:port]?channels=#channel1,#channel2,#channel3[?options]
?option=value&option=value&...
Options
Name | Description | Example | Default Value |
---|---|---|---|
channels
|
New in 2.0, comma separated list of IRC channels to join. |
channels=#channel1,#channel2
|
null
|
nickname
|
The nickname used in chat. |
irc:MyNick@irc.server.org#channel or irc:irc.server.org#channel?nickname=MyUser
|
null
|
username
|
The IRC server user name. |
irc:MyUser@irc.server.org#channel or irc:irc.server.org#channel?username=MyUser
|
Same as nickname. |
password
|
The IRC server password. |
password=somepass
|
None |
realname
|
The IRC user's actual name. |
realname=MyName
|
None |
colors
|
Whether or not the server supports color codes. |
true, false
|
true
|
onReply
|
Whether or not to handle general responses to commands or informational messages. |
true, false
|
false
|
onNick
|
Handle nickname change events. |
true, false
|
true
|
onQuit
|
Handle user quit events. |
true, false
|
true
|
onJoin
|
Handle user join events. |
true, false
|
true
|
onKick
|
Handle kick events. |
true, false
|
true
|
onMode
|
Handle mode change events. |
true, false
|
true
|
onPart
|
Handle user part events. |
true, false
|
true
|
onTopic
|
Handle topic change events. |
true, false
|
true
|
onPrivmsg
|
Handle message events. |
true, false
|
true
|
trustManager
|
New in 2.0, the trust manager used to verify the SSL server's certificate. |
trustManager=#referenceToTrustManagerBean
|
The default trust manager, which accepts all certificates, will be used. |
keys
|
Camel 2.2: Comma separated list of IRC channel keys. Important to be listed in same order as channels. When joining multiple channels with only some needing keys just insert an empty value for that channel. |
irc:MyNick@irc.server.org/#channel?keys=chankey
|
null
|
sslContextParameters |
*Camel 2.9:* Reference to a org.apache.camel.util.jsse.SSLContextParameters in the Registry. This reference overrides any configured SSLContextParameters at the component level. See Using the JSSE Configuration Utility. Note that this setting overrides the trustManager option.
|
\#mySslContextParameters |
null
|
Using the JSSE Configuration Utility
Programmatic configuration of the endpoint
KeyStoreParameters ksp = new KeyStoreParameters(); ksp.setResource("/users/home/server/truststore.jks"); ksp.setPassword("keystorePassword"); TrustManagersParameters tmp = new TrustManagersParameters(); tmp.setKeyStore(ksp); SSLContextParameters scp = new SSLContextParameters(); scp.setTrustManagers(tmp); Registry registry = ... registry.bind("sslContextParameters", scp); ... from(...) .to("ircs://camel-prd-user@server:6669/#camel-test?nickname=camel-prd&password=password&sslContextParameters=#sslContextParameters");
Spring DSL based configuration of endpoint
... <camel:sslContextParameters id="sslContextParameters"> <camel:trustManagers> <camel:keyStore resource="/users/home/server/truststore.jks" password="keystorePassword"/> </camel:keyManagers> </camel:sslContextParameters>... ... <to uri="ircs://camel-prd-user@server:6669/#camel-test?nickname=camel-prd&password=password&sslContextParameters=#sslContextParameters"/>...
Using the legacy basic configuration options
ircs:host[:port]/#room?username=user&password=pass
trustManager
parameter as follows:
ircs:host[:port]/#room?username=user&password=pass&trustManager=#referenceToMyTrustManagerBean
Using keys
irc:nick@irc.server.org?channels=#chan1,#chan2,#chan3&keys=chan1Key,,chan3key
Chapter 66. Jasypt
Jasypt component
camel-jasypt
on the classpath those encrypted values will automatic be decrypted on-the-fly by Camel. This ensures that human eyes can't easily spot sensitive information such as usernames and passwords.
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-jasypt</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
Tooling
Apache Camel Jasypt takes the following options -h or -help = Displays the help screen -c or -command <command> = Command either encrypt or decrypt -p or -password <password> = Password to use -i or -input <input> = Text to encrypt or decrypt -a or -algorithm <algorithm> = Optional algorithm to use
tiger
you run with the following parameters. In the apache camel kit, you cd into the lib folder and run the following java cmd, where <CAMEL_HOME>
is where you have downloaded and extract the Camel distribution.
$ cd <CAMEL_HOME>/lib $ java -jar camel-jasypt-2.5.0.jar -c encrypt -p secret -i tiger
Encrypted text: qaEEacuW7BUti8LcMgyjKw==
qaEEacuW7BUti8LcMgyjKw==
can be decrypted back to tiger
if you know the master password which was secret
. If you run the tool again then the encrypted value will return a different result. But decrypting the value will always return the correct original value.
$ cd <CAMEL_HOME>/lib $ java -jar camel-jasypt-2.5.0.jar -c decrypt -p secret -i qaEEacuW7BUti8LcMgyjKw==
Decrypted text: tiger
ENC(value here)
# refer to a mock endpoint name by that encrypted password cool.result=mock:{{cool.password}} # here is a password which is encrypted cool.password=ENC(bsW9uV37gQ0QHFu7KO03Ww==)
Tooling dependencies for Camel 2.5 and 2.6
MANIFEST.MF
file of camel-jasypt
with optional/
as prefix. Hence why the java cmd above can pickup the needed JARs from the Apache Distribution in the optional
directory.
jasypt-1.6.jar commons-lang-2.4.jar commons-codec-1.4.jar icu4j-4.0.1.jar
icu4j-4.0.1.jar
is only needed when running on JDK 1.5.
lib/optional
directory of the Camel distribution. You can download it from Apache Central Maven repo.
Tooling dependencies for Camel 2.7 or better
URI Options
Name | Default Value | Type | Description |
---|---|---|---|
password
|
null
|
String
|
Specifies the master password to use for decrypting. This option is mandatory. See below for more details. |
algorithm
|
null
|
String
|
Name of an optional algorithm to use. |
Protecting the master password
password
option supports prefixes which dictates this. sysenv:
means to lookup the OS system environment with the given key. sys:
means to lookup a JVM system property.
$ export CAMEL_ENCRYPTION_PASSWORD=secret
$ unset CAMEL_ENCRYPTION_PASSWORD
password
option is then a matter of defining as follows: password=sysenv:CAMEL_ENCRYPTION_PASSWORD
.
Example with Java DSL
JasyptPropertiesParser
instance and set it on the Properties component as show below:
// create the jasypt properties parser JasyptPropertiesParser jasypt = new JasyptPropertiesParser(); // and set the master password jasypt.setPassword("secret"); // create the properties component PropertiesComponent pc = new PropertiesComponent(); pc.setLocation("classpath:org/apache/camel/component/jasypt/myproperties.properties"); // and use the jasypt properties parser so we can decrypt values pc.setPropertiesParser(jasypt); // add properties component to camel context context.addComponent("properties", pc);
myproperties.properties
then contain the encrypted value, such as shown below. Notice how the password value is encrypted and the value has the tokens surrounding ENC(value here)
# refer to a mock endpoint name by that encrypted password cool.result=mock:{{cool.password}} # here is a password which is encrypted cool.password=ENC(bsW9uV37gQ0QHFu7KO03Ww==)
Example with Spring XML
JasyptPropertiesParser
which is shown below. Then the Camel Properties component is told to use jasypt
as the properties parser, which means Jasypt have its chance to decrypt values looked up in the properties.
<!-- define the jasypt properties parser with the given password to be used --> <bean id="jasypt" class="org.apache.camel.component.jasypt.JasyptPropertiesParser"> <property name="password" value="secret"/> </bean> <!-- define the camel properties component --> <bean id="properties" class="org.apache.camel.component.properties.PropertiesComponent"> <!-- the properties file is in the classpath --> <property name="location" value="classpath:org/apache/camel/component/jasypt/myproperties.properties"/> <!-- and let it leverage the jasypt parser --> <property name="propertiesParser" ref="jasypt"/> </bean>
<camelContext>
tag which is shown below. Notice how we use the propertiesParserRef
attribute to refer to Jasypt.
<!-- define the jasypt properties parser with the given password to be used --> <bean id="jasypt" class="org.apache.camel.component.jasypt.JasyptPropertiesParser"> <!-- password is mandatory, you can prefix it with sysenv: or sys: to indicate it should use an OS environment or JVM system property value, so you dont have the master password defined here --> <property name="password" value="secret"/> </bean> <camelContext xmlns="http://camel.apache.org/schema/spring"> <!-- define the camel properties placeholder, and let it leverage jasypt --> <propertyPlaceholder id="properties" location="classpath:org/apache/camel/component/jasypt/myproperties.properties" propertiesParserRef="jasypt"/> <route> <from uri="direct:start"/> <to uri="{{cool.result}}"/> </route> </camelContext>
See Also
- Encrypted passwords in ActiveMQ - ActiveMQ has a similar feature as this
camel-jasypt
component
Chapter 67. jclouds
Jclouds Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-jclouds</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
Configuring the component
<bean id="jclouds" class="org.apache.camel.component.jclouds.JcloudsComponent"> <property name="computeServices"> <list> <ref bean="computeService"/> </list> </property> <property name="blobStores"> <list> <ref bean="blobStore"/> </list> </property> </bean> <!-- Creating a blobstore from spring / blueprint xml --> <bean id="blobStoreContextFactory" class="org.jclouds.blobstore.BlobStoreContextFactory"/> <bean id="blobStoreContext" factory-bean="blobStoreContextFactory" factory-method="createContext"> <constructor-arg name="provider" value="PROVIDER_NAME"/> <constructor-arg name="identity" value="IDENTITY"/> <constructor-arg name="credential" value="CREDENTIAL"/> </bean> <bean id="blobStore" factory-bean="blobStoreContext" factory-method="getBlobStore"/> <!-- Creating a compute service from spring / blueprint xml --> <bean id="computeServiceContextFactory" class="org.jclouds.compute.ComputeServiceContextFactory"/> <bean id="computeServiceContext" factory-bean="computeServiceContextFactory" factory-method="createContext"> <constructor-arg name="provider" value="PROVIDER_NAME"/> <constructor-arg name="identity" value="IDENTITY"/> <constructor-arg name="credential" value="CREDENTIAL"/> </bean> <bean id="computeService" factory-bean="computeServiceContext" factory-method="getComputeService"/>
URI format
jclouds:blobstore:[provider id][?options] jclouds:compute:[provider id][?options]
?option=value&option=value&...
Blobstore URI Options
Name | Default Value | Description |
---|---|---|
operation
|
PUT | *Producer Only*. Specifies the type of operation that will be performed to the blobstore. Allowed values are PUT, GET. |
container
|
null | The name of the blob container. |
blobName
|
null | The name of the blob. |
jclouds:blobstore:aws-s3?operation=CamelJcloudsGet&container=mycontainer&blobName=someblob
Message Headers for blobstore
Header | Description |
---|---|
CamelJcloudsOperation
|
The operation to be performed on the blob. The valid options are
|
CamelJcloudsContainer
|
The name of the blob container. |
CamelJcloudsBlobName
|
The name of the blob. |
Blobstore Usage Samples
Example 1: Putting to the blob
from("direct:start") .to("jclouds:blobstore:aws-s3" + "?operation=PUT" + "&container=mycontainer" + "&blobName=myblob");
<route> <from uri="direct:start"/> <to uri="jclouds:blobstore:aws-s3?operation=PUT&container=mycontainer&blobName=myblob"/> </route>
Example 2: Getting/Reading from a blob
from("direct:start") .to("jclouds:blobstore:aws-s3" + "?operation=GET" + "&container=mycontainer" + "&blobName=myblob");
<route> <from uri="direct:start"/> <to uri="jclouds:blobstore:aws-s3?operation=PUT&container=mycontainer&blobName=myblob"/> </route>
Example 3: Consuming a blob
from("jclouds:blobstore:aws-s3" + "?container=mycontainer") .to("direct:next");
<route> <from uri="jclouds:blobstore:aws-s3?operation=GET&container=mycontainer&blobName=myblob"/> <to uri="direct:next"/> </route>
Compute Service URI Options
Name | Default Value | Description |
---|---|---|
operation
|
CamelJcloudsPut | Specifies the type of operation that will be performed to the compute service. Allowed values are CamelJcloudsCreateNode, CamelJcloudsRunScript, CamelJcloudsDestroyNode, CamelJcloudsListNodes, CamelJCloudsListImages, CamelJCloudsListHardware. |
imageId
|
null | *CamelJcloudsCreateNode operation only* The imageId that will be used for creating a node. Values depend on the actual cloud provider. |
locationId
|
null | *CamelJcloudsCreateNode operation only* The location that will be used for creating a node. Values depend on the actual cloud provider. |
hardwareId
|
null | *CamelJcloudsCreateNode operation only* The hardware that will be used for creating a node. Values depend on the actual cloud provider. |
group
|
null | *CamelJcloudsCreateNode operation only* The group that will be assigned to the newly created node. Values depend on the actual cloud provider. |
nodeId
|
null | *CamelJcloudsRunScript & CamelJcloudsDestroyNode operation only* The id of the node that will run the script or destroyed. |
user
|
null | *CamelJcloudsRunScript operation only* The user on the target node that will run the script. |
jclouds:compute:aws-ec2?operation=CamelJcloudsCreateNode&imageId=AMI_XXXXX&locationId=eu-west-1&group=mygroup
Compute Usage Samples
Example 1: Listing the available images.
from("jclouds:compute:aws-ec2" + "&operation=CamelJCloudsListImages") .to("direct:next");
<route> <from uri="jclouds:compute:aws-ec2?operation=CamelJCloudsListImages"/> <to uri="direct:next"/> </route>
Example 2: Create a new node.
from("direct:start"). to("jclouds:compute:aws-ec2" + "?operation=CamelJcloudsCreateNode" + "&imageId=AMI_XXXXX" + "&locationId=XXXXX" + "&group=myGroup");
<route> <from uri="direct:start"/> <to uri="jclouds:compute:aws-ec2?operation=CamelJcloudsCreateNode&imageId=AMI_XXXXX&locationId=XXXXX&group=myGroup"/> </route>
Example 3: Run a shell script on running node.
from("direct:start"). to("jclouds:compute:aws-ec2" + "?operation=CamelJcloudsRunScript" + "?nodeId=10" + "&user=ubuntu");
nodeId
. The nodeId can be retrieved either upon the creation of the node, it will be part of the resulting metadata or by a executing a CamelJcloudsListNodes
operation.
<route> <from uri="direct:start"/> <to uri="jclouds:compute:aws-ec2?operation=CamelJcloudsRunScript&?nodeId=10&user=ubuntu"/> </route>
See also
Chapter 68. JCR
JCR Component
jcr
component allows you to add/read nodes to/from a JCR compliant content repository (for example, Apache Jackrabbit) with its producer, or register an EventListener
with the consumer.
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-jcr</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
jcr://user:password@repository/path/to/node
Usage
repository
element of the URI is used to look up the JCR Repository
object in the Camel context registry.
Producer
Name | Default Value | Description |
---|---|---|
CamelJcrOperation
|
CamelJcrInsert
|
CamelJcrInsert or CamelJcrGetById operation to use |
CamelJcrNodeName
|
null
|
Used to determine the node name to use. |
- If the operation is CamelJcrInsert: A new node is created in the content repository, all the message headers of the IN message are transformed to
javax.jcr.Value
instances and added to the new node and the node's UUID is returned in the OUT message. - If the operation is
CamelJcrGetById
: A new node is retrieved from the repository using the message body as node identifier.
Consumer
List<javax.jcr.observation.Event>
in the message body.
Name | Default Value | Description |
---|---|---|
eventTypes
|
0
|
A combination of one or more event types encoded as a bit mask value such as javax.jcr.observation.Event.NODE_ADDED, javax.jcr.observation.Event.NODE_REMOVED, etc. |
deep
|
false
|
When it is true, events whose associated parent node is at current path or within its subgraph are received. |
uuids
|
null
|
Only events whose associated parent node has one of the identifiers in the comma separated uuid list will be received. |
nodeTypeNames
|
null
|
Only events whose associated parent node has one of the node types (or a subtype of one of the node types) in this list will be received. |
noLocal
|
false
|
If noLocal is true , then events generated by the session through which the listener was registered are ignored. Otherwise, they are not ignored.
|
sessionLiveCheckInterval
|
60000
|
Interval in milliseconds to wait before each session live checking. |
sessionLiveCheckIntervalOnStart
|
3000
|
Interval in milliseconds to wait before the first session live checking. |
username
|
Camel 2.15: Allows to specify the username as a uri parameter instead of in the authority section of the uri | |
password
|
Camel 2.15: Allows to specify the password as a uri parameter instead of in the authority section of the uri |
Example
node
under the /home/test
node in the content repository. One additional property is added to the node as well: my.contents.property
which will contain the body of the message being sent.
from("direct:a").setHeader(JcrConstants.JCR_NODE_NAME, constant("node")) .setHeader("my.contents.property", body()) .to("jcr://user:pass@repository/home/test");
<route> <from uri="jcr://user:pass@repository/import-application/inbox?eventTypes=3&deep=true" /> <to uri="direct:execute-import-application" /> </route>
Chapter 69. JDBC
JDBC Component
SELECT
) and operations (INSERT
, UPDATE
, and so on) are sent in the message body. This component uses the standard JDBC API, unlike the SQL Component component, which uses spring-jdbc.
from()
statement.
URI format
jdbc:dataSourceName[?options]
?option=value&option=value&...
Options
Name | Default Value | Description |
---|---|---|
readSize
|
0
|
The default maximum number of rows that can be read by a polling query. |
statement.<xxx>
|
null
|
Apache Camel 2.1: Sets additional options on the java.sql.Statement that is used behind the scenes to execute the queries. For instance, statement.maxRows=10 . For detailed documentation, see the java.sql.Statement javadoc documentation.
|
useJDBC4ColumnNameAndLabelSemantics
|
true
|
Sets whether to use JDBC 4/3 column label/name semantics. You can use this option to turn it false in case you have issues with your JDBC driver to select data. This only applies when using SQL SELECT using aliases (e.g. SQL SELECT id as identifier, name as given_name from persons ).
|
resetAutoCommit
|
true
|
Camel 2.9: Camel will set the autoCommit on the JDBC connection to be false, commit the change after executed the statement and reset the autoCommit flag of the connection at the end, if the resetAutoCommit is true. If the JDBC connection doesn't support to reset the autoCommit flag, you can set the resetAutoCommit flag to be false, and Camel will not try to reset the autoCommit flag. When used with XA transactions you most likely need to set it to false so that the transaction manager is in charge of committing this tx.
|
allowNamedParameters
|
true
|
Camel 2.12: Whether to allow using named parameters in the queries. |
prepareStatementStrategy
|
Camel 2.12: Allows to plugin to use a custom org.apache.camel.component.jdbc.JdbcPrepareStatementStrategy to control preparation of the query and prepared statement.
|
|
useHeadersAsParameters
|
false
|
Camel 2.12: Set this option to true to use the prepareStatementStrategy with named parameters. This allows to define queries with named placeholders, and use headers with the dynamic values for the query placeholders.
|
outputType
|
SelectList
|
Camel 2.12.1: Make the output of the producer to SelectList as List of Map, or SelectOne as single Java object in the following way: a) If the query has only single column, then that JDBC Column object is returned. (such as SELECT COUNT( * ) FROM PROJECT will return a Long object. b) If the query has more than one column, then it will return a Map of that result. c) If the outputClass is set, then it will convert the query result into an Java bean object by calling all the setters that match the column names. It will assume your class has a default constructor to create instance with. From Camel 2.14 onwards,
SelectList is also supported. d) If the query resulted in more than one rows, it throws an non-unique result exception.
Camel 2.14.0: New
StreamList output type value that streams the result of the query using an Iterator<Map<String, Object>> , it can be used along with the Splitter EIP.
|
outputClass
|
null
|
Camel 2.12.1: Specify the full package and class name to use as conversion when outputType=SelectOne. From Camel 2.14 onwards then SelectList is also supported.
|
beanRowMapper
|
Camel 2.12.1: To use a custom org.apache.camel.component.jdbc.BeanRowMapper when using outputClass . The default implementation will lower case the row names and skip underscores, and dashes. For example "CUST_ID" is mapped as "custId" .
|
Result
ArrayList<HashMap<String, Object>>
. The List
object contains the list of rows and the Map
objects contain each row with the String
key as the column name.
ResultSetMetaData
to be able to return the column name as the key in the Map
.
Message Headers
Header | Description |
---|---|
CamelJdbcRowCount
|
If the query is a SELECT , the row count is returned in this OUT header.
|
CamelJdbcUpdateCount
|
If the query is an UPDATE , the update count is returned in this OUT header.
|
CamelGeneratedKeysRows
|
Camel 2.10: Rows that contains the generated kets. |
CamelGeneratedKeysRowCount
|
Camel 2.10: The number of rows in the header that contains generated keys. |
CamelJdbcColumnNames
|
Camel 2.11.1: The column names from the ResultSet as a java.util.Set type.
|
CamelJdbcParametes
|
Camel 2.12: A java.util.Map which has the headers to be used if useHeadersAsParameters has been enabled.
|
Generated keys
CamelRetrieveGeneratedKeys=true
. Then the generated keys will be provided as headers with the keys listed in the table above.
Using named parameters
from("direct:projects") .setHeader("lic", constant("ASF")) .setHeader("min", constant(123)) .setBody("select * from projects where license = :?lic and id > :?min order by id") .to("jdbc:myDataSource?useHeadersAsParameters=true")
java.util.Map
and store the map on the headers with the key CamelJdbcParameters
.
Samples
testdb
:
JndiRegistry reg = super.createRegistry(); reg.bind("testdb", db); return reg;
testdb
datasource that was bound in the previous step:
// lets add simple route public void configure() throws Exception { from("direct:hello").to("jdbc:testdb?readSize=100"); }
DataSource
in Spring like this:
<camelContext id="camel" xmlns="http://camel.apache.org/schema/spring"> <route> <!-- trigger every second --> <from uri="timer://kickoff?period=1s"/> <setBody> <constant>select * from customer</constant> </setBody> <to uri="jdbc:testdb"/> <to uri="mock:result"/> </route> </camelContext> <!-- Just add a demo to show how to bind a date source for camel in Spring--> <jdbc:embedded-database id="testdb" type="DERBY"> <jdbc:script location="classpath:sql/init.sql"/> </jdbc:embedded-database>
// first we create our exchange using the endpoint Endpoint endpoint = context.getEndpoint("direct:hello"); Exchange exchange = endpoint.createExchange(); // then we set the SQL on the in body exchange.getIn().setBody("select * from customer order by ID"); // now we send the exchange to the endpoint, and receives the response from Camel Exchange out = template.send(endpoint, exchange); // assertions of the response assertNotNull(out); assertNotNull(out.getOut()); List<Map<String, Object>> data = out.getOut().getBody(List.class); assertNotNull(data); assertEquals(3, data.size()); Map<String, Object> row = data.get(0); assertEquals("cust1", row.get("ID")); assertEquals("jstrachan", row.get("NAME")); row = data.get(1); assertEquals("cust2", row.get("ID")); assertEquals("nsandhu", row.get("NAME"));
from("direct:hello") // here we split the data from the testdb into new messages one by one // so the mock endpoint will receive a message per row in the table // the StreamList option allows to stream the result of the query without creating a List of rows // and notice we also enable streaming mode on the splitter .to("jdbc:testdb?outputType=StreamList") .split(body()).streaming() .to("mock:result");
Sample - Polling the database every minute
from("timer://foo?period=60000").setBody(constant("select * from customer")).to("jdbc:testdb").to("activemq:queue:customers");
Sample - Move Data Between Data Sources
from("timer://MoveNewCustomersEveryHour?period=3600000") .setBody(constant("select * from customer where create_time > (sysdate-1/24)")) .to("jdbc:testdb") .split(body()) .process(new MyCustomerProcessor()) //filter/transform results as needed .setBody(simple("insert into processed_customer values('${body[ID]}','${body[NAME]}')")) .to("jdbc:testdb");
See also
Chapter 70. Jetty
Jetty Component
Exchange.HTTP_RESPONSE_CODE
data multiple times (eg: doing multicasting, or redelivery error handling) you should use Stream Caching or convert the message body to a String
which is safe to be re-read multiple times.
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-jetty</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
jetty:http://hostname[:port][/resourceUri][?options]
?option=value&option=value&...
Options
Name | Default Value | Description |
---|---|---|
sessionSupport
|
false
|
Specifies whether to enable the session manager on the server side of Jetty. |
httpClient.XXX
|
null
|
Configuration of Jetty's HttpClient. For example, setting httpClient.idleTimeout=30000 sets the idle timeout to 30 seconds.
|
httpClient
|
null
|
To use a shared org.eclipse.jetty.client.HttpClient for all producers created by this endpoint. This option should only be used in special circumstances.
|
httpClientMinThreads
|
null
|
Camel 2.11:Producer only: To set a value for minimum number of threads in HttpClient thread pool. This setting override any setting configured on component level. Notice that both a min and max size must be configured. If not set it default to min 8 threads used in Jetty's thread pool.
|
httpClientMaxThreads
|
null
|
Camel 2.11:Producer only: To set a value for maximum number of threads in HttpClient thread pool. This setting override any setting configured on component level. Notice that both a min and max size must be configured. If not set it default to min 8 threads used in Jetty's thread pool.
|
httpBindingRef
|
null
|
Reference to an org.apache.camel.component.http.HttpBinding in the Registry. HttpBinding can be used to customize how a response should be written for the consumer.
|
jettyHttpBindingRef
|
null
|
Camel 2.6.0+: Reference to an org.apache.camel.component.jetty.JettyHttpBinding in the Registry. JettyHttpBinding can be used to customize how a response should be written for the producer.
|
matchOnUriPrefix
|
false
|
Whether or not the CamelServlet should try to find a target consumer by matching the URI prefix if no exact match is found. See here How do I let Jetty match wildcards.
|
handlers
|
null
|
Specifies a comma-delimited set of org.mortbay.jetty.Handler instances in your Registry (such as your Spring ApplicationContext ). These handlers are added to the Jetty servlet context (for example, to add security).
|
chunked
|
true
|
Camel 2.2: If this option is false Jetty servlet will disable the HTTP streaming and set the content-length header on the response |
enableJmx
|
false
|
Camel 2.3: If this option is true, Jetty JMX support will be enabled for this endpoint. See Jetty JMX support for more details. |
disableStreamCache
|
false
|
Camel 2.3: Determines whether or not the raw input stream from Jetty 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 Jetty input stream to support reading it multiple times to ensure it 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. DefaultHttpBinding 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. If you use Jetty to bridge/proxy an endpoint then consider enabling this option to improve performance, in case you do not need to read the message payload multiple times.
|
throwExceptionOnFailure
|
true
|
Option to disable throwing the HttpOperationFailedException in case of failed responses from the remote server. This allows you to get all responses regardles of the HTTP status code.
|
transferException
|
false
|
Camel 2.6: If enabled and an Exchange failed processing on the consumer side, and if the caused Exception was send back serialized in the response as a application/x-java-serialized-object content type. On the producer side the exception will be deserialized and thrown as is, instead of the HttpOperationFailedException . The caused exception is required to be serialized.
|
bridgeEndpoint
|
false
|
>Camel 2.1: If the option is true , HttpProducer will ignore the Exchange.HTTP_URI header, and use the endpoint's URI for request. You may also set the throwExceptionOnFailure to be false to let the HttpProducer send all the fault response back. Camel 2.3: If the option is true, HttpProducer and CamelServlet will skip the gzip processing if the content-encoding is "gzip". Also consider setting disableStreamCache to true to optimize when bridging.
|
enableMultipartFilter
|
true
|
Camel 2.5: Whether Jetty org.eclipse.jetty.servlets.MultiPartFilter is enabled or not. You should set this value to false when bridging endpoints, to ensure multipart requests is proxied/bridged as well.
|
multipartFilterRef
|
null
|
Camel 2.6: Allows using a custom multipart filter. Note: setting multipartFilterRef forces the value of enableMultipartFilter to true .
|
FiltersRef
|
null
|
Camel 2.9: Allows using a custom filters which is putted into a list and can be find in the Registry |
continuationTimeout
|
null
|
Camel 2.6: Allows to set a timeout in millis when using Jetty as consumer (server). By default Jetty uses 30000. You can use a value of <= 0 to never expire. If a timeout occurs then the request will be expired and Jetty will return back a http error 503 to the client. This option is only in use when using Jetty with the Asynchronous Routing Engine.
|
useContinuation
|
true
|
Camel 2.6: Whether or not to use Jetty continuations for the Jetty Server. |
sslContextParametersRef
|
null
|
Camel 2.8: Reference to a org.apache.camel.util.jsse.SSLContextParameters in the CAMEL:Registry. This reference overrides any configured SSLContextParameters at the component level. See Using the JSSE Configuration Utility.
|
traceEnabled
|
false
|
Specifies whether to enable HTTP TRACE for this Jetty consumer. By default TRACE is turned off. |
headerFilterStrategy
|
null
|
Camel 2.11: Reference to a instance of org.apache.camel.spi.HeaderFilterStrategy in the Registry. It will be used to apply the custom headerFilterStrategy on the new create HttpJettyEndpoint.
|
httpMethodRestrict
|
null
|
Camel 2.11: Consumer only: Used to only allow consuming if the
HttpMethod matches, such as GET /POST /PUT etc. From Camel 2.15 onwards multiple methods can be specified separated by comma.
|
urlRewrite
|
null
|
Camel 2.11:Producer only Refers to a custom org.apache.camel.component.http.UrlRewrite which allows you to rewrite urls when you bridge/proxy endpoints. See more details at UrlRewrite and How to use Camel as a HTTP proxy between a client and server.
|
responseBufferSize
|
null
|
Camel 2.12: To use a custom buffer size on the javax.servlet.ServletResponse .
|
proxyHost
|
null
|
Camel 2.11: Producer only The http proxy Host url which will be used by Jetty client.
|
proxyPort
|
null
|
Camel 2.11: Producer only The http proxy port which will be used by Jetty client.
|
sendServerVersion
|
true
|
Camel 2.13: if the option is true, jetty will send the server header with the jetty version information to the client which sends the request. NOTE please make sure there is no any other camel-jetty endpoint is share the same port, otherwise this option may not work as expected.
|
sendDateHeader
|
false
|
Camel 2.14: if the option is true, jetty server will send the date header to the client which sends the request. NOTE please make sure there is no any other camel-jetty endpoint is share the same port, otherwise this option may not work as expected.
|
enableCORS
|
false
|
Camel 2.15: if the option is
true , Jetty server will set up the CrossOriginFilter which supports the CORS out of box.
|
Message Headers
http://myserver/myserver?orderid=123
, the exchange will contain a header named orderid
with the value 123.
Usage
Component Options
JettyHttpComponent
provides the following options:
Name | Default Value | Description |
---|---|---|
enableJmx
|
false
|
Camel 2.3: If this option is true, Jetty JMX support will be enabled for this endpoint. See Jetty JMX support for more details. |
sslKeyPassword
|
null
|
Consumer only: The password for the keystore when using SSL. |
sslPassword
|
null
|
Consumer only: The password when using SSL. |
sslKeystore
|
null
|
Consumer only: The path to the keystore. |
minThreads
|
null
|
Camel 2.5 Consumer only: To set a value for minimum number of threads in server thread pool. |
maxThreads
|
null
|
Camel 2.5 Consumer only: To set a value for maximum number of threads in server thread pool. |
threadPool
|
null
|
Camel 2.5 Consumer only: To use a custom thread pool for the server. |
sslSocketConnectors
|
null
|
Camel 2.3 Consumer only: A map which contains per port number specific SSL connectors. See section SSL support for more details. |
socketConnectors
|
null
|
Camel 2.5 Consumer only: A map which contains per port number specific HTTP connectors. Uses the same principle as sslSocketConnectors and therefore see section SSL support for more details.
|
sslSocketConnectorProperties
|
null
|
Camel 2.5 Consumer only. A map which contains general SSL connector properties. See section SSL support for more details. |
socketConnectorProperties
|
null
|
Camel 2.5 Consumer only. A map which contains general HTTP connector properties. Uses the same principle as sslSocketConnectorProperties and therefore see section SSL support for more details.
|
httpClient
|
null
|
Deprecated:Producer only: To use a custom HttpClient with the jetty producer. This option is removed from Camel 2.11 onwards, instead you can set the option on the endpoint instead.
|
httpClientMinThreads
|
null
|
Producer only: To set a value for minimum number of threads in HttpClient thread pool. Notice that both a min and max size must be configured.
|
httpClientMaxThreads
|
null
|
Producer only: To set a value for maximum number of threads in HttpClient thread pool. Notice that both a min and max size must be configured.
|
httpClientThreadPool
|
null
|
Deprecated:Producer only: To use a custom thread pool for the client. This option is removed from Camel 2.11 onwards. |
sslContextParameters
|
null
|
Camel 2.8: To configure a custom SSL/TLS configuration options at the component level. See Using the JSSE Configuration Utility for more details. |
requestBufferSize
|
null
|
Camel 2.11.2: Allows to configure a custom value of the request buffer size on the Jetty connectors. |
requestHeaderSize
|
null
|
Camel 2.11.2: Allows to configure a custom value of the request header size on the Jetty connectors. |
responseBufferSize
|
null
|
Camel 2.11.2: Allows to configure a custom value of the response buffer size on the Jetty connectors. |
responseHeaderSize
|
null
|
Camel 2.11.2: Allows to configure a custom value of the response header size on the Jetty connectors. |
proxyHost
|
null
|
Camel 2.12.2/2.11.3 To use a http proxy.
|
proxyPort
|
null
|
Camel 2.12.2/2.11.3: To use a http proxy.
|
errorHandler
|
null
|
Camel 2.15: This option is used to set the ErrorHandler that Jetty server uses.
|
Producer Example
from("direct:start").to("jetty://http://www.google.com");
<route> <from uri="direct:start"/> <to uri="jetty://http://www.google.com"/> <route>
Consumer Example
http://localhost:8080/myapp/myservice
:
from("jetty:http://localhost:{{port}}/myapp/myservice").process(new MyBookService());
localhost
in a URL, Camel exposes the endpoint only on the local TCP/IP network interface, so it cannot be accessed from outside the machine it operates on.
0.0.0.0
address should be used.
MyBookService
class, which accesses the HTTP request contents and then returns a response. Note: The assert
call appears in this example, because the code is part of an unit test.
public class MyBookService implements Processor { public void process(Exchange exchange) throws Exception { // just get the body as a string String body = exchange.getIn().getBody(String.class); // we have access to the HttpServletRequest here and we can grab it if we need it HttpServletRequest req = exchange.getIn().getBody(HttpServletRequest.class); assertNotNull(req); // for unit testing assertEquals("bookid=123", body); // send a html response exchange.getOut().setBody("<html><body>Book 123 is Camel in Action</body></html>"); } }
one
, to the endpoint, mock:one
, and all others to mock:other
.
from("jetty:" + serverUri) .choice() .when().simple("${header.one}").to("mock:one") .otherwise() .to("mock:other");
http://serverUri?one=hello
, the Jetty component will copy the HTTP request parameter, one
to the exchange's in.header
. We can then use the simple
language to route exchanges that contain this header to a specific endpoint and all others to another. If we used a language more powerful than Simple\-\--such as- El or OGNL\--we could also test for the parameter value and do routing based on the header value as well.
Session Support
sessionSupport
, can be used to enable a HttpSession
object and access the session object while processing the exchange. For example, the following route enables sessions:
<route> <from uri="jetty:http://0.0.0.0/myapp/myservice/?sessionSupport=true"/> <processRef ref="myCode"/> <route>
<bean id="myCode"class="com.mycompany.MyCodeProcessor"/>
HttpSession
as follows:
public void process(Exchange exchange) throws Exception { HttpSession session = exchange.getIn(HttpMessage.class).getRequest().getSession(); ... }
Using the JSSE Configuration Utility
Programmatic configuration of the component
KeyStoreParameters ksp = new KeyStoreParameters(); ksp.setResource("/users/home/server/keystore.jks"); ksp.setPassword("keystorePassword"); KeyManagersParameters kmp = new KeyManagersParameters(); kmp.setKeyStore(ksp); kmp.setKeyPassword("keyPassword"); SSLContextParameters scp = new SSLContextParameters(); scp.setKeyManagers(kmp); JettyComponent jettyComponent = getContext().getComponent("jetty", JettyComponent.class); jettyComponent.setSslContextParameters(scp);
Spring DSL based configuration of endpoint
... <camel:sslContextParameters id="sslContextParameters"> <camel:keyManagers keyPassword="keyPassword"> <camel:keyStore resource="/users/home/server/keystore.jks" password="keystorePassword"/> </camel:keyManagers> </camel:sslContextParameters>... ... <to uri="jetty:https://127.0.0.1/mail/?sslContextParametersRef=sslContextParameters"/> ...
Configuring Jetty Directly
https://
prefix---for example:
<from uri="jetty:https://0.0.0.0/myapp/myservice/"/>
jetty.ssl.keystore
specifies the location of the Java keystore file, which contains the Jetty server's own X.509 certificate in a key entry. A key entry stores the X.509 certificate (effectively, the public key) and also its associated private key.jetty.ssl.password
the store password, which is required to access the keystore file (this is the same password that is supplied to thekeystore
command's\-storepass
option).jetty.ssl.keypassword
the key password, which is used to access the certificate's key entry in the keystore (this is the same password that is supplied to thekeystore
command's\-keypass
option).
org.eclipse.jetty.ssl.keystore
specifies the location of the Java keystore file, which contains the Jetty server's own X.509 certificate in a key entry. A key entry stores the X.509 certificate (effectively, the public key) and also its associated private key.org.eclipse.jetty.ssl.password
the store password, which is required to access the keystore file (this is the same password that is supplied to thekeystore
command's\-storepass
option).org.eclipse.jetty.ssl.keypassword
the key password, which is used to access the certificate's key entry in the keystore (this is the same password that is supplied to thekeystore
command's\-keypass
option).
<bean id="jetty" class="org.apache.camel.component.jetty.JettyHttpComponent"> <property name="sslSocketConnectors"> <map> <entry key="8043"> <bean class="org.mortbay.jetty.security.SslSocketConnector"> <property name="password"value="..."/> <property name="keyPassword"value="..."/> <property name="keystore"value="..."/> <property name="needClientAuth"value="..."/> <property name="truststore"value="..."/> </bean> </entry> </map> </property> </bean>
<bean id="jetty" class="org.apache.camel.component.jetty.JettyHttpComponent"> <property name="sslSocketConnectors"> <map> <entry key="8043"> <bean class="org.eclipse.jetty.server.ssl.SslSocketConnector"> <property name="password"value="..."/> <property name="keyPassword"value="..."/> <property name="keystore"value="..."/> <property name="needClientAuth"value="..."/> <property name="truststore"value="..."/> </bean> </entry> </map> </property> </bean>
<bean id="jetty" class="org.apache.camel.component.jetty.JettyHttpComponent"> <property name="sslSocketConnectors"> <map> <entry key="8043"> <bean class="org.eclipse.jetty.server.ssl.SslSelectChannelConnector"> <property name="password"value="..."/> <property name="keyPassword"value="..."/> <property name="keystore"value="..."/> <property name="needClientAuth"value="..."/> <property name="truststore"value="..."/> </bean> </entry> </map> </property> </bean>
Configuring general SSL properties
<bean id="jetty" class="org.apache.camel.component.jetty.JettyHttpComponent"> <property name="sslSocketConnectorProperties"> <map> <entry key="password"value="..."/> <entry key="keyPassword"value="..."/> <entry key="keystore"value="..."/> <entry key="needClientAuth"value="..."/> <entry key="truststore"value="..."/> </map> </property> </bean>
How to obtain reference to the X509Certificate
HttpServletRequest req = exchange.getIn().getBody(HttpServletRequest.class); X509Certificate cert = (X509Certificate) req.getAttribute("javax.servlet.request.X509Certificate")
Configuring general HTTP properties
<bean id="jetty" class="org.apache.camel.component.jetty.JettyHttpComponent"> <property name="socketConnectorProperties"> <map> <entry key="acceptors" value="4"/> <entry key="maxIdleTime" value="300000"/> </map> </property> </bean>
Obtaining X-Forwarded-For header with HttpServletRequest.getRemoteAddr()
mod_proxy
, the original client IP address is in the X-Forwarded-For
header and the HttpServletRequest.getRemoteAddr()
will return the address of the Apache proxy.
X-Forwarded-For
and places it in the HttpServletRequest
remoteAddr
property. This property is not available directly through the endpoint configuration but it can be easily added using the socketConnectors
property:
<bean id="jetty" class="org.apache.camel.component.jetty.JettyHttpComponent"> <property name="socketConnectors"> <map> <entry key="8080"> <bean class="org.eclipse.jetty.server.nio.SelectChannelConnector"> <property name="forwarded" value="true"/> </bean> </entry> </map> </property> </bean>
Default behaviour for returning HTTP status codes
org.apache.camel.component.http.DefaultHttpBinding
class, which handles how a response is written and also sets the HTTP status code.
Exchange.HTTP_RESPONSE_CODE
header of the OUT message.
Customizing HttpBinding
org.apache.camel.component.http.DefaultHttpBinding
to handle how a response is written. If you like, you can customize this behavior either by implementing your own HttpBinding
class or by extending DefaultHttpBinding
and overriding the appropriate methods.
DefaultHttpBinding
in order to change how exceptions are returned:
public class MyHttpBinding extends DefaultHttpBinding { public MyHttpBinding(HttpEndpoint ep) { super(ep); } @Override public void doWriteExceptionResponse(Throwable exception, HttpServletResponse response) throws IOException { // we override the doWriteExceptionResponse as we only want to alter the binding how exceptions is // written back to the client. // we just return HTTP 200 so the client thinks its okay response.setStatus(200); // and we return this fixed text response.getWriter().write("Something went wrong but we dont care"); } }
<bean id="mybinding"class="com.mycompany.MyHttpBinding"/>
<route><from uri="jetty:http://0.0.0.0:8080/myapp/myservice?httpBindingRef=mybinding"/><to uri="bean:doSomething"/></route>
Jetty handlers and security configuration
<-- Jetty Security handling --> <bean id="userRealm" class="org.mortbay.jetty.plus.jaas.JAASUserRealm"> <property name="name" value="tracker-users"/> <property name="loginModuleName" value="ldaploginmodule"/> </bean> <bean id="constraint" class="org.mortbay.jetty.security.Constraint"> <property name="name" value="BASIC"/> <property name="roles" value="tracker-users"/> <property name="authenticate" value="true"/> </bean> <bean id="constraintMapping" class="org.mortbay.jetty.security.ConstraintMapping"> <property name="constraint" ref="constraint"/> <property name="pathSpec" value="/*"/> </bean> <bean id="securityHandler" class="org.mortbay.jetty.security.SecurityHandler"> <property name="userRealm" ref="userRealm"/> <property name="constraintMappings" ref="constraintMapping"/> </bean>
<-- Jetty Security handling --> <bean id="constraint" class="org.eclipse.jetty.http.security.Constraint"> <property name="name" value="BASIC"/> <property name="roles" value="tracker-users"/> <property name="authenticate" value="true"/> </bean> <bean id="constraintMapping" class="org.eclipse.jetty.security.ConstraintMapping"> <property name="constraint" ref="constraint"/> <property name="pathSpec" value="/*"/> </bean> <bean id="securityHandler" class="org.eclipse.jetty.security.ConstraintSecurityHandler"> <property name="authenticator"> <bean class="org.eclipse.jetty.security.authentication.BasicAuthenticator"/> </property> <property name="constraintMappings"> <list> <ref bean="constraintMapping"/> </list> </property> </bean>
from("jetty:http://0.0.0.0:9080/myservice?handlers=securityHandler")
handlers
option equal to a comma-separated list of bean IDs.
How to return a custom HTTP 500 reply message
HttpBinding
to be in control of the message mapping, but often it may be easier to use Camel's Exception Clause to construct the custom reply message. For example as show here, where we return Dude something went wrong
with HTTP error code 500:
from("jetty://http://localhost:{{port}}/myserver") // use onException to catch all exceptions and return a custom reply message .onException(Exception.class) .handled(true) // create a custom failure response .transform(constant("Dude something went wrong")) // we must remember to set error code 500 as handled(true) // otherwise would let Camel thing its a OK response (200) .setHeader(Exchange.HTTP_RESPONSE_CODE, constant(500)) .end() // now just force an exception immediately .throwException(new IllegalArgumentException("I cannot do this"));
Multi-part Form support
// Set the jetty temp directory which store the file for multi part form // camel-jetty will clean up the file after it handled the request. // The option works rightly from Camel 2.4.0 getContext().getProperties().put("CamelJettyTempDir", "target"); from("jetty://http://localhost:{{port}}/test").process(new Processor() { public void process(Exchange exchange) throws Exception { Message in = exchange.getIn(); assertEquals("Get a wrong attachement size", 1, in.getAttachments().size()); // The file name is attachment id DataHandler data = in.getAttachment("NOTICE.txt"); assertNotNull("Should get the DataHandle NOTICE.txt", data); // This assert is wrong, but the correct content-type (application/octet-stream) // will not be returned until Jetty makes it available - currently the content-type // returned is just the default for FileDataHandler (for the implentation being used) //assertEquals("Get a wrong content type", "text/plain", data.getContentType()); assertEquals("Got the wrong name", "NOTICE.txt", data.getName()); assertTrue("We should get the data from the DataHandle", data.getDataSource() .getInputStream().available() > 0); // The other form date can be get from the message header exchange.getOut().setBody(in.getHeader("comment")); } });
Jetty JMX support
<from uri="jetty:https://0.0.0.0/myapp/myservice1/?enableJmx=true"/>
<from uri="jetty:https://0.0.0.0/myapp/myservice2/?enableJmx=false"/>
Chapter 71. JGroups
JGroups Component
pom.xml
for this component:
<dependency> <groupId>org.apache-extra.camel</groupId> <artifactId>camel-jgroups</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
jgroups:clusterName[?options]
Options
Name | Default Value | Description |
---|---|---|
channelProperties
|
null
|
*Camel 2.10.0:* Specifies configuration properties of the JChannel used by the endpoint. |
Usage
jgroups
component on the consumer side of the route will capture messages received by the JChannel
associated with the endpoint and forward them to the Camel route. JGroups consumer processes incoming messages asynchronously.
// Capture messages from cluster named // 'clusterName' and send them to Camel route. from("jgroups:clusterName").to("seda:queue");
jgroups
component on the producer side of the route will forward body of the Camel exchanges to the JChannel
instance managed by the endpoint.
// Send message to the cluster named 'clusterName' from("direct:start").to("jgroups:clusterName");
Chapter 72. Jing
Jing Component
URI format
rng:someLocalOrRemoteResource rnc:someLocalOrRemoteResource
Example | Description |
---|---|
rng:foo/bar.rng
|
References the XML file foo/bar.rng on the classpath |
rnc:http://foo.com/bar.rnc
|
References the RelaxNG Compact Syntax file from the URL, http://foo.com/bar.rnc .
|
?option=value&option=value&...
Options
Option | Default | Description |
---|---|---|
compactSyntax
|
false
|
Whether to validate using RelaxNG compact syntax or not.
|
Example
<camelContext xmlns="http://camel.apache.org/schema/spring"> <route> <from uri="direct:start"/> <doTry> <to uri="rnc:org/apache/camel/component/validator/jing/schema.rnc"/> <to uri="mock:valid"/> <doCatch> <exception>org.apache.camel.ValidationException</exception> <to uri="mock:invalid"/> </doCatch> <doFinally> <to uri="mock:finally"/> </doFinally> </doTry> </route> </camelContext>
Chapter 73. JIRA
JIRA component
- Concern for reliability/stability
- The types of payloads we're polling aren't typically large (plus, paging is available in the API)
- The need to support apps running somewhere not publicly accessible where a webhook would fail
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-jira</artifactId> <version>${camel-version}</version> </dependency>
URI format
jira://endpoint[?options]
Mandatory Options:
Option
|
Description
|
---|---|
serverUrl | JIRA host server URL |
username
|
JIRA username
|
password
|
JIRA password
|
Consumer Endpoints:
Endpoint
|
Context
|
Body Type
|
---|---|---|
newIssue
|
polling
|
com.atlassian.jira.rest.client.domain.BasicIssue
|
newComment
|
polling
|
com.atlassian.jira.rest.client.domain.Comment
|
Producer Endpoints:
Endpoint
|
Body
| Required Message Headers |
---|---|---|
pullRequestComment
|
String (issue description)
|
|
URI Options:
Name
|
Default Value
|
Description
|
---|---|---|
delay
|
60
|
in seconds
|
jql | Used by the consumer endpoints. More info below. |
JQL:
jira://[endpoint]?[required options]&jql=project=[project key]
jira://[endpoint]?[required options]&jql=RAW(project=[project key] AND status in (Open, \"Coding In Progress\") AND \"Number of comments\">0)"
Chapter 74. JMS
JMS Component
JmsTemplate
for sending and a MessageListenerContainer
for consuming.
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-jms</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
jms:[queue:|topic:]destinationName[?options]
destinationName
is a JMS queue or topic name. By default, the destinationName
is interpreted as a queue name. For example, to connect to the queue, FOO.BAR
use:
jms:FOO.BAR
queue:
prefix, if you prefer:
jms:queue:FOO.BAR
topic:
prefix. For example, to connect to the topic, Stocks.Prices
, use:
jms:topic:Stocks.Prices
?option=value&option=value&...
Using ActiveMQ
JmsTemplate
for sending messages. This is not ideal for use in a non-J2EE container and typically requires some caching in the JMS provider to avoid poor performance.
- Use the ActiveMQ component, which is already optimized to use ActiveMQ efficiently
- Use the
PoolingConnectionFactory
in ActiveMQ.
Transactions and Cache Levels
transacted=true
) then the default settings for cache level can impact performance. If you are using XA transactions then you cannot cache as it can cause the XA transaction to not work properly.
cacheLevelName=CACHE_CONSUMER
.
cacheLevelName
is CACHE_CONSUMER
. You will need to explicitly set cacheLevelName=CACHE_NONE
. In Camel 2.8 onwards, the default setting for cacheLevelName
is CACHE_AUTO
. This default auto detects the mode and sets the cache level accordingly to:
- CACHE_CONSUMER = if transacted=false
- CACHE_NONE = if transacted=true
cacheLevelName=CACHE_CONSUMER
if you are using non-XA transactions.
Durable Subscriptions
clientId
must be unique and can only be used by a single JMS connection instance in your entire network. You may prefer to use Virtual Topics instead to avoid this limitation. More background on durable messaging here.
Message Header Mapping
- Dots are replaced by
\_DOT\_
and the replacement is reversed when Camel consume the message - Hyphen is replaced by
\_HYPHEN\_
and the replacement is reversed when Camel consumes the message
Options
Most commonly used options
Option | Default Value | Description |
---|---|---|
clientId
|
null
|
Sets the JMS client ID to use. Note that this value, if specified, must be unique and can only be used by a single JMS connection instance. It is typically only required for durable topic subscriptions. You may prefer to use Virtual Topics instead. |
concurrentConsumers
|
1
|
Specifies the default number of concurrent consumers. From Camel 2.10.3 onwards this option can also be used when doing request/reply over JMS. See also the maxMessagesPerTask option to control dynamic scaling up/down of threads.
|
disableReplyTo
|
false
|
If true , a producer will behave like a InOnly exchange with the exception that JMSReplyTo header is sent out and not be suppressed like in the case of InOnly . Like InOnly the producer will not wait for a reply. A consumer with this flag will behave like InOnly . This feature can be used to bridge InOut requests to another queue so that a route on the other queue will send its response directly back to the original JMSReplyTo .
|
durableSubscriptionName
|
null
|
The durable subscriber name for specifying durable topic subscriptions. The clientId option must be configured as well.
|
maxConcurrentConsumers
|
1
|
Specifies the maximum number of concurrent consumers. From Camel 2.10.3 onwards this option can also be used when doing request/reply over JMS. See also the maxMessagesPerTask option to control dynamic scaling up/down of threads.
|
maxMessagesPerTask
|
-1
|
The number of messages per task. \-1 is unlimited. If you use a range for concurrent consumers (eg min < max), then this option can be used to set a value to eg 100 to control how fast the consumers will shrink when less work is required.
|
preserveMessageQos
|
false
|
Set to true , if you want to send message using the QoS settings specified on the message, instead of the QoS settings on the JMS endpoint. The following three headers are considered JMSPriority , JMSDeliveryMode , and JMSExpiration . You can provide all or only some of them. If not provided, Camel will fall back to use the values from the endpoint instead. So, when using this option, the headers override the values from the endpoint. The explicitQosEnabled option, by contrast, will only use options set on the endpoint, and not values from the message header.
|
replyTo
|
null
|
Provides an explicit ReplyTo destination, which overrides any incoming value of Message.getJMSReplyTo() . If you do Request Reply over JMS then make sure to read the section Request-reply over JMS further below for more details, and the replyToType option as well.
|
replyToOverride
|
null
|
Camel 2.15: Provides an explicit ReplyTo destination in the JMS message, which overrides the setting of replyTo. It is useful if you want to forward the message to a remote Queue and receive the reply message from the ReplyTo destination. |
replyToType
|
null
|
Camel 2.9: Allows for explicitly specifying which kind of strategy to use for replyTo queues when doing request/reply over JMS. Possible values are: Temporary , Shared , or Exclusive . By default Camel will use temporary queues. However if replyTo has been configured, then Shared is used by default. This option allows you to use exclusive queues instead of shared ones. See further below for more details, and especially the notes about the implications if running in a clustered environment, and the fact that Shared reply queues has lower performance than its alternatives Temporary and Exclusive .
|
requestTimeout
|
20000
|
Producer only: The timeout for waiting for a reply when using the InOut Exchange Pattern (in milliseconds). The default is 20 seconds. From Camel 2.13/2.12.3 onwards you can include the header CamelJmsRequestTimeout to override this endpoint configured timeout value, and thus have per message individual timeout values. See below in section About time to live for more details. See also the requestTimeoutCheckerInterval option.
|
selector
|
null
|
Sets the JMS Selector, which is an SQL 92 predicate that is used to filter messages within the broker. You may have to encode special characters such as = as %3D Before Camel 2.3.0, we don't support this option in CamelConsumerTemplate |
timeToLive
|
null
|
When sending messages, specifies the time-to-live of the message (in milliseconds). See below in section About time to live for more details. |
transacted
|
false
|
Specifies whether to use transacted mode for sending/receiving messages using the InOnly Exchange Pattern. |
testConnectionOnStartup
|
false
|
Camel 2.1: Specifies whether to test the connection on startup. This ensures that when Camel starts that all the JMS consumers have a valid connection to the JMS broker. If a connection cannot be granted then Camel throws an exception on startup. This ensures that Camel is not started with failed connections. From Camel 2.8 onwards also the JMS producers is tested as well. |
All the other options
Option | Default Value | Description |
---|---|---|
acceptMessagesWhileStopping
|
false
|
Specifies whether the consumer accept messages while it is stopping. You may consider enabling this option, if you start and stop JMS routes at runtime, while there are still messages enqued on the queue. If this option is false , and you stop the JMS route, then messages may be rejected, and the JMS broker would have to attempt redeliveries, which yet again may be rejected, and eventually the message may be moved at a dead letter queue on the JMS broker. To avoid this its recommended to enable this option.
|
acknowledgementModeName
|
AUTO_ACKNOWLEDGE
|
The JMS acknowledgement name, which is one of: SESSION_TRANSACTED , CLIENT_ACKNOWLEDGE , AUTO_ACKNOWLEDGE , DUPS_OK_ACKNOWLEDGE
|
acknowledgementMode
|
\-1
|
The JMS acknowledgement mode defined as an Integer. Allows you to set vendor-specific extensions to the acknowledgment mode. For the regular modes, it is preferable to use the acknowledgementModeName instead.
|
allowNullBody
|
true
|
Camel 2.9.3/2.10.1: Whether to allow sending messages with no body. If this option is false and the message body is null, then an JMSException is thrown.
|
alwaysCopyMessage
|
false
|
If true , Camel will always make a JMS message copy of the message when it is passed to the producer for sending. Copying the message is needed in some situations, such as when a replyToDestinationSelectorName is set (incidentally, Camel will set the alwaysCopyMessage option to true , if a replyToDestinationSelectorName is set)
|
asyncConsumer
|
false
|
Camel 2.9: Whether the JmsConsumer processes the Exchange asynchronously. If enabled then the JmsConsumer may pickup the next message from the JMS queue, while the previous message is being processed asynchronously (by the Asynchronous Routing Engine). This means that messages may be processed not 100% strictly in order. If disabled (as default) then the Exchange is fully processed before the JmsConsumer will pickup the next message from the JMS queue. Note if transacted has been enabled, then asyncConsumer=true does not run asynchronously, as transactions must be executed synchronously (Camel 3.0 may support async transactions).
|
asyncStartListener
|
false
|
Camel 2.10: Whether to startup the JmsConsumer message listener asynchronously, when starting a route. For example if a JmsConsumer cannot get a connection to a remote JMS broker, then it may block while retrying and/or failover. This will cause Camel to block while starting routes. By setting this option to true , you will let routes startup, while the JmsConsumer connects to the JMS broker using a dedicated thread in asynchronous mode. If this option is used, then beware that if the connection could not be established, then an exception is logged at WARN level, and the consumer will not be able to receive messages; You can then restart the route to retry.
|
asyncStopListener
|
false
|
Camel 2.10: Whether to stop the JmsConsumer message listener asynchronously, when stopping a route.
|
autoStartup
|
true
|
Specifies whether the consumer container should auto-startup. |
cacheLevelName
|
CACHE_AUTO (Camel >= 2.8.0) CACHE_CONSUMER (Camel <= 2.7.1)
|
Sets the cache level by name for the underlying JMS resources. Possible values are: CACHE_AUTO , CACHE_CONNECTION , CACHE_CONSUMER , CACHE_NONE , and CACHE_SESSION . The default setting for Camel 2.8 and newer is CACHE_AUTO . For Camel 2.7.1 and older the default is CACHE_CONSUMER . See the Spring documentation and Transactions Cache Levels for more information.
|
cacheLevel
|
Sets the cache level by ID for the underlying JMS resources. See cacheLevelName option for more details.
|
|
consumerType
|
Default
|
The consumer type to use, which can be one of: Simple , Default , or Custom . The consumer type determines which Spring JMS listener to use. Default will use org.springframework.jms.listener.DefaultMessageListenerContainer , Simple will use org.springframework.jms.listener.SimpleMessageListenerContainer . When Custom is specified, the MessageListenerContainerFactory defined by the messageListenerContainerFactoryRef option will determine what org.springframework.jms.listener.AbstractMessageListenerContainer to use (new option in Camel 2.11 and 2.10.2). This option was temporary removed in Camel 2.7 and 2.8. But has been added back from Camel 2.9 onwards.
|
connectionFactory
|
null
|
The default JMS connection factory to use for the listenerConnectionFactory and templateConnectionFactory , if neither is specified.
|
defaultTaskExecutorType
|
(see description) |
Camel 2.10.4: Specifies what default TaskExecutor type to use in the DefaultMessageListenerContainer, for both consumer endpoints and the ReplyTo consumer of producer endpoints. Possible values: SimpleAsync (uses Spring's SimpleAsyncTaskExecutor) or ThreadPool (uses Spring's ThreadPoolTaskExecutor with optimal values - cached threadpool-like). If not set, it defaults to the previous behaviour, which uses a cached thread pool for consumer endpoints and SimpleAsync for reply consumers. The use of ThreadPool is recommended to reduce "thread trash" in elastic configurations with dynamically increasing and decreasing concurrent consumers.
|
deliveryMode
|
null
|
Camel 2.12.2/2.13: Specifies the delivery mode to be used. Possibles values are those defined by
javax.jms.DeliveryMode .
|
deliveryPersistent
|
true
|
Specifies whether persistent delivery is used by default. |
destination
|
null
|
Specifies the JMS Destination object to use on this endpoint. |
destinationName
|
null
|
Specifies the JMS destination name to use on this endpoint. |
destinationResolver
|
null
|
A pluggable org.springframework.jms.support.destination.DestinationResolver that allows you to use your own resolver (for example, to lookup the real destination in a JNDI registry).
|
disableTimeToLive
|
false
|
Camel 2.8: Use this option to force disabling time to live. For example when you do request/reply over JMS, then Camel will by default use the requestTimeout value as time to live on the message being sent. The problem is that the sender and receiver systems have to have their clocks synchronized, so they are in sync. This is not always so easy to archive. So you can use disableTimeToLive=true to not set a time to live value on the sent message. Then the message will not expire on the receiver system. See below in section About time to live for more details.
|
eagerLoadingOfProperties
|
false
|
Enables eager loading of JMS properties as soon as a message is received, which is generally inefficient, because the JMS properties might not be required. But this feature can sometimes catch early any issues with the underlying JMS provider and the use of JMS properties. This feature can also be used for testing purposes, to ensure JMS properties can be understood and handled correctly. |
exceptionListener
|
null
|
Specifies the JMS Exception Listener that is to be notified of any underlying JMS exceptions. |
errorHandler
|
null
|
>Camel 2.8.2, 2.9: Specifies a org.springframework.util.ErrorHandler to be invoked in case of any uncaught exceptions thrown while processing a Message . By default these exceptions will be logged at the WARN level, if no errorHandler has been configured. From Camel 2.9.1: onwards you can configure logging level and whether stack traces should be logged using the below two options. This makes it much easier to configure, than having to code a custom errorHandler .
|
errorHandlerLoggingLevel
|
WARN
|
Camel 2.9.1: Allows to configure the default errorHandler logging level for logging uncaught exceptions.
|
errorHandlerLogStackTrace
|
true
|
Camel 2.9.1: Allows to control whether stacktraces should be logged or not, by the default errorHandler .
|
explicitQosEnabled
|
false
|
Set if the deliveryMode , priority or timeToLive qualities of service should be used when sending messages. This option is based on Spring's JmsTemplate . The deliveryMode , priority and timeToLive options are applied to the current endpoint. This contrasts with the preserveMessageQos option, which operates at message granularity, reading QoS properties exclusively from the Camel In message headers.
|
exposeListenerSession
|
true
|
Specifies whether the listener session should be exposed when consuming messages. |
forceSendOriginalMessage
|
false
|
>Camel 2.7: When using mapJmsMessage=false Camel will create a new JMS message to send to a new JMS destination if you touch the headers (get or set) during the route. Set this option to true to force Camel to send the original JMS message that was received.
|
idleTaskExecutionLimit
|
1
|
Specifies the limit for idle executions of a receive task, not having received any message within its execution. If this limit is reached, the task will shut down and leave receiving to other executing tasks (in the case of dynamic scheduling; see the maxConcurrentConsumers setting).
|
idleConsumerLimit
|
1
|
Camel 2.8.2, 2.9: Specify the limit for the number of consumers that are allowed to be idle at any given time. |
includeSentJMSMessageID
|
false
|
Camel 2.10.3: Only applicable when sending to JMS destination using InOnly (eg fire and forget). Enabling this option will enrich the Camel Exchange with the actual JMSMessageID that was used by the JMS client when the message was sent to the JMS destination. |
includeAllJMSXProperties
|
false
|
Camel 2.11.2/2.12: Whether to include all JMSXxxx properties when mapping from JMS to Camel Message. Setting this to true will include properties such as JMSXAppID , and JMSXUserID etc. Note: If you are using a custom headerFilterStrategy then this option does not apply.
|
jmsMessageType
|
null
|
Allows you to force the use of a specific javax.jms.Message implementation for sending JMS messages. Possible values are: Bytes , Map , Object , Stream , Text . By default, Camel would determine which JMS message type to use from the In body type. This option allows you to specify it.
|
jmsKeyFormatStrategy
|
default
|
Pluggable strategy for encoding and decoding JMS keys so they can be compliant with the JMS specification. Camel provides two implementations out of the box: default and passthrough . The default strategy will safely marshal dots and hyphens (. and \- ). The passthrough strategy leaves the key as is. Can be used for JMS brokers which do not care whether JMS header keys contain illegal characters. You can provide your own implementation of the org.apache.camel.component.jms.JmsKeyFormatStrategy and refer to it using the \# notation.
|
jmsOperations
|
null
|
Allows you to use your own implementation of the org.springframework.jms.core.JmsOperations interface. Camel uses JmsTemplate as default. Can be used for testing purpose, but not used much as stated in the spring API docs.
|
lazyCreateTransactionManager
|
true
|
If true , Camel will create a JmsTransactionManager , if there is no transactionManager injected when option transacted=true .
|
listenerConnectionFactory
|
null
|
The JMS connection factory used for consuming messages. |
mapJmsMessage
|
true
|
Specifies whether Camel should auto map the received JMS message to an appropiate payload type, such as javax.jms.TextMessage to a String etc. See section about how mapping works below for more details.
|
maximumBrowseSize
|
\-1
|
Limits the number of messages fetched at most, when browsing endpoints using Browse or JMX API. |
messageConverter
|
null
|
To use a custom Spring org.springframework.jms.support.converter.MessageConverter so you can be 100% in control how to map to/from a javax.jms.Message .
|
messageIdEnabled
|
true
|
When sending, specifies whether message IDs should be added. |
messageListenerContainerFactoryRef
|
null
|
Camel 2.10.2: Registry ID of the MessageListenerContainerFactory used to determine what org.springframework.jms.listener.AbstractMessageListenerContainer to use to consume messages. Setting this will automatically set consumerType to Custom .
|
messageTimestampEnabled
|
true
|
Specifies whether timestamps should be enabled by default on sending messages. |
password
|
null
|
The password for the connector factory. |
priority
|
4
|
Values greater than 1 specify the message priority when sending (where 0 is the lowest priority and 9 is the highest). The explicitQosEnabled option must also be enabled in order for this option to have any effect.
|
pubSubNoLocal
|
false
|
Specifies whether to inhibit the delivery of messages published by its own connection. |
receiveTimeout
|
1000
|
The timeout for receiving messages (in milliseconds). |
recoveryInterval
|
5000
|
Specifies the interval between recovery attempts, i.e. when a connection is being refreshed, in milliseconds. The default is 5000 ms, that is, 5 seconds. |
replyToCacheLevelName
|
CACHE_CONSUMER |
Camel 2.9.1: Sets the cache level by name for the reply consumer when doing request/reply over JMS. This option only applies when using fixed reply queues (not temporary). Camel will by default use: CACHE_CONSUMER for exclusive or shared w/ replyToSelectorName . And CACHE_SESSION for shared without replyToSelectorName . Some JMS brokers such as IBM WebSphere may require to set the replyToCacheLevelName=CACHE_NONE to work.
|
replyToDestinationSelectorName
|
null
|
Sets the JMS Selector using the fixed name to be used so you can filter out your own replies from the others when using a shared queue (that is, if you are not using a temporary reply queue). |
replyToDeliveryPersistent
|
true
|
Specifies whether to use persistent delivery by default for replies. |
requestTimeoutCheckerInterval
|
1000
|
Camel 2.9.2: Configures how often Camel should check for timed out Exchanges when doing request/reply over JMS.By default Camel checks once per second. But if you must react faster when a timeout occurs, then you can lower this interval, to check more frequently. The timeout is determined by the option requestTimeout. |
subscriptionDurable
|
false
|
@deprecated: Enabled by default, if you specify a durableSubscriptionName and a clientId .
|
taskExecutor
|
null
|
Allows you to specify a custom task executor for consuming messages. |
taskExecutorSpring2
|
null
|
Camel 2.6: To use when using Spring 2.x with Camel. Allows you to specify a custom task executor for consuming messages. |
templateConnectionFactory
|
null
|
The JMS connection factory used for sending messages. |
transactedInOut
|
false
|
@deprecated: Specifies whether to use transacted mode for sending messages using the InOut Exchange Pattern. Applies only to producer endpoints. See section Enabling Transacted Consumption for more details. |
transactionManager
|
null
|
The Spring transaction manager to use. |
transactionName
|
"JmsConsumer[destinationName]"
|
The name of the transaction to use. |
transactionTimeout
|
null
|
The timeout value of the transaction (in seconds), if using transacted mode. |
transferException
|
false
|
If enabled and you are using Request Reply messaging (InOut) and an Exchange failed on the consumer side, then the caused Exception will be send back in response as a javax.jms.ObjectMessage . If the client is Camel, the returned Exception is rethrown. This allows you to use Camel JMS as a bridge in your routing - for example, using persistent queues to enable robust routing. Notice that if you also have transferExchange enabled, this option takes precedence. The caught exception is required to be serializable. The original Exception on the consumer side can be wrapped in an outer exception such as org.apache.camel.RuntimeCamelException when returned to the producer.
|
transferExchange
|
false
|
You can transfer the exchange over the wire instead of just the body and headers. The following fields are transferred: In body, Out body, Fault body, In headers, Out headers, Fault headers, exchange properties, exchange exception. This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level. You must enable this option on both the producer and consumer side, so Camel knows the payloads is an Exchange and not a regular payload.
|
username
|
null
|
The username for the connector factory. |
useMessageIDAsCorrelationID
|
false
|
Specifies whether JMSMessageID should always be used as JMSCorrelationID for InOut messages.
|
useVersion102
|
false
|
@deprecated (removed from Camel 2.5 onwards): Specifies whether the old JMS API should be used. |
Message Mapping between JMS and Camel
javax.jms.Message
and org.apache.camel.Message
.
Body Type | JMS Message | Comment |
---|---|---|
String
|
javax.jms.TextMessage
|
|
org.w3c.dom.Node
|
javax.jms.TextMessage
|
The DOM will be converted to String .
|
Map
|
javax.jms.MapMessage
|
|
java.io.Serializable
|
javax.jms.ObjectMessage
|
|
byte[]
|
javax.jms.BytesMessage
|
|
java.io.File
|
javax.jms.BytesMessage
|
|
java.io.Reader
|
javax.jms.BytesMessage
|
|
java.io.InputStream
|
javax.jms.BytesMessage
|
|
java.nio.ByteBuffer
|
javax.jms.BytesMessage
|
JMS Message | Body Type |
---|---|
javax.jms.TextMessage
|
String
|
javax.jms.BytesMessage
|
byte[]
|
javax.jms.MapMessage
|
Map<String, Object>
|
javax.jms.ObjectMessage
|
Object
|
Disabling auto-mapping of JMS messages
mapJmsMessage
option to disable the auto-mapping above. If disabled, Camel will not try to map the received JMS message, but instead uses it directly as the payload. This allows you to avoid 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.
Using a custom MessageConverter
messageConverter
option to do the mapping yourself in a Spring org.springframework.jms.support.converter.MessageConverter
class.
from("file://inbox/order").to("jms:queue:order?messageConverter=#myMessageConverter");
Controlling the mapping strategy selected
javax.jms.TextMessage
as we have forced the JMS producer endpoint to use text messages:
from("file://inbox/order").to("jms:queue:order?jmsMessageType=Text");
CamelJmsMessageType
. For example:
from("file://inbox/order").setHeader("CamelJmsMessageType", JmsMessageType.Text).to("jms:queue:order");
enum
class, org.apache.camel.jms.JmsMessageType
.
Message format when sending
exchange.in.header
the following rules apply for the header keys:
- Keys starting with
JMS
orJMSX
are reserved. exchange.in.headers
keys must be literals and all be valid Java identifiers (do not use dots in the key name).- Camel replaces dots & hyphens and the reverse when when consuming JMS messages:
.
is replaced by\_DOT\_
and the reverse replacement when Camel consumes the message.\-
is replaced by\_HYPHEN\_
and the reverse replacement when Camel consumes the message. - See also the option
jmsKeyFormatStrategy
, which allows use of your own custom strategy for formatting keys.
exchange.in.header
, the following rules apply for the header values:
- The values must be primitives or their counter objects (such as
Integer
,Long
,Character
). The types,String
,CharSequence
,Date
,BigDecimal
andBigInteger
are all converted to theirtoString()
representation. All other types are dropped.
org.apache.camel.component.jms.JmsBinding
at DEBUG level if it drops a given header value. For example:
2008-07-09 06:43:04,046 [main ] DEBUG JmsBinding - Ignoring non primitive header: order of class: org.apache.camel.component.jms.issues.DummyOrder with value: DummyOrder{orderId=333, itemId=4444, quantity=2}
Message format when receiving
Exchange
when it receives a message:
Property | Type | Description |
---|---|---|
org.apache.camel.jms.replyDestination
|
javax.jms.Destination
|
The reply destination. |
Header | Type | Description |
---|---|---|
JMSCorrelationID
|
String
|
The JMS correlation ID. |
JMSDeliveryMode
|
int
|
The JMS delivery mode. |
JMSDestination
|
javax.jms.Destination
|
The JMS destination. |
JMSExpiration
|
long
|
The JMS expiration. |
JMSMessageID
|
String
|
The JMS unique message ID. |
JMSPriority
|
int
|
The JMS priority (with 0 as the lowest priority and 9 as the highest). |
JMSRedelivered
|
boolean
|
Is the JMS message redelivered. |
JMSReplyTo
|
javax.jms.Destination
|
The JMS reply-to destination. |
JMSTimestamp
|
long
|
The JMS timestamp. |
JMSType
|
String
|
The JMS type. |
JMSXGroupID
|
String
|
The JMS group ID. |
About using Camel to send and receive messages and JMSReplyTo
JMSProducer
, it checks the following conditions:
- The message exchange pattern,
- Whether a
JMSReplyTo
was set in the endpoint or in the message headers, - Whether any of the following options have been set on the JMS endpoint:
disableReplyTo
,preserveMessageQos
,explicitQosEnabled
.
JmsProducer
JmsProducer
behaves as follows, depending on configuration:
Exchange Pattern | Other options | Description |
---|---|---|
InOut | \- |
Camel will expect a reply, set a temporary JMSReplyTo , and after sending the message, it will start to listen for the reply message on the temporary queue.
|
InOut |
JMSReplyTo is set
|
Camel will expect a reply and, after sending the message, it will start to listen for the reply message on the specified JMSReplyTo queue.
|
InOnly | \- | Camel will send the message and not expect a reply. |
InOnly |
JMSReplyTo is set
|
By default, Camel discards the JMSReplyTo destination and clears the JMSReplyTo header before sending the message. Camel then sends the message and does not expect a reply. Camel logs this in the log at WARN level (changed to DEBUG level from Camel 2.6 onwards. You can use preserveMessageQuo=true to instruct Camel to keep the JMSReplyTo . In all situations the JmsProducer does not expect any reply and thus continue after sending the message.
|
JmsConsumer
JmsConsumer
behaves as follows, depending on configuration:
Exchange Pattern | Other options | Description |
---|---|---|
InOut | \- |
Camel will send the reply back to the JMSReplyTo queue.
|
InOnly | \- | Camel will not send a reply back, as the pattern is InOnly. |
\- |
disableReplyTo=true
|
This option suppresses replies. |
InOnly
message to a JMS topic:
from("activemq:queue:in") .to("bean:validateOrder") .to(ExchangePattern.InOnly, "activemq:topic:order") .to("bean:handleOrder");
Reuse endpoint and send to different destinations computed at runtime
Header | Type | Description |
---|---|---|
CamelJmsDestination
|
javax.jms.Destination
|
A destination object. |
CamelJmsDestinationName
|
String
|
The destination name. |
from("file://inbox") .to("bean:computeDestination") .to("activemq:queue:dummy");
dummy
, is just a placeholder. It must be provided as part of the JMS endpoint URL, but it will be ignored in this example.
computeDestination
bean, specify the real destination by setting the CamelJmsDestinationName
header as follows:
public void setJmsHeader(Exchange exchange) { String id = .... exchange.getIn().setHeader("CamelJmsDestinationName", "order:" + id"); }
activemq:queue:order:2
, assuming the id
value was 2.
CamelJmsDestination
and the CamelJmsDestinationName
headers are set, CamelJmsDestination
takes priority. Keep in mind that the JMS producer removes both CamelJmsDestination
and CamelJmsDestinationName
headers from the exchange and do not propagate 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).
Configuring different JMS providers
<camelContext id="camel" xmlns="http://camel.apache.org/schema/spring"> <jmxAgent id="agent" disabled="true"/> </camelContext> <bean id="activemq" class="org.apache.activemq.camel.component.ActiveMQComponent"> <property name="connectionFactory"> <bean class="org.apache.activemq.ActiveMQConnectionFactory"> <property name="brokerURL" value="vm://localhost?broker.persistent=false&roker.useJmx=false"/> </bean> </property> </bean>
id
attribute. The preceding example configures an activemq
component. You could do the same to configure MQSeries, TibCo, BEA, Sonic and so on.
activemq
, you can then refer to destinations using the URI format, activemq:[queue:|topic:]destinationName
. You can use the same approach for all other JMS providers.
Using JNDI to find the ConnectionFactory
ConnectionFactory
rather than use the usual <bean>
mechanism in Spring. You can do this using Spring's factory bean or the new Spring XML namespace. For example:
<bean id="weblogic" class="org.apache.camel.component.jms.JmsComponent"> <property name="connectionFactory" ref="myConnectionFactory"/> </bean> <jee:jndi-lookup id="myConnectionFactory" jndi-name="jms/connectionFactory"/>
Concurrent Consuming
concurrentConsumers
option to specify the number of threads servicing the JMS endpoint, as follows:
from("jms:SomeQueue?concurrentConsumers=20"). bean(MyClass.class);
- On the
JmsComponent
, - On the endpoint URI or,
- By invoking
setConcurrentConsumers()
directly on theJmsEndpoint
.
Concurrent Consuming with async consumer
asyncConsumer=true
to let the consumer pickup the next message from the JMS queue, while the previous message is being processed asynchronously (by the Asynchronous Routing Engine). See more details in the table on top of the page about the asyncConsumer
option.
from("jms:SomeQueue?concurrentConsumers=20&asyncConsumer=true"). bean(MyClass.class);
Request-reply over JMS
InOut
when you send a message to a JMS queue.
Option | Performance | Cluster | Description |
---|---|---|---|
Temporary
|
Fast | Yes |
A temporary queue is used as reply queue, and automatic created by Camel. To use this do not specify a replyTo queue name. And you can optionally configure replyToType=Temporary to make it stand out that temporary queues are in use.
|
Shared
|
Slow | Yes |
A shared persistent queue is used as reply queue. The queue must be created beforehand, although some brokers can create them on the fly such as Apache ActiveMQ. To use this you must specify the replyTo queue name. And you can optionally configure replyToType=Shared to make it stand out that shared queues are in use. A shared queue can be used in a clustered environment with multiple nodes running this Camel application at the same time. All using the same shared reply queue. This is possible because JMS Message selectors are used to correlate expected reply messages; this impacts performance though. JMS Message selectors is slower, and therefore not as fast as Temporary or Exclusive queues. See further below how to tweak this for better performance.
|
Exclusive
|
Fast | No |
An exclusive persistent queue is used as reply queue. The queue must be created beforehand, although some brokers can create them on the fly such as Apache ActiveMQ. To use this you must specify the replyTo queue name. And you must configure replyToType=Exclusive to instruct Camel to use exclusive queues, as Shared is used by default, if a replyTo queue name was configured. When using exclusive reply queues, then JMS Message selectors are not in use, and therefore other applications must not use this queue as well. An exclusive queue cannot be used in a clustered environment with multiple nodes running this Camel application at the same time; as we do not have control if the reply queue comes back to the same node that sent the request message; that is why shared queues use JMS Message selectors to make sure of this. Though if you configure each Exclusive reply queue with an unique name per node, then you can run this in a clustered environment. As then the reply message will be sent back to that queue for the given node, that awaits the reply message.
|
concurrentConsumers
|
Fast | Yes |
Camel 2.10.3: Allows to process reply messages concurrently using concurrent message listeners in use. You can specify a range using the concurrentConsumers and maxConcurrentConsumers options. Notice: That using Shared reply queues may not work as well with concurrent listeners, so use this option with care.
|
maxConcurrentConsumers
|
Fast | Yes |
Camel 2.10.3: Allows to process reply messages concurrently using concurrent message listeners in use. You can specify a range using the concurrentConsumers and maxConcurrentConsumers options. Notice: That using Shared reply queues may not work as well with concurrent listeners, so use this option with care.
|
JmsProducer
detects the InOut
and provides a JMSReplyTo
header with the reply destination to be used. By default Camel uses a temporary queue, but you can use the replyTo
option on the endpoint to specify a fixed reply queue (see more below about fixed reply queue).
DefaultMessageListenerContainer
which listen for replies. However it's fixed to 1 concurrent consumer. That means replies will be processed in sequence as there are only 1 thread to process the replies. If you want to process replies faster, then we need to use concurrency. But not using the concurrentConsumer
option. We should use the threads
from the Camel DSL instead, as shown in the route below:
from(xxx) .inOut().to("activemq:queue:foo") .threads(5) .to(yyy) .to(zzz);
concurrentConsumers
option if using Camel 2.10.3 or better. See further below.
concurrentConsumers
and maxConcurrentConsumers
options. This allows you to easier configure this in Camel as shown below:
from(xxx) .inOut().to("activemq:queue:foo?concurrentConsumers=5") .to(yyy) .to(zzz);
Request-reply over JMS and using an exclusive fixed reply queue
JMSSelector
to only consume reply messages which it expects. However there is a drawback doing this as JMS selectos is slower. Also the consumer on the reply queue is slower to update with new JMS selector ids. In fact it only updates when the receiveTimeout
option times out, which by default is 1 second. So in theory the reply messages could take up till about 1 sec to be detected. On the other hand if the fixed reply queue is exclusive to the Camel reply consumer, then we can avoid using the JMS selectors, and thus be more performant. In fact as fast as using temporary queues. So in Camel 2.9 onwards we introduced the ReplyToType
option which you can configure to Exclusive
to tell Camel that the reply queue is exclusive as shown in the example below:
from(xxx) .inOut().to("activemq:queue:foo?replyTo=bar&replyToType=Exclusive") .to(yyy)
from(xxx) .inOut().to("activemq:queue:foo?replyTo=bar&replyToType=Exclusive") .to(yyy) from(aaa) .inOut().to("activemq:queue:order?replyTo=order.reply&replyToType=Exclusive") .to(bbb)
Synchronizing clocks between senders and receivers
About time to live
requestTimeout
option. You can control this by setting a higher/lower value. However the time to live value is still set on the JMS message being send. So that requires the clocks to be synchronized between the systems. If they are not, then you may want to disable the time to live value being set. This is now possible using the disableTimeToLive
option from Camel 2.8 onwards. So if you set this option to disableTimeToLive=true
, then Camel does not set any time to live value when sending JMS messages. But the request timeout is still active. So for example if you do request/reply over JMS and have disabled time to live, then Camel will still use a timeout by 20 seconds (the requestTimeout
option). That option can of course also be configured. So the two options requestTimeout
and disableTimeToLive
gives you fine grained control when doing request/reply.
from("direct:someWhere") .to("jms:queue:foo?replyTo=bar&requestTimeout=30s") .to("bean:processReply");
requestTimeout
of 30 seconds. So Camel will wait up till 30 seconds for that reply message to come back on the bar queue. If no reply message is received then a org.apache.camel.ExchangeTimedOutException
is set on the Exchange and Camel continues routing the message, which would then fail due the exception, and Camel's error handler reacts.
org.apache.camel.component.jms.JmsConstants#JMS_REQUEST_TIMEOUT
which has constant value "CamelJmsRequestTimeout"
with a timeout value as long type.
whatIsTheTimeout
method on the service bean as shown below:
from("direct:someWhere") .setHeader("CamelJmsRequestTimeout", method(ServiceBean.class, "whatIsTheTimeout")) .to("jms:queue:foo?replyTo=bar&requestTimeout=30s") .to("bean:processReply");
timeToLive
option. For example to indicate a 5 sec., you set timeToLive=5000
. The option disableTimeToLive
can be used to force disabling the time to live, also for InOnly messaging. The requestTimeout
option is not being used for InOnly messaging.
Enabling Transacted Consumption
transacted
= truetransactionManager
= a Transsaction Manager \- typically theJmsTransactionManager
transacted
= truelazyCreateTransactionManager
= false
Using JMSReplyTo for late replies
javax.jms.Destination
object, having the key ReplyTo
. You can obtain this Destination
as follows:
Destination replyDestination = exchange.getIn().getHeader(JmsConstants.JMS_REPLY_DESTINATION, Destination.class);
// we need to pass in the JMS component, and in this sample we use ActiveMQ JmsEndpoint endpoint = JmsEndpoint.newInstance(replyDestination, activeMQComponent); // now we have the endpoint we can use regular Camel API to send a message to it template.sendBody(endpoint, "Here is the late reply.");
replyDestination
object in the same Exchange property when sending. Camel will then pick up this property and use it for the real destination. The endpoint URI must include a dummy destination, however. For example:
// we pretend to send it to some non existing dummy queue template.send("activemq:queue:dummy, new Processor() { public void process(Exchange exchange) throws Exception { // and here we override the destination with the ReplyTo destination object so the message is sent to there instead of dummy exchange.getIn().setHeader(JmsConstants.JMS_DESTINATION, replyDestination); exchange.getIn().setBody("Here is the late reply."); } }
Using a request timeout
requestBody
method = InOut
) to the slow queue for further processing in Camel and we wait for a return reply:
// send a in-out with a timeout for 5 sec Object out = template.requestBody("activemq:queue:slow?requestTimeout=5000", "Hello World");
Samples
Receiving from JMS
from("jms:queue:foo"). to("bean:myBusinessLogic");
from("jms:topic:OrdersTopic"). filter().method("myBean", "isGoldCustomer"). to("jms:queue:BigSpendersQueue");
Sending to a JMS
TextMessage
instead of a BytesMessage
, we need to convert the body to a String
:
from("file://orders"). convertBodyTo(String.class). to("jms:topic:OrdersTopic");
Using Annotations
Spring DSL sample
<route> <from uri="jms:topic:OrdersTopic"/> <filter> <method bean="myBean" method="isGoldCustomer"/> <to uri="jms:queue:BigSpendersQueue"/> </filter> </route>
Other samples
Using JMS as a Dead Letter Queue storing Exchange
javax.jms.ObjectMessage
that holds a org.apache.camel.impl.DefaultExchangeHolder
. This allows you to consume from the Dead Letter Queue and retrieve the caused exception from the Exchange property with the key Exchange.EXCEPTION_CAUGHT
. The demo below illustrates this:
// setup error handler to use JMS as queue and store the entire Exchange errorHandler(deadLetterChannel("jms:queue:dead?transferExchange=true"));
from("jms:queue:dead").to("bean:myErrorAnalyzer"); // and in our bean String body = exchange.getIn().getBody(); Exception cause = exchange.getProperty(Exchange.EXCEPTION_CAUGHT, Exception.class); // the cause message is String problem = cause.getMessage();
Using JMS as a Dead Letter Channel storing error only
// we sent it to a seda dead queue first errorHandler(deadLetterChannel("seda:dead")); // and on the seda dead queue we can do the custom transformation before its sent to the JMS queue from("seda:dead").transform(exceptionMessage()).to("jms:queue:dead");
Sending an InOnly message and keeping the JMSReplyTo header
template.send("activemq:queue:foo?preserveMessageQos=true", new Processor() { public void process(Exchange exchange) throws Exception { exchange.getIn().setBody("World"); exchange.getIn().setHeader("JMSReplyTo", "bar"); } });
preserveMessageQos=true
to instruct Camel to keep the JMSReplyTo header.
Setting JMS provider options on the destination
... .setHeader("CamelJmsDestinationName", constant("queue:///MY_QUEUE?targetClient=1")) .to("wmq:queue:MY_QUEUE?useMessageIDAsCorrelationID=true");
com.ibm.msg.client.jms.DetailedJMSException: JMSCC0005: The specified value 'MY_QUEUE?targetClient=1' is not allowed for 'XMSC_DESTINATION_NAME'
JmsComponent wmq = new JmsComponent(connectionFactory); wmq.setDestinationResolver(new DestinationResolver(){ public Destination resolveDestinationName(Session session, String destinationName, boolean pubSubDomain) throws JMSException { MQQueueSession wmqSession = (MQQueueSession) session; return wmqSession.createQueue("queue:///" + destinationName + "?targetClient=1"); } });
Chapter 75. JMX
JMX Component
Notification
object directly through the exchange or serializing it to XML according to the schema provided within this project. This is a consumer-only component. Exceptions are thrown if you attempt to create a producer for it.
URI Format
jmx://platform?options
jmx:
scheme prefix, as follows:
jmx:service:jmx:rmi:///jndi/rmi://localhost:1099/jmxrmi?options
?option=value&option=value&...
.
URI Options
Property | Required | Default | Description |
---|---|---|---|
format
|
xml
|
Format for the message body. Either xml or raw . If xml , the notification is serialized to XML. If raw , the raw java object is set as the body.
|
|
password
|
Credentials for making a remote connection. | ||
objectDomain
|
Yes | The domain of the MBean you are connecting to. | |
objectName
|
The name key for the MBean you are connecting to. Either this property of a list of keys must be provided (but not both). For more details, see the section called “ObjectName Construction”. | ||
notificationFilter
|
Reference to a bean that implements the NotificationFilter interface. The #beanID syntax should be used to reference the bean in the registry.
|
||
handback
|
Value to hand back to the listener when a notification is received. This value will be put into the jmx.handback message header.
|
||
testConnectionOnStartup
|
true
|
*Camel 2.11* If true, the consumer will throw an exception when unable to establish the JMX connection upon startup. If false, the consumer will attempt to establish the JMX connection every 'x' seconds until the connection is made - where 'x' is the configured reconnectDelay. | |
reconnectOnConnectionFailure
|
false
|
*Camel 2.11* If true, the consumer will attempt to reconnect to the JMX server when any connection failure occurs. The consumer will attempt to re-establish the JMX connection every 'x' seconds until the connection is made-- where 'x' is the configured reconnectDelay. | |
reconnectDelay
|
10
|
*Camel 2.11* The number of seconds to wait before retrying creation of the initial connection or before reconnecting a lost connection. |
ObjectName Construction
objectDomain
property. In addition, the URI must contain either objectName
or one or more properties that start with key
.
Domain with Name property
objectName
property is provided, the following constructor is used to build the ObjectName
instance for the MBean:
ObjectName(String domain, String key, String value)
key
value in the preceding constructor must be name
and the value is the value of the objectName
property.
Domain with Hashtable
ObjectName(String domain, Hashtable<String,String> table)
Hashtable
is constructed by extracting properties that start with key
. The properties will have the key
prefix stripped prior to building the Hashtable
. This allows the URI to contain a variable number of properties to identify the MBean.
Example
from("jmx:platform?objectDomain=jmxExample&key.name=simpleBean"). to("log:jmxEvent");
Full example
examples/camel-example-jmx
directory.
Monitor Type Consumer
CounterMonitor monitor = new CounterMonitor(); monitor.addObservedObject(makeObjectName("simpleBean")); monitor.setObservedAttribute("MonitorNumber"); monitor.setNotify(true); monitor.setInitThreshold(1); monitor.setGranularityPeriod(500); registerBean(monitor, makeObjectName("counter")); monitor.start();
Example
from("jmx:platform?objectDomain=myDomain&objectName=simpleBean&" + "monitorType=counter&observedAttribute=MonitorNumber&initThreshold=1&" + "granularityPeriod=500").to("mock:sink");
MonitorNumber
attribute on the simpleBean
. Additional types of monitor beans and options are detailed below. The newly deployed monitor bean is automatically undeployed when the consumer is stopped.
URI Options for Monitor Type
property | type | applies to | description |
---|---|---|---|
monitorType
|
enum
|
all | one of the counters, guage, string |
observedAttribute
|
string
|
all | the attribute being observed |
granularityPeriod
|
long
|
all | granularity period (in millis) for the attribute being observed. As per JMX, default is 10 seconds |
initThreshold
|
number
|
counter | initial threshold value |
offset
|
number
|
counter | offset value |
modulus
|
number
|
counter | modulus value |
differenceMode
|
boolean
|
counter, gauge | true if difference should be reported, false for actual value |
notifyHigh
|
boolean
|
gauge | high notification on/off switch |
notifyLow
|
boolean
|
gauge | low notification on/off switch |
highThreshold
|
number
|
gauge | threshold for reporting high notification |
lowThreshold
|
number
|
gauge | threshold for reporting low notificaton |
notifyDiffer
|
boolean
|
string | true to fire notification when string differs |
notifyMatch
|
boolean
|
string | true to fire notification when string matches |
stringToCompare
|
string
|
string | string to compare against the attribute value |
Chapter 76. JPA
JPA Component
Sending to the endpoint
Consuming from the endpoint
consumeDelete=false
on the URI. This will result in the entity being processed each poll.
@PreConsumed
which will be invoked on your entity bean before it has been processed (before routing).
URI format
jpa:entityClassName[?options]
?option=value&option=value&...
Options
Name | Default Value | Description |
---|---|---|
entityType
|
entityClassName | Overrides the entityClassName from the URI. |
persistenceUnit
|
camel
|
The JPA persistence unit used by default. |
consumeDelete
|
true
|
JPA consumer only: If true , the entity is deleted after it is consumed; if false , the entity is not deleted.
|
consumeLockEntity
|
true
|
JPA consumer only: Specifies whether or not to set an exclusive lock on each entity bean while processing the results from polling. |
flushOnSend
|
true
|
JPA producer only: Flushes the EntityManager after the entity bean has been persisted. |
maximumResults
|
-1
|
JPA consumer only: Set the maximum number of results to retrieve on the Query. |
transactionManager
|
null
|
This option is Registry based, which requires the # notation so that the given transactionManager being specified can be looked up properly, e.g. transactionManager=#myTransactionManager . It specifies the transaction manager to use. If none provided, Apache Camel will use a JpaTransactionManager by default. Can be used to set a JTA transaction manager (for integration with an EJB container).
|
consumer.delay
|
500
|
JPA consumer only: Delay in milliseconds between each poll. |
consumer.initialDelay
|
1000
|
JPA consumer only: Milliseconds before polling starts. |
consumer.useFixedDelay
|
false
|
JPA consumer only: Set to true to use fixed delay between polls, otherwise fixed rate is used. See ScheduledExecutorService in JDK for details.
|
maxMessagesPerPoll
|
0
|
Apache Camel 2.0:JPA consumer only: An integer value to define the maximum number of messages to gather per poll. By default, no maximum is set. Can be used to avoid polling many thousands of messages when starting up the server. Set a value of 0 or negative to disable. |
consumer.query
|
JPA consumer only: To use a custom query when consuming data. | |
consumer.namedQuery
|
JPA consumer only: To use a named query when consuming data. | |
consumer.nativeQuery
|
JPA consumer only: To use a custom native query when consuming data. | |
consumer.parameters
|
Camel 2.12: JPA consumer only: the parameters map which will be used for building the query. The parameters is an instance of Map which key is String and value is Object. It's is expected to be of the generic type java.util.Map<String, Object> , where the keys are the named parameters of a given JPA query and the values are their corresponding effective values you want to select for.
|
|
consumer.resultClass
|
Camel 2.7: JPA consumer only: Defines the type of the returned payload (we will call entityManager.createNativeQuery(nativeQuery, resultClass) instead of entityManager.createNativeQuery(nativeQuery) ). Without this option, we will return an object array. Only has an affect when using in conjunction with native query when consuming data.
|
|
consumer.transacted
|
false
|
*Camel 2.7.5/2.8.3/2.9: JPA consumer only:* Whether to run the consumer in transacted mode, by which all messages will either commit or rollback, when the entire batch has been processed. The default behavior (false) is to commit all the previously successfully processed messages, and only rollback the last failed message. |
consumer.lockModeType
|
WRITE
|
Camel 2.11.2/2.12: To configure the lock mode on the consumer. The possible values is defined in the enum javax.persistence.LockModeType . The default value is changed to PESSIMISTIC_WRITE since Camel 2.13.
|
consumer.SkipLockedEntity
|
false
|
Camel 2.13: To configure whether to use NOWAIT on lock and silently skip the entity.
|
usePersist
|
false
|
Camel 2.5: JPA producer only: Indicates to use entityManager.persist(entity) instead of entityManager.merge(entity) . Note: entityManager.persist(entity) doesn't work for detached entities (where the EntityManager has to execute an UPDATE instead of an INSERT query)!
|
consumer.SkipLockedEntity
|
false
|
Camel 2.13: To configure whether to use NOWAIT on lock and silently skip the entity.
|
Message Headers
Header | Type | Description |
---|---|---|
CamelEntityManager
|
EntityManager
|
Camel 2.12: JPA consumer / Camel 2.12.2: JPA producer: The JPA EntityManager object being used by JpaConsumer or JpaProducer. |
Configuring EntityManagerFactory
EntityManagerFactory
instance. If you do not do so, each JpaEndpoint
will auto-create its own EntityManagerFactory
instance.For example, you can instantiate a JPA component that references the myEMFactory
entity manager factory, as follows:
<bean id="jpa" class="org.apache.camel.component.jpa.JpaComponent"> <property name="entityManagerFactory" ref="myEMFactory"/> </bean>
JpaComponent
will auto lookup the EntityManagerFactory
from the Registry which means 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.
Configuring TransactionManager
JpaComponent
will auto lookup the TransactionManager
from the Registry. If Camel does not find any TransactionManager
instance registered, it will also look up for the TransactionTemplate
and try to extract TransactionManager
from it. If no TransactionTemplate
is available in the registry, JpaEndpoint
will auto-create its own instance of TransactionManager
.
TransactionManager
is found, Camel logs a WARN
message. In such cases, you might want to instantiate and explicitly configure a JPA component that references the myTransactionManager
transaction manager, as follows:
<bean id="jpa" class="org.apache.camel.component.jpa.JpaComponent"> <property name="entityManagerFactory" ref="myEMFactory"/> <property name="transactionManager" ref="myTransactionManager"/> </bean>
Using a consumer with a named query
consumer.namedQuery
URI query option. First, you have to define the named query in the JPA Entity class:
@Entity @NamedQuery(name = "step1", query = "select x from MultiSteps x where x.step = 1") public class MultiSteps { ... }
from("jpa://org.apache.camel.examples.MultiSteps?consumer.namedQuery=step1") .to("bean:myBusinessLogic");
Using a consumer with a query
consumer.query
URI query option. You only have to define the query option:
from("jpa://org.apache.camel.examples.MultiSteps?consumer.query=select o from org.apache.camel.examples.MultiSteps o where o.step = 1") .to("bean:myBusinessLogic");
Using a consumer with a native query
consumer.nativeQuery
URI query option. You only have to define the native query option:
from("jpa://org.apache.camel.examples.MultiSteps?consumer.nativeQuery=select * from MultiSteps where step = 1") .to("bean:myBusinessLogic");
Example
Using the JPA based idempotent repository
persistence-unit
in the persistence.xml file:
<persistence-unit name="idempotentDb" transaction-type="RESOURCE_LOCAL"> <class>org.apache.camel.processor.idempotent.jpa.MessageProcessed</class> <properties> <property name="openjpa.ConnectionURL" value="jdbc:derby:target/idempotentTest;create=true"/> <property name="openjpa.ConnectionDriverName" value="org.apache.derby.jdbc.EmbeddedDriver"/> <property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema"/> <property name="openjpa.Log" value="DefaultLevel=WARN, Tool=INFO"/> </properties> </persistence-unit>
org.springframework.orm.jpa.JpaTemplate
which is used by the org.apache.camel.processor.idempotent.jpa.JpaMessageIdRepository
:
<!-- this is standard spring JPA configuration --> <bean id="jpaTemplate" class="org.springframework.orm.jpa.JpaTemplate"> <property name="entityManagerFactory" ref="entityManagerFactory"/> </bean> <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean"> <!-- we use idempotentDB as the persitence unit name defined in the persistence.xml file --> <property name="persistenceUnitName" value="idempotentDb"/> </bean>
org.apache.camel.processor.idempotent.jpa.JpaMessageIdRepository
:
<!-- we define our jpa based idempotent repository we want to use in the file consumer --> <bean id="jpaStore" class="org.apache.camel.processor.idempotent.jpa.JpaMessageIdRepository"> <!-- Here we refer to the spring jpaTemplate --> <constructor-arg index="0" ref="jpaTemplate"/> <!-- This 2nd parameter is the name (= a cateogry name). You can have different repositories with different names --> <constructor-arg index="1" value="FileConsumer"/> </bean>
<camelContext xmlns="http://camel.apache.org/schema/spring"> <route id="JpaMessageIdRepositoryTest"> <from uri="direct:start" /> <idempotentConsumer messageIdRepositoryRef="jpaStore"> <header>messageId</header> <to uri="mock:result" /> </idempotentConsumer> </route> </camelContext>
Chapter 77. Jsch
Jsch
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-jsch</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
scp://host[:port]/destination[?options]
?option=value&option=value&...
Exchange.FILE_NAME
if used in code).
Options
Name | Description | Example | Default Value |
---|---|---|---|
username
|
Specifies the username to use to log in to the remote file system. |
null
|
|
password
|
Specifies the password to use to log in to the remote file system. |
null
|
|
knownHostsFile
|
Sets the known_hosts file, so that the scp endpoint can do host key verification.
|
null
|
|
strictHostKeyChecking
|
Sets whether to use strict host key checking. Possible values are: no , yes
|
no
|
|
chmod
|
Allows you to set chmod on the stored file. For example chmod=664 .
|
null
|
|
useUserKnownHostsFile
|
Camel 2.15: If knownHostFile has not been explicitly configured, use the host file from System.getProperty("user.home") + "/.ssh/known_hosts" .
|
true
|
Component options
Name | Description | Default Value |
---|---|---|
verboseLogging
|
Camel 2.15: JSCH is verbose logging out of the box. Therefore, we turn the logging down to DEBUG logging by default.
|
true
|
Limitations
camel-jsch
supports only a Producer (i.e. copy files to another host).
Chapter 78. JT400
JT/400 Component
jt400
component allows you to exchanges messages with an AS/400 system using data queues.
URI format
jt400://user:password@system/QSYS.LIB/LIBRARY.LIB/QUEUE.DTAQ[?options]
jt400://user:password@system/QSYS.LIB/LIBRARY.LIB/program.PGM[?options]
?option=value&option=value&...
URI options
Name | Default value | Description |
---|---|---|
ccsid
|
default system CCSID | Specifies the CCSID to use for the connection with the AS/400 system. |
format
|
text
|
Specifies the data format for sending messages valid options are: text (represented by String ) and binary (represented by byte[] )
|
consumer.delay
|
500
|
Delay in milliseconds between each poll. |
consumer.initialDelay
|
1000
|
Milliseconds before polling starts. |
consumer.userFixedDelay
|
false
|
true to use fixed delay between polls, otherwise fixed rate is used. See ScheduledExecutorService in JDK for details.
|
guiAvailable
|
false
|
Camel 2.8: Specifies whether AS/400 prompting is enabled in the environment running Camel. |
keyed
|
false
|
*Camel 2.10:* Whether to use keyed or non-keyed data queues. |
searchKey
|
null
|
*Camel 2.10:* Search key for keyed data queues. |
searchType
|
EQ
|
*Camel 2.10:* Search type which can be a value of EQ , NE , LT , LE , GT , or GE .
|
connectionPool
|
AS400ConnectionPool instance
|
*Camel 2.10:* Reference to an com.ibm.as400.access.AS400ConnectionPool instance in the Registry. This is used for obtaining connections to the AS/400 system. The look up notation ('#' character) should be used. |
Name | Default value | Description |
---|---|---|
outputFieldsIdx
|
Specifies which fields (program parameters) are output parameters. | |
fieldsLength
|
Specifies the fields (program parameters) length as in the AS/400 program definition. | |
format
|
text
|
*Camel 2.10:* Specifies the data format for sending messages valid options are: text (represented by String ) and binary (represented by byte[] )
|
guiAvailable
|
false
|
*Camel 2.8:* Specifies whether AS/400 prompting is enabled in the environment running Camel. |
connectionPool
|
AS400ConnectionPool instance
|
*Camel 2.10:* Reference to an com.ibm.as400.access.AS400ConnectionPool instance in the Registry. This is used for obtaining connections to the AS/400 system. The look up notation ('#' character) should be used. |
Usage
Exchange
is sent with the entry's data in the In message's body, 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.
Connection pool
Remote program call (Camel 2.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!
Example
direct:george
endpoint will be put in the data queue PENNYLANE
in library BEATLES
on a system named LIVERPOOL
. Another user connects to the same data queue to receive the information from the data queue and forward it to the mock:ringo
endpoint.
public class Jt400RouteBuilder extends RouteBuilder { @Override public void configure() throws Exception { from("direct:george").to("jt400://GEORGE:EGROEG@LIVERPOOL/QSYS.LIB/BEATLES.LIB/PENNYLANE.DTAQ"); from("jt400://RINGO:OGNIR@LIVERPOOL/QSYS.LIB/BEATLES.LIB/PENNYLANE.DTAQ").to("mock:ringo"); } }
Remote program call example (Camel 2.7)
public class Jt400RouteBuilder extends RouteBuilder { @Override public void configure() throws Exception { from("direct:work").to("jt400://GRUPO:ATWORK@server/QSYS.LIB/assets.LIB/compute.PGM?fieldsLength=10,10,512&ouputFieldsIdx=2,3").to("direct:play"); } }
Writing to keyed data queues
from("jms:queue:input") .to("jt400://username:password@system/lib.lib/MSGINDQ.DTAQ?keyed=true");
Reading from keyed data queues
from("jt400://username:password@system/lib.lib/MSGOUTDQ.DTAQ?keyed=true&searchKey=MYKEY&searchType=GE") .to("jms:queue:output");
Chapter 79. Kafka
Kafka Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-kafka</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
kafka:server:port[?options]
Options
Property
|
Default
|
Description
|
---|---|---|
zookeeperHost
|
|
The zookeeper host to use
|
zookeeperPort
|
2181
|
The zookeeper port to use
|
zookeeperConnect | Camel 2.13.3/2.14.1: If in use, then zookeeperHost/zookeeperPort is not used. | |
topic
|
|
The topic to use
|
groupId | ||
partitioner | ||
consumerStreams | 10 | |
clientId | ||
zookeeperSessionTimeoutMs | ||
zookeeperConnectionTimeoutMs | ||
zookeeperSyncTimeMs | ||
consumersCount |
1
|
Camel 2.15.0: The number of consumers that connect to Kafka server. |
batchSize |
100
|
Camel 2.15.0: The batchSize that the BatchingConsumerTask processes once.
|
barrierAwaitTimeoutMs |
10000
|
Camel 2.15.0: If the BatchingConsumerTask processes exchange exceed the batchSize , it will wait for barrierAwaitTimeoutMs .
|
?option=value&option=value&...
Producer Options
Property
|
Default
|
Description
|
---|---|---|
producerType
|
|
|
compressionCodec | ||
compressedTopics | ||
messageSendMaxRetries | ||
retryBackoffMs | ||
topicMetadataRefreshIntervalMs | ||
sendBufferBytes | ||
requestRequiredAcks | ||
requestTimeoutMs | ||
queueBufferingMaxMs | ||
queueBufferingMaxMessages | ||
queueEnqueueTimeoutMs | ||
batchNumMessages | ||
serializerClass | ||
keySerializerClass |
Consumer Options
Property
|
Default
|
Description
|
---|---|---|
consumerId
|
|
|
socketTimeoutMs | ||
socketReceiveBufferBytes | ||
fetchMessageMaxBytes | ||
autoCommitEnable | ||
autoCommitIntervalMs | ||
queuedMaxMessages | ||
rebalanceMaxRetries | ||
fetchMinBytes | ||
fetchWaitMaxMs | ||
rebalanceBackoffMs | ||
refreshLeaderBackoffMs | ||
autoOffsetReset | ||
consumerTimeoutMs |
Samples
from("kafka:localhost:9092?topic=test&zookeeperHost=localhost&zookeeperPort=2181&groupId=group1").to("log:input");
Endpoints
- createProducer() will create a Producer for sending message exchanges to the endpoint
- createConsumer() implements the Event Driven Consumer pattern for consuming message exchanges from the endpoint via a Processor when creating a Consumer
- createPollingConsumer() implements the Polling Consumer pattern for consuming message exchanges from the endpoint via a PollingConsumer
See Also
Chapter 80. Kestrel
Kestrel Component
URI format
kestrel://[addresslist/]queuename[?options]
host:port
pairs. For example, to connect to the queue foo
on kserver01:22133
, use:
kestrel://kserver01:22133/foo
localhost:22133
is assumed, i.e.:
kestrel://foo
host:port
pair in addresslist, the default port 22133 is assumed, i.e.:
kestrel://kserver01/foo
kestrel://kserver01:22133,kserver02:22133,kserver03:22133/massive
kestrel://kserver03:22133/massive?concurrentConsumers=25&waitTimeMs=500
Options
?parameters
portion of the endpoint URI. Any ?parameters
that are omitted will default to what is configured on the KestrelComponent's base KestrelConfiguration. The following properties may be set on KestrelConfiguration and/or each individual endpoint:
Option | Default Value | Description |
---|---|---|
concurrentConsumers
|
1
|
Specifies the number of concurrent consumer threads. |
waitTimeMs
|
100
|
Specifies the /t=... wait time passed to Kestrel on GET requests.
|
/t=...
specifier does not get passed to the server on GET requests. When a queue is empty, the GET call returns immediately with no value. In order to prevent "tight looping" in the polling phase, this component will do a Thread.sleep(100)
whenever nothing is returned from the GET request (only when nothing is returned). You are highly encouraged to configure a positive non-zero value for waitTimeMs.
Configuring the Kestrel component using Spring XML
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd"> <bean id="kestrel" class="org.apache.camel.component.kestrel.KestrelComponent"/> <camelContext xmlns="http://camel.apache.org/schema/spring"> </camelContext> </beans>
localhost:22133
, 100ms wait time, and a single non-concurrent consumer by default.
?properties
are not specified), you can set up a KestrelConfiguration POJO as follows:
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd"> <bean id="kestrelConfiguration" class="org.apache.camel.component.kestrel.KestrelConfiguration"> <property name="addresses" value="kestrel01:22133"/> <property name="waitTimeMs" value="100"/> <property name="concurrentConsumers" value="1"/> </bean> <bean id="kestrel" class="org.apache.camel.component.kestrel.KestrelComponent"> <property name="configuration" ref="kestrelConfiguration"/> </bean> <camelContext xmlns="http://camel.apache.org/schema/spring"> </camelContext> </beans>
Usage Examples
Example 1: Consuming
from("kestrel://kserver02:22133/massive?concurrentConsumers=10&waitTimeMs=500") .bean("myConsumer", "onMessage");
public class MyConsumer { public void onMessage(String message) { ... } }
Example 2: Producing
public class MyProducer { @EndpointInject(uri = "kestrel://kserver01:22133,kserver02:22133/myqueue") ProducerTemplate producerTemplate; public void produceSomething() { producerTemplate.sendBody("Hello, world."); } }
Example 3: Spring XML Configuration
<camelContext xmlns="http://camel.apache.org/schema/spring"> <route> <from uri="kestrel://ks01:22133/sequential?concurrentConsumers=1&waitTimeMs=500"/> <bean ref="myBean" method="onMessage"/> </route> <route> <from uri="direct:start"/> <to uri="kestrel://ks02:22133/stuff"/> </route> </camelContext>
public class MyBean { public void onMessage(String message) { ... } }
Dependencies
spymemcached
2.5 (or greater)
spymemcached
spymemcached
jar on your classpath. Here is a snippet you can use in your pom.xml:
<dependency> <groupId>spy</groupId> <artifactId>memcached</artifactId> <version>2.5</version> </dependency>
/t=...
extension (i.e. if you're using the waitTimeMs
option on an endpoint URI, which is highly encouraged).
enableAssertions
to false
. Please refer to the surefire:test reference for details.
Chapter 81. Krati
Krati Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-krati</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
krati:[the path of the datastore][?options]
?option=value&option=value&...
Krati URI Options
Name | Default Value | Description |
---|---|---|
operation
|
CamelKratiPut | Producer Only. Specifies the type of operation that will be performed to the datastore. Allowed values are CamelKratiPut, CamelKratiGet, CamelKratiDelete & CamelKratiDeleteAll. |
initialCapacity
|
100 | The inital capcity of the store. |
keySerializer
|
KratiDefaultSerializer | The serializer serializer that will be used to serialize the key. |
valueSerializer
|
KratiDefaultSerializer | The serializer serializer that will be used to serialize the value. |
segmentFactory
|
ChannelSegmentFactory | The segment factory to use. Allowed instance classes: ChannelSegmentFactory,MemorySegmentFactory, MappedSegmentFactory & WriteBufferSegmentFactory. |
hashFunction
|
FnvHashFunction | The hash function to use. Allowed instance classes: FnvHashFunction,Fnv1Hash32,FnvHash64,Fnv1aHash32,Fnv1aHash64, JenkisHashFunction, MurmurHashFunctiom |
maxMessagesPerPoll
|
Camel 2.10.5/2.11.1: The maximum number of messages which can be received in one poll. This can be used to avoid reading in too much data and taking up too much memory. |
Message Headers for datastore
Header | Description |
---|---|
CamelKratiOperation
|
The operation to be performed on the datastore. The valid options are
|
CamelKratiKey
|
The key. |
CamelKratiValue
|
The value. |
Usage Samples
Example 1: Putting to the datastore.
from("direct:put").to("krati:target/test/producertest");
<route> <from uri="direct:put"/> <to uri="krati:target/test/producerspringtest"/> </route>
Example 2: Getting/Reading from a datastore
from("direct:get") .setHeader(KratiConstants.KRATI_OPERATION, constant(KratiConstants.KRATI_OPERATION_GET)) .to("krati:target/test/producertest");
<route> <from uri="direct:get"/> <to uri="krati:target/test/producerspringtest?operation=CamelKratiGet"/> </route>
Example 3: Consuming from a datastore
from("krati:target/test/consumertest") .to("direct:next");
<route> <from uri="krati:target/test/consumerspringtest"/> <to uri="mock:results"/> </route>
Idempotent Repository
from("direct://in").idempotentConsumer(header("messageId"), new KratiIdempotentRepositroy("/tmp/idempotent").to("log://out");
See also
Chapter 82. Kura
Kura component
KuraRouter activator
org.apache.camel.kura.KuraRouter
class:
public class MyKuraRouter extends KuraRouter { @Override public void configure() throws Exception { from("timer:trigger"). to("netty-http:http://app.mydatacenter.com/api"); } }
KuraRouter
implements the org.osgi.framework.BundleActivator
interface, so you need to register its start
and stop
lifecycle methods while creating Kura bundle component class.
CamelContext
. It means that for every class extending KuraRouter
, there will be a dedicated CamelContext
instance. Ideally we recommend to deploy one KuraRouter
per OSGi bundle.
Deploying KuraRouter
Import-Package: org.osgi.framework;version="1.3.0", org.slf4j;version="1.6.4", org.apache.camel,org.apache.camel.impl,org.apache.camel.core.osgi,org.apache.camel.builder,org.apache.camel.model, org.apache.camel.component.kura
install file:///home/user/.m2/repository/org/apache/camel/camel-core/2.15.0/camel-core-2.15.0.jar start <camel-core-bundle-id> install file:///home/user/.m2/repository/org/apache/camel/camel-core-osgi/2.15.0/camel-core-osgi-2.15.0.jar start <camel-core-osgi-bundle-id> install file:///home/user/.m2/repository/org/apache/camel/camel-kura/2.15.0/camel-kura-2.15.0.jar start <camel-kura-bundle-id>
install file:///home/user/.m2/repository/org/apache/camel/camel-stream/2.15.0/camel-stream-2.15.0.jar start <camel-stream-bundle-id>
install file:///home/user/.m2/repository/com/example/myrouter/1.0/myrouter-1.0.jar start <your-bundle-id>
KuraRouter utilities
SLF4J logger
log
returns SLF4J logger instance associated with the given Kura router.
public class MyKuraRouter extends KuraRouter { @Override public void configure() throws Exception { log.info("Configuring Camel routes!"); ... } }
BundleContext
bundleContext
returns bundle context associated with the given Kura router.
public class MyKuraRouter extends KuraRouter { @Override public void configure() throws Exception { ServiceReference<MyService> serviceRef = bundleContext.getServiceReference(LogService.class.getName()); MyService myService = content.getService(serviceRef); ... } }
CamelContext
camelContext
is the CamelContext
associated with the given Kura router.
public class MyKuraRouter extends KuraRouter { @Override public void configure() throws Exception { camelContext.getStatus(); ... } }
OSGi service resolver
service(Class<T> serviceType)
) can be used to easily retrieve service by type from the OSGi bundle context.
public class MyKuraRouter extends KuraRouter { @Override public void configure() throws Exception { MyService myService = service(MyService.class); ... } }
KuraRouter activator callbacks
CamelContext
instance associated with the router just before the former is started, override beforeStart
method of the KuraRouter
class:
public class MyKuraRouter extends KuraRouter { ... protected void beforeStart(CamelContext camelContext) { OsgiDefaultCamelContext osgiContext = (OsgiCamelContext) camelContext; osgiContext.setName("NameOfTheRouter"); } }
Chapter 83. Language
Language
language
endpoints where the script is dynamic defined as well.
camel-core
and hence no additional JARs is needed. You only have to include additional Camel components if the language of choice mandates it, such as using Groovy or JavaScript languages.
language://languageName:resource:scheme:location][?options]
URI format
language://languageName[:script][?options]
URI Options
Name | Default Value | Type | Description |
---|---|---|---|
languageName
|
null
|
String
|
The name of the Language to use, such as simple , groovy , javascript etc. This option is mandatory.
|
script
|
null
|
String
|
The script to execute. |
transform
|
true
|
boolean
|
Whether or not the result of the script should be used as the new message body. By setting to false the script is executed but the result of the script is discarded.
|
contentCache
|
true
|
boolean
|
Camel 2.9: Whether to cache the script if loaded from a resource. Note: from Camel 2.10.3 a cached script can be forced to reload at runtime via JMX using the clearContentCache operation.
|
cacheScript
|
false
|
boolean
|
Camel 2.13/2.12.2/2.11.3: Whether to cache the compiled script. Turning this option on can gain performance as the script is only compiled/created once, and reuse when processing Camel messages. But this may cause side-effects with data left from previous evaluation spills into the next, and concurrency issues as well. If the script being evaluated is idempotent then this option can be turned on.
|
binary
|
false
|
boolean
|
Camel 2.14.1: Whether the script is binary content. This is intended to be used for loading resources using the Constant language, such as loading binary files. |
Message Headers
Header | Description |
---|---|
CamelLanguageScript
|
The script to execute provided in the header. Takes precedence over script configured on the endpoint. |
Examples
String script = URLEncoder.encode("Hello ${body}", "UTF-8"); from("direct:start").to("language:simple:" + script).to("mock:result");
String script = URLEncoder.encode("${mandatoryBodyAs(String)}", "UTF-8"); from("direct:start").to("language:simple:" + script).to("mock:result");
from("direct:start").to("language:groovy:request.body * 2").to("mock:result");
<foo>
tag.
Object out = producer.requestBodyAndHeader("language:xpath", "<foo>Hello World</foo>", Exchange.LANGUAGE_SCRIPT, "/foo/text()"); assertEquals("Hello World", out);
Loading scripts from resources
Exchange.LANGUAGE_SCRIPT
header. The uri must start with one of the following schemes: file:, classpath:, or http:
from("direct:start") // load the script from the classpath .to("language:simple:classpath:org/apache/camel/component/language/mysimplescript.txt") .to("mock:result");
contentCache
option and have the script loaded on each evaluation. For example if the file myscript.txt is changed on disk, then the updated script is used:
from("direct:start") // the script will be loaded on each message, as we disabled cache .to("language:simple:file:target/script/myscript.txt?contentCache=false") .to("mock:result");
"resource:"
as shown below:
from("direct:start") // load the script from the classpath .to("language:simple:resource:classpath:org/apache/camel/component/language/mysimplescript.txt") .to("mock:result");
- Routing SlipRouting Slip
- Dynamic RouterDynamic Router
Chapter 84. LDAP
LDAP Component
javax.naming
package) to access the server.
URI format
ldap:ldapServerBean[?options]
ldap
URI cannot appear in the from
at the start of a route.
?option=value&option=value&...
Options
Name | Default Value | Description |
---|---|---|
base
|
ou=system
|
The base DN for searches. |
scope
|
subtree
|
Specifies how deeply to search the tree of entries, starting at the base DN. Value can be object , onelevel , or subtree .
|
pageSize
|
No paging used. |
When specified the LDAP module uses paging to retrieve all results (most LDAP Servers throw an exception when trying to retrieve more than 1000 entries in one query). To be able to use this, an LdapContext (subclass of DirContext ) has to be passed in as ldapServerBean (otherwise an exception is thrown)
|
returnedAttributes
|
Depends on LDAP Server (could be all or none) . | Comma-separated list of attributes that should be set in each entry of the result |
Result
ArrayList<javax.naming.directory.SearchResult>
object.
DirContext
ldap:ldapserver
, references a Spring bean with the ID, ldapserver
. The ldapserver
bean may be defined as follows:
<bean id="ldapserver" class="javax.naming.directory.InitialDirContext" scope="prototype"> <constructor-arg> <props> <prop key="java.naming.factory.initial">com.sun.jndi.ldap.LdapCtxFactory</prop> <prop key="java.naming.provider.url">ldap://localhost:10389</prop> <prop key="java.naming.security.authentication">none</prop> </props> </constructor-arg> </bean>
DirContext
that connects anonymously to a locally hosted LDAP server.
DirContext
objects are not required to support concurrency by contract. It is therefore important that the directory context is declared with the setting, scope="prototype"
, in the bean
definition or that the context supports concurrency. In the Spring framework, prototype
scoped objects are instantiated each time they are looked up.
Samples
ProducerTemplate<Exchange> template = exchange .getContext().createProducerTemplate(); Collection<?> results = (Collection<?>) (template .sendBody( "ldap:ldapserver?base=ou=mygroup,ou=groups,ou=system", "(member=uid=huntc,ou=users,ou=system)")); if (results.size() > 0) { // Extract what we need from the device's profile Iterator<?> resultIter = results.iterator(); SearchResult searchResult = (SearchResult) resultIter .next(); Attributes attributes = searchResult .getAttributes(); Attribute deviceCNAttr = attributes.get("cn"); String deviceCN = (String) deviceCNAttr.get(); ...
(cn=*)
Binding using credentials
Properties props = new Properties(); props.setProperty(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory"); props.setProperty(Context.PROVIDER_URL, "ldap://localhost:389"); props.setProperty(Context.URL_PKG_PREFIXES, "com.sun.jndi.url"); props.setProperty(Context.REFERRAL, "ignore"); props.setProperty(Context.SECURITY_AUTHENTICATION, "simple"); props.setProperty(Context.SECURITY_PRINCIPAL, "cn=Manager"); props.setProperty(Context.SECURITY_CREDENTIALS, "secret"); SimpleRegistry reg = new SimpleRegistry(); reg.put("myldap", new InitialLdapContext(props, null)); CamelContext context = new DefaultCamelContext(reg); context.addRoutes( new RouteBuilder() { public void configure() throws Exception { from("direct:start").to("ldap:myldap?base=ou=test"); } } ); context.start(); ProducerTemplate template = context.createProducerTemplate(); Endpoint endpoint = context.getEndpoint("direct:start"); Exchange exchange = endpoint.createExchange(); exchange.getIn().setBody("(uid=test)"); Exchange out = template.send(endpoint, exchange); Collection<SearchResult> data = out.getOut().getBody(Collection.class); assert data != null; assert !data.isEmpty(); System.out.println(out.getOut().getBody()); context.stop();
Configuring SSL
InitialDirContext
bean, as shown in the following example:
<?xml version="1.0" encoding="UTF-8"?> <blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.osgi.org/xmlns/blueprint/v1.0.0 http://www.osgi.org/xmlns/blueprint/v1.0.0/blueprint.xsd http://camel.apache.org/schema/blueprint http://camel.apache.org/schema/blueprint/camel-blueprint.xsd"> <sslContextParameters xmlns="http://camel.apache.org/schema/blueprint" id="sslContextParameters"> <keyManagers keyPassword="{{keystore.pwd}}"> <keyStore resource="{{keystore.url}}" password="{{keystore.pwd}}"/> </keyManagers> </sslContextParameters> <bean id="customSocketFactory" class="zotix.co.util.CustomSocketFactory"> <argument ref="sslContextParameters" /> </bean> <bean id="ldapserver" class="javax.naming.directory.InitialDirContext" scope="prototype"> <argument> <props> <prop key="java.naming.factory.initial" value="com.sun.jndi.ldap.LdapCtxFactory"/> <prop key="java.naming.provider.url" value="ldaps://lab.zotix.co:636"/> <prop key="java.naming.security.protocol" value="ssl"/> <prop key="java.naming.security.authentication" value="simple" /> <prop key="java.naming.security.principal" value="cn=Manager,dc=example,dc=com"/> <prop key="java.naming.security.credentials" value="passw0rd"/> <prop key="java.naming.ldap.factory.socket" value="zotix.co.util.CustomSocketFactory"/> </props> </argument> </bean> </blueprint>
CustomSocketFactory
class is implemented as follows:
import org.apache.camel.util.jsse.SSLContextParameters; import javax.net.SocketFactory; import javax.net.ssl.SSLContext; import javax.net.ssl.SSLSocketFactory; import javax.net.ssl.TrustManagerFactory; import java.io.IOException; import java.net.InetAddress; import java.net.Socket; import java.security.KeyStore; /** * The CustomSocketFactory. Loads the KeyStore and creates an instance of SSLSocketFactory */ public class CustomSocketFactory extends SSLSocketFactory { private static SSLSocketFactory socketFactory; /** * Called by the getDefault() method. */ public CustomSocketFactory() { } /** * Called by Blueprint DI to initialise an instance of SocketFactory * * @param sslContextParameters */ public CustomSocketFactory(SSLContextParameters sslContextParameters) { try { KeyStore keyStore = sslContextParameters.getKeyManagers().getKeyStore().createKeyStore(); TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509"); tmf.init(keyStore); SSLContext ctx = SSLContext.getInstance("TLS"); ctx.init(null, tmf.getTrustManagers(), null); socketFactory = ctx.getSocketFactory(); } catch (Exception ex) { ex.printStackTrace(System.err); /* handle exception */ } } /** * Getter for the SocketFactory * * @return */ public static SocketFactory getDefault() { return new CustomSocketFactory(); } @Override public String[] getDefaultCipherSuites() { return socketFactory.getDefaultCipherSuites(); } @Override public String[] getSupportedCipherSuites() { return socketFactory.getSupportedCipherSuites(); } @Override public Socket createSocket(Socket socket, String string, int i, boolean bln) throws IOException { return socketFactory.createSocket(socket, string, i, bln); } @Override public Socket createSocket(String string, int i) throws IOException { return socketFactory.createSocket(string, i); } @Override public Socket createSocket(String string, int i, InetAddress ia, int i1) throws IOException { return socketFactory.createSocket(string, i, ia, i1); } @Override public Socket createSocket(InetAddress ia, int i) throws IOException { return socketFactory.createSocket(ia, i); } @Override public Socket createSocket(InetAddress ia, int i, InetAddress ia1, int i1) throws IOException { return socketFactory.createSocket(ia, i, ia1, i1); } }
Chapter 85. LevelDB
LevelDB
- LevelDBAggregationRepository
Using LevelDBAggregationRepository
LevelDBAggregationRepository
is an AggregationRepository
which on the fly persists the aggregated messages. This ensures that you will not loose messages, as the default aggregator will use an in memory only AggregationRepository
.
Option | Type | Description |
---|---|---|
repositoryName
|
String |
A mandatory repository name. Allows you to use a shared LevelDBFile for multiple repositories.
|
persistentFileName
|
String | Filename for the persistent storage. If no file exists on startup a new file is created. |
levelDBFile
|
LevelDBFile |
Use an existing configured org.apache.camel.component.leveldb.LevelDBFile instance.
|
sync
|
boolean | Camel 2.12: Whether or not the LevelDBFile should sync on write or not. Default is false. By sync on write ensures that its always waiting for all writes to be spooled to disk and thus will not loose updates. See LevelDB docs for more details about async vs sync writes. |
returnOldExchange
|
boolean |
Whether the get operation should return the old existing Exchange if any existed. By default this option is false to optimize as we do not need the old exchange when aggregating.
|
useRecovery
|
boolean |
Whether or not recovery is enabled. This option is by default true . When enabled the Camel Aggregator automatic recover failed aggregated exchange and have them resubmitted.
|
recoveryInterval
|
long | If recovery is enabled then a background task is run every x'th time to scan for failed exchanges to recover and resubmit. By default this interval is 5000 millis. |
maximumRedeliveries
|
int |
Allows you to limit the maximum number of redelivery attempts for a recovered exchange. If enabled then the Exchange will be moved to the dead letter channel if all redelivery attempts failed. By default this option is disabled. If this option is used then the deadLetterUri option must also be provided.
|
deadLetterUri
|
String |
An endpoint uri for a Dead Letter Channel where exhausted recovered Exchanges will be moved. If this option is used then the maximumRedeliveries option must also be provided.
|
repositoryName
option must be provided. Then either the persistentFileName
or the levelDBFile
must be provided.
What is preserved when persisting
LevelDBAggregationRepository
will only preserve any Serializable
compatible data types. If a data type is not such a type its dropped and a WARN
is logged. And it only persists the Message
body and the Message
headers. The Exchange
properties are not persisted.
Recovery
LevelDBAggregationRepository
will by default recover any failed Exchange. It does this by having a background tasks that scans for failed Exchanges in the persistent store. You can use the checkInterval
option to set how often this task runs. The recovery works as transactional which ensures that Camel will try to recover and redeliver the failed Exchange. Any Exchange which was found to be recovered will be restored from the persistent store and resubmitted and send out again.
Header | Type | Description |
---|---|---|
Exchange.REDELIVERED
|
Boolean | Is set to true to indicate the Exchange is being redelivered. |
Exchange.REDELIVERY_COUNTER
|
Integer | The redelivery attempt, starting from 1. |
confirm
method is invoked on the AggregationRepository
. This means if the same Exchange fails again it will be kept retried until it success.
maximumRedeliveries
to limit the maximum number of redelivery attempts for a given recovered Exchange. You must also set the deadLetterUri
option so Camel knows where to send the Exchange when the maximumRedeliveries
was hit.
Using LevelDBAggregationRepository in Java DSL
target/data/leveldb.dat
file.
public void configure() throws Exception { // create the leveldb repo LevelDBAggregationRepository repo = new LevelDBAggregationRepository("repo1", "target/data/leveldb.dat"); // here is the Camel route where we aggregate from("direct:start") .aggregate(header("id"), new MyAggregationStrategy()) // use our created leveldb repo as aggregation repository .completionSize(5).aggregationRepository(repo) .to("mock:aggregated"); }
Using LevelDBAggregationRepository in Spring XML
<!-- a persistent aggregation repository using camel-leveldb --> <bean id="repo" class="org.apache.camel.component.leveldb.LevelDBAggregationRepository"> <!-- store the repo in the leveldb.dat file --> <property name="persistentFileName" value="target/data/leveldb.dat"/> <!-- and use repo2 as the repository name --> <property name="repositoryName" value="repo2"/> </bean> <!-- aggregate the messages using this strategy --> <bean id="myAggregatorStrategy" class="org.apache.camel.component.leveldb.LevelDBSpringAggregateTest$MyAggregationStrategy"/> <!-- this is the camel routes --> <camelContext id="camel" xmlns="http://camel.apache.org/schema/spring"> <route> <from uri="direct:start"/> <!-- aggregate using our strategy and leveldb repo, and complete when we have 5 messages aggregated --> <aggregate strategyRef="myAggregatorStrategy" aggregationRepositoryRef="repo" completionSize="5"> <!-- correlate by header with the key id --> <correlationExpression><header>id</header></correlationExpression> <!-- send aggregated messages to the mock endpoint --> <to uri="mock:aggregated"/> </aggregate> </route> </camelContext>
Dependencies
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-leveldb</artifactId> <version>2.10.0</version> </dependency>
Chapter 86. LinkedIn
LinkedIn Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-linkedin</artifactId> <version>${camel-version}</version> </dependency>
URI format
linkedin://endpoint-prefix/endpoint?[options]
endpoint-prefix
can be one of:
comments
companies
groups
jobs
people
posts
search
LinkedInComponent
Option | Type | Description |
---|---|---|
clientId
|
String
|
LinkedIn application client ID |
clientSecret
|
String
|
LinkedIn application client secret |
httpParams
|
java.util.Map
|
Custom HTTP params, for example proxy host and port, use constants from AllClientPNames |
lazyAuth
|
boolean
|
Flag to enable/disable lazy OAuth, default is true. when enabled, OAuth token retrieval or generation is not done until the first REST call |
redirectUri
|
String
|
Application redirect URI, although the component never redirects to this page to avoid having to have a functioning redirect server. So for testing one could use https://localhost |
scopes
|
org.apache.camel.component.linkedin.api.OAuthScope[]
|
List of LinkedIn scopes as specified at https://developer.linkedin.com/documents/authentication#granting |
secureStorage
|
org.apache.camel.component.linkedin.api.OAuthSecureStorage
|
Callback interface for providing an OAuth token or to store the token generated by the component. The callback should return null on the first call and then save the created token in the saveToken() callback. If the callback returns null the first time, a userPassword MUST be provided |
userName
|
String
|
LinkedIn user account name, MUST be provided |
userPassword
|
String
|
LinkedIn account password |
Producer Endpoints:
Endpoint prefix comments
linkedin://comments/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
getComment
|
comment
|
comment_id , fields
|
org.apache.camel.component.linkedin.api.model.Comment
|
removeComment
|
comment
|
comment_id
|
URI Options for comments
Name | Type |
---|---|
comment_id
|
String
|
fields
|
String
|
Endpoint prefix companies
linkedin://companies/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
addCompanyUpdateComment
|
companyUpdateComment
|
company_id , update_key , updatecomment
|
|
addCompanyUpdateCommentAsCompany
|
companyUpdateCommentAsCompany
|
company_id , update_key , updatecomment
|
|
addShare
|
share
|
company_id , share
|
|
getCompanies
|
companies
|
email_domain , fields , is_company_admin
|
org.apache.camel.component.linkedin.api.model.Companies
|
getCompanyById
|
companyById
|
company_id , fields
|
org.apache.camel.component.linkedin.api.model.Company
|
getCompanyByName
|
companyByName
|
fields , universal_name
|
org.apache.camel.component.linkedin.api.model.Company
|
getCompanyUpdateComments
|
companyUpdateComments
|
company_id , fields , secure_urls , update_key
|
org.apache.camel.component.linkedin.api.model.Comments
|
getCompanyUpdateLikes
|
companyUpdateLikes
|
company_id , fields , secure_urls , update_key
|
org.apache.camel.component.linkedin.api.model.Likes
|
getCompanyUpdates
|
companyUpdates
|
company_id , count , event_type , fields , start
|
org.apache.camel.component.linkedin.api.model.Updates
|
getHistoricalFollowStatistics
|
historicalFollowStatistics
|
company_id , end_timestamp , start_timestamp , time_granularity
|
org.apache.camel.component.linkedin.api.model.HistoricalFollowStatistics
|
getHistoricalStatusUpdateStatistics
|
historicalStatusUpdateStatistics
|
company_id , end_timestamp , start_timestamp , time_granularity , update_key
|
org.apache.camel.component.linkedin.api.model.HistoricalStatusUpdateStatistics
|
getNumberOfFollowers
|
numberOfFollowers
|
companySizes , company_id , geos , industries , jobFunc , seniorities
|
org.apache.camel.component.linkedin.api.model.NumFollowers
|
getStatistics
|
statistics
|
company_id
|
org.apache.camel.component.linkedin.api.model.CompanyStatistics
|
isShareEnabled
|
company_id
|
org.apache.camel.component.linkedin.api.model.IsCompanyShareEnabled
|
|
isViewerShareEnabled
|
company_id
|
org.apache.camel.component.linkedin.api.model.IsCompanyShareEnabled
|
|
likeCompanyUpdate
|
company_id , isliked , update_key
|
URI Options for companies
Name | Type |
---|---|
companySizes
|
java.util.List
|
company_id
|
Long
|
count
|
Long
|
email_domain
|
String
|
end_timestamp
|
Long
|
event_type
|
org.apache.camel.component.linkedin.api.Eventtype
|
fields
|
String
|
geos
|
java.util.List
|
industries
|
java.util.List
|
is_company_admin
|
Boolean
|
isliked
|
org.apache.camel.component.linkedin.api.model.IsLiked
|
jobFunc
|
java.util.List
|
secure_urls
|
Boolean
|
seniorities
|
java.util.List
|
share
|
org.apache.camel.component.linkedin.api.model.Share
|
start
|
Long
|
start_timestamp
|
Long
|
time_granularity
|
org.apache.camel.component.linkedin.api.Timegranularity
|
universal_name
|
String
|
update_key
|
String
|
updatecomment
|
org.apache.camel.component.linkedin.api.model.UpdateComment
|
Endpoint prefix groups
linkedin://groups/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
addPost
|
post
|
group_id , post
|
|
getGroup
|
group
|
group_id
|
org.apache.camel.component.linkedin.api.model.Group
|
URI Options for groups
Name | Type |
---|---|
group_id
|
Long
|
post
|
org.apache.camel.component.linkedin.api.model.Post
|
Endpoint prefix jobs
linkedin://jobs/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
addJob
|
job
|
job
|
|
editJob
|
job , partner_job_id
|
||
getJob
|
job
|
fields , job_id
|
org.apache.camel.component.linkedin.api.model.Job
|
removeJob
|
job
|
partner_job_id
|
URI Options for jobs
Name | Type |
---|---|
fields
|
String
|
job
|
org.apache.camel.component.linkedin.api.model.Job
|
job_id
|
Long
|
partner_job_id
|
Long
|
Endpoint prefix people
linkedin://people/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
addActivity
|
activity
|
activity
|
|
addGroupMembership
|
groupMembership
|
groupmembership
|
|
addInvite
|
invite
|
mailboxitem
|
|
addJobBookmark
|
jobBookmark
|
jobbookmark
|
|
addUpdateComment
|
updateComment
|
update_key , updatecomment
|
|
followCompany
|
company
|
||
getConnections
|
connections
|
fields , secure_urls
|
org.apache.camel.component.linkedin.api.model.Connections
|
getConnectionsById
|
connectionsById
|
fields , person_id , secure_urls
|
org.apache.camel.component.linkedin.api.model.Connections
|
getConnectionsByUrl
|
connectionsByUrl
|
fields , public_profile_url , secure_urls
|
org.apache.camel.component.linkedin.api.model.Connections
|
getFollowedCompanies
|
followedCompanies
|
fields
|
org.apache.camel.component.linkedin.api.model.Companies
|
getGroupMembershipSettings
|
groupMembershipSettings
|
count , fields , group_id , start
|
org.apache.camel.component.linkedin.api.model.GroupMemberships
|
getGroupMemberships
|
groupMemberships
|
count , fields , membership_state , start
|
org.apache.camel.component.linkedin.api.model.GroupMemberships
|
getJobBookmarks
|
jobBookmarks
|
org.apache.camel.component.linkedin.api.model.JobBookmarks
|
|
getNetworkStats
|
networkStats
|
org.apache.camel.component.linkedin.api.model.NetworkStats
|
|
getNetworkUpdates
|
networkUpdates
|
after , before , count , fields , scope , secure_urls , show_hidden_members , start , type
|
org.apache.camel.component.linkedin.api.model.Updates
|
getNetworkUpdatesById
|
networkUpdatesById
|
after , before , count , fields , person_id , scope , secure_urls , show_hidden_members , start , type
|
org.apache.camel.component.linkedin.api.model.Updates
|
getPerson
|
person
|
fields , secure_urls
|
org.apache.camel.component.linkedin.api.model.Person
|
getPersonById
|
personById
|
fields , person_id , secure_urls
|
org.apache.camel.component.linkedin.api.model.Person
|
getPersonByUrl
|
personByUrl
|
fields , public_profile_url , secure_urls
|
org.apache.camel.component.linkedin.api.model.Person
|
getPosts
|
posts
|
category , count , fields , group_id , modified_since , order , role , start
|
org.apache.camel.component.linkedin.api.model.Posts
|
getSuggestedCompanies
|
suggestedCompanies
|
fields
|
org.apache.camel.component.linkedin.api.model.Companies
|
getSuggestedGroupPosts
|
suggestedGroupPosts
|
category , count , fields , group_id , modified_since , order , role , start
|
org.apache.camel.component.linkedin.api.model.Posts
|
getSuggestedGroups
|
suggestedGroups
|
fields
|
org.apache.camel.component.linkedin.api.model.Groups
|
getSuggestedJobs
|
suggestedJobs
|
fields
|
org.apache.camel.component.linkedin.api.model.JobSuggestions
|
getUpdateComments
|
updateComments
|
fields , secure_urls , update_key
|
org.apache.camel.component.linkedin.api.model.Comments
|
getUpdateLikes
|
updateLikes
|
fields , secure_urls , update_key
|
org.apache.camel.component.linkedin.api.model.Likes
|
likeUpdate
|
isliked , update_key
|
||
removeGroupMembership
|
groupMembership
|
group_id
|
|
removeGroupSuggestion
|
groupSuggestion
|
group_id
|
|
removeJobBookmark
|
jobBookmark
|
job_id
|
|
share
|
share
|
org.apache.camel.component.linkedin.api.model.Update
|
|
stopFollowingCompany
|
company_id
|
||
updateGroupMembership
|
group_id , groupmembership
|
URI Options for people
Name | Type |
---|---|
activity
|
org.apache.camel.component.linkedin.api.model.Activity
|
after
|
Long
|
before
|
Long
|
category
|
org.apache.camel.component.linkedin.api.Category
|
company
|
org.apache.camel.component.linkedin.api.model.Company
|
company_id
|
Long
|
count
|
Long
|
fields
|
String
|
group_id
|
Long
|
groupmembership
|
org.apache.camel.component.linkedin.api.model.GroupMembership
|
isliked
|
org.apache.camel.component.linkedin.api.model.IsLiked
|
job_id
|
Long
|
jobbookmark
|
org.apache.camel.component.linkedin.api.model.JobBookmark
|
mailboxitem
|
org.apache.camel.component.linkedin.api.model.MailboxItem
|
membership_state
|
org.apache.camel.component.linkedin.api.model.MembershipState
|
modified_since
|
Long
|
order
|
org.apache.camel.component.linkedin.api.Order
|
person_id
|
String
|
public_profile_url
|
String
|
role
|
org.apache.camel.component.linkedin.api.Role
|
scope
|
String
|
secure_urls
|
Boolean
|
share
|
org.apache.camel.component.linkedin.api.model.Share
|
show_hidden_members
|
Boolean
|
start
|
Long
|
type
|
org.apache.camel.component.linkedin.api.Type
|
update_key
|
String
|
updatecomment
|
org.apache.camel.component.linkedin.api.model.UpdateComment
|
Endpoint prefix posts
linkedin://posts/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
addComment
|
comment
|
comment , post_id
|
|
flagCategory
|
post_id , postcategorycode
|
||
followPost
|
isfollowing , post_id
|
||
getPost
|
post
|
count , fields , post_id , start
|
org.apache.camel.component.linkedin.api.model.Post
|
getPostComments
|
postComments
|
count , fields , post_id , start
|
org.apache.camel.component.linkedin.api.model.Comments
|
likePost
|
isliked , post_id
|
||
removePost
|
post
|
post_id
|
URI Options for posts
Name | Type |
---|---|
comment
|
org.apache.camel.component.linkedin.api.model.Comment
|
count
|
Long
|
fields
|
String
|
isfollowing
|
org.apache.camel.component.linkedin.api.model.IsFollowing
|
isliked
|
org.apache.camel.component.linkedin.api.model.IsLiked
|
post_id
|
String
|
postcategorycode
|
org.apache.camel.component.linkedin.api.model.PostCategoryCode
|
start
|
Long
|
Endpoint prefix search
linkedin://search/endpoint?[options]
Endpoint | Shorthand Alias | Options | Result Body Type |
---|---|---|---|
searchCompanies
|
companies
|
count , facet , facets , fields , hq_only , keywords , sort , start
|
org.apache.camel.component.linkedin.api.model.CompanySearch
|
searchJobs
|
jobs
|
company_name , count , country_code , distance , facet , facets , fields , job_title , keywords , postal_code , sort , start
|
org.apache.camel.component.linkedin.api.model.JobSearch
|
searchPeople
|
people
|
company_name , count , country_code , current_company , current_school , current_title , distance , facet , facets , fields , first_name , keywords , last_name , postal_code , school_name , sort , start , title
|
org.apache.camel.component.linkedin.api.model.PeopleSearch
|
URI Options for search
Name | Type |
---|---|
company_name
|
String
|
count
|
Long
|
country_code
|
String
|
current_company
|
String
|
current_school
|
String
|
current_title
|
String
|
distance
|
org.apache.camel.component.linkedin.api.model.Distance
|
facet
|
String
|
facets
|
String
|
fields
|
String
|
first_name
|
String
|
hq_only
|
String
|
job_title
|
String
|
keywords
|
String
|
last_name
|
String
|
postal_code
|
String
|
school_name
|
String
|
sort
|
String
|
start
|
Long
|
title
|
String
|
Consumer Endpoints
Message Headers
Message body
Use cases
from("direct:foo") .to("linkedin://people/person");
from("linkedin://people/connections?consumer.timeUnit=SECONDS&consumer.delay=30") .to("bean:foo");
from("direct:foo") .setHeader("CamelLinkedIn.person_id", header("personId")) .to("linkedin://people/connectionsById") .to("bean://bar");
Chapter 87. List
List Component
URI format
list:someName
Sample
from("activemq:order.in").to("list:orderReceived").to("bean:processOrder");
private CamelContext context; public void inspectRecievedOrders() { BrowsableEndpoint browse = context.getEndpoint("list:orderReceived", BrowsableEndpoint.class); List<Exchange> exchanges = browse.getExchanges(); ... // then we can inspect the list of received exchanges from Java for (Exchange exchange : exchanges) { String payload = exchange.getIn().getBody(); ... } }
Chapter 88. Log
Log Component
URI format
log:loggingCategory[?options]
?option=value&option=value&...
org.slf4j.Logger
found in the Registry, the loggingCategory is no longer used to create logger instance. The registered instance is used instead. Also it is possible to reference particular Logger
instance using ?logger=#myLogger
URI parameter. Eventually, if there's no registered and URI logger
parameter, the logger instance is created using loggingCategory.
level
option, as follows:
log:org.apache.camel.example?level=DEBUG
Throughput
logger, which is used whenever the groupSize
option is specified.
log
directly in the DSL, but it has a different purpose. Its meant for lightweight and human logs. See more details at LogEIP.
Options
Option | Default | Type | Description |
---|---|---|---|
level
|
INFO
|
String
|
Logging level to use. Possible values: ERROR , WARN , INFO , DEBUG , TRACE , OFF
|
marker
|
null
|
String
|
Camel 2.9: An optional Marker name to use. |
groupSize
|
null
|
Integer
|
An integer that specifies a group size for throughput logging. |
groupInterval
|
null
|
Integer
|
If specified will group message stats by this time interval (in millis) |
groupDelay
|
0
|
Integer
|
Set the initial delay for stats (in millis) |
groupActiveOnly
|
true
|
boolean
|
If true, will hide stats when no new messages have been received for a time interval, if false, show stats regardless of message traffic |
logger
|
Logger
|
Camel 2.12.4/2.13.1: An optional reference to org.slf4j.Logger from Registry to use.
|
Formatting
LogFormatter
to format the log output, where LogFormatter
has the following options:
Option | Default | Description |
---|---|---|
showAll
|
false
|
Quick option for turning all options on (multiline, maxChars has to be manually set if to be used). |
showExchangeId
|
false
|
Show the unique exchange ID. |
showExchangePattern
|
true
|
Shows the Message Exchange Pattern (or MEP for short). |
showProperties
|
false
|
Show the exchange properties. |
showHeaders
|
false
|
Show the In message headers. |
skipBodyLineSeparator
|
true
|
Camel 2.12.2: Whether to skip line separators when logging the message body. This allows to log the message body in one line, setting this option to
false will preserve any line separators from the body, which then will log the body as is.
|
showBodyType
|
true
|
Show the In body Java type. |
showBody
|
true
|
Show the In body. |
showOut
|
false
|
If the exchange has an Out message, show the Out message. |
showException
|
false
|
Apache Camel 2.0: If the exchange has an exception, show the exception message (no stack trace). |
showCaughtException
|
false
|
Apache Camel 2.0: If the exchange has a caught exception, show the exception message (no stack trace). A caught exception is stored as a property on the exchange and for instance a doCatch can catch exceptions. See Try Catch Finally.
|
showStackTrace
|
false
|
Apache Camel 2.0: Show the stack trace, if an exchange has an exception. Only effective if one of showAll , showException or showCaughtException are enabled.
|
showFiles
|
false
|
Camel 2.9: Whether Camel should show file bodies or not (eg such as java.io.File). |
showFuture
|
false
|
Whether Camel should show java.util.concurrent.Future bodies or not. If enabled Camel could potentially wait until the Future task is done. Will by default not wait.
|
showStreams
|
false
|
Camel 2.8: Whether Camel should show stream bodies or not (eg such as java.io.InputStream). Beware if you enable this option then you may not be able later to access the message body as the stream have already been read by this logger. To remedy this you will have to use Stream Caching. |
multiline
|
false
|
If true , each piece of information is logged on a new line.
|
maxChars
|
Limits the number of characters logged per line. The default value is 10000 from Camel 2.9 onwards.
|
camelContext.getProperties().put(Exchange.LOG_DEBUG_BODY_STREAMS, true);
Regular logger sample
DEBUG
level before the order is processed:
from("activemq:orders").to("log:com.mycompany.order?level=DEBUG").to("bean:processOrder");
<route> <from uri="activemq:orders"/> <to uri="log:com.mycompany.order?level=DEBUG"/> <to uri="bean:processOrder"/> </route>
Regular logger with formatter sample
INFO
level before the order is processed.
from("activemq:orders"). to("log:com.mycompany.order?showAll=true&multiline=true").to("bean:processOrder");
Throughput logger with groupSize sample
DEBUG
level grouped by 10 messages.
from("activemq:orders"). to("log:com.mycompany.order?level=DEBUG&groupSize=10").to("bean:processOrder");
Throughput logger with groupInterval sample
from("activemq:orders") .to("log:com.mycompany.order?level=DEBUG&groupInterval=10000&groupDelay=60000&groupActiveOnly=false") .to("bean:processOrder");
"Received: 1000 new messages, with total 2000 so far. Last group took: 10000 millis which is: 100 messages per second. average: 100"
Full customization of the logging output
Exchange[Id:ID-machine-local-50656-1234567901234-1-2, ExchangePattern:InOut, Properties:{CamelToEndpoint=log://org.apache.camel.component.log.TEST?showAll=true, CamelCreatedTimestamp=Thu Mar 28 00:00:00 WET 2013}, Headers:{breadcrumbId=ID-machine-local-50656-1234567901234-1-1}, BodyType:String, Body:Hello World, Out: null]
- ... filter the headers and properties that are printed, to strike a balance between insight and verbosity.
- ... adjust the log message to whatever you deem most readable.
- ... tailor log messages for digestion by log mining systems, e.g. Splunk.
- ... print specific body types differently.
- ... etc.
ExchangeFormatter
interface. Within the format(Exchange)
method you have access to the full Exchange, so you can select and extract the precise information you need, format it in a custom manner and return it. The return value will become the final log message.
ExchangeFormatter
in either of two ways:
<bean name="log" class="org.apache.camel.component.log.LogComponent"> <property name="exchangeFormatter" ref="myCustomFormatter" /> </bean>
logFormatter
; the Log Component is intelligent enough to pick it up automatically.
<bean name="logFormatter" class="com.xyz.MyCustomExchangeFormatter" />
ExchangeFormatter
gets applied to all Log endpoints within that Camel Context. If you need different ExchangeFormatters for different endpoints, just instantiate the LogComponent as many times as needed, and use the relevant bean name as the endpoint prefix.
<bean name="logFormatter" class="com.xyz.MyCustomExchangeFormatter" scope="prototype"/>
<to uri="log:foo?param1=foo&aram2=100"/> ... <to uri="log:bar?param1=bar&aram2=200"/>
Using Log component in OSGi
org.slf4j.LoggerFactory.getLogger()
method and associates the bundle with the logger instance. Without specifying custom org.sfl4j.Logger
instance, the logger created by Log component is associated with camel-core
bundle.
org.slf4j.Logger
in the Registry or reference it using logger
URI parameter.
Chapter 89. Lucene
Lucene (Indexer and Search) Component
- builds a searchable index of documents when payloads are sent to the Lucene Endpoint
- facilitates performing of indexed searches in Apache Camel
URI format
lucene:searcherName:insert[?options] lucene:searcherName:query[?options]
?option=value&option=value&...
Insert Options
Name | Default Value | Description |
---|---|---|
analyzer
|
StandardAnalyzer
|
An Analyzer builds TokenStreams, which analyze text. It thus represents a policy for extracting index terms from text. The value for analyzer can be any class that extends the abstract class org.apache.lucene.analysis.Analyzer. Lucene also offers a rich set of analyzers out of the box |
indexDir
|
./indexDirectory
|
A file system directory in which index files are created upon analysis of the document by the specified analyzer |
srcDir
|
null
|
An optional directory containing files to be used to be analyzed and added to the index at producer startup. |
Query Options
Name | Default Value | Description |
---|---|---|
analyzer
|
StandardAnalyzer
|
An Analyzer builds TokenStreams, which analyze text. It thus represents a policy for extracting index terms from text. The value for analyzer can be any class that extends the abstract class org.apache.lucene.analysis.Analyzer. Lucene also offers a rich set of analyzers out of the box |
indexDir
|
./indexDirectory
|
A file system directory in which index files are created upon analysis of the document by the specified analyzer |
maxHits
|
10
|
An integer value that limits the result set of the search operation |
Message Headers
Header | Description |
---|---|
QUERY
|
The Lucene Query to performed on the index. The query may include wildcards and phrases. |
RETURN_LUCENE_DOCS
|
Camel 2.15: Set this header to true to include the actual Lucene documentation when returning hit information. |
Lucene Producers
- insert - The insert producer builds a searchable index by analyzing the body in incoming exchanges and associating it with a token ("content").
- query - The query producer performs searches on a pre-created index. The query uses the searchable index to perform score & relevance based searches. Queries are sent via the incoming exchange contains a header 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
Lucene Processor
Example 1: Creating a Lucene index
RouteBuilder builder = new RouteBuilder() { public void configure() { from("direct:start"). to("lucene:whitespaceQuotesIndex:insert?analyzer=#whitespaceAnalyzer&indexDir=#whitespace&srcDir=#load_dir"). to("mock:result"); } };
Example 2: Loading properties into the JNDI registry in the Camel Context
@Override protected JndiRegistry createRegistry() throws Exception { JndiRegistry registry = new JndiRegistry(createJndiContext()); registry.bind("whitespace", new File("./whitespaceIndexDir")); registry.bind("load_dir", new File("src/test/resources/sources")); registry.bind("whitespaceAnalyzer", new WhitespaceAnalyzer()); return registry; } ... CamelContext context = new DefaultCamelContext(createRegistry());
Example 2: Performing searches using a Query Producer
RouteBuilder builder = new RouteBuilder() { public void configure() { from("direct:start"). setHeader("QUERY", constant("Seinfeld")). to("lucene:searchIndex:query?analyzer=#whitespaceAnalyzer&indexDir=#whitespace&maxHits=20"). to("direct:next"); from("direct:next").process(new Processor() { public void process(Exchange exchange) throws Exception { Hits hits = exchange.getIn().getBody(Hits.class); printResults(hits); } private void printResults(Hits hits) { LOG.debug("Number of hits: " + hits.getNumberOfHits()); for (int i = 0; i < hits.getNumberOfHits(); i++) { LOG.debug("Hit " + i + " Index Location:" + hits.getHit().get(i).getHitLocation()); LOG.debug("Hit " + i + " Score:" + hits.getHit().get(i).getScore()); LOG.debug("Hit " + i + " Data:" + hits.getHit().get(i).getData()); } } }).to("mock:searchResult"); } };
Example 3: Performing searches using a Query Processor
RouteBuilder builder = new RouteBuilder() { public void configure() { try { from("direct:start"). setHeader("QUERY", constant("Rodney Dangerfield")). process(new LuceneQueryProcessor("target/stdindexDir", analyzer, null, 20)). to("direct:next"); } catch (Exception e) { e.printStackTrace(); } from("direct:next").process(new Processor() { public void process(Exchange exchange) throws Exception { Hits hits = exchange.getIn().getBody(Hits.class); printResults(hits); } private void printResults(Hits hits) { LOG.debug("Number of hits: " + hits.getNumberOfHits()); for (int i = 0; i < hits.getNumberOfHits(); i++) { LOG.debug("Hit " + i + " Index Location:" + hits.getHit().get(i).getHitLocation()); LOG.debug("Hit " + i + " Score:" + hits.getHit().get(i).getScore()); LOG.debug("Hit " + i + " Data:" + hits.getHit().get(i).getData()); } } }).to("mock:searchResult"); } };
Chapter 90. Mail
Mail Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-mail</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
.jar
(v1.6) has a bug when polling mails with attachments. It cannot correctly identify the Content-Type
. So, if you attach a .jpeg
file to a mail and you poll it, the Content-Type
is resolved as text/plain
and not as image/jpeg
. For that reason, we have added an org.apache.camel.component.ContentTypeResolver
SPI interface which enables you to provide your own implementation and fix this bug by returning the correct Mime type based on the file name. So if the file name ends with jpeg/jpg
, you can return image/jpeg
.
MailComponent
instance or on the MailEndpoint
instance.
URI format
smtp://[username@]host[:port][?options] pop3://[username@]host[:port][?options] imap://[username@]host[:port][?options]
s
to the scheme:
smtps://[username@]host[:port][?options] pop3s://[username@]host[:port][?options] imaps://[username@]host[:port][?options]
?option=value&option=value&...
Sample endpoints
smtp://[username@]host[:port][?password=somepwd]
smtp://host[:port]?password=somepwd&username=someuser
smtp://mycompany.mailserver:30?password=tiger&username=scott
Default ports
Protocol | Default Port Number |
---|---|
SMTP
|
25
|
SMTPS
|
465
|
POP3
|
110
|
POP3S
|
995
|
IMAP
|
143
|
IMAPS
|
993
|
Options
Property | Default | Description |
---|---|---|
host
|
The host name or IP address to connect to. | |
port
|
See DefaultPorts | The TCP port number to connect on. |
username
|
The user name on the email server. | |
password
|
null
|
The password on the email server. |
ignoreUriScheme
|
false
|
If false , Camel uses the scheme to determine the transport protocol (POP, IMAP, SMTP etc.)
|
contentType
|
text/plain
|
The mail message content type. Use text/html for HTML mails.
|
folderName
|
INBOX
|
The folder to poll. |
destination
|
username@host
|
@deprecated Use the to option instead. The TO recipients (receivers of the email).
|
to
|
username@host
|
The TO recipients (the receivers of the mail). Separate multiple email addresses with a comma. |
replyTo
|
alias@host
|
As of Camel 2.8.4, 2.9.1\+, the Reply-To recipients (the receivers of the response mail). Separate multiple email addresses with a comma. |
CC
|
null
|
The CC recipients (the receivers of the mail). Separate multiple email addresses with a comma. |
BCC
|
null
|
The BCC recipients (the receivers of the mail). Separate multiple email addresses with a comma. |
from
|
camel@localhost
|
The FROM email address. |
subject
|
As of Camel 2.3, the Subject of the message being sent. Note: Setting the subject in the header takes precedence over this option. | |
peek
|
true
|
Camel 2.11.3/2.12.2: Consumer only. Will mark the
javax.mail.Message as peeked before processing the mail message. This applies to IMAPMessage messages types only. By using peek the mail will not be eager marked as SEEN on the mail server, which allows us to roll back the mail message if there is an error processing in Camel.
|
delete
|
false
|
Deletes the messages after they have been processed. This is done by setting the DELETED flag on the mail message. If false , the SEEN flag is set instead. As of Camel 2.10 you can override this configuration option by setting a header with the key delete to determine if the mail should be deleted or not.
|
unseen
|
true
|
It is possible to configure a consumer endpoint so that it processes only unseen messages (that is, new messages) or all messages. Note that Camel always skips deleted messages. The default option of true will filter to only unseen messages. POP3 does not support the SEEN flag, so this option is not supported in POP3; use IMAP instead. Important: This option is not in use if you also use searchTerm options. Instead if you want to disable unseen when using searchTerm 's then add searchTerm.unseen=false as a term.
|
copyTo
|
null
|
Camel 2.10: Consumer only. After processing a mail message, it can be copied to a mail folder with the given name. You can override this configuration value, with a header with the key copyTo , allowing you to copy messages to folder names configured at runtime.
|
fetchSize
|
\-1
|
Sets the maximum number of messages to consume during a poll. This can be used to avoid overloading a mail server, if a mailbox folder contains a lot of messages. Default value of \-1 means no fetch size and all messages will be consumed. Setting the value to 0 is a special corner case, where Camel will not consume any messages at all.
|
alternativeBodyHeader
|
CamelMailAlternativeBody
|
Specifies the key to an IN message header that contains an alternative email body. For example, if you send emails in text/html format and want to provide an alternative mail body for non-HTML email clients, set the alternative mail body with this key as a header.
|
debugMode
|
false
|
Enable debug mode on the underlying mail framework. The SUN Mail framework logs the debug messages to System.out by default.
|
connectionTimeout
|
30000
|
The connection timeout in milliseconds. Default is 30 seconds. |
consumer.initialDelay
|
1000
|
Milliseconds before the polling starts. |
consumer.delay
|
60000
|
Camel will poll the mailbox only once a minute by default to avoid overloading the mail server. |
consumer.useFixedDelay
|
false
|
Set to true to use a fixed delay between polls, otherwise fixed rate is used. See ScheduledExecutorService in JDK for details.
|
disconnect
|
false
|
Camel 2.8.3/2.9: Whether the consumer should disconnect after polling. If enabled this forces Camel to connect on each poll. |
closeFolder
|
true
|
Camel 2.10.4: Whether the consumer should close the folder after polling. Setting this option to false and having disconnect=false as well, then the consumer keep the folder open between polls.
|
mail.XXX
|
null
|
Set any additional java mail properties. For instance if you want to set a special property when using POP3 you can now provide the option directly in the URI such as: mail.pop3.forgettopheaders=true . You can set multiple such options, for example: mail.pop3.forgettopheaders=true&mail.mime.encodefilename=true .
|
mapMailMessage
|
true
|
Camel 2.8: Specifies whether Camel should map the received mail message to Camel body/headers. If set to true, the body of the mail message is mapped to the body of the Camel IN message and the mail headers are mapped to IN headers. If this option is set to false then the IN message contains a raw javax.mail.Message . You can retrieve this raw message by calling exchange.getIn().getBody(javax.mail.Message.class) .
|
maxMessagesPerPoll
|
0
|
Specifies the maximum number of messages to gather per poll. By default, no maximum is set. Can be used to set a limit of e.g. 1000 to avoid downloading thousands of files when the server starts up. Set a value of 0 or negative to disable this option. |
javaMailSender
|
null
|
Specifies a pluggable org.apache.camel.component.mail.JavaMailSender instance in order to use a custom email implementation.
|
ignoreUnsupportedCharset
|
false
|
Option to let Camel ignore unsupported charset in the local JVM when sending mails. If the charset is unsupported then charset=XXX (where XXX represents the unsupported charset) is removed from the content-type and it relies on the platform default instead.
|
sslContextParameters
|
null
|
Camel 2.10: Reference to a org.apache.camel.util.jsse.SSLContextParameters in the Registry. This reference overrides any configured SSLContextParameters at the component level. See Using the JSSE Configuration Utility.
|
searchTerm
|
null
|
Camel 2.11: Refers to a javax.mail.search.SearchTerm which allows to filter mails based on search criteria such as subject, body, from, sent after a certain date etc. See further below for examples.
|
searchTerm.xxx
|
null
|
Camel 2.11: To configure search terms directly from the endpoint uri, which supports a limited number of terms defined by the org.apache.camel.component.mail.SimpleSearchTerm class. See further below for examples.
|
sortTerm
|
null
|
Camel 2.15: To configure the sortTerms that IMAP supports to sort the searched mails. You may need to define an array ofcom.sun.mail.imap.sortTerm in the registry first and #name to reference it in this URI option.
|
postProcessAction
|
null
|
Camel 2.15: Refers to aorg.apache.camel.component.mail. MailBoxPostProcessAction for doing post processing tasks on the mailbox once the normal processing ended.
|
skipFailedMessage
|
false
|
Camel 2.15: If the mail consumer cannot retrieve a given mail message, then this option allows to skip the message and move on to retrieve the next mail message. The default behavior would be the consumer throws an exception and no mails from the batch would be able to be routed by Camel. |
handleFailedMessage
|
false
|
Camel 2.15: If the mail consumer cannot retrieve a given mail message, then this option allows to handle the caused exception by the consumer's error handler. By enable the bridge error handler on the consumer, then the Camel routing error handler can handle the exception instead. The default behavior would be the consumer throws an exception and no mails from the batch would be able to be routed by Camel. |
SSL support
Using the JSSE Configuration Utility
Programmatic configuration of the endpoint
KeyStoreParameters ksp = new KeyStoreParameters(); ksp.setResource("/users/home/server/truststore.jks"); ksp.setPassword("keystorePassword"); TrustManagersParameters tmp = new TrustManagersParameters(); tmp.setKeyStore(ksp); SSLContextParameters scp = new SSLContextParameters(); scp.setTrustManagers(tmp); Registry registry = ... registry.bind("sslContextParameters", scp); ... from(...) .to("smtps://smtp.google.com?username=user@gmail.com&password=password&sslContextParameters=#sslContextParameters");
Spring DSL based configuration of endpoint
... <camel:sslContextParameters id="sslContextParameters"> <camel:trustManagers> <camel:keyStore resource="/users/home/server/truststore.jks" password="keystorePassword"/> </camel:trustManagers> </camel:sslContextParameters>... ... <to uri="smtps://smtp.google.com?username=user@gmail.com&password=password&sslContextParameters=#sslContextParameters"/>...
Configuring JavaMail Directly
SSLNOTES.txt
in JavaMail for details).
Mail Message Content
String.class
.
from("direct:a").setHeader("subject", constant(subject)).to("smtp://james2@localhost");
To
:
Map<String, Object> map = new HashMap<String, Object>(); map.put("To", "davsclaus@apache.org"); map.put("From", "jstrachan@apache.org"); map.put("Subject", "Camel rocks"); String body = "Hello Claus.\nYes it does.\n\nRegards James."; template.sendBodyAndHeaders("smtp://davsclaus@apache.org", body, map);
CamelMailMessageId
from the Camel message header.
Headers take precedence over pre-configured recipients
davsclaus@apache.org
, because it takes precedence over the pre-configured recipient, info@mycompany.com
. Any CC
and BCC
settings in the endpoint URI are also ignored and those recipients will not receive any mail. The choice between headers and pre-configured settings is all or nothing: the mail component either takes the recipients exclusively from the headers or exclusively from the pre-configured settings. It is not possible to mix and match headers and pre-configured settings.
Map<String, Object> headers = new HashMap<String, Object>(); headers.put("to", "davsclaus@apache.org"); template.sendBodyAndHeaders("smtp://admin@localhost?to=info@mycompany.com", "Hello World", headers);
Multiple recipients for easier configuration
Map<String, Object> headers = new HashMap<String, Object>(); headers.put("to", "davsclaus@apache.org ; jstrachan@apache.org ; ningjiang@apache.org");
;
, as the separator character.
Setting sender name and email
name <email>
, to include both the name and the email address of the recipient.
Map headers = new HashMap(); map.put("To", "Claus Ibsen <davsclaus@apache.org>"); map.put("From", "James Strachan <jstrachan@apache.org>"); map.put("Subject", "Camel is cool");
SUN JavaMail
- And generally about the MAIL Flags
Samples
admin
account on mymailserver.com
.
from("jms://queue:subscription").to("smtp://admin@mymailserver.com?password=secret");
consumer
option for setting the poll interval, consumer.delay
, as 60000 milliseconds = 60 seconds.
from("imap://admin@mymailserver.com password=secret&unseen=true&consumer.delay=60000") .to("seda://mails");
// all the recipients of this mail are: // To: camel@riders.org , easy@riders.org // CC: me@you.org // BCC: someone@somewhere.org String recipients = "&To=camel@riders.org,easy@riders.org&CC=me@you.org&BCC=someone@somewhere.org"; from("direct:a").to("smtp://you@mymailserver.com?password=secret&From=you@apache.org" + recipients);
Sending mail with attachment sample
// create an exchange with a normal body and attachment to be produced as email Endpoint endpoint = context.getEndpoint("smtp://james@mymailserver.com?password=secret"); // create the exchange with the mail message that is multipart with a file and a Hello World text/plain message. Exchange exchange = endpoint.createExchange(); Message in = exchange.getIn(); in.setBody("Hello World"); in.addAttachment("logo.jpeg", new DataHandler(new FileDataSource("src/test/data/logo.jpeg"))); // create a producer that can produce the exchange (= send the mail) Producer producer = endpoint.createProducer(); // start the producer producer.start(); // and let it go (processes the exchange by sending the email) producer.process(exchange);
SSL sample
from("imaps://imap.gmail.com?username=YOUR_USERNAME@gmail.com&password=YOUR_PASSWORD" + "&delete=false&unseen=true&consumer.delay=60000").to("log:newmail");
newmail
logger category. Running the sample with DEBUG
logging enabled, we can monitor the progress in the logs:
2008-05-08 06:32:09,640 DEBUG MailConsumer - Connecting to MailStore imaps//imap.gmail.com:993 (SSL enabled), folder=INBOX 2008-05-08 06:32:11,203 DEBUG MailConsumer - Polling mailfolder: imaps//imap.gmail.com:993 (SSL enabled), folder=INBOX 2008-05-08 06:32:11,640 DEBUG MailConsumer - Fetching 1 messages. Total 1 messages. 2008-05-08 06:32:12,171 DEBUG MailConsumer - Processing message: messageNumber=[332], from=[James Bond <007@mi5.co.uk>], to=YOUR_USERNAME@gmail.com], subject=[... 2008-05-08 06:32:12,187 INFO newmail - Exchange[MailMessage: messageNumber=[332], from=[James Bond <007@mi5.co.uk>], to=YOUR_USERNAME@gmail.com], subject=[...
Consuming mails with attachment sample
from("imaps://imap.gmail.com?username=YOUR_USERNAME@gmail.com&password=YOUR_PASSWORD" + "&delete=false&unseen=true&consumer.delay=60000").process(new MyMailProcessor());
public void process(Exchange exchange) throws Exception { // the API is a bit clunky so we need to loop Map<String, DataHandler> attachments = exchange.getIn().getAttachments(); if (attachments.size() > 0) { for (String name : attachments.keySet()) { DataHandler dh = attachments.get(name); // get the file name String filename = dh.getName(); // get the content and convert it to byte[] byte[] data = exchange.getContext().getTypeConverter() .convertTo(byte[].class, dh.getInputStream()); // write the data to a file FileOutputStream out = new FileOutputStream(filename); out.write(data); out.flush(); out.close(); } } }
javax.activation.DataHandler
so you can handle the attachments using standard API.
How to split a mail message with attachments
camel-mail
component. The code is in the class: org.apache.camel.component.mail.SplitAttachmentsExpression
, which you can find the source code here
from("pop3://james@mymailserver.com?password=secret&consumer.delay=1000") .to("log:email") // use the SplitAttachmentsExpression which will split the message per attachment .split(new SplitAttachmentsExpression()) // each message going to this mock has a single attachment .to("mock:split") .end();
<split> <method beanType="org.apache.camel.component.mail.SplitAttachmentsExpression"/> <to uri="mock:split"/> </split>
Using custom SearchTerm
searchTerm
on the MailEndpoint
which allows you to filter out unwanted mails.
<route> <from uri="imaps://mymailseerver?username=foo&password=secret&searchTerm.subjectOrBody=Camel"/> <to uri="bean:myBean"/> </route>
"searchTerm.subjectOrBody"
as parameter key to indicate that we want to search on mail subject or body, to contain the word "Camel". The class org.apache.camel.component.mail.SimpleSearchTerm
has a number of options you can configure:
<route> <from uri="imaps://mymailseerver?username=foo&password=secret&searchTerm.fromSentDate=now-24h"/> <to uri="bean:myBean"/> </route>
<route> <from uri="imaps://mymailseerver?username=foo&password=secret&searchTerm.subject=Camel&searchTerm.fromSentDate=now-24h"/> <to uri="bean:myBean"/> </route>
Option | Default | Description |
---|---|---|
unseen |
true
|
Whether to limit by unseen mails only. |
subjectOrBody |
null
|
To limit by subject or body to contain the word. |
subject |
null
|
The subject must contain the word. |
body |
null
|
The body must contain the word. |
from |
null
|
The mail must be from a given email pattern. |
to |
null
|
The mail must be to a given email pattern. |
fromSentDate |
null
|
The mail must be sent after or equals (GE) a given date. The date pattern is yyyy-MM-dd HH:mm:SS , eg use "2012-01-01 00:00:00" to be from the year 2012 onwards. You can use "now" for current timestamp. The "now" syntax supports an optional offset, that can be specified as either + or - with a numeric value. For example for last 24 hours, you can use "now - 24h" or without spaces "now-24h" . Notice that Camel supports shorthands for hours, minutes, and seconds.
|
toSentDate |
null
|
The mail must be sent before or equals (BE) a given date. The date pattern is yyyy-MM-dd HH:mm:SS , eg use "2012-01-01 00:00:00" to be before the year 2012. You can use "now" for current timestamp. The "now" syntax supports an optional offset, that can be specified as either + or - with a numeric value. For example for last 24 hours, you can use "now - 24h" or without spaces "now-24h" . Notice that Camel supports shorthands for hours, minutes, and seconds.
|
SimpleSearchTerm
is designed to be easily configurable from a POJO, so you can also configure it using a <bean> style in XML
<bean id="mySearchTerm" class="org.apache.camel.component.mail.SimpleSearchTerm"> <property name="subject" value="Order"/> <property name="to" value="acme-order@acme.com"/> <property name="fromSentDate" value="now"/> </bean>
<route> <from uri="imaps://mymailseerver?username=foo&password=secret&searchTerm=#mySearchTerm"/> <to uri="bean:myBean"/> </route>
SearchTerm
s using the org.apache.camel.component.mail.SearchTermBuilder
class. This allows you to build complex terms such as:
// we just want the unseen mails which is not spam SearchTermBuilder builder = new SearchTermBuilder(); builder.unseen().body(Op.not, "Spam").subject(Op.not, "Spam") // which was sent from either foo or bar .from("foo@somewhere.com").from(Op.or, "bar@somewhere.com"); // .. and we could continue building the terms SearchTerm term = builder.build();
Chapter 91. Master Component
Abstract
Dependencies
fabric-camel
feature is installed.
my-master-profile
, you would add the fabric-camel
feature by entering the following console command:
karaf@root> fabric:profile-edit --features fabric-camel my-master-profile
URI format
master:ClusterID:EndpointURI[?Options]
EndpointURI
, is published in the fabric registry and associated with the ClusterId
cluster.
URI options
EndpointURI
.
How to use the Master component
seda:bar
endpoint, you would proceed as follows:
- Define the Master endpoints with the following URI (where each endpoint in the cluster uses exactly the same URI):
master:mysedalock:seda:bar
Each of the Master endpoints in the cluster tries to get themysedalock
lock (implemented as a key in the Zookeeper registry). The Master endpoint that succeeds in getting the lock becomes active (the master) and starts consuming messages from theseda:bar
endpoint. The other Master endpoints enter a waiting state and continue to try the lock (the slaves). - You must remember to include the
fabric-camel
feature in the profile that deploys a Master endpoint. - In Blueprint XML, you can define a Master endpoint at the start of a Camel route, as follows:
<?xml version="1.0" encoding="UTF-8"?> <blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> ... <camelContext id="camel" xmlns="http://camel.apache.org/schema/blueprint"> <route> <from uri="master:mysedalock:seda:bar"/> ... </route> </camelContext> ... </blueprint>
Example of a master-slave cluster polling a JMS ActiveMQ broker
FABRIC.DEMO
.
Steps to create a cluster that polls messages from an ActiveMQ broker
- If you do not already have a fabric, enter the following console command to create one:
JBossFuse:karaf@root> fabric:create --new-user AdminUser --new-user-password AdminPass --zookeeper-password ZooPass --wait-for-provisioning
The--new-user
and--new-user-password
options specify the credentials for a new administrator user. The Zookeeper password is used to protect sensitive data in the Fabric registry service (all of the nodes under/fabric
).NoteIf you use a VPN (virtual private network) on your local machine, it is advisable to log off VPN before you create the fabric and to stay logged off while you are using the local container. A local Fabric Server is permanently associated with a fixed IP address or hostname. If VPN is enabled when you create the fabric, the underlying Java runtime is liable to detect and use the VPN hostname instead of your permanent local hostname. This can also be an issue with multi-homed machines. To be absolutely sure about the hostname, you could specify the IP address explicitly—see chapter "Creating a New Fabric" in "Fabric Guide". - For this example, you must have access to a running instance of an Apache ActiveMQ broker and you must know the IP port of the broker's OpenWire connector. For example, you might get access to an ActiveMQ broker in one of the following ways:
- You just created the fabric on a clean installation of JBoss Fuse (after a cold restart). In this case, the
root
container ought to include thejboss-fuse-full
profile by default. You can check whether this is the case by entering thefabric:container-list
console command, as follows:JBossFuse:karaf@root> fabric:container-list [id] [version] [connected] [profiles] [provision status] root* 1.0 true fabric, fabric-ensemble-0000-1, jboss-fuse-full success
By default, thejboss-fuse-full
profile instantiates an ActiveMQ broker that listens on port61616
. You can use this broker for the current example. - If no broker is running in the root container (or any other container), you can quickly install a broker into a new fabric child container,
broker1
, by entering the following fabric command at the console prompt:JBossFuse:karaf@root> fabric:container-create-child --profile mq-default root broker1
In this case, you can use the browser-based Fuse Management Console to discover the IP port of the OpenWire connector on the broker.
- Create the
master-example
profile, which will be used to deploy a simple Apache Camel route that uses the Master component. Enter the following console command to create the profile:JBossFuse:karaf@root> fabric:profile-create --parents default master-example
- Add the requisite Karaf features to the
master-example
profile. Enter the following console commands:fabric:profile-edit --features fabric-camel master-example fabric:profile-edit --features activemq-camel master-example
- Define the simple Camel route as a resource in the
master-example
profile. Invoke the built-in text editor to create a newcamel.xml
resource, as follows:fabric:profile-edit --resource camel.xml master-example
Copy and paste the following content into the built-in text editor:<?xml version="1.0" encoding="UTF-8"?> <blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <camelContext id="camel" xmlns="http://camel.apache.org/schema/blueprint"> <route id="fabric-server"> <from uri="master:lockhandle:activemq:queue:FABRIC.DEMO"/> <log message="Message received : ${body}"/> </route> </camelContext> <bean id="activemq" class="org.apache.activemq.camel.component.ActiveMQComponent"> <property name="brokerURL" value="tcp://localhost:OpenWirePort"/> <property name="userName" value="UserName"/> <property name="password" value="Password"/> </bean> </blueprint>
Remember to customize the route configuration by replacing OpenWirePort with the port number of the OpenWire connector on the broker, and by replacing UserName and Password by any valid JAAS credentials on the container (for example, you could substitute the AdminUser and AdminPass credentials created in Step 1 of these instructions).To save and exit from the text editor, type Ctrl-S, Ctrl-X. - Configure the
master-example
profile to deploy thecamel.xml
resource as an OSGi bundle. Enter the following console command to create a new entry in themaster-example
agent properties:fabric:profile-edit --bundles blueprint:profile:camel.xml master-example
NoteTheblueprint:
prefix tells Fabric to deploy the specified resource as a Blueprint XML file, and theprofile:
prefix tells Fabric where to find the resource (that is, in the current version of the current profile). - Create two new child containers, so that you can deploy the
master-example
profile as a cluster (one master and one slave). Enter the following console command:fabric:container-create-child root child 2
- Now deploy both the
master-example
profile and themq-client
profile to each of the child containers, as follows:fabric:container-change-profile child1 master-example mq-client fabric:container-change-profile child2 master-example mq-client
- If you now send some messages to the
FABRIC.DEMO
queue on the broker, the messages are consumed by one (and only one) of the deployed master endpoints. For example, you can easily create and send messages to the broker using the browser-based Fuse Management console. - If you stop the container that hosts the current master (initially, the
child1
container), the slave will be promoted to be the new master (in thechild2
container) and will start consuming messages from theFABRIC.DEMO
queue. For example, assuming thatchild2
contains the current master, you can stop it by entering the following console command:fabric:container-stop child2
OSGi bundle plug-in configuration
Import-Package
bundle header must be configured to import the following Java packages:
io.fabric8.zookeeper
Example 91.1. Maven Bundle Plug-In Configuration
<project ... > ... <build> <defaultGoal>install</defaultGoal> <plugins> ... <plugin> <groupId>org.apache.felix</groupId> <artifactId>maven-bundle-plugin</artifactId> <extensions>true</extensions> <configuration> <instructions> <Bundle-SymbolicName>${project.groupId}.${project.artifactId}</Bundle-SymbolicName> <Import-Package> io.fabric8.zookeeper, * </Import-Package> </instructions> </configuration> </plugin> </plugins> </build> ... </project>
Chapter 92. Metrics
Metrics Component
MetricsRoutePolicyFactory
which allows to expose route statistics using codehale metrics, see bottom of page for details.
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-metrics</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
metrics:[ meter | counter | histogram | timer ]:metricname[?options]
Metric Registry
MetricRegistry
with Slf4jReporter
and 60 second reporting interval. Default registry can be replaced with custom one by providing bean with name metricRegistry
in Camel registry. For example using Spring Java Configuration.
@Configuration public static class MyConfig extends SingleRouteCamelConfiguration { @Bean @Override public RouteBuilder route() { return new RouteBuilder() { @Override public void configure() throws Exception { // define Camel routes here } }; } @Bean(name = MetricsComponent.METRIC_REGISTRY_NAME) public MetricRegistry getMetricRegistry() { MetricRegistry registry = ...; return registry; } }
MetricRegistry
uses internal thread(s) for reporting. There is no public API in version 3.0.1 for users to clean up on exit. Thus using Camel Metrics Component leads to Java classloader leak and my cause OutOfMemoryErrors
in some cases.
Usage
Headers
CamelMetricsName
.
from("direct:in") .setHeader(MetricsConstants.HEADER_METRIC_NAME, constant("new.name")) .to("metrics:counter:name.not.used") .to("direct:out");
new.name
instead of name.not.used
.
warn
.
Metrics type counter
metrics:counter:metricname[?options]
Options
Name
|
Default
|
Description
|
increment
|
-
|
Long value to add to the counter
|
decrement
|
-
|
Long value to subtract from the counter
|
increment
or decrement
is defined then counter value will be incremented by one. If increment
and decrement
are both defined only increment operation is called.
// update counter simple.counter by 7 from("direct:in") .to("metric:counter:simple.counter?increment=7") .to("direct:out");
// increment counter simple.counter by 1 from("direct:in") .to("metric:counter:simple.counter") .to("direct:out");
// decrement counter simple.counter by 3 from("direct:in") .to("metric:counter:simple.counter?decrement=3") .to("direct:out");
Headers
increment
and decrement
values specified in Metrics component URI.
Name
|
Description
|
Expected type
|
CamelMetricsCounterIncrement
|
Override increment value in URI
|
Long
|
CamelMetricsCounterDecrement
|
Override decrement value in URI
|
Long
|
// update counter simple.counter by 417 from("direct:in") .setHeader(MetricsConstants.HEADER_COUNTER_INCREMENT, constant(417L)) .to("metric:counter:simple.counter?increment=7") .to("direct:out");
// updates counter using simple language to evaluate body.length from("direct:in") .setHeader(MetricsConstants.HEADER_COUNTER_INCREMENT, simple("${body.length}")) .to("metrics:counter:body.length") .to("mock:out");
Metric type histogram
metrics:histogram:metricname[?options]
Options
Name
|
Default
|
Description
|
value
|
-
|
Value to use in histogram
|
value
is not set nothing is added to histogram and warning is logged.
// adds value 9923 to simple.histogram from("direct:in") .to("metric:histogram:simple.histogram?value=9923") .to("direct:out");
// nothing is added to simple.histogram; warning is logged from("direct:in") .to("metric:histogram:simple.histogram") .to("direct:out");
Headers
Name
|
Description
|
Expected type
|
CamelMetricsHistogramValue
|
Override histogram value in URI
|
Long
|
// adds value 992 to simple.histogram from("direct:in") .setHeader(MetricsConstants.HEADER_HISTOGRAM_VALUE, constant(992L)) .to("metric:histogram:simple.histogram?value=700") .to("direct:out")
Metric type meter
metrics:meter:metricname[?options]
Options
Name
|
Default
|
Description
|
mark
|
-
|
Long value to use as mark
|
mark
is not set then meter.mark()
is called without argument.
// marks simple.meter without value from("direct:in") .to("metric:simple.meter") .to("direct:out");
// marks simple.meter with value 81 from("direct:in") .to("metric:meter:simple.meter?mark=81") .to("direct:out");
Headers
mark
value specified in Metrics component URI.
Name
|
Description
|
Expected type
|
CamelMetricsMeterMark
|
Override mark value in URI
|
Long
|
// updates meter simple.meter with value 345 from("direct:in") .setHeader(MetricsConstants.HEADER_METER_MARK, constant(345L)) .to("metric:meter:simple.meter?mark=123") .to("direct:out");
Metrics type timer
metrics:timer:metricname[?options]
Options
Name
|
Default
|
Description
|
action
|
-
|
start or stop
|
action
or invalid value is provided then warning is logged without any timer update. If action start
is called on already running timer or stop
is called on not running timer then nothing is updated and warning is logged.
// measure time taken by route "calculate" from("direct:in") .to("metrics:timer:simple.timer?action=start") .to("direct:calculate") .to("metrics:timer:simple.timer?action=stop");
TimerContext
objects are stored as Exchange properties between different Metrics component calls.
Headers
Name
|
Description
|
Expected type
|
CamelMetricsTimerAction
|
Override timer action in URI
|
org.apache.camel.component.metrics.timer.TimerEndpoint.TimerAction
|
// sets timer action using header from("direct:in") .setHeader(MetricsConstants.HEADER_TIMER_ACTION, TimerAction.start) .to("metric:timer:simple.timer") .to("direct:out");
MetricsRoutePolicyFactory
CamelContext
as shown below:
context.addRoutePolicyFactory(new MetricsRoutePolicyFactory());
<!-- use camel-metrics route policy to gather metrics for all routes --> <bean id="metricsRoutePolicyFactory" class="org.apache.camel.component.metrics.routepolicy.MetricsRoutePolicyFactory"/>
MetricsRoutePolicyFactory
and MetricsRoutePolicy
supports the following options:
Name
|
Default
|
Description
|
useJmx
|
false
|
Whether to report fine grained statistics to JMX by using the
com.codahale.metrics.JmxReporter . Notice that if JMX is enabled on CamelContext then a MetricsRegistryService mbean is enlisted under the services type in the JMX tree. That mbean has a single operation to output the statistics using json. Setting useJmx to true is only needed if you want fine grained mbeans per statistics type.
|
jmxDomain
|
org.apache.camel.metrics
|
The JMX domain name
|
prettyPrint
|
false
|
Whether to use pretty print when outputting statistics in json format
|
metricsRegistry
|
|
Allow to use a shared
com.codahale.metrics.MetricRegistry . If none is provided then Camel will create a shared instance used by the this CamelContext.
|
rateUnit
|
TimeUnit.SECONDS
|
The unit to use for rate in the metrics reporter or when dumping the statistics as json.
|
durationUnit
|
TimeUnit.MILLISECONDS
|
The unit to use for duration in the metrics reporter or when dumping the statistics as json.
|
com.codahale.metrics.MetricRegistry
from the org.apache.camel.component.metrics.routepolicy.MetricsRegistryService
as shown below:
MetricRegistryService registryService = context.hasService(MetricsRegistryService.class); if (registryService != null) { MetricsRegistry registry = registryService.getMetricsRegistry(); ... }
Chapter 93. MINA2 - Deprecated
MINA 2 Component
sync=false
on consumer endpoints. Since camel-mina2, all consumer exchanges are InOut. This is different to camel-mina.
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-mina2</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
mina2:tcp://hostname[:port][?options] mina2:udp://hostname[:port][?options] mina2:vm://hostname[:port][?options]
textline
flag is used to determine if text line based codec or object serialization should be used instead. By default the object serialization is used.
ByteBuffer
based codec.
camel-mina
only supports marshalling the body content—essage headers and exchange properties are not sent. However, the option, transferExchange, does allow you to transfer the exchange itself over the wire. See options below.
?option=value&option=value&...
Options
Option | Default Value | Description |
---|---|---|
codec
|
null
|
You can refer to a named ProtocolCodecFactory instance in your Registry such as your Spring ApplicationContext , which is then used for the marshalling.
|
disconnect
|
false
|
Whether or not to disconnect(close) from Mina session right after use. Can be used for both consumer and producer. |
textline
|
false
|
Only used for TCP. If no codec is specified, you can use this flag to indicate a text line based codec; if not specified or the value is false , then Object Serialization is assumed over TCP.
|
textlineDelimiter
|
DEFAULT
|
Only used for TCP and if textline=true. Sets the text line delimiter to use. Possible values are: DEFAULT , AUTO , WINDOWS , UNIX or MAC . If none provided, Camel will use DEFAULT . This delimiter is used to mark the end of text.
|
sync
|
true
|
Setting to set endpoint as one-way or request-response. |
lazySessionCreation
|
true
|
Sessions can be lazily created to avoid exceptions, if the remote server is not up and running when the Camel producer is started. |
timeout
|
30000
|
You can configure the timeout that specifies how long to wait for a response from a remote server. The timeout unit is in milliseconds, so 60000 is 60 seconds. The timeout is only used for Mina producer. |
encoding
|
JVM Default | You can configure the encoding (a charset name) to use for the TCP textline codec and the UDP protocol. If not provided, Camel will use the JVM default Charset. |
transferExchange
|
false
|
Only used for TCP. You can transfer the exchange over the wire instead of just the body. The following fields are transferred: In body, Out body, fault body, In headers, Out headers, fault headers, exchange properties, exchange exception. This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level.
|
minaLogger
|
false
|
You can enable the Apache MINA logging filter. Apache MINA uses slf4j logging at INFO level to log all input and output.
|
filters
|
null
|
You can set a list of Mina IoFilters to register. The filters can be specified as a comma-separate list of bean references (e.g. \#filterBean1,#filterBean2 ) where each bean must be of type org.apache.mina.common.IoFilter .
|
encoderMaxLineLength
|
\-1
|
Set the textline protocol encoder max line length. By default the default value of Mina itself is used which are Integer.MAX_VALUE .
|
decoderMaxLineLength
|
\-1
|
Set the textline protocol decoder max line length. By default the default value of Mina itself is used which are 1024. |
maximumPoolSize
|
16 | The TCP producer is thread safe and supports concurrency much better. This option allows you to configure the number of threads in its thread pool for concurrent producers. Note: Camel has a pooled service which ensured it was already thread safe and supported concurrency already. |
allowDefaultCodec
|
true
|
The mina component installs a default codec if both, codec is null and textline is false . Setting allowDefaultCodec to false prevents the mina component from installing a default codec as the first element in the filter chain. This is useful in scenarios where another filter must be the first in the filter chain, like the SSL filter.
|
disconnectOnNoReply
|
true
|
If sync is enabled then this option dictates MinaConsumer if it should disconnect where there is no reply to send back. |
noReplyLogLevel
|
WARN
|
If sync is enabled this option dictates MinaConsumer which logging level to use when logging a there is no reply to send back. Values are: FATAL, ERROR, INFO, DEBUG, OFF .
|
orderedThreadPoolExecutor
|
true
|
Whether to use ordered thread pool, to ensure events are processed orderly on the same channel. |
sslContextParameters
|
null
|
SSL configuration using an org.apache.camel.util.jsse.SSLContextParameters instance. See Using the JSSE Configuration Utility.
|
autoStartTls
|
true
|
Whether to auto start SSL handshake. |
cachedAddress
|
true
|
Camel 2.14: Whether to create the InetAddress once and reuse. Setting this to false allows to pickup DNS changes in the network. |
clientMode
|
false
|
Camel 2.15: Consumer only. If the clientMode is true, mina consumer will connect the address as a TCP client. |
Using a custom codec
Sample with sync=false
from("mina2:tcp://localhost:" + port1 + "?textline=true&sync=false").to("mock:result");
MockEndpoint mock = getMockEndpoint("mock:result"); mock.expectedBodiesReceived("Hello World"); template.sendBody("mina2:tcp://localhost:" + port1 + "?textline=true&sync=false", "Hello World"); assertMockEndpointsSatisfied();
Sample with sync=true
sync
option to true
on the consumer.
from("mina2:tcp://localhost:" + port2 + "?textline=true&sync=true").process(new Processor() { public void process(Exchange exchange) throws Exception { String body = exchange.getIn().getBody(String.class); exchange.getOut().setBody("Bye " + body); } });
template.requestBody()
method. As we know the response is a String
, we cast it to String
and can assert that the response is, in fact, something we have dynamically set in our processor code logic.
String response = (String)template.requestBody("mina2:tcp://localhost:" + port2 + "?textline=true&sync=true", "World"); assertEquals("Bye World", response);
Sample with Spring DSL
<route> <from uri="mina2:tcp://localhost:5555?textline=true"/> <to uri="bean:myTCPOrderHandler"/> </route>
myTCPOrderHandler
, handle the request and return a reply. For instance, the handler bean could be implemented as follows:
public String handleOrder(String payload) { ... return "Order: OK" }
Closing Session When Complete
CamelMinaCloseSessionWhenComplete
set to a boolean true
value.
bye
message back to the client:
from("mina2:tcp://localhost:8080?sync=true&textline=true").process(new Processor() { public void process(Exchange exchange) throws Exception { String body = exchange.getIn().getBody(String.class); exchange.getOut().setBody("Bye " + body); exchange.getOut().setHeader(Mina2Constants.MINA_CLOSE_SESSION_WHEN_COMPLETE, true); } });
Get the IoSession for message
Mina2Constants.MINA_IOSESSION
, and also get the local host address with the key Mina2Constants.MINA_LOCAL_ADDRESS
and remote host address with the key Mina2Constants.MINA_REMOTE_ADDRESS
.
Configuring Mina filters
SslFilter
. You can also implement some customized filters. Please note that codec
and logger
are also implemented as Mina filters of type, IoFilter
. Any filters you may define are appended to the end of the filter chain; that is, after codec
and logger
.
- See also:
Chapter 94. Mock
Mock Component
- The correct number of messages are received on each endpoint,
- The correct payloads are received, in the right order,
- Messages arrive on an endpoint in order, using some Expression to create an order testing function,
- Messages arrive match some kind of Predicate such as that specific headers have certain values, or that parts of the messages match some predicate, such as by evaluating an XPath or XQuery Expression.
retainFirst
, and retainLast
that can be used to limit the number of messages the Mock endpoints keep in memory.
URI format
mock:someName[?options]
?option=value&option=value&...
Options
Option | Default | Description |
---|---|---|
reportGroup
|
null
|
A size to use a throughput logger for reporting |
retainFirst
|
Camel 2.10: To only keep first X number of messages in memory.
|
|
retainLast
|
Camel 2.10: To only keep last X number of messages in memory.
|
Simple Example
MockEndpoint resultEndpoint = context.resolveEndpoint("mock:foo", MockEndpoint.class); resultEndpoint.expectedMessageCount(2); // send some messages ... // now lets assert that the mock:foo endpoint received 2 messages resultEndpoint.assertIsSatisfied();
assertIsSatisfied()
is invoked. This can be configured by setting the setResultWaitTime(millis)
method.
Using assertPeriod
assertIsSatisfied
method. That means if a new message arrives on the mock endpoint, just a bit later, that arrival will not affect the outcome of the assertion. Suppose you do want to test that no new messages arrives after a period thereafter, then you can do that by setting the setAssertPeriod
method, for example:
MockEndpoint resultEndpoint = context.resolveEndpoint("mock:foo", MockEndpoint.class); resultEndpoint.setAssertPeriod(5000); resultEndpoint.expectedMessageCount(2); // send some messages ... // now lets assert that the mock:foo endpoint received 2 messages resultEndpoint.assertIsSatisfied();
Setting expectations
Method | Description |
---|---|
expectedMessageCount(int) | To define the expected message count on the endpoint. |
expectedMinimumMessageCount(int) | To define the minimum number of expected messages on the endpoint. |
expectedBodiesReceived(...) | To define the expected bodies that should be received (in order). |
expectedHeaderReceived(...) | To define the expected header that should be received |
expectsAscending(Expression) | To add an expectation that messages are received in order, using the given Expression to compare messages. |
expectsDescending(Expression) | To add an expectation that messages are received in order, using the given Expression to compare messages. |
expectsNoDuplicates(Expression) |
To add an expectation that no duplicate messages are received; using an Expression to calculate a unique identifier for each message. This could be something like the JMSMessageID if using JMS, or some unique reference number within the message.
|
resultEndpoint.expectedBodiesReceived("firstMessageBody", "secondMessageBody", "thirdMessageBody");
Adding expectations to specific messages
java.util.List
), you can use the following code:
resultEndpoint.message(0).header("foo").isEqualTo("bar");
Mocking existing endpoints
@Override protected RouteBuilder createRouteBuilder() throws Exception { return new RouteBuilder() { @Override public void configure() throws Exception { from("direct:start").to("direct:foo").to("log:foo").to("mock:result"); from("direct:foo").transform(constant("Bye World")); } }; }
adviceWith
feature in Camel to mock all the endpoints in a given route from your unit test, as shown below:
public void testAdvisedMockEndpoints() throws Exception { // advice the first route using the inlined AdviceWith route builder // which has extended capabilities than the regular route builder context.getRouteDefinitions().get(0).adviceWith(context, new AdviceWithRouteBuilder() { @Override public void configure() throws Exception { // mock all endpoints mockEndpoints(); } }); getMockEndpoint("mock:direct:start").expectedBodiesReceived("Hello World"); getMockEndpoint("mock:direct:foo").expectedBodiesReceived("Hello World"); getMockEndpoint("mock:log:foo").expectedBodiesReceived("Bye World"); getMockEndpoint("mock:result").expectedBodiesReceived("Bye World"); template.sendBody("direct:start", "Hello World"); assertMockEndpointsSatisfied(); // additional test to ensure correct endpoints in registry assertNotNull(context.hasEndpoint("direct:start")); assertNotNull(context.hasEndpoint("direct:foo")); assertNotNull(context.hasEndpoint("log:foo")); assertNotNull(context.hasEndpoint("mock:result")); // all the endpoints was mocked assertNotNull(context.hasEndpoint("mock:direct:start")); assertNotNull(context.hasEndpoint("mock:direct:foo")); assertNotNull(context.hasEndpoint("mock:log:foo")); }
mock:<endpoint>
, for example mock:direct:foo
. Camel logs at INFO
level the endpoints being mocked:
INFO Adviced endpoint [direct://foo] with mock endpoint [mock:direct:foo]
log
endpoints you do as shown:
public void testAdvisedMockEndpointsWithPattern() throws Exception { // advice the first route using the inlined AdviceWith route builder // which has extended capabilities than the regular route builder context.getRouteDefinitions().get(0).adviceWith(context, new AdviceWithRouteBuilder() { @Override public void configure() throws Exception { // mock only log endpoints mockEndpoints("log*"); } }); // now we can refer to log:foo as a mock and set our expectations getMockEndpoint("mock:log:foo").expectedBodiesReceived("Bye World"); getMockEndpoint("mock:result").expectedBodiesReceived("Bye World"); template.sendBody("direct:start", "Hello World"); assertMockEndpointsSatisfied(); // additional test to ensure correct endpoints in registry assertNotNull(context.hasEndpoint("direct:start")); assertNotNull(context.hasEndpoint("direct:foo")); assertNotNull(context.hasEndpoint("log:foo")); assertNotNull(context.hasEndpoint("mock:result")); // only the log:foo endpoint was mocked assertNotNull(context.hasEndpoint("mock:log:foo")); assertNull(context.hasEndpoint("mock:direct:start")); assertNull(context.hasEndpoint("mock:direct:foo")); }
Mocking existing endpoints using the camel-test component
adviceWith
to instruct Camel to mock endpoints, you can easily enable this behavior when using the camel-test
Test Kit. The same route can be tested as follows. Notice that we return "*"
from the isMockEndpoints
method, which tells Camel to mock all endpoints. If you only want to mock all log
endpoints you can return "log*"
instead.
public class IsMockEndpointsJUnit4Test extends CamelTestSupport { @Override public String isMockEndpoints() { // override this method and return the pattern for which endpoints to mock. // use * to indicate all return "*"; } @Test public void testMockAllEndpoints() throws Exception { // notice we have automatic mocked all endpoints and the name of the endpoints is "mock:uri" getMockEndpoint("mock:direct:start").expectedBodiesReceived("Hello World"); getMockEndpoint("mock:direct:foo").expectedBodiesReceived("Hello World"); getMockEndpoint("mock:log:foo").expectedBodiesReceived("Bye World"); getMockEndpoint("mock:result").expectedBodiesReceived("Bye World"); template.sendBody("direct:start", "Hello World"); assertMockEndpointsSatisfied(); // additional test to ensure correct endpoints in registry assertNotNull(context.hasEndpoint("direct:start")); assertNotNull(context.hasEndpoint("direct:foo")); assertNotNull(context.hasEndpoint("log:foo")); assertNotNull(context.hasEndpoint("mock:result")); // all the endpoints was mocked assertNotNull(context.hasEndpoint("mock:direct:start")); assertNotNull(context.hasEndpoint("mock:direct:foo")); assertNotNull(context.hasEndpoint("mock:log:foo")); } @Override protected RouteBuilder createRouteBuilder() throws Exception { return new RouteBuilder() { @Override public void configure() throws Exception { from("direct:start").to("direct:foo").to("log:foo").to("mock:result"); from("direct:foo").transform(constant("Bye World")); } }; } }
Mocking existing endpoints with XML DSL
camel-test
component for unit testing (as shown above) you can use a different approach when using XML files for routes. The solution is to create a new XML file used by the unit test and then include the intended XML file which has the route you want to test.
camel-route.xml
file:
<!-- this camel route is in the camel-route.xml file --> <camelContext xmlns="http://camel.apache.org/schema/spring"> <route> <from uri="direct:start"/> <to uri="direct:foo"/> <to uri="log:foo"/> <to uri="mock:result"/> </route> <route> <from uri="direct:foo"/> <transform> <constant>Bye World</constant> </transform> </route> </camelContext>
camel-route.xml
file and define a spring bean with the class org.apache.camel.impl.InterceptSendToMockEndpointStrategy
which tells Camel to mock all endpoints:
<!-- the Camel route is defined in another XML file --> <import resource="camel-route.xml"/> <!-- bean which enables mocking all endpoints --> <bean id="mockAllEndpoints" class="org.apache.camel.impl.InterceptSendToMockEndpointStrategy"/>
test-camel-route.xml
) instead of camel-route.xml
.
<bean id="mockAllEndpoints" class="org.apache.camel.impl.InterceptSendToMockEndpointStrategy"> <constructor-arg index="0" value="log*"/> </bean>
Mocking endpoints and skip sending to original endpoint
mockEndpointsAndSkip
method using AdviceWith or the Test Kit. The example below will skip sending to the two endpoints "direct:foo"
, and "direct:bar"
.
public void testAdvisedMockEndpointsWithSkip() throws Exception { // advice the first route using the inlined AdviceWith route builder // which has extended capabilities than the regular route builder context.getRouteDefinitions().get(0).adviceWith(context, new AdviceWithRouteBuilder() { @Override public void configure() throws Exception { // mock sending to direct:foo and direct:bar and skip send to it mockEndpointsAndSkip("direct:foo", "direct:bar"); } }); getMockEndpoint("mock:result").expectedBodiesReceived("Hello World"); getMockEndpoint("mock:direct:foo").expectedMessageCount(1); getMockEndpoint("mock:direct:bar").expectedMessageCount(1); template.sendBody("direct:start", "Hello World"); assertMockEndpointsSatisfied(); // the message was not send to the direct:foo route and thus not sent to the seda endpoint SedaEndpoint seda = context.getEndpoint("seda:foo", SedaEndpoint.class); assertEquals(0, seda.getCurrentQueueSize()); }
public class IsMockEndpointsAndSkipJUnit4Test extends CamelTestSupport { @Override public String isMockEndpointsAndSkip() { // override this method and return the pattern for which endpoints to mock, // and skip sending to the original endpoint. return "direct:foo"; } @Test public void testMockEndpointAndSkip() throws Exception { // notice we have automatic mocked the direct:foo endpoints and the name of the endpoints is "mock:uri" getMockEndpoint("mock:result").expectedBodiesReceived("Hello World"); getMockEndpoint("mock:direct:foo").expectedMessageCount(1); template.sendBody("direct:start", "Hello World"); assertMockEndpointsSatisfied(); // the message was not send to the direct:foo route and thus not sent to the seda endpoint SedaEndpoint seda = context.getEndpoint("seda:foo", SedaEndpoint.class); assertEquals(0, seda.getCurrentQueueSize()); } @Override protected RouteBuilder createRouteBuilder() throws Exception { return new RouteBuilder() { @Override public void configure() throws Exception { from("direct:start").to("direct:foo").to("mock:result"); from("direct:foo").transform(constant("Bye World")).to("seda:foo"); } }; } }
Limiting the number of messages to keep
retainFirst
and retainLast
that can be used to specify to only keep N'th of the first and/or last Exchanges.
MockEndpoint mock = getMockEndpoint("mock:data"); mock.setRetainFirst(5); mock.setRetainLast(5); mock.expectedMessageCount(2000); ... mock.assertIsSatisfied();
getExchanges()
and getReceivedExchanges()
methods on the MockEndpoint
will return only the retained copies of the Exchanges. So in the example above, the list will contain 10 Exchanges; the first five, and the last five. The retainFirst
and retainLast
options also have limitations on which expectation methods you can use. For example the expectedXXX methods that work on message bodies, headers, etc. will only operate on the retained messages. In the example above they can test only the expectations on the 10 retained messages.
Testing with arrival times
Date time = exchange.getProperty(Exchange.RECEIVED_TIMESTAMP, Date.class);
arrives
DSL on the Mock endpoint.
mock.message(0).arrives().noLaterThan(2).seconds().beforeNext();
mock.message(1).arrives().noLaterThan(2).seconds().afterPrevious();
mock.message(1).arrives().between(1, 4).seconds().afterPrevious();
mock.allMessages().arrives().noLaterThan(1).seconds().beforeNext();
seconds
as the time unit, but Camel offers milliseconds
, and minutes
as well.
Chapter 95. MongoDB
Camel MongoDB component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-mongodb</artifactId> <version>x.y.z</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
mongodb:connectionBean?database=databaseName&collection=collectionName&operation=operationName[&moreOptions...]
Endpoint options
Name | Default Value | Description | Producer | Tailable Cursor Consumer |
---|---|---|---|---|
database
|
none |
Required. The name of the database to which this endpoint will be bound. All operations will be executed against this database unless dynamicity is enabled and the CamelMongoDbDatabase header is set.
|
(/) | (/) |
collection
|
none |
Required (Except for getDbStats and command operations). The name of the collection (within the specified database) to which this endpoint will be bound. ll operations will be executed against this database unless dynamicity is enabled and the CamelMongoDbDatabase header is set.
|
(/) | (/) |
collectionIndex
|
none | Camel 2.12: An optional single field index or compound index to create when inserting new collections. | (/) | |
operation
|
none |
Required for producers. The id of the operation this endpoint will execute. Pick from the following:
|
(/) | |
createCollection
|
true |
Determines whether the collection will be automatically created in the MongoDB database during endpoint initialisation if it doesn't exist already. If this option is false and the collection doesn't exist, an initialisation exception will be thrown.
|
(/) | |
invokeGetLastError
|
false (behaviour may be inherited from connections WriteConcern) |
Instructs the MongoDB Java driver to invoke getLastError() after every call. Default behaviour in version 2.7.2 of the MongoDB Java driver is that only network errors will cause the operation to fail, because the actual operation is executed asynchronously in the MongoDB server without holding up the client - to increase performance. The client can obtain the real result of the operation by explicitly invoking getLastError() on the WriteResult object returned or by setting the appropriate WriteConcern . If the backend operation has not finished yet, the client will block until the result is available. Setting this option to true will make the endpoint behave synchronously and return an Exception if the underlying operation failed.
|
(/) | |
writeConcern
|
none (driver's default) |
Set a WriteConcern on the operation out of MongoDB's parameterised values. See WriteConcern.valueOf(String).
|
(/) | |
writeConcernRef
|
none |
Sets a custom WriteConcern that exists in the Registry. Specify the bean name.
|
(/) | |
readPreference
|
none |
Available as of Camel 2.12.4, 2.13.1 and 2.14.0: Sets a ReadPreference on the connection. Accepted values are those supported by the ReadPreference#valueOf() public API. Currently as of MongoDB-Java-Driver version 2.12.0 the supported values are:
primary , primaryPreferred , secondary , secondaryPreferred and nearest . See also the documentation for more details about this option.
|
(/) | |
dynamicity
|
false |
If set to true, the endpoint will inspect the CamelMongoDbDatabase and CamelMongoDbCollection headers of the incoming message, and if any of them exists, the target collection and/or database will be overridden for that particular operation. Set to false by default to avoid triggering the lookup on every Exchange if the feature is not desired.
|
(/) | |
writeResultAsHeader
|
false |
Available as of Camel 2.10.3 and 2.11: In write operations (save, update, insert, etc.), instead of replacing the body with the WriteResult object returned by MongoDB, keep the input body untouched and place the WriteResult in the CamelMongoWriteResult header (constant MongoDbConstants.WRITERESULT ).
|
(/) | |
persistentTailTracking
|
false | Enables or disables persistent tail tracking for Tailable Cursor consumers. See below for more information. | (/) | |
persistentId
|
none | Required if persistent tail tracking is enabled. The id of this persistent tail tracker, to separate its records from the rest on the tail-tracking collection. | (/) | |
tailTrackingIncreasingField
|
none | Required if persistent tail tracking is enabled. Correlation field in the incoming record which is of increasing nature and will be used to position the tailing cursor every time it is generated. The cursor will be (re)created with a query of type: tailTrackIncreasingField > lastValue (where lastValue is possibly recovered from persistent tail tracking). Can be of type Integer, Date, String, etc. NOTE: No support for dot notation at the current time, so the field should be at the top level of the document. | (/) | |
cursorRegenerationDelay
|
1000ms | Establishes how long the endpoint will wait to regenerate the cursor after it has been killed by the MongoDB server (normal behaviour). | (/) | |
tailTrackDb
|
same as endpoint's | Database on which the persistent tail tracker will store its runtime information. | (/) | |
tailTrackCollection
|
camelTailTracking | Collection on which the persistent tail tracker will store its runtime information. | (/) | |
tailTrackField
|
lastTrackingValue | Field in which the persistent tail tracker will store the last tracked value. | (/) |
Configuration of database in Spring XML
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="mongoBean" class="com.mongodb.Mongo"> <constructor-arg name="host" value="${mongodb.host}" /> <constructor-arg name="port" value="${mongodb.port}" /> </bean> </beans>
Sample route
<route> <from uri="direct:start" /> <!-- using bean 'mongoBean' defined above --> <to uri="mongodb:mongoBean?database=${mongodb.database}&collection=${mongodb.collection}&operation=getDbStats" /> <to uri="direct:result" /> </route>
MongoDB operations - producer endpoints
Query operations
findById
from("direct:findById") .to("mongodb:myDb?database=flights&collection=tickets&operation=findById") .to("mock:resultFindById");
findOneByQuery
DBObject
or convertible to DBObject
. It can be a JSON String or a Hashmap. See Type conversions for more info.
from("direct:findOneByQuery") .to("mongodb:myDb?database=flights&collection=tickets&operation=findOneByQuery") .to("mock:resultFindOneByQuery");
from("direct:findOneByQuery") .setBody().constant("{ \"name\": \"Raul Kripalani\" }") .to("mongodb:myDb?database=flights&collection=tickets&operation=findOneByQuery") .to("mock:resultFindOneByQuery");
findAll
findAll
operation returns all documents matching a query, or none at all, in which case all documents contained in the collection are returned. The query object is extracted from the IN message body, i.e. it should be of type DBObject
or convertible to DBObject
. It can be a JSON String or a Hashmap. See Type conversions for more info.
from("direct:findAll") .to("mongodb:myDb?database=flights&collection=tickets&operation=findAll") .to("mock:resultFindAll");
from("direct:findAll") .setBody().constant("{ \"name\": \"Raul Kripalani\" }") .to("mongodb:myDb?database=flights&collection=tickets&operation=findAll") .to("mock:resultFindAll");
Header key | Quick constant | Description (extracted from MongoDB API doc) | Expected type |
---|---|---|---|
CamelMongoDbNumToSkip
|
MongoDbConstants.NUM_TO_SKIP
|
Discards a given number of elements at the beginning of the cursor. | int/Integer |
CamelMongoDbLimit
|
MongoDbConstants.LIMIT
|
Limits the number of elements returned. | int/Integer |
CamelMongoDbBatchSize
|
MongoDbConstants.BATCH_SIZE
|
Limits the number of elements returned in one batch. A cursor typically fetches a batch of result objects and store them locally. If batchSize is positive, it represents the size of each batch of objects retrieved. It can be adjusted to optimize performance and limit data transfer. If batchSize is negative, it will limit of number objects returned, that fit within the max batch size limit (usually 4MB), and cursor will be closed. For example if batchSize is -10, then the server will return a maximum of 10 documents and as many as can fit in 4MB, then close the cursor. Note that this feature is different from limit() in that documents must fit within a maximum size, and it removes the need to send a request to close the cursor server-side. The batch size can be changed even after a cursor is iterated, in which case the setting will apply on the next batch retrieval. | int/Integer |
DBObject
describing your sorting in the CamelMongoDbSortBy
header, quick constant: MongoDbConstants.SORT_BY
.
findAll
operation will also return the following OUT headers to enable you to iterate through result pages if you are using paging:
Header key | Quick constant | Description (extracted from MongoDB API doc) | Data type |
---|---|---|---|
CamelMongoDbResultTotalSize
|
MongoDbConstants.RESULT_TOTAL_SIZE
|
Number of objects matching the query. This does not take limit/skip into consideration. | int/Integer |
CamelMongoDbResultPageSize
|
MongoDbConstants.RESULT_PAGE_SIZE
|
Number of objects matching the query. This does not take limit/skip into consideration. | int/Integer |
count
Long
as the Out message body. The following example will count the number of records in the dynamicCollectionName
collection. Notice how dynamicity is enabled, and as a result, the operation will not run against the notableScientists
collection, but against the dynamicCollectionName
collection.
// from("direct:count").to("mongodb:myDb?database=tickets&collection=flights&operation=count&dynamicity=true"); Long result = template.requestBodyAndHeader("direct:count", "irrelevantBody", MongoDbConstants.COLLECTION, "dynamicCollectionName"); assertTrue("Result is not of type Long", result instanceof Long);
com.mongodb.DBObject
object in the message body as a query, and operation will return the amount of documents matching this criteria.
DBObject query = ... Long count = template.requestBodyAndHeader("direct:count", query, MongoDbConstants.COLLECTION, "dynamicCollectionName");
Specifying a fields filter
DBObject
(or type convertible to DBObject
, such as a JSON String, Map, etc.) on the CamelMongoDbFieldsFilter
header, constant shortcut: MongoDbConstants.FIELDS_FILTER
.
_id
and boringField
:
// route: from("direct:findAll").to("mongodb:myDb?database=flights&collection=tickets&operation=findAll") DBObject fieldFilter = BasicDBObjectBuilder.start().add("_id", 0).add("boringField", 0).get(); Object result = template.requestBodyAndHeader("direct:findAll", (Object) null, MongoDbConstants.FIELDS_FILTER, fieldFilter);
Create/update operations
insert
DBObject
or a List
. Two modes are supported: single insert and multiple insert. For multiple insert, the endpoint will expect a List, Array or Collections of objects of any type, as long as they are - or can be converted to - DBObject
. All objects are inserted at once. The endpoint will intelligently decide which backend operation to invoke (single or multiple insert) depending on the input.
from("direct:insert") .to("mongodb:myDb?database=flights&collection=tickets&operation=insert");
WriteConcern
or the value of the invokeGetLastError
option, getLastError()
would have been called already or not. If you want to access the ultimate result of the write operation, you need to retrieve the CommandResult
by calling getLastError()
or getCachedLastError()
on the WriteResult
. Then you can verify the result by calling CommandResult.ok()
, CommandResult.getErrorMessage()
and/or CommandResult.getException()
.
_id
must be unique in the collection. If you don't specify the value, MongoDB will automatically generate one for you. But if you do specify it and it is not unique, the insert operation will fail (and for Camel to notice, you will need to enable invokeGetLastError or set a WriteConcern that waits for the write result).
_id
, you are expected to ensure at the application level that is unique (and this is a good practice too).
CamelMongoOid
key (MongoDbConstants.OID
constant). The value stored is org.bson.types.ObjectId
for single insert or java.util.List<org.bson.types.ObjectId>
if multiple records have been inserted.
save
- perform a query to retrieve the entire object first along with all its fields (may not be efficient), alter it inside Camel and then save it.
- use the update operation with $modifiers, which will execute the update at the server-side instead. You can enable the upsert flag, in which case if an insert is required, MongoDB will apply the $modifiers to the filter query object and insert the result.
from("direct:insert") .to("mongodb:myDb?database=flights&collection=tickets&operation=save");
update
- Element 1 (index 0) => filter query => determines what objects will be affected, same as a typical query object
- Element 2 (index 1) => update rules => how matched objects will be updated. All modifier operations from MongoDB are supported.
CamelMongoDbMultiUpdate
IN message header to true
.
CamelMongoDbRecordsAffected
will be returned (MongoDbConstants.RECORDS_AFFECTED
constant) with the number of records updated (copied from WriteResult.getN()
).
Header key | Quick constant | Description (extracted from MongoDB API doc) | Expected type |
---|---|---|---|
CamelMongoDbMultiUpdate
|
MongoDbConstants.MULTIUPDATE
|
If the update should be applied to all objects matching. See http://www.mongodb.org/display/DOCS/Atomic+Operations | boolean/Boolean |
CamelMongoDbUpsert
|
MongoDbConstants.UPSERT
|
If the database should create the element if it does not exist | boolean/Boolean |
// route: from("direct:update").to("mongodb:myDb?database=science&collection=notableScientists&operation=update"); DBObject filterField = new BasicDBObject("filterField", true); DBObject updateObj = new BasicDBObject("$set", new BasicDBObject("scientist", "Darwin")); Object result = template.requestBodyAndHeader("direct:update", new Object[] {filterField, updateObj}, MongoDbConstants.MULTIUPDATE, true);
Delete operations
remove
DBObject
or a type convertible to it. The following example will remove all objects whose field 'conditionField' equals true, in the science database, notableScientists collection:
// route: from("direct:remove").to("mongodb:myDb?database=science&collection=notableScientists&operation=remove"); DBObject conditionField = new BasicDBObject("conditionField", true); Object result = template.requestBody("direct:remove", conditionField);
CamelMongoDbRecordsAffected
is returned (MongoDbConstants.RECORDS_AFFECTED
constant) with type int
, containing the number of records deleted (copied from WriteResult.getN()
).
Other operations
aggregate
// route: from("direct:aggregate").to("mongodb:myDb?database=science&collection=notableScientists&operation=aggregate"); from("direct:aggregate") .setBody().constant("[{ $match : {$or : [{\"scientist\" : \"Darwin\"},{\"scientist\" : \"Einstein\"}]}},{ $group: { _id: \"$scientist\", count: { $sum: 1 }} } ]") .to("mongodb:myDb?database=science&collection=notableScientists&operation=aggregate") .to("mock:resultAggregate");
getDbStats
db.stats()
command in the MongoDB shell, which displays useful statistic figures about the database. For example:
> db.stats(); { "db" : "test", "collections" : 7, "objects" : 719, "avgObjSize" : 59.73296244784423, "dataSize" : 42948, "storageSize" : 1000058880, "numExtents" : 9, "indexes" : 4, "indexSize" : 32704, "fileSize" : 1275068416, "nsSizeMB" : 16, "ok" : 1 }
// from("direct:getDbStats").to("mongodb:myDb?database=flights&collection=tickets&operation=getDbStats"); Object result = template.requestBody("direct:getDbStats", "irrelevantBody"); assertTrue("Result is not of type DBObject", result instanceof DBObject);
DBObject
in the OUT message body.
getColStats
db.collection.stats()
command in the MongoDB shell, which displays useful statistic figures about the collection. For example:
> db.camelTest.stats(); { "ns" : "test.camelTest", "count" : 100, "size" : 5792, "avgObjSize" : 57.92, "storageSize" : 20480, "numExtents" : 2, "nindexes" : 1, "lastExtentSize" : 16384, "paddingFactor" : 1, "flags" : 1, "totalIndexSize" : 8176, "indexSizes" : { "_id_" : 8176 }, "ok" : 1 }
// from("direct:getColStats").to("mongodb:myDb?database=flights&collection=tickets&operation=getColStats"); Object result = template.requestBody("direct:getColStats", "irrelevantBody"); assertTrue("Result is not of type DBObject", result instanceof DBObject);
DBObject
in the OUT message body.
command
// route: from("command").to("mongodb:myDb?database=science&operation=command"); DBObject commandBody = new BasicDBObject("hostInfo", "1"); Object result = template.requestBody("direct:command", commandBody);
Dynamic operations
CamelMongoDbOperation
header, defined by the MongoDbConstants.OPERATION_HEADER
constant. The values supported are determined by the MongoDbOperation enumeration and match the accepted values for the operation
parameter on the endpoint URI.
// from("direct:insert").to("mongodb:myDb?database=flights&collection=tickets&operation=insert"); Object result = template.requestBodyAndHeader("direct:insert", "irrelevantBody", MongoDbConstants.OPERATION_HEADER, "count"); assertTrue("Result is not of type Long", result instanceof Long);
Tailable Cursor Consumer
tail -f
command of *nix systems. This mechanism is significantly more efficient than a scheduled poll, due to the fact that the server pushes new data to the client as it becomes available, rather than making the client ping back at scheduled intervals to fetch new data. It also reduces otherwise redundant network traffic.
How the tailable cursor consumer works
DBCursor.next()
method until new data arrives. However, the MongoDB server reserves itself the right to kill your cursor if new data doesn't appear after an indeterminate period. If you are interested to continue consuming new data, you have to regenerate the cursor. And to do so, you will have to remember the position where you left off or else you will start consuming from the top again.
increasingField > lastValue
, so that only unread data is consumed.
tailTrackingIncreasingField
option. In Camel 2.10, it must be a top-level field in your data, as nested navigation for this field is not yet supported. That is, the "timestamp" field is okay, but "nested.timestamp" will not work. Please open a ticket in the Camel JIRA if you do require support for nested increasing fields.
cursorRegenerationDelay
option has been introduced (with a default value of 1000ms.), which you can modify to suit your needs.
from("mongodb:myDb?database=flights&collection=cancellations&tailTrackIncreasingField=departureTime") .id("tailableCursorConsumer1") .autoStartup(false) .to("mock:test");
Persistent tail tracking
Enabling persistent tail tracking
persistentTailTracking
option totrue
persistentId
option to a unique identifier for this consumer, so that the same collection can be reused across many consumers
tailTrackDb
, tailTrackCollection
and tailTrackField
options to customise where the runtime information will be stored. Refer to the endpoint options table at the top of this page for descriptions of each option.
camelTailTracking
and lastTrackingValue
are defaults).
from("mongodb:myDb?database=flights&collection=cancellations&tailTrackIncreasingField=departureTime&persistentTailTracking=true" + "&persistentId=cancellationsTracker") .id("tailableCursorConsumer2") .autoStartup(false) .to("mock:test");
from("mongodb:myDb?database=flights&collection=cancellations&tailTrackIncreasingField=departureTime&persistentTailTracking=true" + "&persistentId=cancellationsTracker"&tailTrackDb=trackers&tailTrackCollection=camelTrackers" + "&tailTrackField=lastProcessedDepartureTime") .id("tailableCursorConsumer3") .autoStartup(false) .to("mock:test");
Type conversions
MongoDbBasicConverters
type converter included with the camel-mongodb component provides the following conversions:
Name | From type | To type | How? |
---|---|---|---|
fromMapToDBObject |
Map
|
DBObject
|
constructs a new BasicDBObject via the new BasicDBObject(Map m) constructor
|
fromBasicDBObjectToMap |
BasicDBObject
|
Map
|
BasicDBObject already implements Map
|
fromStringToDBObject |
String
|
DBObject
|
uses com.mongodb.util.JSON.parse(String s)
|
fromAnyObjectToDBObject |
Object
|
DBObject
|
uses the Jackson library to convert the object to a Map , which is in turn used to initialise a new BasicDBObject
|
See also
- Unit tests for more examples of usage
Chapter 96. MQTT
MQTT Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-mqtt</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
mqtt://name[?options]
Options
Property | Default | Description |
---|---|---|
host
|
tcp://127.0.0.1:1883
|
The URI of the MQTT broker to connect too - this component also supports SSL - e.g. ssl://127.0.0.1:8883 |
localAddress
|
The local InetAddress and port to use | |
username
|
User name to be used for authentication against the MQTT broker. | |
password
|
Password to be used for authentication against the MQTT broker. | |
connectAttemptsMax
|
-1
|
The maximum number of attempts to establish an initial connection - -1 in infinite. |
reconnectAttemptsMax
|
-1
|
The maximum number of attempts to re-establish a connection after failure - -1 in infinite. |
reconnectDelay
|
10
|
The time in milliseconds between attempts to reestablish an initial or failed connection |
reconnectBackOffMultiplier
|
2.0
|
The multiplier to use to the delay between connection attempts for successive failed connection attempts |
reconnectDelayMax
|
30000
|
The maximum time in milliseconds between a new attempt to establish a connection. So even using the reconnectBackOffMultiplier, this property will define the maximum delay before another connection attempt to the MQTT broker |
qualityOfService
|
AtLeastOnce
|
The MQTT Quality of Service to use for message exchanges. It can be one of AtMostOnce, AtLeastOnce or ExactlyOnce |
subscribeTopicName
|
The name of the Topic to subscribe to for messages. Deprecated since 2.15.0 (use subscribeTopicNames instead). | |
subscribeTopicNames
|
Camel 2.15.0: A comma-delimited list of Topics to subscribe to for messages.
Note that each item of this list can contain MQTT wildcards (
+ and/or # ), in order to subscribe to topics matching a certain pattern within a hierarchy. For example, + is a wildcard for all topics at a level within the hierarchy, so if a broker has topics topics/one and topics/two , then topics/+ can be used to subscribe to both. A caveat to consider here is that if the broker adds topics/three , the route would also begin to receive messages from that topic.
|
|
publishTopicName
|
camel/mqtt/test
|
The default Topic to publish messages on |
byDefaultRetain
|
false
|
The default retain policy to be used on messages sent to the MQTT broker |
mqttTopicPropertyName
|
_MQTTTopicPropertyName+
|
The property name to look for on an Exchange for an individual published message. If this is set - the name will be used as the Topic to publish a message to the MQTT message broker. This option is removed since camel 2.14.0.
Since Camel 2.14.0, Camel uses
CamelMQTTSubscribeTopic as the topic property name of the MQTT consumer, and CamelMQTTPublishTopic as the topic property name of the MQTT producer.
|
mqttRetainPropertyName
|
MQTTRetain
|
The property name to look for on an Exchange for an individual published message. If this is set (expects a Boolean value) - then the retain property will be set on the message sent to the MQTT message broker. |
mqttQosPropertyName
|
MQTTQos
|
The property name to look for on an Exchange for an individual published message. If this is set (one of AtMostOnce, AtLeastOnce or ExactlyOnce ) - then that QoS will be set on the message sent to the MQTT message broker. |
connectWaitInSeconds
|
10
|
Delay in seconds the Component will wait for a connection to be established to the MQTT broker |
disconnectWaitInSeconds
|
5
|
The number of seconds the Component will wait for a valid disconnect on stop() from the MQTT broker |
sendWaitInSeconds
|
5
|
The maximum time the Component will wait for a receipt from the MQTT broker to acknowledge a published message before throwing an exception |
clientId
|
The identifier to use for the Component connection to the MQTT broker. If not specified it will be assigned automatically. | |
cleanSession
|
true
|
If true , all state information is discarded when connecting to, or disconnecting from, the MQTT broker. Note that a clientId must be specified when setting cleanSession to false .
|
?option=value&option=value&...
Samples
from("direct:foo") .to("mqtt:cheese?publishTopicName=test.mqtt.topic");
from("mqtt:bar?subscribeTopicName=test.mqtt.topic") .transform(body().convertToString()) .to("mock:result")
Chapter 97. MSV
MSV Component
URI format
msv:someLocalOrRemoteResource[?options]
msv:org/foo/bar.rng msv:file:../foo/bar.rng msv:http://acme.com/cheese.rng
?option=value&option=value&...
Options
Option | Default | Description |
---|---|---|
useDom
|
true
|
Whether DOMSource/DOMResult or SaxSource/SaxResult should be used by the validator. Note: DOM must be used by the MSV component. |
Example
<camelContext xmlns="http://camel.apache.org/schema/spring"> <route> <from uri="direct:start"/> <doTry> <to uri="msv:org/apache/camel/component/validator/msv/schema.rng"/> <to uri="mock:valid"/> <doCatch> <exception>org.apache.camel.ValidationException</exception> <to uri="mock:invalid"/> </doCatch> <doFinally> <to uri="mock:finally"/> </doFinally> </doTry> </route> </camelContext>
Chapter 98. Mustache
Mustache
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-mustache</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
mustache:templateName[?options]
?option=value&option=value&...
Options
Option | Default | Description |
---|---|---|
encoding
|
null
|
Character encoding of the resource content. |
startDelimiter
|
{{ | Characters used to mark template code beginning. |
endDelimiter
|
}} | Characters used to mark template code end. |
Mustache Context
Map
). The Exchange
is transferred as:
key | value |
---|---|
exchange
|
The Exchange itself.
|
exchange.properties
|
The Exchange properties.
|
headers
|
The headers of the In message. |
camelContext
|
The Camel Context. |
request
|
The In message. |
body
|
The In message body. |
response
|
The Out message (only for InOut message exchange pattern). |
Dynamic templates
Header | Type | Description | Support Version |
---|---|---|---|
MustacheConstants.MUSTACHE_RESOURCE_URI | String | A URI for the template resource to use instead of the endpoint configured. | |
MustacheConstants.MUSTACHE_TEMPLATE | String | The template to use instead of the endpoint configured. |
Samples
from("activemq:My.Queue"). to("mustache:com/acme/MyResponse.mustache");
JMSReplyTo
header).
from("activemq:My.Queue"). to("mustache:com/acme/MyResponse.mustache"). to("activemq:Another.Queue");
from("direct:in"). setHeader(MustacheConstants.MUSTACHE_RESOURCE_URI).constant("path/to/my/template.mustache"). to("mustache:dummy");
The Email Sample
Dear {{headers.lastName}}}, {{headers.firstName}} Thanks for the order of {{headers.item}}. Regards Camel Riders Bookstore {{body}}
Chapter 99. MVEL Component
MVEL Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-mvel</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
mvel:templateName[?options]
?option=value&option=value&...
Options
Option | Default | Description |
---|---|---|
contentCache
|
true
|
Cache for the resource content when it is loaded. The cached resource content can be cleared via JMX using the endpoint's clearContentCache operation.
|
encoding
|
null
|
Character encoding of the resource content. |
Message Headers
Header | Description |
---|---|
CamelMvelResourceUri
|
The templateName as a String object.
|
MVEL Context
Map
). The Exchange
is transfered as:
key | value |
---|---|
exchange
|
The Exchange itself.
|
exchange.properties
|
The Exchange properties.
|
headers
|
The headers of the In message. |
camelContext
|
The Camel Context intance. |
request
|
The In message. |
in
|
The In message. |
body
|
The In message body. |
out
|
The Out message (only for InOut message exchange pattern). |
response
|
The Out message (only for InOut message exchange pattern). |
Hot reloading
contentCache=true
, Camel will only load the resource once, and thus hot reloading is not possible. This scenario can be used in production, when the resource never changes.
Dynamic templates
Header | Type | Description |
---|---|---|
CamelMvelResourceUri | String | A URI for the template resource to use instead of the endpoint configured. |
CamelMvelTemplate | String | The template to use instead of the endpoint configured. |
Samples
from("activemq:My.Queue"). to("mvel:com/acme/MyResponse.mvel");
JMSReplyTo
header).
from("direct:in"). setHeader("CamelMvelResourceUri").constant("path/to/my/template.mvel"). to("mvel:dummy");
from("direct:in"). setHeader("CamelMvelTemplate").constant("@{\"The result is \" + request.body * 3}\" }"). to("velocity:dummy");
Chapter 100. MyBatis
MyBatis
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-mybatis</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
mybatis:statementName[?options]
?option=value&option=value&...
SqlMapConfig.xml
. If the file is located in another location, you will need to configure the configurationUri
option on the MyBatisComponent
component.
Options
Option | Type | Default | Description |
---|---|---|---|
consumer.onConsume
|
String
|
null
|
Statements to run after consuming. Can be used, for example, to update rows after they have been consumed and processed in Camel. See sample later. Multiple statements can be separated with commas. |
consumer.useIterator
|
boolean
|
true
|
If true each row returned when polling will be processed individually. If false the entire List of data is set as the IN body.
|
consumer.routeEmptyResultSet
|
boolean
|
false
|
Sets whether empty result sets should be routed. |
statementType
|
StatementType
|
null
|
Mandatory to specify for the producer to control which kind of operation to invoke. The enum values are: SelectOne , SelectList , Insert , InsertList , Update , UpdateList , Delete , and DeleteList . Notice:InsertList is available as of Camel 2.10, and UpdateList , DeleteList is available as of Camel 2.11.
|
maxMessagesPerPoll
|
int
|
0
|
This option is intended to split results returned by the database pool into the batches and deliver them in multiple exchanges. This integer defines the maximum messages to deliver in single exchange. By default, no maximum is set. Can be used to set a limit of e.g. 1000 to avoid when starting up the server that there are thousands of files. Set a value of 0 or negative to disable it. |
executorType
|
String
|
null
|
Camel 2.11: The executor type to be used while executing statements. The supported values are: simple, reuse, batch. By default, the value is not specified and is equal to what MyBatis uses, i.e. simple. simple executor does nothing special. reuse executor reuses prepared statements. batch executor reuses statements and batches updates. |
outputHeader
|
String
|
null
|
Camel 2.15: To store the result as a header instead of the message body. This allows to preserve the existing message body as-is. |
inputHeader
|
String
|
null
|
Camel 2.15: To use a header value as input to the component instead of the body. |
Message Headers
Header | Type | Description |
---|---|---|
CamelMyBatisStatementName
|
String
|
The statementName used (for example: insertAccount). |
CamelMyBatisResult
|
Object
|
The response returned from MtBatis in any of the operations. For instance an INSERT could return the auto-generated key, or number of rows etc.
|
Message Body
SELECT
statement. That means, for example, for INSERT
statements Camel will not replace the body. This allows you to continue routing and keep the original body. The response from MyBatis is always stored in the header with the key CamelMyBatisResult
.
Samples
from("activemq:queue:newAccount"). to("mybatis:insertAccount?statementType=Insert");
statementType
, as we need to instruct Camel which kind of operation to invoke.
<!-- Insert example, using the Account parameter class --> <insert id="insertAccount" parameterType="Account"> insert into ACCOUNT ( ACC_ID, ACC_FIRST_NAME, ACC_LAST_NAME, ACC_EMAIL ) values ( #{id}, #{firstName}, #{lastName}, #{emailAddress} ) </insert>
Using StatementType for better control of MyBatis
SELECT
, UPDATE
, DELETE
or INSERT
etc. So for instance if we want to route to an MyBatis endpoint in which the IN body contains parameters to a SELECT
statement we can do:
from("direct:start") .to("mybatis:selectAccountById?statementType=SelectOne") .to("mock:result");
selectAccountById
and the IN body should contain the account id we want to retrieve, such as an Integer
type.
SelectList
:
from("direct:start") .to("mybatis:selectAllAccounts?statementType=SelectList") .to("mock:result");
UPDATE
, where we can send an Account
object as the IN body to MyBatis:
from("direct:start") .to("mybatis:updateAccount?statementType=Update") .to("mock:result");
Using InsertList StatementType
<!-- Batch Insert example, using the Account parameter class --> <insert id="batchInsertAccount" parameterType="java.util.List"> insert into ACCOUNT ( ACC_ID, ACC_FIRST_NAME, ACC_LAST_NAME, ACC_EMAIL ) values ( <foreach item="Account" collection="list" open="" close="" separator="),("> #{Account.id}, #{Account.firstName}, #{Account.lastName}, #{Account.emailAddress} </foreach> ) </insert>
mybatis
endpoint which uses the InsertList
statement type, as shown below:
from("direct:start") .to("mybatis:batchInsertAccount?statementType=InsertList") .to("mock:result");
Using UpdateList StatementType
<update id="batchUpdateAccount" parameterType="java.util.Map"> update ACCOUNT set ACC_EMAIL = #{emailAddress} where ACC_ID in <foreach item="Account" collection="list" open="(" close=")" separator=","> #{Account.id} </foreach> </update>
from("direct:start") .to("mybatis:batchUpdateAccount?statementType=UpdateList") .to("mock:result");
Using DeleteList StatementType
<delete id="batchDeleteAccountById" parameterType="java.util.List"> delete from ACCOUNT where ACC_ID in <foreach item="AccountID" collection="list" open="(" close=")" separator=","> #{AccountID} </foreach> </delete>
from("direct:start") .to("mybatis:batchDeleteAccount?statementType=DeleteList") .to("mock:result");
Notice on InsertList, UpdateList and DeleteList StatementTypes
Scheduled polling example
from("mybatis:selectAllAccounts?delay=60000").to("activemq:queue:allAccounts");
from("timer://pollTheDatabase?delay=30000").to("mybatis:selectAllAccounts").to("activemq:queue:allAccounts");
<!-- Select with no parameters using the result map for Account class. --> <select id="selectAllAccounts" resultMap="AccountResult"> select * from ACCOUNT </select>
Using onConsume
UPDATE
statements. Camel supports executing multiple statements whose names should be separated by commas.
from("mybatis:selectUnprocessedAccounts?consumer.onConsume=consumeAccount").to("mock:results");
<select id="selectUnprocessedAccounts" resultMap="AccountResult"> select * from ACCOUNT where PROCESSED = false </select>
<update id="consumeAccount" parameterType="Account"> update ACCOUNT set PROCESSED = true where ACC_ID = #{id} </update>
Participating in transactions
SqlMapConfig.xml
file.
DataSource
. This is typically a pool (either DBCP, or c3p0), which needs to be wrapped in a Spring proxy. This proxy enables non-Spring use of the DataSource
to participate in Spring transactions (the MyBatis SqlSessionFactory
does just this).
<bean id="dataSource" class="org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy"> <constructor-arg> <bean class="com.mchange.v2.c3p0.ComboPooledDataSource"> <property name="driverClass" value="org.postgresql.Driver"/> <property name="jdbcUrl" value="jdbc:postgresql://localhost:5432/myDatabase"/> <property name="user" value="myUser"/> <property name="password" value="myPassword"/> </bean> </constructor-arg> </bean>
DataSource
:
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"/> </bean>
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="dataSource"/> <!-- standard mybatis config file --> <property name="configLocation" value="/META-INF/SqlMapConfig.xml"/> <!-- externalised mappers --> <property name="mapperLocations" value="classpath*:META-INF/mappers/**/*.xml"/> </bean>
<bean id="mybatis" class="org.apache.camel.component.mybatis.MyBatisComponent"> <property name="sqlSessionFactory" ref="sqlSessionFactory"/> </bean>
<bean id="PROPAGATION_REQUIRED" class="org.apache.camel.spring.spi.SpringTransactionPolicy"> <property name="transactionManager" ref="txManager"/> <property name="propagationBehaviorName" value="PROPAGATION_REQUIRED"/> </bean> <camelContext id="my-model-context" xmlns="http://camel.apache.org/schema/spring"> <route id="insertModel"> <from uri="direct:insert"/> <transacted ref="PROPAGATION_REQUIRED"/> <to uri="mybatis:myModel.insert?statementType=Insert"/> </route> </camelContext>
Chapter 101. Nagios
Nagios
URI format
nagios://host[:port][?Options]
Options
Name | Default Value | Description |
---|---|---|
host
|
none | This is the address of the Nagios host where checks should be send. |
port
|
The port number of the host. | |
password
|
Password to be authenticated when sending checks to Nagios. | |
connectionTimeout
|
5000 | Connection timeout in millis. |
timeout
|
5000 | Sending timeout in millis. |
nagiosSettings
|
To use an already configured com.googlecode.jsendnsca.core.NagiosSettings object. Then any of the other options are not in use, if using this.
|
|
sendSync
|
true
|
Whether or not to use synchronous when sending a passive check. Setting it to false will allow Apache Camel to continue routing the message and the passive check message will be send asynchronously.
|
encryptionMethod
|
No
|
*Camel 2.9:* To specify an encryption method. Possible values: No , Xor , or TripleDes .
|
Headers
Name | Description |
---|---|
CamelNagiosHostName
|
This is the address of the Nagios host where checks should be send. This header will override any existing hostname configured on the endpoint. |
CamelNagiosLevel
|
This is the severity level. You can use values CRITICAL, WARNING, OK . Apache Camel will by default use OK .
|
CamelNagiosServiceName
|
The servie name. Will default use the CamelContext name. |
Sending message examples
OK
level and use the CamelContext name as the service name. You can overrule these values using headers as shown above.
Hello Nagios
message to Nagios as follows:
template.sendBody("direct:start", "Hello Nagios"); from("direct:start").to("nagios:127.0.0.1:5667?password=secret").to("mock:result");
CRITICAL
message you can send the headers such as:
Map headers = new HashMap(); headers.put(NagiosConstants.LEVEL, "CRITICAL"); headers.put(NagiosConstants.HOST_NAME, "myHost"); headers.put(NagiosConstants.SERVICE_NAME, "myService"); template.sendBodyAndHeaders("direct:start", "Hello Nagios", headers);
Using NagiosEventNotifer
NagiosEventNotifier notifier = new NagiosEventNotifier(); notifier.getConfiguration().setHost("localhost"); notifier.getConfiguration().setPort(5667); notifier.getConfiguration().setPassword("password"); CamelContext context = ... context.getManagementStrategy().addEventNotifier(notifier); return context;
EventNotifier
and Apache Camel will pick it up as documented here: Advanced configuration of CamelContext using Spring.
Chapter 102. Netty
Netty Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-netty</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
netty:tcp://localhost:99999[?options] netty:udp://remotehost:99999/[?options]
?option=value&option=value&...
Options
Name | Default Value | Description |
---|---|---|
keepAlive
|
true
|
Setting to ensure socket is not closed due to inactivity |
tcpNoDelay
|
true
|
Setting to improve TCP protocol performance |
backlog
|
Camel 2.9.6/2.10.4/2.11: Allows to configure a backlog for netty consumer (server). Note the backlog is just a best effort depending on the OS. Setting this option to a value such as 200 , 500 or 1000 , tells the TCP stack how long the "accept" queue can be. If this option is not configured, then the backlog depends on OS setting.
|
|
broadcast
|
false
|
Setting to choose Multicast over UDP |
connectTimeout
|
10000
|
Time to wait for a socket connection to be available. Value is in millis. |
reuseAddress
|
true
|
Setting to facilitate socket multiplexing |
sync
|
true
|
Setting to set endpoint as one-way or request-response |
synchronous
|
false
|
Camel 2.10: Whether Asynchronous Routing Engine is not in use. false then the Asynchronous Routing Engine is used, true to force processing synchronous.
|
ssl
|
false
|
Setting to specify whether SSL encryption is applied to this endpoint |
sslClientCertHeaders
|
false
|
Camel 2.12: When enabled and in SSL mode, then the Netty consumer will enrich the Camel Message with headers having information about the client certificate such as subject name, issuer name, serial number, and the valid date range. |
sendBufferSize
|
65536 bytes
|
The TCP/UDP buffer sizes to be used during outbound communication. Size is bytes. |
receiveBufferSize
|
65536 bytes
|
The TCP/UDP buffer sizes to be used during inbound communication. Size is bytes. |
option.XXX
|
null
|
Camel 2.11/2.10.4: Allows to configure additional netty options using "option." as prefix. For example "option.child.keepAlive=false" to set the netty option "child.keepAlive=false". See the Netty documentation for possible options that can be used. |
corePoolSize
|
10
|
The number of allocated threads at component startup. Defaults to 10. Note: This option is removed from Camel 2.9.2 onwards. As we rely on Nettys default settings. |
maxPoolSize
|
100
|
The maximum number of threads that may be allocated to this endpoint. Defaults to 100. Note: This option is removed from Camel 2.9.2 onwards. As we rely on Nettys default settings. |
disconnect
|
false
|
Whether or not to disconnect(close) from Netty Channel right after use. Can be used for both consumer and producer. |
lazyChannelCreation
|
true
|
Channels can be lazily created to avoid exceptions, if the remote server is not up and running when the Camel producer is started. |
transferExchange
|
false
|
Only used for TCP. You can transfer the exchange over the wire instead of just the body. The following fields are transferred: In body, Out body, fault body, In headers, Out headers, fault headers, exchange properties, exchange exception. This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level. |
disconnectOnNoReply
|
true
|
If sync is enabled then this option dictates NettyConsumer if it should disconnect where there is no reply to send back. |
noReplyLogLevel
|
WARN
|
If sync is enabled this option dictates NettyConsumer which logging level to use when logging a there is no reply to send back. Values are: FATAL, ERROR, INFO, DEBUG, OFF .
|
serverExceptionCaughtLogLevel
|
WARN
|
Camel 2.11.1: If the server (NettyConsumer) catches an exception then its logged using this logging level. |
serverClosedChannelExceptionCaughtLogLevel
|
DEBUG
|
Camel 2.11.1: If the server (NettyConsumer) catches an java.nio.channels.ClosedChannelException then its logged using this logging level. This is used to avoid logging the closed channel exceptions, as clients can disconnect abruptly and then cause a flod of closed exceptions in the Netty server.
|
allowDefaultCodec
|
true
|
Camel 2.4: The netty component installs a default codec if both, encoder/deocder is null and textline is false. Setting allowDefaultCodec to false prevents the netty component from installing a default codec as the first element in the filter chain. |
textline
|
false
|
Camel 2.4: Only used for TCP. If no codec is specified, you can use this flag to indicate a text line based codec; if not specified or the value is false, then Object Serialization is assumed over TCP. |
delimiter
|
LINE
|
Camel 2.4: The delimiter to use for the textline codec. Possible values are LINE and NULL .
|
decoderMaxLineLength
|
1024
|
Camel 2.4: The max line length to use for the textline codec. |
autoAppendDelimiter
|
true
|
Camel 2.4: Whether or not to auto append missing end delimiter when sending using the textline codec. |
encoding
|
null
|
Camel 2.4: The encoding (a charset name) to use for the textline codec. If not provided, Camel will use the JVM default Charset. |
workerCount
|
null
|
Camel 2.9: When netty works on nio mode, it uses default workerCount parameter from Netty, which is cpu_core_threads*2. User can use this operation to override the default workerCount from Netty |
sslContextParameters
|
null
|
Camel 2.9: SSL configuration using an org.apache.camel.util.jsse.SSLContextParameters instance. See Using the JSSE Configuration Utility.
|
receiveBufferSizePredictor
|
null
|
Camel 2.9: Configures the buffer size predictor. See details at Jetty documentation and this mail thread. |
requestTimeout
|
0
|
Camel 2.11.1: Allows to use a timeout for the Netty producer when calling a remote server. By default no timeout is in use. The value is in milliseconds. The requestTimeout option uses Netty's ReadTimeoutHandler to trigger the timeout.
|
needClientAuth
|
false
|
Camel 2.11: Configures whether the server needs client authentication when using SSL. |
orderedThreadPoolExecutor
|
true
|
Camel 2.10.2: Whether to use ordered thread pool, to ensure events are processed orderly on the same channel. See details at the netty javadoc of org.jboss.netty.handler.execution.OrderedMemoryAwareThreadPoolExecutor for more details.
|
maximumPoolSize
|
16
|
Camel 2.10.2: The core pool size for the ordered thread pool, if its in use. |
producerPoolEnabled
|
true
|
Camel 2.10.4/Camel 2.11: Producer only. Whether producer pool is enabled or not. Important: Do not turn this off, as the pooling is needed for handling concurrency and reliable request/reply. |
producerPoolMaxActive
|
-1
|
Camel 2.10.3: Producer only. Sets the cap on the number of objects that can be allocated by the pool (checked out to clients, or idle awaiting checkout) at a given time. Use a negative value for no limit. |
producerPoolMinIdle
|
0
|
Camel 2.10.3: Producer only. Sets the minimum number of instances allowed in the producer pool before the evictor thread (if active) spawns new objects. |
producerPoolMaxIdle
|
100
|
Camel 2.10.3: Producer only. Sets the cap on the number of "idle" instances in the pool. |
producerPoolMinEvictableIdle
|
30000
|
Camel 2.10.3: Producer only. Sets the minimum amount of time (value in millis) an object may sit idle in the pool before it is eligible for eviction by the idle object evictor. |
bootstrapConfiguration
|
null
|
Camel 2.12: Consumer only. Allows to configure the Netty ServerBootstrap options using a org.apache.camel.component.netty.NettyServerBootstrapConfiguration instance. This can be used to reuse the same configuration for multiple consumers, to align their configuration more easily.
|
bossPoll
|
null
|
Camel 2.12: To use a explicit org.jboss.netty.channel.socket.nio.BossPool as the boss thread pool. For example to share a thread pool with multiple consumers. By default each consumer has their own boss pool with 1 core thread.
|
workerPool
|
null
|
Camel 2.12: To use a explicit org.jboss.netty.channel.socket.nio.WorkerPool as the worker thread pool. For example to share a thread pool with multiple consumers. By default each consumer has their own worker pool with 2 x cpu count core threads.
|
networkInterface
|
null
|
Camel 2.12: Consumer only. When using UDP then this option can be used to specify a network interface by its name, such as eth0 to join a multicast group.
|
udpConnectionlessSending
|
false
|
Camel 2.15: Producer only. This option supports connectionless UDP sending, which is genuine fire-and-forget. A UDP send attempt receives the
PortUnreachableException exception, if no one is listening on the receiving port.
|
clientMode
|
false
|
Camel 2.15: Consumer only. If clientMode is true , the Netty consumer connects to the address as a TCP client.
|
Registry based Options
Name | Description |
---|---|
passphrase
|
password setting to use in order to encrypt/decrypt payloads sent using SSH |
keyStoreFormat
|
keystore format to be used for payload encryption. Defaults to "JKS" if not set |
securityProvider
|
Security provider to be used for payload encryption. Defaults to "SunX509" if not set. |
keyStoreFile
|
deprecated: Client side certificate keystore to be used for encryption |
trustStoreFile
|
deprecated: Server side certificate keystore to be used for encryption |
keyStoreResource
|
Camel 2.11.1: Client side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with "classpath:" , "file:" , or "http:" to load the resource from different systems.
|
trustStoreResource
|
Camel 2.11.1: Server side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with "classpath:" , "file:" , or "http:" to load the resource from different systems.
|
sslHandler
|
Reference to a class that could be used to return an SSL Handler |
encoder
|
A custom ChannelHandler class that can be used to perform special marshalling of outbound payloads. Must override org.jboss.netty.channel.ChannelDownStreamHandler .
|
encorders
|
A list of encoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |
decoder
|
A custom ChannelHandler class that can be used to perform special marshalling of inbound payloads. Must override org.jboss.netty.channel.ChannelUpStreamHandler . With no decoder defined Netty will default to serialized Java objects via the ObjectDecoder class; if a different format is expected then a decoder must be specified.
|
decoders
|
A list of decoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |
Sending Messages to/from a Netty endpoint
Netty Producer
Netty Consumer
- listen on a specified socket using either TCP or UDP protocols (with optional SSL support),
- receive requests on the socket using text/xml, binary and serialized object based payloads and
- send them along on a route as message exchanges.
Headers
Header Key | Class | Description |
---|---|---|
NettyConstants.NETTY_CHANNEL_HANDLER_CONTEXT / CamelNettyChannelHandlerContext | org.jboss.netty.channel.ChannelHandlerContext | ChannelHandlerContext instance associated with the connection received by Netty. |
NettyConstants.NETTY_MESSAGE_EVENT / CamelNettyMessageEvent | org.jboss.netty.channel.MessageEvent | MessageEvent instance associated with the connection received by Netty. |
NettyConstants.NETTY_REMOTE_ADDRESS / CamelNettyRemoteAddress | java.net.SocketAddress | Remote address of the incoming socket connection. |
NettyConstants.NETTY_LOCAL_ADDRESS / CamelNettyLocalAddress | java.net.SocketAddress | Local address of the incoming socket connection. |
A UDP Netty endpoint using Request-Reply and serialized object payload
RouteBuilder builder = new RouteBuilder() { public void configure() { from("netty:udp://localhost:5155?sync=true") .process(new Processor() { public void process(Exchange exchange) throws Exception { Poetry poetry = (Poetry) exchange.getIn().getBody(); poetry.setPoet("Dr. Sarojini Naidu"); exchange.getOut().setBody(poetry); } } } };
A TCP based Netty consumer endpoint using One-way communication
RouteBuilder builder = new RouteBuilder() { public void configure() { from("netty:tcp://localhost:5150") .to("mock:result"); } };
An SSL/TCP based Netty consumer endpoint using Request-Reply communication
Using the JSSE Configuration Utility
Programmatic configuration of the component
KeyStoreParameters ksp = new KeyStoreParameters(); ksp.setResource("/users/home/server/keystore.jks"); ksp.setPassword("keystorePassword"); KeyManagersParameters kmp = new KeyManagersParameters(); kmp.setKeyStore(ksp); kmp.setKeyPassword("keyPassword"); SSLContextParameters scp = new SSLContextParameters(); scp.setKeyManagers(kmp); NettyComponent nettyComponent = getContext().getComponent("netty", NettyComponent.class); nettyComponent.setSslContextParameters(scp);
Spring DSL based configuration of endpoint
... <camel:sslContextParameters id="sslContextParameters"> <camel:keyManagers keyPassword="keyPassword"> <camel:keyStore resource="/users/home/server/keystore.jks" password="keystorePassword"/> </camel:keyManagers> </camel:sslContextParameters>... ... <to uri="netty:tcp://localhost:5150?sync=true&ssl=true&sslContextParameters=#sslContextParameters"/> ...
Using Basic SSL/TLS configuration on the Jetty Component
JndiRegistry registry = new JndiRegistry(createJndiContext()); registry.bind("password", "changeit"); registry.bind("ksf", new File("src/test/resources/keystore.jks")); registry.bind("tsf", new File("src/test/resources/keystore.jks")); context.createRegistry(registry); context.addRoutes(new RouteBuilder() { public void configure() { String netty_ssl_endpoint = "netty:tcp://localhost:5150?sync=true&ssl=true&passphrase=#password" + "&keyStoreFile=#ksf&trustStoreFile=#tsf"; String return_string = "When You Go Home, Tell Them Of Us And Say," + "For Your Tomorrow, We Gave Our Today."; from(netty_ssl_endpoint) .process(new Processor() { public void process(Exchange exchange) throws Exception { exchange.getOut().setBody(return_string); } } } });
Getting access to SSLSession and the client certificate
javax.net.ssl.SSLSession
if you eg need to get details about the client certificate. When ssl=true
then the Netty component will store the SSLSession
as a header on the Camel Message as shown below:
SSLSession session = exchange.getIn().getHeader(NettyConstants.NETTY_SSL_SESSION, SSLSession.class); // get the first certificate which is client certificate javax.security.cert.X509Certificate cert = session.getPeerCertificateChain()[0]; Principal principal = cert.getSubjectDN();
needClientAuth=true
to authenticate the client, otherwise SSLSession
cannot access information about the client certificate, and you may get an exception javax.net.ssl.SSLPeerUnverifiedException: peer not authenticated
. You may also get this exception if the client certificate is expired or not valid etc.
sslClientCertHeaders
can be set to true
which then enriches the Camel Message with headers having details about the client certificate. For example the subject name is readily available in the header CamelNettySSLClientCertSubjectName
.
Using Multiple Codecs
ChannelHandlerFactory lengthDecoder = ChannelHandlerFactories.newLengthFieldBasedFrameDecoder(1048576, 0, 4, 0, 4); StringDecoder stringDecoder = new StringDecoder(); registry.bind("length-decoder", lengthDecoder); registry.bind("string-decoder", stringDecoder); LengthFieldPrepender lengthEncoder = new LengthFieldPrepender(4); StringEncoder stringEncoder = new StringEncoder(); registry.bind("length-encoder", lengthEncoder); registry.bind("string-encoder", stringEncoder); List<ChannelHandler> decoders = new ArrayList<ChannelHandler>(); decoders.add(lengthDecoder); decoders.add(stringDecoder); List<ChannelHandler> encoders = new ArrayList<ChannelHandler>(); encoders.add(lengthEncoder); encoders.add(stringEncoder); registry.bind("encoders", encoders); registry.bind("decoders", decoders);
<util:list id="decoders" list-class="java.util.LinkedList"> <bean class="org.apache.camel.component.netty.ChannelHandlerFactories" factory-method="newLengthFieldBasedFrameDecoder"> <constructor-arg value="1048576"/> <constructor-arg value="0"/> <constructor-arg value="4"/> <constructor-arg value="0"/> <constructor-arg value="4"/> </bean> <bean class="org.jboss.netty.handler.codec.string.StringDecoder"/> </util:list> <util:list id="encoders" list-class="java.util.LinkedList"> <bean class="org.jboss.netty.handler.codec.frame.LengthFieldPrepender"> <constructor-arg value="4"/> </bean> <bean class="org.jboss.netty.handler.codec.string.StringEncoder"/> </util:list> <bean id="length-encoder" class="org.jboss.netty.handler.codec.frame.LengthFieldPrepender"> <constructor-arg value="4"/> </bean> <bean id="string-encoder" class="org.jboss.netty.handler.codec.string.StringEncoder"/> <bean id="length-decoder" class="org.apache.camel.component.netty.ChannelHandlerFactories" factory-method="newLengthFieldBasedFrameDecoder"> <constructor-arg value="1048576"/> <constructor-arg value="0"/> <constructor-arg value="4"/> <constructor-arg value="0"/> <constructor-arg value="4"/> </bean> <bean id="string-decoder" class="org.jboss.netty.handler.codec.string.StringDecoder"/> </beans>
from("direct:multiple-codec").to("netty:tcp://localhost:{{port}}?encoders=#encoders&sync=false"); from("netty:tcp://localhost:{{port}}?decoders=#length-decoder,#string-decoder&sync=false").to("mock:multiple-codec"); } }; } }
<camelContext id="multiple-netty-codecs-context" xmlns="http://camel.apache.org/schema/spring"> <route> <from uri="direct:multiple-codec"/> <to uri="netty:tcp://localhost:5150?encoders=#encoders&ync=false"/> </route> <route> <from uri="netty:tcp://localhost:5150?decoders=#length-decoder,#string-decoder&ync=false"/> <to uri="mock:multiple-codec"/> </route> </camelContext>
Closing Channel When Complete
disconnect=true
.
CamelNettyCloseChannelWhenComplete
set to a boolean true
value. For instance, the example below will close the channel after it has written the bye message back to the client:
from("netty:tcp://localhost:8080").process(new Processor() { public void process(Exchange exchange) throws Exception { String body = exchange.getIn().getBody(String.class); exchange.getOut().setBody("Bye " + body); // some condition which determines if we should close if (close) { exchange.getOut().setHeader(NettyConstants.NETTY_CLOSE_CHANNEL_WHEN_COMPLETE, true); } } });
Adding custom channel pipeline factories to gain complete control over a created pipeline
- A Producer linked channel pipeline factory must extend the abstract class
ClientPipelineFactory
. - A Consumer linked channel pipeline factory must extend the abstract class
ServerPipelineFactory
. - The classes should override the getPipeline() method in order to insert custom handler(s), encoder(s) and decoder(s). Not overriding the getPipeline() method creates a pipeline with no handlers, encoders or decoders wired to the pipeline.
public class SampleServerChannelPipelineFactory extends ServerPipelineFactory { private int maxLineSize = 1024; public ChannelPipeline getPipeline() throws Exception { ChannelPipeline channelPipeline = Channels.pipeline(); channelPipeline.addLast("encoder-SD", new StringEncoder(CharsetUtil.UTF_8)); channelPipeline.addLast("decoder-DELIM", new DelimiterBasedFrameDecoder(maxLineSize, true, Delimiters.lineDelimiter())); channelPipeline.addLast("decoder-SD", new StringDecoder(CharsetUtil.UTF_8)); // here we add the default Camel ServerChannelHandler for the consumer, to allow Camel to route the message etc. channelPipeline.addLast("handler", new ServerChannelHandler(consumer)); return channelPipeline; } }
Registry registry = camelContext.getRegistry(); serverPipelineFactory = new TestServerChannelPipelineFactory(); registry.bind("spf", serverPipelineFactory); context.addRoutes(new RouteBuilder() { public void configure() { String netty_ssl_endpoint = "netty:tcp://localhost:5150?serverPipelineFactory=#spf" String return_string = "When You Go Home, Tell Them Of Us And Say," + "For Your Tomorrow, We Gave Our Today."; from(netty_ssl_endpoint) .process(new Processor() { public void process(Exchange exchange) throws Exception { exchange.getOut().setBody(return_string); } } } });
Reusing Netty boss and worker thread pools
NettyWorkerPoolBuilder
with 2 worker threads as shown below:
<!-- use the worker pool builder to create to help create the shared thread pool --> <bean id="poolBuilder" class="org.apache.camel.component.netty.NettyWorkerPoolBuilder"> <property name="workerCount" value="2"/> </bean> <!-- the shared worker thread pool --> <bean id="sharedPool" class="org.jboss.netty.channel.socket.nio.WorkerPool" factory-bean="poolBuilder" factory-method="build" destroy-method="shutdown"> </bean>
org.apache.camel.component.netty.NettyServerBossPoolBuilder
builder for Netty consumers, and a org.apache.camel.component.netty.NettyClientBossPoolBuilder
for the Netty produces.
workerPool
option in the URI as shown below:
<route> <from uri="netty:tcp://localhost:5021?textline=true&ync=true&orkerPool=#sharedPool&rderedThreadPoolExecutor=false"/> <to uri="log:result"/> ... </route>
<route> <from uri="netty:tcp://localhost:5022?textline=true&ync=true&orkerPool=#sharedPool&rderedThreadPoolExecutor=false"/> <to uri="log:result"/> ... </route>
See also
Chapter 103. Netty4
Netty4 Component
netwServerInitializerFactoryork
applications such as protocol servers and clients. Netty4 greatly simplifies and streamlines network programming such as TCP and UDP socket server.
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-netty4</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
netty4:tcp://localhost:99999[?options] netty4:udp://remotehost:99999/[?options]
?option=value&option=value&...
Options
Name
|
Default Value
|
Description
|
---|---|---|
keepAlive
|
true
|
Setting to ensure socket is not closed due to inactivity
|
tcpNoDelay
|
true
|
Setting to improve TCP protocol performance
|
backlog
|
|
Allows to configure a backlog for netty consumer (server). Note the backlog is just a best effort depending on the OS. Setting this option to a value such as
200 , 500 or 1000 , tells the TCP stack how long the "accept" queue can be. If this option is not configured, then the backlog depends on OS setting.
|
broadcast
|
false
|
Setting to choose Multicast over UDP
|
connectTimeout
|
10000
|
Time to wait for a socket connection to be available. Value is in millis.
|
reuseAddress
|
true
|
Setting to facilitate socket multiplexing
|
sync
|
true
|
Setting to set endpoint as one-way or request-response
|
synchronous
|
false
|
Whether Asynchronous Routing Engine is not in use.
false then the Asynchronous Routing Engine is used, true to force processing synchronous.
|
ssl
|
false
|
Setting to specify whether SSL encryption is applied to this endpoint
|
sslClientCertHeaders
|
false
|
When enabled and in SSL mode, then the Netty consumer will enrich the Camel Message with headers having information about the client certificate such as subject name, issuer name, serial number, and the valid date range.
|
sendBufferSize
|
65536 bytes
|
The TCP/UDP buffer sizes to be used during outbound communication. Size is bytes.
|
receiveBufferSize
|
65536 bytes
|
The TCP/UDP buffer sizes to be used during inbound communication. Size is bytes.
|
option.XXX
|
null
|
Allows to configure additional netty options using "option." as prefix. For example "option.child.keepAlive=false" to set the netty option "child.keepAlive=false". See the Netty documentation for possible options that can be used.
|
corePoolSize
|
10
|
The number of allocated threads at component startup. Defaults to 10. Note: This option is removed from Camel 2.9.2 onwards. As we rely on Nettys default settings.
|
maxPoolSize
|
100
|
The maximum number of threads that may be allocated to this endpoint. Defaults to 100. Note: This option is removed from Camel 2.9.2 onwards. As we rely on Nettys default settings.
|
disconnect
|
false
|
Whether or not to disconnect(close) from Netty Channel right after use. Can be used for both consumer and producer.
|
lazyChannelCreation
|
true
|
Channels can be lazily created to avoid exceptions, if the remote server is not up and running when the Camel producer is started.
|
transferExchange
|
false
|
Only used for TCP. You can transfer the exchange over the wire instead of just the body. The following fields are transferred: In body, Out body, fault body, In headers, Out headers, fault headers, exchange properties, exchange exception. This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level.
|
disconnectOnNoReply
|
true
|
If sync is enabled then this option dictates NettyConsumer if it should disconnect where there is no reply to send back.
|
noReplyLogLevel
|
WARN
|
If sync is enabled this option dictates NettyConsumer which logging level to use when logging a there is no reply to send back. Values are:
FATAL, ERROR, INFO, DEBUG, OFF .
|
serverExceptionCaughtLogLevel
|
WARN
|
If the server (NettyConsumer) catches an exception then its logged using this logging level.
|
serverClosedChannelExceptionCaughtLogLevel
|
DEBUG
|
If the server (NettyConsumer) catches an
java.nio.channels.ClosedChannelException then its logged using this logging level. This is used to avoid logging the closed channel exceptions, as clients can disconnect abruptly and then cause a flod of closed exceptions in the Netty server.
|
allowDefaultCodec
|
true
|
The netty component installs a default codec if both, encoder/deocder is null and textline is false. Setting allowDefaultCodec to false prevents the netty component from installing a default codec as the first element in the filter chain.
|
textline
|
false
|
Only used for TCP. If no codec is specified, you can use this flag to indicate a text line based codec; if not specified or the value is false, then Object Serialization is assumed over TCP.
|
delimiter
|
LINE
|
The delimiter to use for the textline codec. Possible values are
LINE and NULL .
|
decoderMaxLineLength
|
1024
|
The max line length to use for the textline codec.
|
autoAppendDelimiter
|
true
|
Whether or not to auto append missing end delimiter when sending using the textline codec.
|
encoding
|
null
|
The encoding (a charset name) to use for the textline codec. If not provided, Camel will use the JVM default Charset.
|
workerCount
|
null
|
When netty works on nio mode, it uses default workerCount parameter from Netty, which is cpu_core_threads*2. User can use this operation to override the default workerCount from Netty
|
sslContextParameters
|
null
|
SSL configuration using an
org.apache.camel.util.jsse.SSLContextParameters instance. See Using the JSSE Configuration Utility.
|
receiveBufferSizePredictor
|
null
|
Configures the buffer size predictor. See details at Jetty documentation and this mail thread.
|
requestTimeout
|
0
|
Allows to use a timeout for the Netty producer when calling a remote server. By default no timeout is in use. The value is in milli seconds. The
requestTimeout uses Netty's ReadTimeoutHandler to trigger the timeout.
|
needClientAuth
|
false
|
Configures whether the server needs client authentication when using SSL.
|
usingExecutorService
|
true
|
Whether to use executorService to handle the message inside the camel route, the executorService can be set from NettyComponent.
|
maximumPoolSize
|
16
|
The core pool size for the ordered thread pool, if its in use.
|
producerPoolEnabled
|
true
|
Producer only. Whether producer pool is enabled or not. Important: Do not turn this off, as the pooling is needed for handling concurrency and reliable request/reply.
|
producerPoolMaxActive
|
-1
|
Producer only. Sets the cap on the number of objects that can be allocated by the pool (checked out to clients, or idle awaiting checkout) at a given time. Use a negative value for no limit.
|
producerPoolMinIdle
|
0
|
Producer only. Sets the minimum number of instances allowed in the producer pool before the evictor thread (if active) spawns new objects.
|
producerPoolMaxIdle
|
100
|
Producer only. Sets the cap on the number of "idle" instances in the pool.
|
producerPoolMinEvictableIdle
|
30000
|
Producer only. Sets the minimum amount of time (value in millis) an object may sit idle in the pool before it is eligible for eviction by the idle object evictor.
|
bootstrapConfiguration
|
null
|
Consumer only. Allows to configure the Netty ServerBootstrap options using a
org.apache.camel.component.netty4.NettyServerBootstrapConfiguration instance. This can be used to reuse the same configuration for multiple consumers, to align their configuration more easily.
|
bossPoll
|
null
|
To use a explicit
io.netty.channel.EventLoopGroup as the boss thread pool. For example to share a thread pool with multiple consumers. By default each consumer has their own boss pool with 1 core thread.
|
workerPool
|
null
|
To use a explicit
io.netty.channel.EventLoopGroup as the worker thread pool. For example to share a thread pool with multiple consumers. By default each consumer has their own worker pool with 2 x cpu count core threads.
|
networkInterface
|
null
|
Consumer only. When using UDP then this option can be used to specify a network interface by its name, such as
eth0 to join a multicast group.
|
clientInitializerFactory
|
null
|
Camel 2.15: To use a custom client initializer factory to control the pipelines in the channel. See further below for more details. |
serverInitializerFactory
|
null
|
Camel 2.15: To use a custom server initializer factory to control the pipelines in the channel. See further below for more details. |
clientPipelineFactory
|
null
|
Deprecated: Use clientInitializerFactory instead.
|
serverPipelineFactory
|
null
|
Deprecated: Use serverInitializerFactory instead.
|
udpConnectionlessSending
|
false
|
Camel 2.15: Producer only. This option supports connectionless UDP sending, which is genuine fire-and-forget. A UDP send attempt receives the PortUnreachableException exception, if no one is listening on the receiving port.
|
clientMode
|
false
|
Camel 2.15: Consumer only. If clientMode is true , the Netty consumer connects to the address as a TCP client.
|
Registry based Options
Name
|
Description
|
---|---|
passphrase
|
password setting to use in order to encrypt/decrypt payloads sent using SSH
|
keyStoreFormat
|
keystore format to be used for payload encryption. Defaults to "JKS" if not set
|
securityProvider
|
Security provider to be used for payload encryption. Defaults to "SunX509" if not set.
|
keyStoreFile
|
deprecated: Client side certificate keystore to be used for encryption
|
trustStoreFile
|
deprecated: Server side certificate keystore to be used for encryption
|
keyStoreResource
|
Camel 2.11.1: Client side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with
"classpath:" , "file:" , or "http:" to load the resource from different systems.
|
trustStoreResource
|
Camel 2.11.1: Server side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with
"classpath:" , "file:" , or "http:" to load the resource from different systems.
|
sslHandler
|
Reference to a class that could be used to return an SSL Handler
|
encoder
|
A custom
ChannelHandler class that can be used to perform special marshalling of outbound payloads. Must override io.netty.channel.ChannelInboundHandlerAdapter .
|
encorders
|
A list of encoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup.
|
decoder
|
A custom
ChannelHandler class that can be used to perform special marshalling of inbound payloads. Must override io.netty.channel.ChannelOutboundHandlerAdapter .
|
decoders
|
A list of decoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup.
|
Using non shareable encoders or decoders
org.apache.camel.component.netty.ChannelHandlerFactory
interface, and return a new instance in the newChannelHandler
method. This is to ensure the encoder/decoder can safely be used. If this is not the case, then the Netty component will log a WARN when an endpoint is created.
org.apache.camel.component.netty.ChannelHandlerFactories
factory class, that has a number of commonly used methods.
Sending Messages to/from a Netty endpoint
Netty Producer
Netty Consumer
- listen on a specified socket using either TCP or UDP protocols (with optional SSL support),
- receive requests on the socket using text/xml, binary and serialized object based payloads and
- send them along on a route as message exchanges.
Usage Samples
A UDP Netty endpoint using Request-Reply and serialized object payload
RouteBuilder builder = new RouteBuilder() { public void configure() { from("netty4:udp://localhost:5155?sync=true") .process(new Processor() { public void process(Exchange exchange) throws Exception { Poetry poetry = (Poetry) exchange.getIn().getBody(); poetry.setPoet("Dr. Sarojini Naidu"); exchange.getOut().setBody(poetry); } } } };
A TCP based Netty consumer endpoint using One-way communication
RouteBuilder builder = new RouteBuilder() { public void configure() { from("netty4:tcp://localhost:5150") .to("mock:result"); } };
An SSL/TCP based Netty consumer endpoint using Request-Reply communication
Using the JSSE Configuration Utility
Programmatic configuration of the component
KeyStoreParameters ksp = new KeyStoreParameters(); ksp.setResource("/users/home/server/keystore.jks"); ksp.setPassword("keystorePassword"); KeyManagersParameters kmp = new KeyManagersParameters(); kmp.setKeyStore(ksp); kmp.setKeyPassword("keyPassword"); SSLContextParameters scp = new SSLContextParameters(); scp.setKeyManagers(kmp); NettyComponent nettyComponent = getContext().getComponent("netty4", NettyComponent.class); nettyComponent.setSslContextParameters(scp);
Spring DSL based configuration of endpoint
... <camel:sslContextParameters id="sslContextParameters"> <camel:keyManagers keyPassword="keyPassword"> <camel:keyStore resource="/users/home/server/keystore.jks" password="keystorePassword"/> </camel:keyManagers> </camel:sslContextParameters>... ... <to uri="netty4:tcp://localhost:5150?sync=true&ssl=true&sslContextParameters=#sslContextParameters"/> ...
Using Basic SSL/TLS configuration on the Jetty Component
JndiRegistry registry = new JndiRegistry(createJndiContext()); registry.bind("password", "changeit"); registry.bind("ksf", new File("src/test/resources/keystore.jks")); registry.bind("tsf", new File("src/test/resources/keystore.jks")); context.createRegistry(registry); context.addRoutes(new RouteBuilder() { public void configure() { String netty_ssl_endpoint = "netty4:tcp://localhost:5150?sync=true&ssl=true&passphrase=#password" + "&keyStoreFile=#ksf&trustStoreFile=#tsf"; String return_string = "When You Go Home, Tell Them Of Us And Say," + "For Your Tomorrow, We Gave Our Today."; from(netty_ssl_endpoint) .process(new Processor() { public void process(Exchange exchange) throws Exception { exchange.getOut().setBody(return_string); } } } });
Getting access to SSLSession and the client certificate
javax.net.ssl.SSLSession
if you eg need to get details about the client certificate. When ssl=true
then the Netty4 component will store the SSLSession
as a header on the Camel Message as shown below:
SSLSession session = exchange.getIn().getHeader(NettyConstants.NETTY_SSL_SESSION, SSLSession.class); // get the first certificate which is client certificate javax.security.cert.X509Certificate cert = session.getPeerCertificateChain()[0]; Principal principal = cert.getSubjectDN();
needClientAuth=true
to authenticate the client, otherwise SSLSession
cannot access information about the client certificate, and you may get an exception javax.net.ssl.SSLPeerUnverifiedException: peer not authenticated
. You may also get this exception if the client certificate is expired or not valid etc.
sslClientCertHeaders
can be set to true
which then enriches the Camel Message with headers having details about the client certificate. For example the subject name is readily available in the header CamelNettySSLClientCertSubjectName
.
Using Multiple Codecs
ChannelHandlerFactory lengthDecoder = ChannelHandlerFactories.newLengthFieldBasedFrameDecoder(1048576, 0, 4, 0, 4); StringDecoder stringDecoder = new StringDecoder(); registry.bind("length-decoder", lengthDecoder); registry.bind("string-decoder", stringDecoder); LengthFieldPrepender lengthEncoder = new LengthFieldPrepender(4); StringEncoder stringEncoder = new StringEncoder(); registry.bind("length-encoder", lengthEncoder); registry.bind("string-encoder", stringEncoder); List<ChannelHandler> decoders = new ArrayList<ChannelHandler>(); decoders.add(lengthDecoder); decoders.add(stringDecoder); List<ChannelHandler> encoders = new ArrayList<ChannelHandler>(); encoders.add(lengthEncoder); encoders.add(stringEncoder); registry.bind("encoders", encoders); registry.bind("decoders", decoders);
<util:list id="decoders" list-class="java.util.LinkedList"> <bean class="org.apache.camel.component.netty4.ChannelHandlerFactories" factory-method="newLengthFieldBasedFrameDecoder"> <constructor-arg value="1048576"/> <constructor-arg value="0"/> <constructor-arg value="4"/> <constructor-arg value="0"/> <constructor-arg value="4"/> </bean> <bean class="io.netty.handler.codec.string.StringDecoder"/> </util:list> <util:list id="encoders" list-class="java.util.LinkedList"> <bean class="io.netty.handler.codec.LengthFieldPrepender"> <constructor-arg value="4"/> </bean> <bean class="io.netty.handler.codec.string.StringEncoder"/> </util:list> <bean id="length-encoder" class="io.netty.handler.codec.LengthFieldPrepender"> <constructor-arg value="4"/> </bean> <bean id="string-encoder" class="io.netty.handler.codec.string.StringEncoder"/> <bean id="length-decoder" class="org.apache.camel.component.netty4.ChannelHandlerFactories" factory-method="newLengthFieldBasedFrameDecoder"> <constructor-arg value="1048576"/> <constructor-arg value="0"/> <constructor-arg value="4"/> <constructor-arg value="0"/> <constructor-arg value="4"/> </bean> <bean id="string-decoder" class="io.netty.handler.codec.string.StringDecoder"/>
from("direct:multiple-codec").to("netty4:tcp://localhost:{{port}}?encoders=#encoders&sync=false"); from("netty4:tcp://localhost:{{port}}?decoders=#length-decoder,#string-decoder&sync=false").to("mock:multiple-codec");
<camelContext id="multiple-netty-codecs-context" xmlns="http://camel.apache.org/schema/spring"> <route> <from uri="direct:multiple-codec"/> <to uri="netty4:tcp://localhost:5150?encoders=#encoders&sync=false"/> </route> <route> <from uri="netty4:tcp://localhost:5150?decoders=#length-decoder,#string-decoder&sync=false"/> <to uri="mock:multiple-codec"/> </route> </camelContext>
Closing Channel When Complete
disconnect=true
.
CamelNettyCloseChannelWhenComplete
set to a boolean true
value. For instance, the example below will close the channel after it has written the bye message back to the client:
from("netty4:tcp://localhost:8080").process(new Processor() { public void process(Exchange exchange) throws Exception { String body = exchange.getIn().getBody(String.class); exchange.getOut().setBody("Bye " + body); // some condition which determines if we should close if (close) { exchange.getOut().setHeader(NettyConstants.NETTY_CLOSE_CHANNEL_WHEN_COMPLETE, true); } } });
Adding custom channel pipeline factories to gain complete control over a created pipeline
- A Producer linked channel pipeline factory must extend the abstract class
ClientInitializerFactory
. - A Consumer linked channel pipeline factory must extend the abstract class
ServerInitializerFactory
. - The classes should override the
initChannel()
method in order to insert custom handler(s), encoder(s) and decoder(s). Not overriding theinitChannel()
method creates a pipeline with no handlers, encoders or decoders wired to the pipeline.
ServerInitializerFactory
factory may be created
Example 103.1. Using server initializer factory
public class SampleServerInitializerFactory extends ServerInitializerFactory { private int maxLineSize = 1024; protected void initChannel(Channel ch) throws Exception { ChannelPipeline channelPipeline = ch.pipeline(); channelPipeline.addLast("encoder-SD", new StringEncoder(CharsetUtil.UTF_8)); channelPipeline.addLast("decoder-DELIM", new DelimiterBasedFrameDecoder(maxLineSize, true, Delimiters.lineDelimiter())); channelPipeline.addLast("decoder-SD", new StringDecoder(CharsetUtil.UTF_8)); // here we add the default Camel ServerChannelHandler for the consumer, to allow Camel to route the message etc. channelPipeline.addLast("handler", new ServerChannelHandler(consumer)); } }
Registry registry = camelContext.getRegistry(); ServerInitializerFactory factory = new TestServerInitializerFactory(); registry.bind("spf", factory); context.addRoutes(new RouteBuilder() { public void configure() { String netty_ssl_endpoint = "netty4:tcp://localhost:5150?serverInitializerFactory=#spf" String return_string = "When You Go Home, Tell Them Of Us And Say," + "For Your Tomorrow, We Gave Our Today."; from(netty_ssl_endpoint) .process(new Processor() { public void process(Exchange exchange) throws Exception { exchange.getOut().setBody(return_string); } } } });
Reusing Netty boss and worker thread pools
NettyWorkerPoolBuilder
with 2 worker threads as shown below:
<!-- use the worker pool builder to create to help create the shared thread pool --> <bean id="poolBuilder" class="org.apache.camel.component.netty.NettyWorkerPoolBuilder"> <property name="workerCount" value="2"/> </bean> <!-- the shared worker thread pool --> <bean id="sharedPool" class="org.jboss.netty.channel.socket.nio.WorkerPool" factory-bean="poolBuilder" factory-method="build" destroy-method="shutdown"> </bean>
org.apache.camel.component.netty4.NettyServerBossPoolBuilder
builder for Netty consumers, and a org.apache.camel.component.netty4.NettyClientBossPoolBuilder
for the Netty produces.
workerPool
option in the URI as shown below:
<route> <from uri="netty4:tcp://localhost:5021?textline=true&sync=true&workerPool=#sharedPool&usingExecutorService=false"/> <to uri="log:result"/> ... </route>
<route> <from uri="netty4:tcp://localhost:5022?textline=true&sync=true&workerPool=#sharedPool&usingExecutorService=false"/> <to uri="log:result"/> ... </route>
Chapter 104. Netty HTTP
Netty HTTP Component
camel-netty4
component has finished being upgraded. At the time being this component is still based on Netty 3.x. The upgrade is intended to be as backwards compatible as possible.
String
which is safe to be re-read multiple times.
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-netty-http</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
netty-http:http://localhost:8080[?options]
?option=value&option=value&...
netty-http:http//example.com?myParam=myValue&compression=true
. In this example myParam
is the HTTP parameter, while compression
is the Camel endpoint option. The strategy used by Camel in such situations is to resolve available endpoint options and remove them from the URI. It means that for the discussed example, the HTTP request sent by Netty HTTP producer to the endpoint will look as follows - http//example.com?myParam=myValue
, because compression
endpoint option will be resolved and removed from the target URL.
CamelHttpQuery
). Endpoint options can be specified only at the endpoint URI definition level (like to
or from
DSL elements).
HTTP Options
Name | Default Value | Description |
---|---|---|
chunkedMaxContentLength
|
1mb
|
Value in bytes the max content length per chunked frame received on the Netty HTTP server. |
compression
|
false
|
Allow using gzip/deflate for compression on the Netty HTTP server if the client supports it from the HTTP headers. |
headerFilterStrategy
|
To use a custom org.apache.camel.spi.HeaderFilterStrategy to filter headers.
|
|
httpMethodRestrict
|
To disable HTTP methods on the Netty HTTP consumer. You can specify multiple separated by comma. | |
mapHeaders
|
true
|
If this option is enabled, then during binding from Netty to Camel Message then the headers will be mapped as well (eg added as header to the Camel Message as well). You can turn off this option to disable this. The headers can still be accessed from the org.apache.camel.component.netty.http.NettyHttpMessage message with the method getHttpRequest() that returns the Netty HTTP request org.jboss.netty.handler.codec.http.HttpRequest instance.
|
matchOnUriPrefix
|
false
|
Whether or not Camel should try to find a target consumer by matching the URI prefix if no exact match is found. See further below for more details. |
nettyHttpBinding
|
To use a custom org.apache.camel.component.netty.http.NettyHttpBinding for binding to/from Netty and Camel Message API.
|
|
bridgeEndpoint
|
false
|
If the option is true , the producer will ignore the Exchange.HTTP_URI header, and use the endpoint's URI for request. You may also set the throwExceptionOnFailure to be false to let the producer send all the fault response back. The consumer working in the bridge mode will skip the gzip compression and WWW URL form encoding (by adding the Exchange.SKIP_GZIP_ENCODING and Exchange.SKIP_WWW_FORM_URLENCODED headers to the consumed exchange).
|
throwExceptionOnFailure
|
true
|
Option to disable throwing the HttpOperationFailedException in case of failed responses from the remote server. This allows you to get all responses regardles of the HTTP status code.
|
traceEnabled
|
false
|
Specifies whether to enable HTTP TRACE for this Netty HTTP consumer. By default TRACE is turned off. |
transferException
|
false
|
If enabled and an Exchange failed processing on the consumer side, and if the caused Exception was send back serialized in the response as a application/x-java-serialized-object content type. On the producer side the exception will be deserialized and thrown as is, instead of the HttpOperationFailedException . The caused exception is required to be serialized.
|
urlDecodeHeaders
|
false
|
If this option is enabled, then during binding from Netty to Camel Message then the header values will be URL decoded (eg %20 will be a space character. Notice this option is used by the default org.apache.camel.component.netty.http.NettyHttpBinding and therefore if you implement a custom org.apache.camel.component.netty.http.NettyHttpBinding then you would need to decode the headers accordingly to this option.
|
nettySharedHttpServer
|
null
|
To use a shared Netty HTTP server. See Netty HTTP Server Example for more details. |
disableStreamCache
|
false
|
Determines whether or not the raw input stream from Netty HttpRequest#getContent() is cached or not (Camel will read the stream into a in light-weight memory based Stream caching) cache. By default Camel will cache the Netty input stream to support reading it multiple times to ensure it 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. Mind that if you enable this option, then you cannot read the Netty stream multiple times out of the box, and you would need manually to reset the reader index on the Netty raw stream.
|
securityConfiguration
|
null
|
Consumer only. Refers to a org.apache.camel.component.netty.http.NettyHttpSecurityConfiguration for configuring secure web resources.
|
send503whenSuspended
|
true
|
Consumer only. Whether to send back HTTP status code 503 when the consumer has been suspended. If the option is false then the Netty Acceptor is unbound when the consumer is suspended, so clients cannot connect anymore.
|
NettyHttpSecurityConfiguration
has the following options:
Name | Default Value | Description |
---|---|---|
authenticate
|
true
|
Whether authentication is enabled. Can be used to quickly turn this off. |
constraint
|
Basic
|
The constraint supported. Currently only Basic is implemented and supported.
|
realm
|
null
|
The name of the JAAS security realm. This option is mandatory. |
securityConstraint
|
null
|
Allows to plugin a security constraint mapper where you can define ACL to web resources. |
securityAuthenticator
|
null
|
Allows to plugin a authenticator that performs the authentication. If none has been configured then the org.apache.camel.component.netty.http.JAASSecurityAuthenticator is used by default.
|
loginDeniedLoggingLevel
|
DEBUG
|
Logging level used when a login attempt failed, which allows to see more details why the login failed. |
roleClassName
|
null
|
To specify FQN class names of Principal implementations that contains user roles. If none has been specified, then the Netty HTTP component will by default assume a Principal is role based if its FQN classname has the lower-case word role in its classname. You can specify multiple class names separated by comma.
|
Message Headers
Name | Type | Description |
---|---|---|
CamelHttpMethod
|
String
|
Allow to control what HTTP method to use such as GET, POST, TRACE etc. The type can also be a org.jboss.netty.handler.codec.http.HttpMethod instance.
|
CamelHttpQuery
|
String
|
Allows to provide URI query parameters as a String value that overrides the endpoint configuration. Separate multiple parameters using the & sign. For example: foo=bar&beer=yes .
|
CamelHttpPath
|
String
|
Camel 2.13.1/2.12.4: Allows to provide URI context-path and query parameters as a String value that overrides the endpoint configuration. This allows to reuse the same producer for calling same remote HTTP server, but using a dynamic context-path and query parameters.
|
Content-Type
|
String
|
To set the content-type of the HTTP body. For example: text/plain; charset="UTF-8" .
|
CamelHttpResponseCode
|
int
|
Allows to set the HTTP Status code to use. By default 200 is used for success, and 500 for failure. |
from("netty-http:http:0.0.0.0:8080/myapp")...
Name | Type | Description |
---|---|---|
CamelHttpMethod
|
String
|
The HTTP method used, such as GET, POST, TRACE etc. |
CamelHttpUrl
|
String
|
The URL including protocol, host and port, etc: http://0.0.0.0:8080/myapp |
CamelHttpUri
|
String
|
The URI without protocol, host and port, etc: /myapp |
CamelHttpQuery
|
String
|
Any query parameters, such as foo=bar&beer=yes
|
CamelHttpRawQuery
|
String
|
Camel 2.13.0: Any query parameters, such as
foo=bar&beer=yes . Stored in the raw form, as they arrived to the consumer (i.e. before URL decoding).
|
CamelHttpPath
|
String
|
Additional context-path. This value is empty if the client called the context-path /myapp . If the client calls /myapp/mystuff , then this header value is /mystuff . In other words its the value after the context-path configured on the route endpoint.
|
CamelHttpCharacterEncoding
|
String
|
The charset from the content-type header. |
CamelHttpAuthentication
|
String
|
If the user was authenticated using HTTP Basic then this header is added with the value Basic .
|
Content-Type
|
String
|
The content type if provided. For example: text/plain; charset="UTF-8" .
|
Access to Netty types
org.apache.camel.component.netty.http.NettyHttpMessage
as the message implementation on the Exchange. This allows end users to get access to the original Netty request/response instances if needed, as shown below. Mind that the original response may not be accessible at all times.
org.jboss.netty.handler.codec.http.HttpRequest request = exchange.getIn(NettyHttpMessage.class).getHttpRequest();
Examples
from("netty-http:http://0.0.0.0:8080/foo") .transform().constant("Bye World");
String out = template.requestBody("netty-http:http://localhost:8080/foo", "Hello World", String.class); System.out.println(out);
How do I let Netty match wildcards
from("netty-http:http://0.0.0.0:8123/foo").to("mock:foo");
http://0.0.0.0:8123/foo
but not match if you do http://0.0.0.0:8123/foo/bar
.
from("netty-http:http://0.0.0.0:8123/foo?matchOnUriPrefix=true").to("mock:foo");
foo
.
from("netty-http:http://0.0.0.0:8123?matchOnUriPrefix=true").to("mock:foo");
Using multiple routes with same port
org.jboss.netty.bootstrap.ServerBootstrap
instance). Doing this requires a number of bootstrap options to be identical in the routes, as the routes will share the same org.jboss.netty.bootstrap.ServerBootstrap
instance. The instance will be configured with the options from the first route created.
org.apache.camel.component.netty.NettyServerBootstrapConfiguration
configuration class. If you have configured another route with different options, Camel will throw an exception on startup, indicating the options is not identical. To mitigate this ensure all options is identical.
from("netty-http:http://0.0.0.0:{{port}}/foo") .to("mock:foo") .transform().constant("Bye World"); from("netty-http:http://0.0.0.0:{{port}}/bar") .to("mock:bar") .transform().constant("Bye Camel");
org.apache.camel.component.netty.NettyServerBootstrapConfiguration
option as the 1st route. This will cause Camel to fail on startup.
from("netty-http:http://0.0.0.0:{{port}}/foo") .to("mock:foo") .transform().constant("Bye World"); // we cannot have a 2nd route on same port with SSL enabled, when the 1st route is NOT from("netty-http:http://0.0.0.0:{{port}}/bar?ssl=true") .to("mock:bar") .transform().constant("Bye Camel");
Reusing same server bootstrap configuration with multiple routes
org.apache.camel.component.netty.NettyServerBootstrapConfiguration
type, we can use the bootstrapConfiguration
option on the Netty HTTP consumers to refer and reuse the same options across all consumers.
<bean id="nettyHttpBootstrapOptions" class="org.apache.camel.component.netty.NettyServerBootstrapConfiguration"> <property name="backlog" value="200"/> <property name="connectTimeout" value="20000"/> <property name="workerCount" value="16"/> </bean>
<route> <from uri="netty-http:http://0.0.0.0:{{port}}/foo?bootstrapConfiguration=#nettyHttpBootstrapOptions"/> ... </route> <route> <from uri="netty-http:http://0.0.0.0:{{port}}/bar?bootstrapConfiguration=#nettyHttpBootstrapOptions"/> ... </route> <route> <from uri="netty-http:http://0.0.0.0:{{port}}/beer?bootstrapConfiguration=#nettyHttpBootstrapOptions"/> ... </route>
Reusing same server bootstrap configuration with multiple routes across multiple bundles in OSGi container
Using HTTP Basic Authentication
<route> <from uri="netty-http:http://0.0.0.0:{{port}}/foo?securityConfiguration.realm=karaf"/> ... </route>
LoginModule
s of this realm for authentication.
Specifying ACL on web resources
org.apache.camel.component.netty.http.SecurityConstraint
allows to define constrains on web resources. And the org.apache.camel.component.netty.http.SecurityConstraintMapping
is provided out of the box, allowing to easily define inclusions and exclusions with roles.
<bean id="constraint" class="org.apache.camel.component.netty.http.SecurityConstraintMapping"> <!-- inclusions defines url -> roles restrictions --> <!-- a * should be used for any role accepted (or even no roles) --> <property name="inclusions"> <map> <entry key="/*" value="*"/> <entry key="/admin/*" value="admin"/> <entry key="/guest/*" value="admin,guest"/> </map> </property> <!-- exclusions is used to define public urls, which requires no authentication --> <property name="exclusions"> <set> <value>/public/*</value> </set> </property> </bean>
- access to /* is restricted and any roles is accepted (also if user has no roles)
- access to /admin/* requires the admin role
- access to /guest/* requires the admin or guest role
- access to /public/* is an exclusion which means no authentication is needed, and is therefore public for everyone without logging in
<route> <from uri="netty-http:http://0.0.0.0:{{port}}/foo?matchOnUriPrefix=true&ecurityConfiguration.realm=karaf&ecurityConfiguration.securityConstraint=#constraint"/> ... </route>
Chapter 105. Netty4-HTTP
Netty4 HTTP Component
String
which is safe to be re-read multiple times.
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-netty4-http</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
netty4-http:http://localhost:8080[?options]
?option=value&option=value&...
netty4-http:http//example.com?myParam=myValue&compression=true
. In this example myParam
is the HTTP parameter, while compression
is the Camel endpoint option. The strategy used by Camel in such situations is to resolve available endpoint options and remove them from the URI. It means that for the discussed example, the HTTP request sent by Netty HTTP producer to the endpoint will look as follows - http//example.com?myParam=myValue
, because compression
endpoint option will be resolved and removed from the target URL.
CamelHttpQuery
). Endpoint options can be specified only at the endpoint URI definition level (like to
or from
DSL elements).
HTTP Options
Name
|
Default Value
|
Description
|
---|---|---|
chunkedMaxContentLength
|
1mb
|
Value in bytes the max content length per chunked frame received on the Netty HTTP server.
|
compression
|
false
|
Allow using gzip/deflate for compression on the Netty HTTP server if the client supports it from the HTTP headers.
|
headerFilterStrategy
|
|
To use a custom
org.apache.camel.spi.HeaderFilterStrategy to filter headers.
|
httpMethodRestrict
|
|
To disable HTTP methods on the Netty HTTP consumer. You can specify multiple separated by comma.
|
mapHeaders
|
true
|
If this option is enabled, then during binding from Netty to Camel Message then the headers will be mapped as well (eg added as header to the Camel Message as well). You can turn off this option to disable this. The headers can still be accessed from the
org.apache.camel.component.netty4.http.NettyHttpMessage message with the method getHttpRequest() that returns the Netty HTTP request io.netty.handler.codec.http.HttpRequest instance.
|
matchOnUriPrefix
|
false
|
Whether or not Camel should try to find a target consumer by matching the URI prefix if no exact match is found. See further below for more details.
|
nettyHttpBinding
|
|
To use a custom
org.apache.camel.component.netty4.http.NettyHttpBinding for binding to/from Netty and Camel Message API.
|
bridgeEndpoint
|
false
|
If the option is
true , the producer will ignore the Exchange.HTTP_URI header, and use the endpoint's URI for request. You may also set the throwExceptionOnFailure to be false to let the producer send all the fault response back.
|
throwExceptionOnFailure
|
true
|
Option to disable throwing the
HttpOperationFailedException in case of failed responses from the remote server. This allows you to get all responses regardles of the HTTP status code.
|
traceEnabled
|
false
|
Specifies whether to enable HTTP TRACE for this Netty HTTP consumer. By default TRACE is turned off.
|
transferException
|
false
|
If enabled and an Exchange failed processing on the consumer side, and if the caused Exception was send back serialized in the response as a
application/x-java-serialized-object content type. On the producer side the exception will be deserialized and thrown as is, instead of the HttpOperationFailedException . The caused exception is required to be serialized.
|
urlDecodeHeaders
|
|
If this option is enabled, then during binding from Netty to Camel Message then the header values will be URL decoded (eg %20 will be a space character. Notice this option is used by the default
org.apache.camel.component.netty4.http.NettyHttpBinding and therefore if you implement a custom org.apache.camel.component.netty4.http.NettyHttpBinding then you would need to decode the headers accordingly to this option. Notice: This option is default false .
|
nettySharedHttpServer
|
null
|
To use a shared Netty4 HTTP server. See Netty HTTP Server Example for more details.
|
disableStreamCache
|
false
|
Determines whether or not the raw input stream from Netty
HttpRequest#getContent() is cached or not (Camel will read the stream into a in light-weight memory based Stream caching) cache. By default Camel will cache the Netty input stream to support reading it multiple times to ensure it 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. Mind that if you enable this option, then you cannot read the Netty stream multiple times out of the box, and you would need manually to reset the reader index on the Netty raw stream.
|
securityConfiguration
|
null
|
Consumer only. Refers to a
org.apache.camel.component.netty4.http.NettyHttpSecurityConfiguration for configuring secure web resources.
|
send503whenSuspended
|
true
|
Consumer only. Whether to send back HTTP status code 503 when the consumer has been suspended. If the option is
false then the Netty Acceptor is unbound when the consumer is suspended, so clients cannot connect anymore.
|
NettyHttpSecurityConfiguration
has the following options:
Name
|
Default Value
|
Description
|
---|---|---|
authenticate
|
true
|
Whether authentication is enabled. Can be used to quickly turn this off.
|
constraint
|
Basic
|
The constraint supported. Currently only
Basic is implemented and supported.
|
realm
|
null
|
The name of the JAAS security realm. This option is mandatory.
|
securityConstraint
|
null
|
Allows to plugin a security constraint mapper where you can define ACL to web resources.
|
securityAuthenticator
|
null
|
Allows to plugin a authenticator that performs the authentication. If none has been configured then the
org.apache.camel.component.netty4.http.JAASSecurityAuthenticator is used by default.
|
loginDeniedLoggingLevel
|
DEBUG
|
Logging level used when a login attempt failed, which allows to see more details why the login failed.
|
roleClassName
|
null
|
To specify FQN class names of
Principal implementations that contains user roles. If none has been specified, then the Netty4 HTTP component will by default assume a Principal is role based if its FQN classname has the lower-case word role in its classname. You can specify multiple class names separated by comma.
|
Message Headers
Name
|
Type
|
Description
|
---|---|---|
CamelHttpMethod
|
String
|
Allow to control what HTTP method to use such as GET, POST, TRACE etc. The type can also be a
io.netty.handler.codec.http.HttpMethod instance.
|
CamelHttpQuery
|
String
|
Allows to provide URI query parameters as a
String value that overrides the endpoint configuration. Separate multiple parameters using the & sign. For example: foo=bar&beer=yes .
|
CamelHttpPath
|
String
|
Allows to provide URI context-path and query parameters as a
String value that overrides the endpoint configuration. This allows to reuse the same producer for calling same remote http server, but using a dynamic context-path and query parameters.
|
Content-Type
|
String
|
To set the content-type of the HTTP body. For example:
text/plain; charset="UTF-8" .
|
CamelHttpResponseCode
|
int
|
Allows to set the HTTP Status code to use. By default 200 is used for success, and 500 for failure. |
from("netty4-http:http:0.0.0.0:8080/myapp")...
Name
|
Type
|
Description
|
---|---|---|
CamelHttpMethod
|
String
|
The HTTP method used, such as GET, POST, TRACE etc.
|
CamelHttpUrl
|
String
|
The URL including protocol, host and port, etc:
http://0.0.0.0:8080/myapp |
CamelHttpUri
|
String
|
The URI without protocol, host and port, etc:
/myapp |
CamelHttpQuery
|
String
|
Any query parameters, such as
foo=bar&beer=yes
|
CamelHttpRawQuery
|
String
|
Any query parameters, such as
foo=bar&beer=yes . Stored in the raw form, as they arrived to the consumer (i.e. before URL decoding).
|
CamelHttpPath
|
String
|
Additional context-path. This value is empty if the client called the context-path
/myapp . If the client calls /myapp/mystuff , then this header value is /mystuff . In other words its the value after the context-path configured on the route endpoint.
|
CamelHttpCharacterEncoding
|
String
|
The charset from the content-type header.
|
CamelHttpAuthentication
|
String
|
If the user was authenticated using HTTP Basic then this header is added with the value
Basic .
|
Content-Type
|
String
|
The content type if provided. For example:
text/plain; charset="UTF-8" .
|
Access to Netty types
org.apache.camel.component.netty4.http.NettyHttpMessage
as the message implementation on the Exchange. This allows end users to get access to the original Netty request/response instances if needed, as shown below. Mind that the original response may not be accessible at all times.
io.netty.handler.codec.http.HttpRequest request = exchange.getIn(NettyHttpMessage.class).getHttpRequest();
Examples
from("netty4-http:http://0.0.0.0:8080/foo") .transform().constant("Bye World");
String out = template.requestBody("netty4-http:http://localhost:8080/foo", "Hello World", String.class); System.out.println(out);
How do I let Netty match wildcards
from("netty4-http:http://0.0.0.0:8123/foo").to("mock:foo");
http://0.0.0.0:8123/foo
but not match if you do http://0.0.0.0:8123/foo/bar
.
from("netty4-http:http://0.0.0.0:8123/foo?matchOnUriPrefix=true").to("mock:foo");
foo
.
from("netty4-http:http://0.0.0.0:8123?matchOnUriPrefix=true").to("mock:foo");
Using multiple routes with same port
io.netty.bootstrap.ServerBootstrap
instance). Doing this requires a number of bootstrap options to be identical in the routes, as the routes will share the same io.netty.bootstrap.ServerBootstrap
instance. The instance will be configured with the options from the first route created.
org.apache.camel.component.netty4.NettyServerBootstrapConfiguration
configuration class. If you have configured another route with different options, Camel will throw an exception on startup, indicating the options is not identical. To mitigate this ensure all options is identical.
Example 105.1. Two routes sharing the same port
from("netty4-http:http://0.0.0.0:{{port}}/foo") .to("mock:foo") .transform().constant("Bye World"); from("netty4-http:http://0.0.0.0:{{port}}/bar") .to("mock:bar") .transform().constant("Bye Camel");
org.apache.camel.component.netty4.NettyServerBootstrapConfiguration
option as the 1st route. This will cause Camel to fail on startup.
Example 105.2. Two routes sharing the same port, but the 2nd route is misconfigured and will fail on starting
from("netty4-http:http://0.0.0.0:{{port}}/foo") .to("mock:foo") .transform().constant("Bye World"); // we cannot have a 2nd route on same port with SSL enabled, when the 1st route is NOT from("netty4-http:http://0.0.0.0:{{port}}/bar?ssl=true") .to("mock:bar") .transform().constant("Bye Camel");
Reusing same server bootstrap configuration with multiple routes
org.apache.camel.component.netty4.NettyServerBootstrapConfiguration
type, we can use the bootstrapConfiguration
option on the Netty4 HTTP consumers to refer and reuse the same options across all consumers.
<bean id="nettyHttpBootstrapOptions" class="org.apache.camel.component.netty4.NettyServerBootstrapConfiguration"> <property name="backlog" value="200"/> <property name="connectionTimeout" value="20000"/> <property name="workerCount" value="16"/> </bean>
<route> <from uri="netty4-http:http://0.0.0.0:{{port}}/foo?bootstrapConfiguration=#nettyHttpBootstrapOptions"/> ... </route> <route> <from uri="netty4-http:http://0.0.0.0:{{port}}/bar?bootstrapConfiguration=#nettyHttpBootstrapOptions"/> ... </route> <route> <from uri="netty4-http:http://0.0.0.0:{{port}}/beer?bootstrapConfiguration=#nettyHttpBootstrapOptions"/> ... </route>
Reusing same server bootstrap configuration with multiple routes across multiple bundles in OSGi container
Using HTTP Basic Authentication
<route> <from uri="netty4-http:http://0.0.0.0:{{port}}/foo?securityConfiguration.realm=karaf"/> ... </route>
Specifying ACL on web resources
org.apache.camel.component.netty4.http.SecurityConstraint
allows to define constrains on web resources. And the org.apache.camel.component.netty.http.SecurityConstraintMapping
is provided out of the box, allowing to easily define inclusions and exclusions with roles.
<bean id="constraint" class="org.apache.camel.component.netty4.http.SecurityConstraintMapping"> <!-- inclusions defines url -> roles restrictions --> <!-- a * should be used for any role accepted (or even no roles) --> <property name="inclusions"> <map> <entry key="/*" value="*"/> <entry key="/admin/*" value="admin"/> <entry key="/guest/*" value="admin,guest"/> </map> </property> <!-- exclusions is used to define public urls, which requires no authentication --> <property name="exclusions"> <set> <value>/public/*</value> </set> </property> </bean>
- access to /* is restricted and any roles is accepted (also if user has no roles)
- access to /admin/* requires the admin role
- access to /guest/* requires the admin or guest role
- access to /public/* is an exclusion which means no authentication is needed, and is therefore public for everyone without logging in
<route> <from uri="netty4-http:http://0.0.0.0:{{port}}/foo?matchOnUriPrefix=true&securityConfiguration.realm=karaf&securityConfiguration.securityConstraint=#constraint"/> ... </route>
Chapter 106. Olingo2
Olingo2 Component
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-olingo2</artifactId> <version>${camel-version}</version> </dependency>
URI format
olingo2://endpoint/<resource-path>?[options]
Olingo2Component
configuration
of type org.apache.camel.component.olingo2.Olingo2Configuration
.
Option
|
Type
|
Description
|
serviceUri
|
String
|
Target OData service base URI, e.g. http://services.odata.org/OData/OData.svc
|
contentType
|
String
|
Content-Type header value can be used to specify JSON or XML message format, defaults to application/json;charset=utf-8
|
connectTimeout
|
int
|
HTTP connection creation timeout in milliseconds, defaults to 30,000 (30 seconds)
|
socketTimeout
|
int
|
HTTP request timeout in milliseconds, defaults to 30,000 (30 seconds)
|
httpHeaders
|
java.util.Map<String, String>
|
Custom HTTP headers to inject into every request, this could include OAuth tokens, etc.
|
proxy
|
org.apache.http.HttpHost
|
HTTP proxy server configuration
|
sslContext
|
javax.net.ssl.SSLContext
|
HTTP SSL configuration
|
httpAsyncClientBuilder
|
org.apache.http.impl.nio.client.HttpAsyncClientBuilder
|
Custom HTTP async client builder for more complex HTTP client configuration, overrides connectionTimeout, socketTimeout, proxy and sslContext. Note that a socketTimeout MUST be specified in the builder, otherwise OData requests could block indefinitely
|
Producer Endpoints
inBody
that in turn should contain the name of the endpoint option whose value will be contained in the Camel Exchange In message. The inBody option defaults to data for endpoints that take that option.
CamelOlingo2.<option>
. Note that the inBody
option overrides message header, i.e. the endpoint option inBody=option
would override a CamelOlingo2.option
header. In addition, query parameters can be specified
Endpoint
|
Options
|
HTTP Method
|
Result Body Type
|
batch
|
data
|
POST with multipart/mixed batch request
|
java.util.List<org.apache.camel.component.olingo2.api.batch.Olingo2BatchResponse>
|
create
|
data, resourcePath
|
POST
|
org.apache.olingo.odata2.api.ep.entry.ODataEntry for new entries org.apache.olingo.odata2.api.commons.HttpStatusCodes for other OData resources
|
delete
|
resourcePath
|
DELETE
|
org.apache.olingo.odata2.api.commons.HttpStatusCodes
|
merge
|
data, resourcePath
|
MERGE
|
org.apache.olingo.odata2.api.commons.HttpStatusCodes
|
patch
|
data, resourcePath
|
PATCH
|
org.apache.olingo.odata2.api.commons.HttpStatusCodes
|
read
|
queryParams, resourcePath
|
GET
|
Depends on OData resource being queried as described next
|
update
|
data, resourcePath
|
PUT
|
org.apache.olingo.odata2.api.commons.HttpStatusCodes
|
OData Resource Type Mapping
OData Resource Type
|
Resource URI from resourcePath and keyPredicate
|
In or Out Body Type
|
Entity data model
|
$metadata
|
org.apache.olingo.odata2.api.edm.Edm
|
Service document
|
/
|
org.apache.olingo.odata2.api.servicedocument.ServiceDocument
|
OData feed
|
<entity-set>
|
org.apache.olingo.odata2.api.ep.feed.ODataFeed
|
OData entry
|
<entity-set>(<key-predicate>)
|
org.apache.olingo.odata2.api.ep.entry.ODataEntry for Out body (response), java.util.Map<String, Object> , for In body (request).
|
Simple property
|
<entity-set>(<key-predicate>)/<simple-property>
|
Appropriate Java data type as described by <link xl:href="http://olingo.apache.org/javadoc/odata2/index.html?org/apache/olingo/odata2/api/edm/class-use/EdmProperty.html" >Olingo EdmProperty</link>
|
Simple property value
|
<entity-set>(<key-predicate>)/<simple-property>/$value
|
Appropriate Java data type as described by <link xl:href="http://olingo.apache.org/javadoc/odata2/index.html?org/apache/olingo/odata2/api/edm/class-use/EdmProperty.html" >Olingo EdmProperty</link>
|
Complex property
|
<entity-set>(<key-predicate>)/<complex-property>
|
java.util.Map<String, Object>
|
Zero or one association link
|
<entity-set>(<key-predicate>/$link/<one-to-one-entity-set-property>
|
String for response java.util.Map<String, Object> with key property names and values for request
|
Zero or many association links
|
<entity-set>(<key-predicate>/$link/<one-to-many-entity-set-property>
|
java.util.List<String> for response java.util.List<java.util.Map<String, Object>> containing list of key property names and values for request
|
Count
|
<resource-uri>/$count
|
java.lang.Long
|
URI Options
null
. Note that the null
value will only be used if other options do not satisfy matching endpoints.
Name
|
Type
|
Description
|
data
|
Object
|
Data with appropriate type used to create or modify the OData resource
|
keyPredicate
|
String
|
Key predicate to create a parameterized OData resource endpoint. Useful for create/update operations where the key predicate value is dynamically provided in a header
|
queryParams
|
java.util.Map<String, String>
|
OData system options and custom query options. For more information see OData 2.0 URI Conventions
|
resourcePath
|
String
|
OData resource path, may or may not contain key predicate
|
*
|
String
|
Any other URI option is treated as a query parameter and added to query parameter map, overwriting entries in a queryParams option, if also specified
|
Consumer Endpoints
consumer.
prefix to schedule endpoint invocation. By default consumer endpoints that return an array or collection will generate one exchange per element, and their routes will be executed once for each exchange. This behavior can be disabled by setting the endpoint property consumer.splitResult=false.
Message Headers
CamelOlingo2.
prefix.
Message Body
inBody
endpoint URI parameter. For endpoints that return an array or collection, a consumer endpoint will map every element to distinct messages, unless consumer.splitResult is set to false.
Use cases
from("direct:...") .setHeader("CamelOlingo2.$top","5") .to("olingo2://read/Manufacturers?orderBy=Name%20asc");
from("direct:...") .setHeader("CamelOlingo2.keyPredicate", header("id")) .to("olingo2://read/Manufacturers");
from("direct:...") .to("olingo2://create/Manufacturers");
from("olingo2://read/Manufacturers?queryParams=#paramsBean&consumer.timeUnit=SECONDS&consumer.delay=30") .to("bean:blah");
Chapter 107. Openshift
Openshift Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-openshift</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
openshift:clientId[?options]
?option=value&option=value&...
Options
Name
|
Default Value
|
Description
|
---|---|---|
domain
|
null
|
Domain name. If not specified then the default domain is used.
|
username
|
|
Mandatory: The username to login to openshift server.
|
password
|
|
Mandatory: The password for login to openshift server.
|
server
|
|
Url to the openshift server. If not specified then the default value from the local openshift configuration file
~/.openshift/express.conf is used. And if that fails as well then "openshift.redhat.com" is used.
|
delay
|
10s
|
Consumer only: How frequent to poll for state changes for the applications. By default we poll every 10 seconds.
|
operation
|
list
|
Producer only: The operation to perform which can be:
list , start , stop , restart , and state . The list operation returns information about all the applications in json format. The state operation returns the state such as: started, stopped etc. The other operations does not return any value.
|
application
|
|
Producer only: The application name to
start , stop , restart , or get the state .
|
mode
|
|
Producer only: Whether to output the message body as a pojo or json. For pojo the message is a
List<com.openshift.client.IApplication> type.
|
Examples
Listing all applications
// sending route from("direct:apps") .to("openshift:myClient?username=foo&password=secret&operation=list"); .to("log:apps");
Stopping an application
// stopping the foobar application from("direct:control") .to("openshift:myClient?username=foo&password=secret&operation=stop&application=foobar");
// trigger when state changes on our gears from("openshift:myClient?username=foo&password=secret&delay=30s") .log("Event ${header.CamelOpenShiftEventType} on application ${body.name} changed state to ${header.CamelOpenShiftEventNewState}");
com.openshift.client.IApplication
as the message body. And the following headers is included.
Header
|
May be null
|
Description
|
CamelOpenShiftEventType
|
No
|
The type of the event which can be one of: added, removed or changed.
|
CamelOpenShiftEventOldState
|
Yes
|
The old state, when the event type is changed.
|
CamelOpenShiftEventNewState
|
No
|
The new state, for any of the event types
|
Chapter 108. Pax-Logging
PaxLogging component
paxlogging
component can be used in an OSGi environment to receive PaxLogging events and process them.
Dependencies
pom.xml
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-paxlogging</artifactId> <version>${camel-version}</version> </dependency>
$\{camel-version\}
must be replaced by the actual version of Camel (2.6.0 or higher).
URI format
paxlogging:appender
appender
is the name of the pax appender that need to be configured in the PaxLogging service configuration.
URI options
Name | Default value | Description |
---|
Message headers
Name | Type | Message | Description |
---|
Message body
in
message body will be set to the received PaxLoggingEvent.
Example usage
<route> <from uri="paxlogging:camel"/> <to uri="stream:out"/> </route>
log4j.rootLogger=INFO, out, osgi:VmLogAppender, osgi:camel
Chapter 109. PGEvent
PGEvent component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-pgevent</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
pgevent:datasource[?parameters] pgevent://host:port/database/channel[?parameters]
?option=value&option=value&...
Options
Option
|
Type
|
Default
|
Description
|
---|---|---|---|
datasource
|
String
|
|
Name of datasource to lookup from the registry to use
|
hostname
|
String | localhost | Instead of using datasource, then connect to the PostgresSQL database using this hostname and port |
port | int | 5432 | Instead of using datasource, then connect to the PostgresSQL database using this hostname and port |
database | String | The database name | |
channel | String | The channel name | |
user | String | postgres | Username |
pass | String | Password |
Chapter 110. Printer
Printer Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-printer</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
lpr://localhost/default[?options] lpr://remotehost:port/path/to/printer[?options]
?option=value&option=value&...
Options
Name | Default Value | Description |
---|---|---|
mediaSize
|
NA_LETTER
|
Sets the stationary as defined by enumeration names in the javax.print.attribute.standard.MediaSizeName API API. The default setting is to use North American Letter sized stationary. The value's case is ignored, e.g. values of iso_a4 and ISO_A4 may be used.
|
copies
|
1
|
Sets number of copies based on the javax.print.attribute.standard.Copies API
|
sides
|
Sides.ONE_SIDED
|
Sets one sided or two sided printing based on the javax.print.attribute.standard.Sides API
|
flavor
|
DocFlavor.BYTE_ARRAY
|
Sets DocFlavor based on the javax.print.DocFlavor API
|
mimeType
|
AUTOSENSE
|
Sets mimeTypes supported by the javax.print.DocFlavor API
|
mediaTray
|
AUTOSENSE
|
Since Camel 2.11.x sets MediaTray supported by the javax.print.DocFlavor API |
printerPrefix
|
null
|
Since Camel 2.11.x sets the prefix name of the printer, it is useful when the printer name is not start with //hostname/printer |
sendToPrinter
|
true
|
Setting this option to false prevents sending of the print data to the printer
|
orientation
|
portrait
|
Since Camel 2.13.x Sets the page orientation. Possible values: portrait , landscape , reverse-portrait or reverse-landscape , based on javax.print.attribute.standard.OrientationRequested
|
Printer Producer
Example 1: Printing text based payloads on a Default printer using letter stationary and one-sided mode
RouteBuilder builder = new RouteBuilder() { public void configure() { from(file://inputdir/?delete=true) .to("lpr://localhost/default?copies=2" + "&flavor=DocFlavor.INPUT_STREAM&" + "&mimeType=AUTOSENSE" + "&mediaSize=NA_LETTER" + "&sides=one-sided") }};
Example 2: Printing GIF based payloads on a Remote printer using A4 stationary and one-sided mode
RouteBuilder builder = new RouteBuilder() { public void configure() { from(file://inputdir/?delete=true) .to("lpr://remotehost/sales/salesprinter" + "?copies=2&sides=one-sided" + "&mimeType=GIF&mediaSize=ISO_A4" + "&flavor=DocFlavor.INPUT_STREAM") }};
Example 3: Printing JPEG based payloads on a Remote printer using Japanese Postcard stationary and one-sided mode
RouteBuilder builder = new RouteBuilder() { public void configure() { from(file://inputdir/?delete=true) .to("lpr://remotehost/sales/salesprinter" + "?copies=2&sides=one-sided" + "&mimeType=JPEG" + "&mediaSize=JAPANESE_POSTCARD" + "&flavor=DocFlavor.INPUT_STREAM") }};
Chapter 111. Properties
Properties Component
URI format
properties:key[?options]
Options
Name | Type | Default | Description |
---|---|---|---|
cache
|
boolean
|
true
|
Whether or not to cache loaded properties. |
locations
|
String
|
null
|
A list of locations to load properties. You can use comma to separate multiple locations. This option will override any default locations and only use the locations from this option. |
encoding
|
String
|
null
|
Camel 2.14.3/2.15.1: To use a specific charset to load the properties, such as UTF-8. By default ISO-8859-1 (latin1) is used. |
ignoreMissingLocation
|
boolean
|
false
|
Camel 2.10: Whether to silently ignore if a location cannot be located, such as a properties file not found. |
propertyPrefix
|
String
|
null
|
Camel 2.9: Optional prefix prepended to property names before resolution. |
propertySuffix
|
String
|
null
|
Camel 2.9: Optional suffix appended to property names before resolution. |
fallbackToUnaugmentedProperty
|
boolean
|
true
|
Camel 2.9: If true , first attempt resolution of property name augmented with propertyPrefix and propertySuffix before falling back the plain property name specified. If false , only the augmented property name is searched.
|
prefixToken
|
String
|
{{ | Camel 2.9: The token to indicate the beginning of a property token. |
suffixToken
|
String
|
}} | Camel 2.9: The token to indicate the end of a property token. |
resolvePropertyPlaceholders
on the CamelContext
to resolve a property from any Java code.
See also
- Jasypt for using encrypted values (for example, passwords) in the properties
Chapter 112. Quartz
Quartz Component
URI format
quartz://timerName?options quartz://groupName/timerName?options quartz://groupName/timerName?cron=expression quartz://timerName?cron=expression
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.
?option=value&option=value&...
Options
Parameter | Default | Description |
---|---|---|
cron
|
None |
Specifies a cron expression (not compatible with the trigger.\* or job.\* options).
|
trigger.repeatCount
|
0
|
SimpleTrigger: How many times should the timer repeat? |
trigger.repeatInterval
|
0
|
SimpleTrigger: The amount of time in milliseconds between repeated triggers. |
job.name
|
null
|
Sets the job name. |
job.XXX
|
null
|
Sets the job option with the XXX setter name.
|
trigger.XXX
|
null
|
Sets the trigger option with the XXX setter name.
|
stateful
|
false
|
Uses a Quartz StatefulJob instead of the default job.
|
fireNow
|
false
|
Camel 2.2.0: If true , fire the trigger when the route is started when using SimpleTrigger .
|
deleteJob
|
true
|
Camel 2.12: If true , the trigger automatically delete when route stops. If false , it remains in scheduler and the user may reuse pre-configured trigger with Camel URI. Just ensure the names match. Notice you cannot set both deleteJob and to true .
|
pauseJob
|
false
|
Camel 2.12: If true , the trigger automatically pauses when route stops. If false , it remains in scheduler and the user may reuse pre-configured trigger with Camel URI. Just ensure the names match. Note you cannot set both deleteJob and pauseJob to true .
|
usingFixedCamelContextName
|
false
|
Camel 2.15.0: If true , JobDataMap uses the CamelContext name directly to reference the camel context; if false , JobDataMap uses use the CamelContext management name which could be changed during the deploy time.
|
mock:results
endpoint:
from("quartz://myGroup/myTimerName?trigger.repeatInterval=2&trigger.repeatCount=1").routeId("myRoute").to("mock:result");
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.
Configuring quartz.properties file
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
.
Parameter | Default | Type | Description |
---|---|---|---|
properties
|
null
|
Properties
|
Camel 2.4: You can configure a java.util.Propoperties instance.
|
propertiesFile
|
null
|
String
|
Camel 2.4: File name of the properties to load from the classpath |
<bean id="quartz" class="org.apache.camel.component.quartz.QuartzComponent"> <property name="propertiesFile" value="com/mycompany/myquartz.properties"/> </bean>
Enabling Quartz scheduler in JMX
org.quartz.scheduler.jmx.export
to a true
value in the configuration file.
true
, unless explicit disabled.
Starting the Quartz scheduler
Parameter | Default | Type | Description |
---|---|---|---|
startDelayedSeconds
|
0
|
int
|
Camel 2.4: Seconds to wait before starting the quartz scheduler. |
autoStartScheduler
|
true
|
boolean
|
Camel 2.4: Whether or not the scheduler should be auto started. |
<bean id="quartz" class="org.apache.camel.component.quartz.QuartzComponent"> <property name="startDelayedSeconds" value="5"/> </bean>
Clustering
JobStore
is clustered. Then from Camel 2.4 onwards the Quartz 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.
Message Headers
calendar
, fireTime
, jobDetail
, jobInstance
, jobRuntTime
, mergedJobDataMap
, nextFireTime
, previousFireTime
, refireCount
, result
, scheduledFireTime
, scheduler
, trigger
, triggerName
, triggerGroup
.
fireTime
header contains the java.util.Date
of when the exchange was fired.
Using Cron Triggers
cron
URI parameter; though to preserve valid URI encoding we allow + to be used instead of spaces. Quartz provides a little tutorial on how to use cron expressions.
from("quartz://myGroup/myTimerName?cron=0+0/5+12-18+?+*+MON-FRI").to("activemq:Totally.Rocks");
0 0/5 12-18 ? * MON-FRI
URI Character | Cron character |
---|---|
\+
|
Space |
Specifying time zone
quartz://groupName/timerName?cron=0+0/5+12-18+?+*+MON-FRI&trigger.timeZone=Europe/Stockholm
java.util.TimeZone
.
String
to java.util.TimeZone
Type Converter to be able configure this from the endpoint uri. From Camel 2.8.1 onwards we have included such a Type Converter in the camel-core.
Chapter 113. Quartz2
Quartz2 Component
pom.xml
for this component:
<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>
URI format
quartz2://timerName?options quartz2://groupName/timerName?options quartz2://groupName/timerName?cron=expression quartz2://timerName?cron=expression
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.
?option=value&option=value&...
Options
Parameter | Default | Description |
---|---|---|
cron
|
None |
Specifies a cron expression (not compatible with the trigger.\* or job.\* options).
|
trigger.repeatCount
|
0
|
SimpleTrigger: How many times should the timer repeat? |
trigger.repeatInterval
|
1000
|
SimpleTrigger: The amount of time in milliseconds between repeated triggers. Must enable trigger.repeatCount to use the simple trigger using this interval.
|
job.name
|
null
|
Sets the job name. |
job.XXX
|
null
|
Sets the job option with the XXX setter name.
|
trigger.XXX
|
null
|
Sets the trigger option with the XXX setter name.
|
stateful
|
false
|
Uses a Quartz @PersistJobDataAfterExecution and @DisallowConcurrentExecution instead of the default job.
|
fireNow
|
false
|
If it is true will fire the trigger when the route is start when using SimpleTrigger. |
deleteJob
|
true
|
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. |
pauseJob
|
false
|
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. |
durableJob
|
false
|
Camel 2.12.4/2.13: Whether or not the job should remain stored after it is orphaned (no triggers point to it).
|
recoverableJob
|
false
|
Camel 2.12.4/2.13: Instructs the scheduler whether or not the job should be re-executed if a 'recovery' or 'fail-over' situation is encountered.
|
usingFixedCamelContextName
|
false
|
Camel 2.15.0: If true , JobDataMap uses the CamelContext name directly to reference the camel context; if false , JobDataMap uses use the CamelContext management name which could be changed during the deploy time.
|
mock:results
endpoint:
from("quartz2://myGroup/myTimerName?trigger.repeatInterval=2&trigger.repeatCount=1") .routeId("myRoute") .to("mock:result");
stateful=true
, the JobDataMap is re-persisted after every execution of the job, thus preserving state for the next execution.
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.
Configuring quartz.properties file
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
.
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 |
<bean id="quartz" class="org.apache.camel.component.quartz2.QuartzComponent"> <property name="propertiesFile" value="com/mycompany/myquartz.properties"/> </bean>
Enabling Quartz scheduler in JMX
org.quartz.scheduler.jmx.export
to a true
value in the configuration file.
true
, unless explicit disabled.
Starting the Quartz scheduler
Parameter | Default | Type | Description |
---|---|---|---|
startDelayedSeconds
|
0
|
int
|
Seconds to wait before starting the quartz scheduler. |
autoStartScheduler
|
true
|
boolean
|
Whether or not the scheduler should be auto started. |
<bean id="quartz2" class="org.apache.camel.component.quartz2.QuartzComponent"> <property name="startDelayedSeconds" value="5"/> </bean>
Clustering
JobStore
is clustered. Then the 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.
Message Headers
calendar
, fireTime
, jobDetail
, jobInstance
, jobRuntTime
, mergedJobDataMap
, nextFireTime
, previousFireTime
, refireCount
, result
, scheduledFireTime
, scheduler
, trigger
, triggerName
, triggerGroup
.
fireTime
header contains the java.util.Date
of when the exchange was fired.
Using Cron Triggers
cron
URI parameter; though to preserve valid URI encoding we allow + to be used instead of spaces.
from("quartz2://myGroup/myTimerName?cron=0+0/5+12-18+?+*+MON-FRI").to("activemq:Totally.Rocks");
0 0/5 12-18 ? * MON-FRI
URI Character | Cron character |
---|---|
\+
|
Space |
Specifying time zone
quartz2://groupName/timerName?cron=0+0/5+12-18+?+*+MON-FRI&trigger.timeZone=Europe/Stockholm
java.util.TimeZone
.
Using QuartzScheduledPollConsumerScheduler
from("file:inbox?scheduler=quartz2&scheduler.cron=0/2+*+*+*+*+?") .to("bean:process");
scheduler=quartz2
to instruct Camel to use the Quartz2 based scheduler. Then we use scheduler.xxx
options to configure the scheduler. The Quartz2 scheduler requires the cron option to be set.
Parameter | Default | Type | Description |
---|---|---|---|
quartzScheduler
|
null
|
org.quartz.Scheduler
|
To use a custom Quartz scheduler. If none configure then the shared scheduler from the 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. |
scheduler.
. For example to configure the trigger id and group:
from("file:inbox?scheduler=quartz2&scheduler.cron=0/2+*+*+*+*+?&scheduler.triggerId=myId&scheduler.triggerGroup=myGroup") .to("bean:process");
from("file:inbox?scheduler=spring&scheduler.cron=0/2+*+*+*+*+?") .to("bean:process");
Chapter 114. Quickfix
QuickFIX/J Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-quickfix</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
quickfix:configFile[?sessionID=sessionID&lazyCreateEngine=true|false]
(BeginString):(SenderCompID)[/(SenderSubID)[/(SenderLocationID)]]->(TargetCompID)[/(TargetSubID)[/(TargetLocationID)]]
lazyCreateEngine
(Camel 2.12.3+) parameter allows to create QuickFIX/J engine on demand. Value true
means the engine is started when first message is send or there's consumer configured in route definition. When false
, the engine is started at the endpoint creation. When this parameter is missing, the value of component's property lazyCreateEngines
is used.
quickfix:config.cfg quickfix:config.cfg?sessionID=FIX.4.2:MyTradingCompany->SomeExchange quickfix:config.cfg?sessionID=FIX.4.2:MyTradingCompany->SomeExchange&lazyCreateEngine=true
Endpoints
Exchange Format
Header Name | Description |
---|---|
EventCategory
|
One of AppMessageReceived , AppMessageSent , AdminMessageReceived , AdminMessageSent , SessionCreated , SessionLogon , SessionLogoff . See the QuickfixjEventCategory enum.
|
SessionID
|
The FIX message SessionID |
MessageType
|
The FIX MsgType tag value |
DataDictionary
|
Specifies a data dictionary to used for parsing an incoming message. Can be an instance of a data dictionary or a resource path for a QuickFIX/J data dictionary file |
QuickFIX/J Configuration Extensions
Communication Connectors
Session Setting | Component Action |
---|---|
ConnectionType=initiator
|
Create an initiator connector |
ConnectionType=acceptor
|
Create an acceptor connector |
Default/Global Setting | Component Action |
---|---|
ThreadModel=ThreadPerConnector
|
Use SocketInitiator or SocketAcceptor (default)
|
ThreadModel=ThreadPerSession
|
Use ThreadedSocketInitiator or ThreadedSocketAcceptor
|
Logging
ScreenLog
is the default if none of the following settings are present in the configuration. It's an error to include settings that imply more than one log implementation.
Default/Global Setting | Component Action |
---|---|
ScreenLogShowEvents
|
Use a ScreenLog
|
ScreenLogShowIncoming
|
Use a ScreenLog
|
ScreenLogShowOutgoing
|
Use a ScreenLog
|
SLF4J*
|
Camel 2.6+. Use a SLF4JLog . Any of the SLF4J settings will cause this log to be used.
|
FileLogPath
|
Use a FileLog
|
JdbcDriver
|
Use a JdbcLog
|
Message Store
MemoryStore
is the default if none of the following settings are present in the configuration. It's an error to include settings that imply more than one message store implementation.
Default/Global Setting | Component Action |
---|---|
JdbcDriver
|
Use a JdbcStore
|
FileStorePath
|
Use a FileStore
|
SleepycatDatabaseDir
|
Use a SleepcatStore
|
Message Factory
DefaultMessageFactory
. However, advanced applications may require a custom message factory. This can be set on the QuickFIX/J component.
JMX
Default/Global Setting | Component Action |
---|---|
UseJmx
|
if Y , then enable QuickFIX/J JMX
|
Other Defaults
SessionStartTime
and SessionEndTime
default to "00:00:00", meaning the session will not be automatically started and stopped. The HeartBtInt
(heartbeat interval) defaults to 30 seconds.
Minimal Initiator Configuration Example
[SESSION] ConnectionType=initiator BeginString=FIX.4.4 SenderCompID=YOUR_SENDER TargetCompID=YOUR_TARGET
Using the InOut Message Exchange Pattern
Implementing InOut Exchanges for Consumers
MessageOrderStatusService
in the example below is a bean with a synchronous service method. The method returns the response to the request (an ExecutionReport in this case) which is then sent back to the requestor session.
from("quickfix:examples/inprocess.cfg?sessionID=FIX.4.2:MARKET->TRADER&exchangePattern=InOut") .filter(header(QuickfixjEndpoint.MESSAGE_TYPE_KEY).isEqualTo(MsgType.ORDER_STATUS_REQUEST)) .bean(new MarketOrderStatusService());
Implementing InOut Exchanges for Producers
Exchange
properties.
Description | Key String | Key Constant | Default | Correlation Criteria | "CorrelationCriteria" | QuickfixjProducer.CORRELATION_CRITERIA_KEY | None | |
---|---|---|---|---|---|---|---|---|
Correlation Timeout in Milliseconds | "CorrelationTimeout" | QuickfixjProducer.CORRELATION_TIMEOUT_KEY | 1000 |
MessagePredicate
object. The following example will treat a FIX ExecutionReport from the specified session where the transaction type is STATUS and the Order ID matches our request. The session ID should be for the requestor, the sender and target CompID fields will be reversed when looking for the reply.
exchange.setProperty(QuickfixjProducer.CORRELATION_CRITERIA_KEY, new MessagePredicate(new SessionID(sessionID), MsgType.EXECUTION_REPORT) .withField(ExecTransType.FIELD, Integer.toString(ExecTransType.STATUS)) .withField(OrderID.FIELD, request.getString(OrderID.FIELD)));
Example
RequestReplyExample
that demonstrates the InOut exchanges for a consumer and producer. This example creates a simple HTTP server endpoint that accepts order status requests. The HTTP request is converted to a FIX OrderStatusRequestMessage, is augmented with a correlation criteria, and is then routed to a quickfix endpoint. The response is then converted to a JSON-formatted string and sent back to the HTTP server endpoint to be provided as the web response.
Spring Configuration
FactoryBean
for configuring the session settings within a Spring context. A type converter for QuickFIX/J session ID strings is also included. The following example shows a simple configuration of an acceptor and initiator session with default settings for both sessions.
<!-- camel route --> <camelContext id="quickfixjContext" xmlns="http://camel.apache.org/schema/spring"> <route> <from uri="quickfix:example"/> <filter> <simple>${in.header.EventCategory} == 'AppMessageReceived'</simple> <to uri="log:test"/> </filter> </route> </camelContext> <!-- quickfix component --> <bean id="quickfix" class="org.apache.camel.component.quickfixj.QuickfixjComponent"> <property name="engineSettings"> <util:map> <entry key="quickfix:example" value-ref="quickfixjSettings"/> </util:map> </property> <property name="messageFactory"> <bean class="org.apache.camel.component.quickfixj.QuickfixjSpringTest.CustomMessageFactory"/> </property> </bean> <!-- quickfix settings --> <bean id="quickfixjSettings" class="org.apache.camel.component.quickfixj.QuickfixjSettingsFactory"> <property name="defaultSettings"> <util:map> <entry key="SocketConnectProtocol" value="VM_PIPE"/> <entry key="SocketAcceptProtocol" value="VM_PIPE"/> <entry key="UseDataDictionary" value="N"/> </util:map> </property> <property name="sessionSettings"> <util:map> <entry key="FIX.4.2:INITIATOR->ACCEPTOR"> <util:map> <entry key="ConnectionType" value="initiator"/> <entry key="SocketConnectHost" value="localhost"/> <entry key="SocketConnectPort" value="5000"/> </util:map> </entry> <entry key="FIX.4.2:ACCEPTOR->INITIATOR"> <util:map> <entry key="ConnectionType" value="acceptor"/> <entry key="SocketAcceptPort" value="5000"/> </util:map> </entry> </util:map> </property> </bean>
QuickfixjConfiguration
class for configuring the session settings. A type converter for QuickFIX/J session ID strings is also included. The following example shows a simple configuration of an acceptor and initiator session with default settings for both sessions.
<!-- camel route --> <camelContext id="quickfixjContext" xmlns="http://camel.apache.org/schema/spring"> <route> <from uri="quickfix:example"/> <filter> <simple>${in.header.EventCategory} == 'AppMessageReceived'</simple> <to uri="log:test"/> </filter> </route> </camelContext> <!-- quickfix component --> <bean id="quickfix" class="org.apache.camel.component.quickfixj.QuickfixjComponent"> <property name="configurations"> <util:map> <entry key="example" value-ref="quickfixjConfiguration"/> </util:map> </property> <property name="messageFactory"> <bean class="org.apache.camel.component.quickfixj.QuickfixjSpringTest.CustomMessageFactory"/> </property> </bean> <!-- quickfix settings --> <bean id="quickfixjConfiguration" class="org.apache.camel.component.quickfixj.QuickfixjConfiguration"> <property name="defaultSettings"> <util:map> <entry key="SocketConnectProtocol" value="VM_PIPE"/> <entry key="SocketAcceptProtocol" value="VM_PIPE"/> <entry key="UseDataDictionary" value="N"/> </util:map> </property> <property name="sessionSettings"> <util:map> <entry key="FIX.4.2:INITIATOR->ACCEPTOR"> <util:map> <entry key="ConnectionType" value="initiator"/> <entry key="SocketConnectHost" value="localhost"/> <entry key="SocketConnectPort" value="5000"/> </util:map> </entry> <entry key="FIX.4.2:ACCEPTOR->INITIATOR"> <util:map> <entry key="ConnectionType" value="acceptor"/> <entry key="SocketAcceptPort" value="5000"/> </util:map> </entry> </util:map> </property> </bean>
Exception handling
RejectLogon
exception is thrown while processing an incoming logon administrative message, then the logon will be rejected.
FIX Sequence Number Management
SessionLogon
event category and signals the application to start sending messages.
Route Examples
from("quickfix:examples/inprocess.cfg?sessionID=FIX.4.2:MARKET->TRADER"). filter(header(QuickfixjEndpoint.EVENT_CATEGORY_KEY).isEqualTo(QuickfixjEventCategory.AppMessageReceived)). to("trade-executor:market");
from("trade-executor:market").to("quickfix:examples/inprocess.cfg");
from("quickfix:examples/inprocess.cfg?sessionID=FIX.4.2:TRADER->MARKET"). filter(header(QuickfixjEndpoint.MESSAGE_TYPE_KEY).isEqualTo(MsgType.EXECUTION_REPORT)). bean(new MyTradeExecutionProcessor());
QuickFIX/J Component Prior to Camel 2.5
URI format
quickfix-server:config file quickfix-client:config file
Exchange data format
QuickFix.Message
instance.
Lazy creating engines
Samples
<route> <from uri="activemq:queue:fix"/> <bean ref="fixService" method="createFixMessage" /> // bean method in charge to transform message into a QuickFix.Message <to uri="quickfix-client:META-INF/quickfix/client.cfg" /> // Quickfix engine who will send the FIX messages to the gateway </route>
<route> <from uri="quickfix-server:META-INF/quickfix/server.cfg"/> // QuickFix engine who will receive the message from FIX gateway <bean ref="fixService" method="parseFixMessage" /> // bean method parsing the QuickFix.Message <to uri="uri="activemq:queue:fix"/>" /> </route>
Chapter 115. RabbitMQ
RabbitMQ Component
pom.xml
for this component:
<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>
URI format
rabbitmq://hostname[:port]/exchangeName?[options]
Options
Property | Default | Description |
---|---|---|
autoAck
|
true
|
If messages should be auto acknowledged. |
autoDelete
|
true
|
If true, the exchange will be deleted when it is no longer in use. |
durable
|
true
|
If we are declaring a durable exchange (the exchange will survive a server restart). |
queue
|
random uuid
|
The queue to receive messages from. |
routingKey
|
null
|
The routing key to use when binding a consumer queue to the exchange. For producer routing keys, you set the header (see header section). |
threadPoolSize
|
10
|
The consumer uses a Thread Pool Executor with a fixed number of threads. This setting allows you to set that number of threads. |
username
|
null
|
username in case of authenticated access. |
password
|
null
|
password for authenticated access. |
vhost
|
/
|
the vhost for the channel. |
exchangeType
|
direct
|
Camel 2.12.2: The exchange type such as direct or topic.
|
bridgeEndpoint
|
false
|
Camel 2.12.3: If the bridgeEndpoint is true, the producer will ignore the message header of "rabbitmq.EXCHANGE_NAME" and "rabbitmq.ROUTING_KEY"
|
addresses
|
null
|
Camel 2.12.3: 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".
|
connectionTimeout
|
0
|
Camel 2.14: Connection timeout.
|
requestedChannelMax
|
0
|
Camel 2.14: Connection requested channel max (max number of channels offered).
|
requestedFrameMax
|
0
|
Camel 2.14: Connection requested frame max (max size of frame offered).
|
requestedHeartbeat
|
0
|
Camel 2.14: Connection requested heartbeat (heart-beat in seconds offered).
|
sslProtocol
|
null
|
Camel 2.14: Enables SSL on connection, accepted value are `true`, `TLS` and 'SSLv3`
|
trustManager
|
null
|
Camel 2.14: Configure SSL trust manager, SSL should be enabled for this option to be effective.
|
clientProperties
|
null
|
Camel 2.14: Connection client properties (client info used in negotiating with the server).
|
connectionFactory
|
null
|
Camel 2.14: Custom RabbitMQ connection factory. When this option is set, all connection options (connectionTimeout, requestedChannelMax...) set on URI are not used.
|
automaticRecoveryEnabled
|
false
|
Camel 2.14: Enables connection automatic recovery (uses connection implementation that performs automatic recovery when connection shutdown is not initiated by the application).
|
networkRecoveryInterval
|
5000
|
Camel 2.14: Network recoverty interval in milliseconds (interval used when recovering from network failure).
|
topologyRecoveryEnabled
|
true
|
Camel 2.14: Enables connection topology recovery (should topology recovery be performed?).
|
prefetchEnabled
|
false
|
Camel 2.14: Enables the quality of service on the RabbitMQConsumer side, you need to specify the option of prefetchSize, prefetchCount, prefetchGlobal at the same time
|
prefetchSize
|
0
|
Camel 2.14: The maximum amount of content (measured in octets) that the server will deliver, 0 if unlimited.
|
prefetchCount
|
0
|
Camel 2.14: The maximum number of messages that the server will deliver, 0 if unlimited.
|
prefetchGlobal
|
false
|
Camel 2.14: If the settings should be applied to the entire channel rather than each consumer.
|
declare
|
true
|
Camel 2.14: 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. |
concurrentConsumers
|
1
|
Camel 2.14: Number of concurrent consumers when consuming from broker. (eg similar as to the same option for the JMS component). |
deadLetterRoutingKey
|
Camel 2.14: The routing key for the dead letter exchange. | |
deadLetterExchange
|
Camel 2.14: The name of the dead letter exchange. | |
deadLetterExchangeType
|
direct
|
Camel 2.14: The type of the dead letter exchange. |
channelPoolMaxSize
|
10
|
Camel 2.14.1 (Producer only): Maximum number of channels used to send messages. |
channelPoolMaxWait
|
1000
|
Camel 2.14.1 (Producer only): Maximum time (in milliseconds) waiting for a channel. |
queueArgsConfigurer
|
null
|
Camel 2.15.1: The custom ArgsConfigurer instance which could be used to configure the Args map when declaring the queue.
|
exchangeArgsConfigurer
|
null
|
Camel 2.15.1: The custom ArgsConfigurer instance which could be used to configure the Args map when declaring the exchange.
|
Custom connection factory
<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
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 behaviour. If false , the message is discarded/dead-lettered. If true , the message is re-queued. Default is false .
|
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 |
Message Body
Samples
from("rabbitmq://localhost/A?routingKey=B")
from("rabbitmq://localhost/A?routingKey=B&threadPoolSize=1&autoAck=false")
...to("rabbitmq://localhost/B")
Chapter 116. Ref
Ref Component
URI format
ref:someName
someName
would be the bean ID of an endpoint in the Spring registry.
Runtime lookup
// lookup the endpoint String myEndpointRef = "bigspenderOrder"; Endpoint endpoint = context.getEndpoint("ref:" + myEndpointRef); Producer producer = endpoint.createProducer(); Exchange exchange = producer.createExchange(); exchange.getIn().setBody(payloadToSend); // send the exchange producer.process(exchange); ...
<camelContext id="camel" xmlns="http://activemq.apache.org/camel/schema/spring"> <endpoint id="normalOrder" uri="activemq:order.slow"/> <endpoint id="bigspenderOrder" uri="activemq:order.high"/> ... </camelContext>
Sample
ref:
in the URI to reference the endpoint with the spring ID, endpoint2
:
<bean id="mybean" class="org.apache.camel.spring.example.DummyBean"> <property name="endpoint" ref="endpoint1"/> </bean> <camelContext id="camel" xmlns="http://camel.apache.org/schema/spring"> <jmxAgent id="agent" disabled="true"/> <endpoint id="endpoint1" uri="direct:start"/> <endpoint id="endpoint2" uri="mock:end"/> <route> <from ref="endpoint1"/> <to uri="ref:endpoint2"/> </route> </camelContext>
ref
attribute instead:
<to ref="endpoint2"/>
Chapter 117. Rest
Rest Component
URI format
rest://method:path[:uriTemplate]?[options]
URI Options
Name
|
Default Value
|
Description
|
method
|
|
HTTP method which should be one of: get, post, put, patch, delete, head, trace, connect, or options.
|
path
|
|
the base path which support REST syntax. See further below for examples.
|
uriTemplate
|
|
uri template which support REST syntax. See further below for examples.
|
consumes
|
|
media type such as: 'text/xml', or 'application/json' this REST service accepts. By default we accept all kinds of types.
|
produces
|
|
media type such as: 'text/xml', or 'application/json' this REST service returns.
|
Path and uriTemplate syntax
from("rest:get:hello") .transform().constant("Bye World");
from("rest:get:hello/{me}") .transform().simple("Bye ${header.me}");
from("rest:get:hello:/{me}") .transform().simple("Hi ${header.me}"); from("rest:get:hello:/french/{me}") .transform().simple("Bonjour ${header.me}");
More examples
Chapter 118. Restlet
Restlet Component
synchronous=true
, on the endpoint URI to improve performance.
URI format
restlet:restletUrl[?options]
protocol://hostname[:port][/resourcePattern]
?option=value&option=value&...
Options
Name | Default Value | Description |
---|---|---|
headerFilterStrategy=#refName
|
An instance of RestletHeaderFilterStrategy
|
Use the # notation (headerFilterStrategy=#refName ) to reference a header filter strategy in the Camel Registry. The strategy will be plugged into the restlet binding if it is HeaderFilterStrategyAware .
|
restletBinding=# refName
|
An instance of DefaultRestletBinding
|
The bean ID of a RestletBinding object in the Camel Registry.
|
restletMethod
|
GET
|
On a producer endpoint, specifies the request method to use. On a consumer endpoint, specifies that the endpoint consumes only restletMethod requests. The string value is converted to org.restlet.data.Method by the Method.valueOf(String) method.
|
restletMethods
|
None |
Consumer only Specify one or more methods separated by commas (e.g. restletMethods=post,put ) to be serviced by a restlet consumer endpoint. If both restletMethod and restletMethods options are specified, the restletMethod setting is ignored.
|
restletRealm
|
null
|
Use the # notation (restletRealm=# refName) to specify the bean ID of the Realm Map in the Camel registry.
|
restletUriPatterns=#refName
|
None |
Consumer only Specify one ore more URI templates to be serviced by a restlet consumer endpoint, using the # notation to reference a List<String> 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.
|
throwExceptionOnFailure (2.6 or later)
|
true
|
Producer only Throws exception on a producer failure. |
connectionTimeout
|
300000
|
Since Camel 2.12.3 Producer only The Client will give up connection if the connection is timeout, 0 for unlimited wait.
|
socketTimeout
|
300000
|
Since Camel 2.12.3 Producer only The Client socket receive timeout, 0 for unlimited wait.
|
disableStreamCache
|
false
|
Camel 2.14: Determines whether or not the raw input stream from Jetty 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 Jetty input stream to support reading it multiple times to ensure it 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.
|
Component Options
Name | Default Value | Description |
---|---|---|
controllerDaemon
|
true
|
Camel 2.10: Indicates if the controller thread should be a daemon (not blocking JVM exit). |
controllerSleepTimeMs
|
100
|
Camel 2.10: Time for the controller thread to sleep between each control. |
inboundBufferSize
|
8192
|
Camel 2.10: The size of the buffer when reading messages. |
minThreads
|
1
|
Camel 2.10: Minimum threads waiting to service requests. |
maxThreads
|
10
|
Camel 2.10: Maximum threads that will service requests. |
lowThreads
|
8
|
Camel 2.13: Number of worker threads determining when the connector is considered overloaded.
|
maxQueued
|
0
|
Camel 2.13: 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.
|
maxConnectionsPerHost
|
-1
|
Camel 2.10: Maximum number of concurrent connections per host (IP address). |
maxTotalConnections
|
-1
|
Camel 2.10: Maximum number of concurrent connections in total. |
outboundBufferSize
|
8192
|
Camel 2.10: The size of the buffer when writing messages. |
persistingConnections
|
true
|
Camel 2.10: Indicates if connections should be kept alive after a call. |
pipeliningConnections
|
false
|
Camel 2.10: Indicates if pipelining connections are supported. |
threadMaxIdleTimeMs
|
60000
|
Camel 2.10: Time for an idle thread to wait for an operation before being collected. |
useForwardedForHeader
|
false
|
Camel 2.10: 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
|
true
|
Camel 2.10.5/2.11.1: Enable/disable the SO_REUSEADDR socket option. See java.io.ServerSocket#reuseAddress property for additional details. |
disableStreamCache
|
false
|
Camel 2.14: Determines whether or not the raw input stream from Jetty 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 Jetty input stream to support reading it multiple times to ensure it 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.
|
Message Headers
Name | Type | Description |
---|---|---|
CamelContentType
|
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. nbsp; 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 Apache 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 Apache 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 Apache 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. |
content-type
header, specify Content-Type
, and for location
, specify Location
, and so on.
Message Body
Restlet Endpoint with Authentication
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.
from("restlet:http://localhost:9080/securedOrders?restletMethod=post&restletRealm=#realm").process(new Processor() { public void process(Exchange exchange) throws Exception { exchange.getOut().setBody( "received [" + exchange.getIn().getBody() + "] as an order id = " + exchange.getIn().getHeader("id")); } });
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.
<util:map id="realm"> <entry key="admin" value="foo" /> <entry key="bar" value="foo" /> </util:map>
direct
endpoint that sends requests to the server on http://localhost:8080 (that is, our restlet consumer endpoint).
// Note: restletMethod and restletRealmRef are stripped // from the query before a request is sent as they are // only processed by Camel. from("direct:start-auth").to("restlet:http://localhost:9080/securedOrders?restletMethod=post");
final String id = "89531"; Map<String, Object> headers = new HashMap<String, Object>(); headers.put(RestletConstants.RESTLET_LOGIN, "admin"); headers.put(RestletConstants.RESTLET_PASSWORD, "foo"); headers.put("id", id); String response = (String) template.requestBodyAndHeaders("direct:start-auth", "<order foo='1'/>", headers);
direct:start-auth
endpoint with the following headers:
CamelRestletLogin
(used internally by Apache Camel)CamelRestletPassword
(used internally by Apache Camel)id
(application header)
org.apache.camel.restlet.auth.login
and org.apache.camel.restlet.auth.password
will not be propagated as Restlet header.
received [<order foo='1'/>] as an order id = 89531
Single restlet endpoint to service multiple methods and URI templates (2.0 or later)
restletMethods
option. This snippet also shows how to retrieve the request method from the header:
from("restlet:http://localhost:9080/users/{username}?restletMethods=post,get,put") .process(new Processor() { public void process(Exchange exchange) throws Exception { // echo the method exchange.getOut().setBody(exchange.getIn().getHeader(Exchange.HTTP_METHOD, String.class)); } });
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.
from("restlet:http://localhost:9080?restletMethods=post,get&restletUriPatterns=#uriTemplates") .process(new Processor() { public void process(Exchange exchange) throws Exception { // echo the method String uri = exchange.getIn().getHeader(Exchange.HTTP_URI, String.class); String out = exchange.getIn().getHeader(Exchange.HTTP_METHOD, String.class); if ("http://localhost:9080/users/homer".equals(uri)) { exchange.getOut().setBody(out + " " + exchange.getIn().getHeader("username", String.class)); } else if ("http://localhost:9080/atom/collection/foo/component/bar".equals(uri)) { exchange.getOut().setBody(out + " " + exchange.getIn().getHeader("id", String.class) + " " + exchange.getIn().getHeader("cid", String.class)); } } });
restletUriPatterns=#uriTemplates
option references the List<String>
bean defined in the Spring XML configuration.
<util:list id="uriTemplates"> <value>/users/{username}</value> <value>/atom/collection/{id}/component/{cid}</value> </util:list>
Using Restlet API to populate response
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 Processor:
from("restlet:http://localhost:" + portNum + "/users/{id}/like/{beer}") .process(new Processor() { public void process(Exchange exchange) throws Exception { // the Restlet request should be available if neeeded Request request = exchange.getIn().getHeader(RestletConstants.RESTLET_REQUEST, Request.class); assertNotNull("Restlet Request", request); // use Restlet API to create the response Response response = exchange.getIn().getHeader(RestletConstants.RESTLET_RESPONSE, Response.class); assertNotNull("Restlet Response", response); response.setStatus(Status.SUCCESS_OK); response.setEntity("<response>Beer is Good</response>", MediaType.TEXT_XML); exchange.getOut().setBody(response); } });
Configuring max threads on component
<bean id="restlet" class="org.apache.camel.component.restlet.RestletComponent"> <property name="maxThreads" value="100"/> </bean>
Using the Restlet servlet within a webapp
<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>
<!-- 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>
"Request type : GET and ID : 1234"
<dependency> <groupId>org.restlet.jee</groupId> <artifactId>org.restlet.ext.spring</artifactId> <version>${restlet-version}</version> </dependency>
<repository> <id>maven-restlet</id> <name>Public online Restlet repository</name> <url>http://maven.restlet.org</url> </repository>
Chapter 119. RMI
RMI Component
Remote
objects.
pom.xml
for this component:
<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>
URI format
rmi://rmi-regisitry-host:rmi-registry-port/registry-path[?options]
rmi://localhost:1099/path/to/service
?option=value&option=value&...
Options
Name | Default Value | Description |
---|---|---|
method
|
null
|
As of Apache Camel 1.3, you can set the name of the method to invoke. |
remoteInterfaces
|
null
|
Its now possible to use this option from Camel 2.7: in the XML DSL. It can be a list of interface names separated by comma. |
Using
from("pojo:foo").to("rmi://localhost:1099/foo");
RmiEndpoint endpoint= (RmiEndpoint) endpoint("rmi://localhost:1099/bar"); endpoint.setRemoteInterfaces(ISay.class); from(endpoint).to("pojo:bar");
Remote
interfaces exposed.
<camel:route> <from uri="rmi://localhost:37541/helloServiceBean?remoteInterfaces=org.apache.camel.example.osgi.HelloService"/> <to uri="bean:helloServiceBean"/> </camel:route>
Chapter 120. Routebox
Routebox Component
pom.xml
for this component:
<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>
The need for a Camel Routebox endpoint
- a large collection of routes and
- involving a wide set of endpoint technologies needing integration in different ways
- 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:
Focus Area Coarse-Grained Route Example 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.
URI format
routebox:routeboxname[?options]
?option=value&option=value&...
Options
Name | Default Value | Description |
---|---|---|
dispatchStrategy
|
null
|
A string representing a key in the Camel Registry matching an object value implementing the interface org.apache.camel.component.routebox.strategy.RouteboxDispatchStrategy |
dispatchMap
|
null
|
A string representing a key in the Camel Registry matching an object value of the type HashMap<String, String>. 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. |
innerContext
|
auto created
|
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. |
innerRegistry
|
null
|
A string representing a key in the Camel Registry matching an object value that implements the interface org.apache.camel.spi.Registry. If Registry values are utilized by inner routes to create endpoints, an innerRegistry parameter must be provided |
routeBuilders
|
empty List
|
A string representing a key in the Camel Registry matching an object value of the type List<org.apache.camel.builder.RouteBuilder>. 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 |
innerProtocol
|
Direct
|
The Protocol used internally by the Routebox component. Can be Direct or SEDA. The Routebox component currently offers protocols that are JVM bound. |
sendToConsumer
|
true
|
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. |
forkContext
|
true
|
The Protocol used internally by the Routebox component. Can be Direct or SEDA. The Routebox component currently offers protocols that are JVM bound. |
threads
|
20
|
Number of threads to be used by the routebox to receive requests. Setting applicable only for innerProtocol SEDA. |
queueSize
|
unlimited
|
Create a fixed size queue to receive requests. Setting applicable only for innerProtocol SEDA. |
Sending/Receiving Messages to/from the routebox
Step 1: Loading inner route details into the Registry
@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());
Step 2: Optionaly using a Dispatch Strategy instead of a Dispatch Map
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; } }
Step 2: Launching a routebox consumer
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"); }
Step 3: Using a routebox producer
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");
Chapter 121. RSS
RSS Component
URI format
rss:rssUri
rssUri
is the URI to the RSS feed to poll.
?option=value&option=value&...
Options
Property | Default | Description |
---|---|---|
splitEntries
|
true
|
If true , Apache Camel splits a feed into its individual entries and returns each entry, poll by poll. For example, if a feed contains seven entries, Apache Camel returns the first entry on the first poll, the second entry on the second poll, and so on. When no more entries are left in the feed, Apache Camel contacts the remote RSS URI to obtain a new feed. If false , Apache Camel obtains a fresh feed on every poll and returns all of the feed's entries.
|
filter
|
true
|
Use in combination with the splitEntries option in order to filter returned entries. By default, Apache Camel applies the UpdateDateFilter filter, which returns only new entries from the feed, ensuring that the consumer endpoint never receives an entry more than once. The filter orders the entries chronologically, with the newest returned last.
|
throttleEntries
|
true
|
Camel 2.5: Sets whether all entries identified in a single feed poll should be delivered immediately. If true, only one entry is processed per consumer.delay. Only applicable when splitEntries is set to true. |
lastUpdate
|
null
|
Use in combination with the filter option to block entries earlier than a specific date/time (uses the entry.updated timestamp). The format is: yyyy-MM-ddTHH:MM:ss . Example: 2007-12-24T17:45:59 .
|
feedHeader
|
true
|
Specifies whether to add the ROME SyndFeed object as a header.
|
sortEntries
|
false
|
If splitEntries is true , this specifies whether to sort the entries by updated date.
|
consumer.delay
|
60000
|
Delay in milliseconds between each poll. |
consumer.initialDelay
|
1000
|
Milliseconds before polling starts. |
consumer.userFixedDelay
|
false
|
Set to true to use fixed delay between pools, otherwise fixed rate is used. See ScheduledExecutorService in JDK for details.
|
Exchange data types
SyndFeed
. Depending on the value of the splitEntries
flag, Apache Camel returns either a SyndFeed
with one SyndEntry
or a java.util.List
of SyndEntrys
.
Option | Value | Behavior |
---|---|---|
splitEntries
|
true
|
A single entry from the current feed is set in the exchange. |
splitEntries
|
false
|
The entire list of entries from the current feed is set in the exchange. |
Message Headers
Header | Description |
---|---|
CamelRssFeed
|
Apache Camel 2.0: The entire SyncFeed object.
|
RSS Dataformat
- marshal = from ROME
SyndFeed
to XMLString
- unmarshal = from XML
String
to ROMESyndFeed
from("rss:file:src/test/data/rss20.xml?splitEntries=false&consumer.delay=1000").marshal().rss().to("mock:marshal");
// only entries with Apache Camel in the title will get through the filter from("rss:file:src/test/data/rss20.xml?splitEntries=true&consumer.delay=100") .marshal().rss().filter().xpath("//item/title[contains(.,'Camel')]").to("mock:result");
alt=rss
, then you can for example do from("rss:http://someserver.com/feeds/posts/default?alt=rss&splitEntries=false&consumer.delay=1000").to("bean:rss");
Filtering entries
// only entries with Camel in the title will get through the filter from("rss:file:src/test/data/rss20.xml?splitEntries=true&consumer.delay=100"). filter().method("myFilterBean", "titleContainsCamel").to("mock:result");
public static class FilterBean { public boolean titleContainsCamel(@Body SyndFeed feed) { SyndEntry firstEntry = (SyndEntry) feed.getEntries().get(0); return firstEntry.getTitle().contains("Camel"); } }
See also
Chapter 122. Salesforce
Salesforce component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-salesforce</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
salesforce:topic?options
?option=value&option=value&...
Supported Salesforce APIs
Rest API
getVersions
- Gets supported Salesforce REST API versionsgetResources
- Gets available Salesforce REST Resource endpointsgetGlobalObjects
- Gets metadata for all available SObject typesgetBasicInfo
- Gets basic metadata for a specific SObject typegetDescription
- Gets comprehensive metadata for a specific SObject typegetSObject
- Gets an SObject using its Salesforce IdcreateSObject
- Creates an SObjectupdateSObject
- Updates an SObject using IddeleteSObject
- Deletes an SObject using IdgetSObjectWithId
- Gets an SObject using an external (user defined) id fieldupsertSObject
- Updates or inserts an SObject using an external iddeleteSObjectWithId
- Deletes an SObject using an external idquery
- Runs a Salesforce SOQL queryqueryMore
- Retrieves more results (in case of large number of results) using result link returned from the 'query' APIsearch
- Runs a Salesforce SOSL query
null
if an existing record was updated, or CreateSObjectResult
with an id of the new record, or a list of errors while creating the new object.
...to("salesforce:upsertSObject?sObjectIdName=Name")...
Rest Bulk API
createJob
- Creates a Salesforce Bulk JobgetJob
- Gets a Job using its Salesforce IdcloseJob
- Closes a JobabortJob
- Aborts a JobcreateBatch
- Submits a Batch within a Bulk JobgetBatch
- Gets a Batch using IdgetAllBatches
- Gets all Batches for a Bulk Job IdgetRequest
- Gets Request data (XML/CSV) for a BatchgetResults
- Gets the results of the Batch when its completecreateBatchQuery
- Creates a Batch from an SOQL querygetQueryResultIds
- Gets a list of Result Ids for a Batch QuerygetQueryResult
- Gets results for a Result Id
InputStream
(usually UTF-8 CSV or XML content from a file, etc.) and header fields 'jobId' for the Job and 'contentType' for the Job content type, which can be XML, CSV, ZIP\_XML or ZIP\_CSV. The put message body will contain BatchInfo
on success, or throw a SalesforceException
on error.
...to("salesforce:createBatchJob")..
Rest Streaming API
from("salesforce:CamelTestTopic?notifyForFields=ALL¬ifyForOperations=ALL&sObjectName=Merchandise__c&updateTopic=true&sObjectQuery=SELECT Id, Name FROM Merchandise__c")...
from("salesforce:CamelTestTopic&sObjectName=Merchandise__c")...
Uploading a document to a ContentWorkspace
public class ContentProcessor implements Processor { public void process(Exchange exchange) throws Exception { Message message = exchange.getIn(); ContentVersion cv = new ContentVersion(); ContentWorkspace cw = getWorkspace(exchange); cv.setFirstPublishLocationId(cw.getId()); cv.setTitle("test document"); cv.setPathOnClient("test_doc.html"); byte[] document = message.getBody(byte[].class); ObjectMapper mapper = new ObjectMapper(); String enc = mapper.convertValue(document, String.class); cv.setVersionDataUrl(enc); message.setBody(cv); } protected ContentWorkspace getWorkSpace(Exchange exchange) { // Look up the content workspace somehow, maybe use enrich() to add it to a // header that can be extracted here .... } }
from("file:///home/camel/library") .to(new ContentProcessor()) // convert bytes from the file into a ContentVersion SObject // for the salesforce component .to("salesforce:createSObject");
Camel Salesforce Maven Plugin
Usage
Option | Description |
---|---|
clientId
|
Salesforce client Id for Remote API access. |
clientSecret
|
Salesforce client secret for Remote API access. |
userName
|
Salesforce account user name. |
password
|
Salesforce account password (including secret token). |
version
|
Salesforce Rest API version, defaults to 25.0. |
outputDirectory
|
Directory where to place generated DTOs, defaults to ${project.build.directory}/generated-sources/camel-salesforce .
|
includes
|
List of SObject types to include. |
excludes
|
List of SObject types to exclude. |
includePattern
|
Java RegEx for SObject types to include. |
excludePattern
|
Java RegEx for SObject types to exclude. |
packageName
|
Java package name for generated DTOs, defaults to org.apache.camel.salesforce.dto .
|
mvn camel-salesforce:generate -DclientId=<clientid> -DclientSecret=<clientsecret> -DuserName=<username> -Dpassword=<password>
Chapter 123. SAP Component
Abstract
123.1. Overview
Dependencies
pom.xml
file to use this component:
<dependency> <groupId>org.fusesource</groupId> <artifactId>camel-sap</artifactId> <version>x.x.x</version> <dependency>
Additional platform restrictions for the SAP component
Deploying in a Fuse OSGi Container (non-Fabric)
lib/
directory of the Java runtime (sapjco3.jar
, libsapjco3.jnilib
, and sapidoc3.jar
).
- Download the SAP JCo libraries and the SAP IDoc library from the SAP Service Marketplace (https://websmp210.sap-ag.de/public/connectors), making sure to choose the appropriate version of the libraries for your operating system.NoteYou require version 3.0.11 or greater of the JCo library and version 3.0.10 or greater of the IDoc library. You must have an SAP Service Marketplace Account in order to download and use these libraries.
- Copy the
sapjco3.jar
,libsapjco3.jnilib
, andsapidoc3.jar
library files into thelib/
directory of your JBoss Fuse installation. - Open both the configuration properties file,
etc/config.properties
, and the custom properties file,etc/custom.properties
, in a text editor. In theetc/config.properties
file, look for theorg.osgi.framework.system.packages.extra
property and copy the complete property setting (this setting extends over multiple lines, with a backslash character,\
, used to indicate line continuation). Now paste this setting into theetc/custom.properties
file.You can now add the extra packages required to support the SAP libraries. In theetc/custom.properties
file, add the required packages to theorg.osgi.framework.system.packages.extra
setting as shown:org.osgi.framework.system.packages.extra = \ ... , \ com.sap.conn.idoc, \ com.sap.conn.idoc.jco, \ com.sap.conn.jco, \ com.sap.conn.jco.ext, \ com.sap.conn.jco.monitor, \ com.sap.conn.jco.rt, \ com.sap.conn.jco.server
TipDon't forget to include a comma and a backslash,, \
, at the end of each line preceding the new entries, so that the list is properly continued. - You need to restart the container for these changes to take effect.
- You need to install the
camel-sap
feature in the container. In the Karaf console, enter the following command:JBossFuse:karaf@root> features:install camel-sap
Deploying in a Fuse Fabric
lib/
directory of the Java runtime (sapjco3.jar
, libsapjco3.jnilib
, and sapidoc3.jar
).
lib
directory on a single machine, because Fabric containers need to be deployable anywhere in the network. The correct approach is to define a special profile that is capable of downloading and installing the SAP JCo libraries and the SAP IDoc library on whichever host it is running on.
- Deploy the JCo libraries and the IDoc library (
sapjco3.jar
,libsapjco3.jnilib
, andsapidoc3.jar
) to a network accessible location. For example, you could install the libraries in a Web server, so that the JCo libraries and the IDoc library can be downloaded through HTTP URLs,http://mywebserver/sapjco3.jar
,http://mywebserver/libsapjco3.jnilib
, andhttp://mywebserver/sapidoc3.jar
. - Create a new profile,
camel-sap-profile
, by entering the following console command:JBossFuse:karaf@root> profile-create camel-sap-profile
- Edit the agent properties of the
camel-sap-profile
profile, by entering the following console command:JBossFuse:karaf@root> profile-edit camel-sap-profile
- The built-in profile editor starts up. Use this built-in text editor to add the following contents to the agent properties:
# Profile:my-camel-sap-profile attribute.parents = feature-camel # Deploy JCo3 Libs to Container lib.sapjco3.jar = http://mywebserver/sapjco3.jar lib.sapjco3.jnilib = http://mywebserver/libsapjco3.jnilib lib.sapidoc3.jar = http://mywebserver/sapidoc3.jar # Append JCo3 Packages and IDoc packages to OSGi system property # in order to expose JCo3 and IDoc classes to OSGi environment config.org.osgi.framework.system.packages.extra= \ ... Packages from etc/config.properties file ...\ com.sap.conn.jco, \ com.sap.conn.jco.ext, \ com.sap.conn.jco.monitor, \ com.sap.conn.jco.rt, \ com.sap.conn.jco.server, \ com.sap.conn.idoc, \ com.sap.conn.idoc.jco
Customize the property settings as follows:lib.sapjco3.jar
- Customize the HTTP URL to the actual location of the
sapjco3.jar
file on your Web server. lib.sapjco3.jnilib
- Customize the HTTP URL to the actual location of the
libsapjco3.jnilib
file on your Web server. lib.sapidoc3.jar
- Customize the HTTP URL to the actual location of the
sapidoc3.jar
file on your Web server. config.org.osgi.framework.system.packages.extra
- Open the container configuration properties file,
etc/config.properties
, of your JBoss Fuse installation and look for theorg.osgi.framework.system.packages.extra
property setting. Copy the list of packages from that setting and paste them into the profile's agent properties, replacing the line:... Packages from etc/config.properties file ...\
NoteTheconfig.*
prefix inconfig.org.osgi.framework.system.packages.extra
indicates to Fabric that you are setting a container configuration property in the profile.NoteThe backslash,\
, is the line continuation character (UNIX convention) and must be followed immediately by a newline character.
Type Ctrl-S to save the properties when you are finished. - You can now deploy the
camel-sap-profile
profile to any Fabric container where you want to run the SAP component. For example, to deploy thecamel-sap-profile
profile to thesap-instance
container:JBossFuse:karaf@root> container-add-profile sap-instance came-sap-profile
URI format
sap-srfc-destination:destinationName:rfcName sap-trfc-destination:destinationName:rfcName sap-qrfc-destination:destinationName:queueName:rfcName sap-srfc-server:serverName:rfcName[?options] sap-trfc-server:serverName:rfcName[?options]
sap-idoc-destination:destinationName:idocType[:idocTypeExtension[:systemRelease[:applicationRelease]]] sap-idoclist-destination:destinationName:idocType[:idocTypeExtension[:systemRelease[:applicationRelease]]] sap-qidoc-destination:destinationName:queueName:idocType[:idocTypeExtension[:systemRelease[:applicationRelease]]] sap-qidoclist-destination:destinationName:queueName:idocType[:idocTypeExtension[:systemRelease[:applicationRelease]]] sap-idoclist-server:serverName:idocType[:idocTypeExtension[:systemRelease[:applicationRelease]]][?options]
sap-endpointKind-destination
are used to define destination endpoints (in other words, Camel producer endpoints) and destinationName
is the name of a specific outbound connection to an SAP instance. Outbound connections are named and configured at the component level, as described in Section 123.2.2, “Destination Configuration”.
sap-endpointKind-server
are used to define server endpoints (in other words, Camel consumer endpoints) and serverName
is the name of a specific inbound connection from an SAP instance. Inbound connections are named and configured at the component level, as described in the Section 123.2.3, “Server Configuration”.
rfcName
- (Required) In a destination endpoint URI, is the name of the RFC invoked by the endpoint in the connected SAP instance. In a server endpoint URI, is the name of the RFC handled by the endpoint when invoked from the connected SAP instance.
queueName
- Specifies the queue this endpoint sends an SAP request to.
idocType
- (Required) Specifies the Basic IDoc Type of an IDoc produced by this endpoint.
idocTypeExtension
- Specifies the IDoc Type Extension, if any, of an IDoc produced by this endpoint.
systemRelease
- Specifies the associated SAP Basis Release, if any, of an IDoc produced by this endpoint.
applicationRelease
- Specifes the associated Application Release, if any, of an IDoc produced by this endpoint.
queueName
- Specifies the queue this endpoint sends an SAP request to.
Options for RFC destination endpoints
sap-srfc-destination
, sap-trfc-destination
, and sap-qrfc-destination
) support the following URI options:
Name | Default | Description |
---|---|---|
stateful
|
false
|
If true , specifies that this endpoint initiates an SAP stateful session
|
transacted
|
false
|
If true , specifies that this endpoint initiates an SAP transaction
|
Options for RFC server endpoints
sap-srfc-server
and sap-trfc-server
) support the following URI options:
Name | Default | Description |
---|---|---|
stateful
|
false
|
If true , specifies that this endpoint initiates an SAP stateful session.
|
propagateExceptions
|
false
|
(sap-trfc-server endpoint only) If true , specifies that this endpoint propagates exceptions back to the caller in SAP, instead of the exchange's exception handler
|
Options for the IDoc List Server endpoint
sap-idoclist-server
) supports the following URI options:
Name | Default | Description |
---|---|---|
propagateExceptions
|
false
|
If true , specifies that this endpoint propagates exceptions back to the caller in SAP, instead of the exchange's exception handler
|
Summary of the RFC and IDoc endpoints
sap-srfc-destination
- JBoss Fuse SAP Synchronous Remote Function Call Destination Camel component. This endpoint should be used in cases where Camel routes require synchronous delivery of requests to and responses from an SAP system.NoteThe sRFC protocol used by this component delivers requests and responses to and from an SAP system with best effort. In case of a communication error while sending a request, the completion status of a remote function call in the receiving SAP system remains in doubt.
sap-trfc-destination
- JBoss Fuse SAP Transactional Remote Function Call Destination Camel component. This endpoint should be used in cases where requests must be delivered to the receiving SAP system at most once. To accomplish this, the component generates a transaction ID,
tid
, which accompanies every request sent through the component in a route's exchange. The receiving SAP system records thetid
accompanying a request before delivering the request; if the SAP system receives the request again with the sametid
it will not deliver the request. Thus if a route encounters a communication error when sending a request through an endpoint of this component, it can retry sending the request within the same exchange knowing it will be delivered and executed only once.NoteThe tRFC protocol used by this component is asynchronous and does not return a response. Thus the endpoints of this component do not return a response message.NoteThis component does not guarantee the order of a series of requests through its endpoints, and the delivery and execution order of these requests may differ on the receiving SAP system due to communication errors and resends of a request. For guaranteed delivery order, please see the JBoss Fuse SAP Queued Remote Function Call Destination Camel component. sap-qrfc-destination
- JBoss Fuse SAP Queued Remote Function Call Destination Camel component. This component extends the capabilities of the JBoss Fuse Transactional Remote Function Call Destination camel component by adding in order delivery guarantees to the delivery of requests through its endpoints. This endpoint should be used in cases where a series of requests depend on each other and must be delivered to the receiving SAP system at most once and in order. The component accomplishes the at most once delivery guarantees using the same mechanisms as the JBoss Fuse SAP Transactional Remote Function Call Destination Camel component. The ordering guarantee is accomplished by serializing the requests in the order they are received by the SAP system to an inbound queue. Inbound queues are processed by the QIN scheduler within SAP. When the inbound queue is activated, the QIN Scheduler will execute the queue requests in order.NoteThe qRFC protocol used by this component is asynchronous and does not return a response. Thus the endpoints of this component do not return a response message.
sap-srfc-server
- JBoss Fuse SAP Synchronous Remote Function Call Server Camel component. This component and its endpoints should be used in cases where a Camel route is required to synchronously handle requests from and responses to an SAP system.
sap-trfc-server
- JBoss Fuse SAP Transactional Remote Function Call Server Camel component. This endpoint should be used in cases where the sending SAP system requires at most once delivery of its requests to a Camel route. To accomplish this, the sending SAP system generates a transaction ID,
tid
, which accompanies every request it sends to the component's endpoints. The sending SAP system will first check with the component whether a giventid
has been received by it before sending a series of requests associated with thetid
. The component will check the list of receivedtid
s it maintains, record the senttid
if it is not in that list, and then respond to the sending SAP system, indicating whether or not thetid
had already been recorded. The sending SAP system will only then send the series of requests, if thetid
has not been previously recorded. This enables a sending SAP system to reliably send a series of requests once to a camel route. sap-idoc-destination
- JBoss Fuse SAP IDoc Destination Camel component. This endpoint should be used in cases where a Camel route is required to send a list of Intermediate Documents (IDocs) to an SAP system.
sap-idoclist-destination
- JBoss Fuse SAP IDoc List Destination Camel component. This endpoint should be used in cases where a Camel route is required to send a list of Intermediate documents (IDocs) list to an SAP system.
sap-qidoc-destination
- JBoss Fuse SAP Queued IDoc Destination Camel component. This component and its endpoints should be used in cases where a Camel route is required to send a list of Intermediate documents (IDocs) to an SAP system in order.
sap-qidoclist-destination
- JBoss Fuse SAP Queued IDoc List Destination Camel component. This component and its endpoints should be used in cases where a camel route is required to send a list of Intermediate documents (IDocs) list to an SAP system in order.
sap-idoclist-server
- JBoss Fuse SAP IDoc List Server Camel component. This endpoint should be used in cases where a sending SAP system requires delivery of Intermediate Document lists to a Camel route. This component uses the tRFC protocol to communicate with SAP as described in the `sap-trfc-server-standalone` quick start.
SAP RFC destination endpoint
SAP RFC server endpoint
SAP IDoc and IDoc list destination endpoints
SAP IDoc list server endpoint
Meta-data repositories
- Interface descriptions of function modules
- This meta-data is used by the JCo and ABAP runtimes to check RFC calls to ensure the type-safe transfer of data between communication partners before dispatching those calls. A repository is populated with repository data. Repository data is a map of named function templates. A function template contains the meta-data describing all the parameters and their typing information passed to and from a function module and has the unique name of the function module it describes.
- IDoc type descriptions
- This meta-data is used by the IDoc runtime to ensure that the IDoc documents are correctly formatted before being sent to a communication partner. A basic IDoc type consists of a name, a list of permitted segments, and a description of the hierarchical relationship between the segments. Some additional constraints can be imposed on the segments: a segment can be mandatory or optional; and it is possible to specify a minimum/maximum range for each segment (defining the number of allowed repetitions of that segment).
123.2. Configuration
Abstract
SapConnectionConfiguration
, which automatically gets injected into the SAP component (in the context of Blueprint XML configuration or Spring XML configuration files). The repository data store must be configured directly on the relevant SAP component.
123.2.1. Configuration Overview
Overview
destinationDataStore
, stores destination data keyed by destination name, the property, serverDataStore
, stores server data keyed by server name and the property, repositoryDataStore
, stores repository data keyed by repository name. These configurations must be passed to the component during its initialization.
Example
sap-configuration
bean (of type SapConnectionConfiguration
) will automatically be injected into any SAP component that is used in this XML file.
<?xml version="1.0" encoding="UTF-8"?> <blueprint ... > ... <!-- Configures the Inbound and Outbound SAP Connections --> <bean id="sap-configuration" class="org.fusesource.camel.component.sap.SapConnectionConfiguration"> <property name="destinationDataStore"> <map> <entry key="quickstartDest" value-ref="quickstartDestinationData" /> </map> </property> <property name="serverDataStore"> <map> <entry key="quickstartServer" value-ref="quickstartServerData" /> </map> </property> </bean> <!-- Configures an Outbound SAP Connection --> <!-- *** Please enter the connection property values for your environment *** --> <bean id="quickstartDestinationData" class="org.fusesource.camel.component.sap.model.rfc.impl.DestinationDataImpl"> <property name="ashost" value="example.com" /> <property name="sysnr" value="00" /> <property name="client" value="000" /> <property name="user" value="username" /> <property name="passwd" value="passowrd" /> <property name="lang" value="en" /> </bean> <!-- Configures an Inbound SAP Connection --> <!-- *** Please enter the connection property values for your environment ** --> <bean id="quickstartServerData" class="org.fusesource.camel.component.sap.model.rfc.impl.ServerDataImpl"> <property name="gwhost" value="example.com" /> <property name="gwserv" value="3300" /> <!-- The following property values should not be changed --> <property name="progid" value="QUICKSTART" /> <property name="repositoryDestination" value="quickstartDest" /> <property name="connectionCount" value="2" /> </bean> </blueprint>
123.2.2. Destination Configuration
Overview
destinationDataStore
property of the SAP component. Each entry in this map configures a distinct outbound connection to an SAP instance. The key for each entry is the name of the outbound connection and is used in the destinationName
component of a destination endpoint URI as described in the URI format section.
org.fusesource.camel.component.sap.model.rfc.impl.DestinationDataImpl
- that specifies the configuration of an outbound SAP connection.
Sample destination configuration
quickstartDest
.
<?xml version="1.0" encoding="UTF-8"?> <blueprint ... > ... <!-- Configures the Inbound and Outbound SAP Connections --> <bean id="sap-configuration" class="org.fusesource.camel.component.sap.SapConnectionConfiguration"> <property name="destinationDataStore"> <map> <entry key="quickstartDest" value-ref="quickstartDestinationData" /> </map> </property> </bean> <!-- Configures an Outbound SAP Connection --> <!-- *** Please enter the connection property values for your environment *** --> <bean id="quickstartDestinationData" class="org.fusesource.camel.component.sap.model.rfc.impl.DestinationDataImpl"> <property name="ashost" value="example.com" /> <property name="sysnr" value="00" /> <property name="client" value="000" /> <property name="user" value="username" /> <property name="passwd" value="password" /> <property name="lang" value="en" /> </bean> </blueprint>
BAPI_FLCUST_GETLIST
remote function call on the quickstartDest
destination using the following URI:
sap-srfc-destination:quickstartDest:BAPI_FLCUST_GETLIST
Logon and authentication options
Name | Default Value | Description |
---|---|---|
client
|
SAP client, mandatory logon parameter | |
user
|
Logon user, logon parameter for password based authentication | |
aliasUser
|
Logon user alias, can be used instead of logon user | |
userId
|
User identity which is used for logon to the ABAP AS. Used by the JCo runtime, if the destination configuration uses SSO/assertion ticket, certificate, current user ,or SNC environment for authentication. The user ID is mandatory, if neither user nor user alias is set. This ID will never be sent to the SAP backend, it will be used by the JCo runtime locally. | |
passwd
|
Logon password, logon parameter for password-based authentication | |
lang
|
Logon language, if not defined, the default user language is used | |
mysapsso2
|
Use the specified SAP Cookie Version 2 as logon ticket for SSO based authentication | |
x509cert
|
Use the specified X509 certificate for certificate based authentication | |
lcheck
|
Postpone the authentication until the first call - 1 (enable). Used in special cases only . | |
useSapGui
|
Use a visible, hidden, or do not use SAP GUI | |
codePage
|
Additional logon parameter to define the codepage that will used to convert the logon parameters. Used in special cases only | |
getsso2
|
Order a SSO ticket after logon, the obtained ticket is available in the destination attributes | |
denyInitialPassword
|
If set to 1 , using initial passwords will lead to an exception (default is 0 ).
|
Connection options
Name | Default Value | Description |
---|---|---|
saprouter
|
SAP Router string for connection to systems behind a SAP Router. SAP Router string contains the chain of SAP Routers and its port numbers and has the form: (/H/<host>[/S/<port>])+
|
|
sysnr
|
System number of the SAP ABAP application server, mandatory for a direct connection | |
ashost
|
SAP ABAP application server, mandatory for a direct connection | |
mshost
|
SAP message server, mandatory property for a load balancing connection | |
msserv
|
SAP message server port, optional property for a load balancing connection. In order to resolve the service names sapmsXXX a lookup in etc/services is performed by the network layer of the operating system. If using port numbers instead of symbolic service names, no look-ups are performed and no additional entries are needed.
|
|
gwhost
|
Allows specifying a concrete gateway, which should be used for establishing the connection to an application server. If not specified the gateway on the application server is used | |
gwserv
|
Should be set, when using gwhost. Allows specifying the port used on that gateway. If not specified the port of the gateway on the application server is used. In order to resolve the service names sapgwXXX a lookup in etc/services is performed by the network layer of the operating system. If using port numbers instead of symbolic service names, no lookups are performed and no additional entries are needed. | |
r3name
|
System ID of the SAP system, mandatory property for a load balancing connection. | |
group
|
Group of SAP application servers, mandatory property for a load balancing connection |
Connection pool options
Name | Default Value | Description |
---|---|---|
peakLimit
|
0
|
Maximum number of active outbound connections that can be created for a destination simultaneously. A value of 0 allows an unlimited number of active connections, otherwise if the value is less than the value of jpoolCapacity , it will be automatically increased to this value. Default setting is the value of poolCapacity , or in case of poolCapacity not being specified as well, the default is 0 (unlimited).
|
poolCapacity
|
1
|
Maximum number of idle outbound connections kept open by the destination. A value of 0 has the effect that there is no connection pooling (default is 1 ).
|
expirationTime
|
Time in milliseconds after which a free connection held internally by the destination can be closed | |
expirationPeriod
|
Period in milliseconds after which the destination checks the released connections for expiration. | |
maxGetTime
|
Maximum time in milliseconds to wait for a connection, if the maximum allowed number of connections has already been allocated by the application. |
Secure network connection options
Name | Default Value | Description |
---|---|---|
sncMode
|
Secure network connection (SNC) mode, 0 (off) or 1 (on)
|
|
sncPartnername
|
SNC partner, for example: p:CN=R3, O=XYZ-INC, C=EN
|
|
sncQop
|
SNC level of security: 1 to 9
|
|
sncMyname
|
Own SNC name. Overrides environment settings | |
sncLibrary
|
Path to library that provides SNC service |
Repository options
Name | Default Value | Description |
---|---|---|
repositoryDest
|
Specifies which destination should be used as repository. | |
repositoryUser
|
If a repository destination is not set, and this property is set, it will be used as user for repository calls. This enables you to use a different user for repository look-ups. | |
repositoryPasswd
|
The password for a repository user. Mandatory, if a repository user should be used. | |
repositorySnc
|
(Optional) If SNC is used for this destination, it is possible to turn it off for repository connections, if this property is set to 0 . Default setting is the value of jco.client.snc _mode. For special cases only.
|
|
repositoryRoundtripOptimization
|
Enable the
RFC_METADATA_GET API, which provides repository data in one single round trip.
If the property is not set, the destination initially does a remote call to check whether
RFC_METADATA_GET is available. If it is available, the destination will use it.
Note: If the repository is already initialized (for example because it is used by some other destination) this property does not have any effect. Generally, this property is related to the ABAP System, and should have the same value on all destinations pointing to the same ABAP System. See note 1456826 for backend prerequisites.
|
Trace configuration options
Name | Default Value | Description |
---|---|---|
trace
|
Enable/disable RFC trace (0 or 1 )
|
|
cpicTrace
|
Enable/disable CPIC trace [0..3]
|
123.2.3. Server Configuration
Overview
serverDataStore
property of the SAP component. Each entry in this map configures a distinct inbound connection from an SAP instance. The key for each entry is the name of the outbound connection and is used in the serverName
component of a server endpoint URI as described in the URI format section.
org.fusesource.camel.component.sap.model.rfc.impl.ServerDataImpl
, that defines the configuration of an inbound SAP connection.
Sample server configuration
quickstartServer
.
<?xml version="1.0" encoding="UTF-8"?> <blueprint ... > ... <!-- Configures the Inbound and Outbound SAP Connections --> <bean id="sap-configuration" class="org.fusesource.camel.component.sap.SapConnectionConfiguration"> <property name="destinationDataStore"> <map> <entry key="quickstartDest" value-ref="quickstartDestinationData" /> </map> </property> <property name="serverDataStore"> <map> <entry key="quickstartServer" value-ref="quickstartServerData" /> </map> </property> </bean> <!-- Configures an Outbound SAP Connection --> <!-- *** Please enter the connection property values for your environment *** --> <bean id="quickstartDestinationData" class="org.fusesource.camel.component.sap.model.rfc.impl.DestinationDataImpl"> <property name="ashost" value="example.com" /> <property name="sysnr" value="00" /> <property name="client" value="000" /> <property name="user" value="username" /> <property name="passwd" value="passowrd" /> <property name="lang" value="en" /> </bean> <!-- Configures an Inbound SAP Connection --> <!-- *** Please enter the connection property values for your environment ** --> <bean id="quickstartServerData" class="org.fusesource.camel.component.sap.model.rfc.impl.ServerDataImpl"> <property name="gwhost" value="example.com" /> <property name="gwserv" value="3300" /> <!-- The following property values should not be changed --> <property name="progid" value="QUICKSTART" /> <property name="repositoryDestination" value="quickstartDest" /> <property name="connectionCount" value="2" /> </bean> </blueprint>
quickstartDest
, which the server uses to retrieve meta-data from a remote SAP instance. This destination is configured in the server data through the repositoryDestination
option. If you do not configure this option, you would need to create a local meta-data repository instead (see Section 123.2.4, “Repository Configuration”).
BAPI_FLCUST_GETLIST
remote function call from an invoking client, using the following URI:
sap-srfc-server:quickstartServer:BAPI_FLCUST_GETLIST
Required options
Name | Default Value | Description |
---|---|---|
gwhost
|
Gateway host on which the server connection should be registered. | |
gwserv
|
Gateway service, which is the port on which a registration can be done. In order to resolve the service names sapgwXXX , a look-up in etc/services is performed by the network layer of the operating system. If using port numbers instead of symbolic service names, no look-ups are performed and no additional entries are needed.
|
|
progid
|
The program ID with which the registration is done. Serves as identifier on the gateway and in the destination in the ABAP system. | |
repositoryDestination
|
Specifies a destination name that the server can use in order to retrieve meta-data from a meta-data repository hosted in a remote SAP server. | |
connectionCount
|
The number of connections that should be registered at the gateway. |
Secure network connection options
Name | Default Value | Description |
---|---|---|
sncMode
|
Secure network connection (SNC) mode, 0 (off) or 1 (on)
|
|
sncQop
|
SNC level of security, 1 to 9
|
|
sncMyname
|
SNC name of your server. Overrides the default SNC name. Typically something like p:CN=JCoServer, O=ACompany, C=EN .
|
|
sncLib
|
Path to library which provides SNC service. If this property is not provided, the value of the jco.middleware.snc_lib property is used instead
|
Other options
Name | Default Value | Description |
---|---|---|
saprouter
|
SAP router string to use for a system protected by a firewall, which can therefore only be reached through a SAProuter, when registering the server at the gateway of that ABAP System. A typical router string is /H/firewall.hostname/H/
|
|
maxStartupDelay
|
The maximum time (in seconds) between two start-up attempts in case of failures. The waiting time is doubled from initially 1 second after each start-up failure until either the maximum value is reached or the server could be started successfully. | |
trace
|
Enable/disable RFC trace (0 or 1 )
|
|
workerThreadCount
|
The maximum number of threads used by the server connection. If not set, the value for the connectionCount is used as the workerThreadCount . The maximum number of threads can not exceed 99.
|
|
workerThreadMinCount
|
The minimum number of threads used by server connection. If not set, the value for connectionCount is used as the workerThreadMinCount .
|
123.2.4. Repository Configuration
Overview
repositoryDataStore
property of the SAP Component. Each entry in this map configures a distinct repository. The key for each entry is the name of the repository and this key also corresponds to the name of server to which this repository is attached.
org.fusesource.camel.component.sap.model.rfc.impl.RepositoryDataImpl
, that defines the contents of a meta-data repository. A repository data object is a map of function template configuration objects, org.fuesource.camel.component.sap.model.rfc.impl.FunctionTemplateImpl
. Each entry in this map specifies the interface of a function module and the key for each entry is the name of the function module specified.
Repository data example
<?xml version="1.0" encoding="UTF-8"?> <blueprint ... > ... <!-- Configures the sap-srfc-server component --> <bean id="sap-srfc-server" class="org.fusesource.camel.component.sap.SapSynchronousRfcServerComponent"> <property name="repositoryDataStore"> <map> <entry key="nplServer" value-ref="nplRepositoryData" /> </map> </property> </bean> <!-- Configures a Meta-Data Repository --> <bean id="nplRepositoryData" class="org.fusesource.camel.component.sap.model.rfc.impl.RepositoryDataImpl"> <property name="functionTemplates"> <map> <entry key="BOOK_FLIGHT" value-ref="bookFlightFunctionTemplate" /> </map> </property> </bean> ... </blueprint>
Function template properties
- The import parameter list contains parameter values that are sent to a function module in an RFC call;
- The export parameter list contains parameter values that are returned by a function module in an RFC call;
- The changing parameter list contains parameter values that are sent to and returned by a function module in an RFC call;
- The table parameter list contains internal table values that are sent to and returned by a function module in an RFC call.
- The interface of a function module also consists of an exception list of ABAP exceptions that may be raised when the module is invoked in an RFC call.
Property | Description |
---|---|
importParameterList
|
A list of list field meta-data objects, org.fusesource.camel.component.sap.model.rfc.impl.ListFieldMeataDataImpl . Specifies the parameters that are sent in an RFC call to a function module.
|
changingParameterList
|
A list of list field meta-data objects, org.fusesource.camel.component.sap.model.rfc.impl.ListFieldMeataDataImpl . Specifies the parameters that sent and returned in an RFC call to and from a function module.
|
exportParameterList
|
A list of list field meta-data objects, org.fusesource.camel.component.sap.model.rfc.impl.ListFieldMeataDataImpl . Specifies the parameters that are returned in an RFC call from a function module.
|
tableParameterList
|
A list of list field meta-data objects, org.fusesource.camel.component.sap.model.rfc.impl.ListFieldMeataDataImpl . Specifies the table parameters that are sent and returned in an RFC call to and from a function module.
|
exceptionList
|
A list of ABAP exception meta-data objects, org.fusesource.camel.component.sap.model.rfc.impl.AbapExceptionImpl . Specifies the ABAP exceptions potentially raised in an RFC call of function module.
|
Function template example
<bean id="bookFlightFunctionTemplate" class="org.fusesource.camel.component.sap.model.rfc.impl.FunctionTemplateImpl"> <property name="importParameterList"> <list> ... </list> </property> <property name="changingParameterList"> <list> ... </list> </property> <property name="exportParameterList"> <list> ... </list> </property> <property name="tableParameterList"> <list> ... </list> </property> <property name="exceptionList"> <list> ... </list> </property> </bean>
List field meta-data properties
org.fusesource.camel.component.sap.model.rfc.impl.ListFieldMeataDataImpl
, specifies the name and type of a field in a parameter list. For an elementary parameter field (CHAR
, DATE
, BCD
, TIME
, BYTE
, NUM
, FLOAT
, INT
, INT1
, INT2
, DECF16
, DECF34
, STRING
, XSTRING
), the following table lists the configuration properties that may be set on a list field meta-data object:
Name | Default Value | Description |
---|---|---|
name
|
- | The name of the parameter field. |
type
|
- | The parameter type of the field. |
byteLength
|
- | The field length in bytes for a non-Unicode layout. This value depends on the parameter type. See Section 123.3, “Message Body for RFC”. |
unicodeByteLength
|
- | The field length in bytes for a Unicode layout. This value depends on the parameter type. See Section 123.3, “Message Body for RFC”. |
decimals
|
0
|
The number of decimals in field value; only required for parameter types BCD and FLOAT. See Section 123.3, “Message Body for RFC”. |
optional
|
false
|
If true , the field is optional and need not be set in a RFC call
|
name
, type
, byteLength
and unicodeByteLength
properties be specified in the field meta-data object. In addition, the BCD
, FLOAT
, DECF16
and DECF34
fields require the decimal property to be specified in the field meta-data object.
TABLE
or STRUCTURE
, the following table lists the configuration properties that may be set on a list field meta-data object:
Name | Default Value | Description |
---|---|---|
name
|
- | The name of the parameter field |
type
|
- | The parameter type of the field |
recordMetaData
|
- |
The meta-data for the structure or table. A record meta-data object, org.fusesource.camel.component.sap.model.rfc.impl.RecordMetaDataImpl , is passed to specify the fields in the structure or table rows.
|
optional
|
false
|
If true , the field is optional and need not be set in a RFC call
|
name
, type
and recordMetaData
properties be specified in the field meta-data object. The value of the recordMetaData
property is a record field meta-data object, org.fusesource.camel.component.sap.model.rfc.impl.RecordMetaDataImpl
, which specifies the structure of a nested structure or the structure of a table row.
Elementary list field meta-data example
TICKET_PRICE
:
<bean class="org.fusesource.camel.component.sap.model.rfc.impl.ListFieldMetaDataImpl"> <property name="name" value="TICKET_PRICE" /> <property name="type" value="BCD" /> <property name="byteLength" value="12" /> <property name="unicodeByteLength" value="24" /> <property name="decimals" value="2" /> <property name="optional" value="true" /> </bean>
Complex list field meta-data example
TABLE
parameter named CONNINFO
with a row structure specified by the connectionInfo
record meta-data object:
<bean class="org.fusesource.camel.component.sap.model.rfc.impl.ListFieldMetaDataImpl"> <property name="name" value="CONNINFO" /> <property name="type" value="TABLE" /> <property name="recordMetaData" ref="connectionInfo" /> </bean>
Record meta-data properties
org.fusesource.camel.component.sap.model.rfc.impl.RecordMetaDataImpl
, specifies the name and contents of a nested STRUCTURE
or the row of a TABLE
parameter. A record meta-data object maintains a list of record field meta data objects, org.fusesource.camel.component.sap.model.rfc.impl.FieldMetaDataImpl
, which specify the parameters that reside in the nested structure or table row.
Name | Default Value | Description |
---|---|---|
name
|
- | The name of the record. |
recordFieldMetaData
|
- |
The list of record field meta-data objects, org.fusesource.camel.component.sap.model.rfc.impl.FieldMetaDataImpl . Specifies the fields contained within the structure.
|
Record meta-data example
<bean id="connectionInfo" class="org.fusesource.camel.component.sap.model.rfc.impl.RecordMetaDataImpl"> <property name="name" value="CONNECTION_INFO" /> <property name="recordFieldMetaData"> <list> ... </list> </property> </bean>
Record field meta-data properties
org.fusesource.camel.component.sap.model.rfc.impl.FieldMetaDataImpl
, specifies the name and type of a parameter field withing a structure.
CHAR
, DATE
, BCD
, TIME
, BYTE
, NUM
, FLOAT
, INT
, INT1
, INT2
, DECF16
, DECF34
, STRING
, XSTRING
), the following table lists the configuration properties that may be set on a record field meta-data object:
Name | Default Value | Description |
---|---|---|
name
|
- | The name of the parameter field |
type
|
- | The parameter type of the field |
byteLength
|
- | The field length in bytes for a non-Unicode layout. This value depends on the parameter type. See Section 123.3, “Message Body for RFC”. |
unicodeByteLength
|
- | The field length in bytes for a Unicode layout. This value depends on the parameter type. See Section 123.3, “Message Body for RFC”. |
byteOffset
|
- | The field offset in bytes for non-Unicode layout. This offset is the byte location of the field within the enclosing structure. |
unicodeByteOffset
|
- | The field offset in bytes for Unicode layout. This offset is the byte location of the field within the enclosing structure. |
decimals
|
0
|
The number of decimals in field value; only required for parameter types BCD and FLOAT . See Section 123.3, “Message Body for RFC”.
|
TABLE
or STRUCTURE
, the following table lists the configuration properties that may be set on a record field meta-data object:
Name | Default Value | Description |
---|---|---|
name
|
- | The name of the parameter field |
type
|
- | The parameter type of the field |
byteOffset
|
- | The field offset in bytes for non-Unicode layout. This offset is the byte location of the field within the enclosing structure. |
unicodeByteOffset
|
- | The field offset in bytes for Unicode layout. This offset is the byte location of the field within the enclosing structure. |
recordMetaData
|
- |
The meta-data for the structure or table. A record meta-data object, org.fusesource.camel.component.sap.model.rfc.impl.RecordMetaDataImpl , is passed to specify the fields in the structure or table rows.
|
Elementary record field meta-data example
DATE
field parameter named ARRDATE
located 85 bytes into the enclosing structure in the case of a non-Unicode layout and located 170 bytes into the enclosing structure in the case of a Unicode layout:
<bean class="org.fusesource.camel.component.sap.model.rfc.impl.FieldMetaDataImpl"> <property name="name" value="ARRDATE" /> <property name="type" value="DATE" /> <property name="byteLength" value="8" /> <property name="unicodeByteLength" value="16" /> <property name="byteOffset" value="85" /> <property name="unicodeByteOffset" value="170" /> </bean>
Complex record field meta-data example
STRUCTURE
field parameter named FLTINFO
with a structure specified by the flightInfo
record meta-data object. The parameter is located at the beginning of the enclosing structure in both the case of a non-Unicode and Unicode layout.
<bean class="org.fusesource.camel.component.sap.model.rfc.impl.FieldMetaDataImpl"> <property name="name" value="FLTINFO" /> <property name="type" value="STRUCTURE" /> <property name="byteOffset" value="0" /> <property name="unicodeByteOffset" value="0" /> <property name="recordMetaData" ref="flightInfo" /> </bean>
123.3. Message Body for RFC
Request and response objects
public class SAPEndpoint ... { ... public Structure getRequest() throws Exception; public Structure getResponse() throws Exception; ... }
Structure objects
org.fusesource.camel.component.sap.model.rfc.Structure
interface. This interface extends both the java.util.Map
and org.eclipse.emf.ecore.EObject
interfaces.
public interface Structure extends org.eclipse.emf.ecore.EObject, java.util.Map<String, Object> { <T> T get(Object key, Class<T> type); }
EObject
interface. Instances of a structure object have attached meta-data which define and restrict the structure and contents of the map of fields it provides. This meta-data can be accessed and introspected using the standard methods provided by EMF. Please refer to the EMF documentation for further details.
STRUCTURE
and TABLE
. Note that it is unnecessary to create instances of these types and add them to the structure. Instances of these field values are created on demand if necessary when accessed in the enclosing structure.
Field types
Elementary field types
Field Type | Corresponding Java Type | Byte Length | Unicode Byte Length | Number Decimals Digits | Description |
---|---|---|---|---|---|
CHAR
|
java.lang.String
|
1 to 65535 | 1 to 65535 | - | ABAP Type ‘C’: Fixed sized character string |
DATE
|
java.util.Date
|
8 | 16 | - | ABAP Type ‘D’: Date (format: YYYYMMDD) |
BCD
|
java.math.BigDecimal
|
1 to 16 | 1 to 16 | 0 to 14 | ABAP Type ‘P’: Packed BCD number. A BCD number contains two digits per byte. |
TIME
|
java.util.Date
|
6 | 12 | - | ABAP Type ‘T’: Time (format: HHMMSS) |
BYTE
|
byte[]
|
1 to 65535 | 1 to 65535 | - | ABAP Type ‘X’:Fixed sized byte array |
NUM
|
java.lang.String
|
1 to 65535 | 1 to 65535 | - | ABAP Type ‘N’: Fixed sized numeric character string |
FLOAT
|
java.lang.Double
|
8 | 8 | 0 to 15 | ABAP Type ‘F’: Floating point number |
INT
|
java.lang.Integer
|
4 | 4 | - | ABAP Type ‘I’: 4-byte Integer |
INT2
|
java.lang.Integer
|
2 | 2 | - | ABAP Type ‘S’: 2-byte Integer |
INT1
|
java.lang.Integer
|
1 | 1 | - | ABAP Type ‘B’: 1-byte Integer |
DECF16
|
java.match.BigDecimal
|
8 | 8 | 16 | ABAP Type ‘decfloat16’: 8 -byte Decimal Floating Point Number |
DECF34
|
java.math.BigDecimal
|
16 | 16 | 34 | ABAP Type ‘decfloat34’: 16-byte Decimal Floating Point Number |
STRING
|
java.lang.String
|
8 | 8 | - | ABAP Type ‘G’: Variable length character string |
XSTRING
|
byte[]
|
8 | 8 | - | ABAP Type ‘Y’: Variable length byte array |
Character field types
java.lang.String
objects and the underlying JCo runtime is responsible for the conversion to their ABAP representation.
byteLength
and unicodeByteLength
properties, which determine the length of the field’s character string in each encoding system.
CHAR
- A
CHAR
character field is a text field containing alphanumeric characters and corresponds to the ABAP type C. NUM
- A
NUM
character field is a numeric text field containing numeric characters only and corresponds to the ABAP type N. DATE
- A
DATE
character field is an 8 character date field with the year, month and day formatted asYYYYMMDD
and corresponds to the ABAP type D. TIME
- A
TIME
character field is a 6 character time field with the hours, minutes and seconds formatted asHHMMSS
and corresponds to the ABAP type T.
Numeric field types
INT
- An
INT
numeric field is an integer field stored as a 4-byte integer value in the underlying JCo and ABAP runtimes and corresponds to the ABAP type I. AnINT
field value is represented in Java as ajava.lang.Integer
object. INT2
- An
INT2
numeric field is an integer field stored as a 2-byte integer value in the underlying JCo and ABAP runtimes and corresponds to the ABAP type S. AnINT2
field value is represented in Java as ajava.lang.Integer
object. INT1
- An
INT1
field is an integer field stored as a 1-byte integer value in the underlying JCo and ABAP runtimes value and corresponds to the ABAP type B. AnINT1
field value is represented in Java as ajava.lang.Integer
object. FLOAT
- A
FLOAT
field is a binary floating point number field stored as an 8-byte double value in the underlying JCo and ABAP runtimes and corresponds to the ABAP type F. AFLOAT
field declares the number of decimal digits that the field’s value contains in its associated decimal property. In the case of aFLOAT
field, this decimal property can have a value between 1 and 15 digits. AFLOAT
field value is represented in Java as ajava.lang.Double
object. BCD
- A
BCD
field is a binary coded decimal field stored as a 1 to 16 byte packed number in the underlying JCo and ABAP runtimes and corresponds to the ABAP type P. A packed number stores two decimal digits per byte. ABCD
field declares its field length in its associatedbyteLength
andunicodeByteLength
properties. In the case of aBCD
field, these properties can have a value between 1 and 16 bytes and both properties will have the same value. ABCD
field declares the number of decimal digits that the field’s value contains in its associated decimal property. In the case of aBCD
field, this decimal property can have a value between 1 and 14 digits. ABCD
field value is represented in Java as ajava.math.BigDecimal
. DECF16
- A
DECF16
field is a decimal floating point stored as an 8-byte IEEE 754 decimal64 floating point value in the underlying JCo and ABAP runtimes and corresponds to the ABAP typedecfloat16
. The value of aDECF16
field has 16 decimal digits. The value of aDECF16
field is represented in Java asjava.math.BigDecimal
. DECF34
- A
DECF34
field is a decimal floating point stored as a 16-byte IEEE 754 decimal128 floating point value in the underlying JCo and ABAP runtimes and corresponds to the ABAP typedecfloat34
. The value of aDECF34
field has 34 decimal digits. The value of aDECF34
field is represented in Java asjava.math.BigDecimal
.
Hexadecimal field types
BYTE
- A
BYTE
field is a fixed sized byte string stored as a byte array in the underlying JCo and ABAP runtimes and corresponds to the ABAP type X. ABYTE
field declares its field length in its associatedbyteLength
andunicodeByteLength
properties. In the case of aBYTE
field, these properties can have a value between 1 and 65535 bytes and both properties will have the same value. The value of aBYTE
field is represented in Java as abyte[]
object.
String field types
STRING
- A
STRING
field refers to a character string and is stored in the underlying JCo and ABAP runtimes as an 8-byte value. It corresponds to the ABAP type G. The value of theSTRING
field is represented in Java as ajava.lang.String
object. XSTRING
- An
XSTRING
field refers to a byte string and is stored in the underlying JCo and ABAP runtimes as an 8-byte value. It corresponds to the ABAP type Y. The value of theSTRING
field is represented in Java as abyte[]
object.
Complex field types
Field Type | Corresponding Java Type | Byte Length | Unicode Byte Length | Number Decimals Digits | Description |
---|---|---|---|---|---|
STRUCTURE
|
org.fusesource.camel.component.sap.model.rfc.Structure
|
Total of individual field byte lengths | Total of individual field Unicode byte lengths | - | ABAP Type ‘u’ & ‘v’: Heterogeneous Structure |
TABLE
|
org.fusesource.camel.component.sap.model.rfc.Table
|
Byte length of row structure | Unicode byte length of row structure | - | ABAP Type ‘h’: Table |
Structure field types
STRUCTURE
field contains a structure object and is stored in the underlying JCo and ABAP runtimes as an ABAP structure record. It corresponds to either an ABAP type u
or v
. The value of a STRUCTURE
field is represented in Java as a structure object with the interface org.fusesource.camel.component.sap.model.rfc.Structure
.
Table field types
TABLE
field contains a table object and is stored in the underlying JCo and ABAP runtimes as an ABAP internal table. It corresponds to the ABAP type h
. The value of the field is represented in Java by a table object with the interface org.fusesource.camel.component.sap.model.rfc.Table
.
Table objects
java.util.List
and org.eclipse.emf.ecore.EObject
interfaces.
public interface Table<S extends Structure> extends org.eclipse.emf.ecore.EObject, java.util.List<S> { /** * Creates and adds table row at end of row list */ S add(); /** * Creates and adds table row at index in row list */ S add(int index); }
123.4. Message Body for IDoc
IDoc message type
sap-idoc-destination
endpoint or a sap-qidoc-destination
endpoint, the message body is of Document
type:
org.fusesource.camel.component.sap.model.idoc.Document
sap-idoclist-destination
endpoint, a sap-qidoclist-destination
endpoint, or a sap-idoclist-server
endpoint, the message body is of DocumentList
type:
org.fusesource.camel.component.sap.model.idoc.DocumentList
The IDoc document model
org.fusesource.camel.component.sap.model.idoc.Document org.fusesource.camel.component.sap.model.idoc.Segment
Document
type represents an IDoc document instance. In outline, the Document
interface exposes the following methods:
// Java package org.fusesource.camel.component.sap.model.idoc; ... public interface Document extends EObject { // Access the field values from the IDoc control record String getArchiveKey(); void setArchiveKey(String value); String getClient(); void setClient(String value); ... // Access the IDoc document contents Segment getRootSegment(); }
Document
interface:
- Methods for accessing the control record
- Most of the methods are for accessing or modifying field values of the IDoc control record. These methods are of the form
getAttributeName
,setAttributeName
, whereAttributeName
is the name of a field value (see Table 123.1, “IDoc Document Attributes”). - Method for accessing the document contents
- The
getRootSegment
method provides access to the document contents (IDoc data records), returning the contents as aSegment
object. EachSegment
object can contain an arbitrary number of child segments, and the segments can be nested to an arbitrary degree.Note, however, that the precise layout of the segment hierarchy is defined by the particular IDoc type of the document. When creating (or reading) a segment hierarchy, therefore, you must be sure to follow the exact structure as defined by the IDoc type.
Segment
type is used to access the data records of the IDoc document, where the segments are laid out in accordance with the structure defined by the document's IDoc type. In outline, the Segment
interface exposes the following methods:
// Java package org.fusesource.camel.component.sap.model.idoc; ... public interface Segment extends EObject, java.util.Map<String, Object> { // Returns the value of the '<em><b>Parent</b></em>' reference. Segment getParent(); // Return a immutable list of all child segments <S extends Segment> EList<S> getChildren(); // Returns a list of child segments of the specified segment type. <S extends Segment> SegmentList<S> getChildren(String segmentType); EList<String> getTypes(); Document getDocument(); String getDescription(); String getType(); String getDefinition(); int getHierarchyLevel(); String getIdocType(); String getIdocTypeExtension(); String getSystemRelease(); String getApplicationRelease(); int getNumFields(); long getMaxOccurrence(); long getMinOccurrence(); boolean isMandatory(); boolean isQualified(); int getRecordLength(); <T> T get(Object key, Class<T> type); }
getChildren(String segmentType)
method is particularly useful for adding new (nested) children to a segment. It returns an object of type, SegmentList
, which is defined as follows:
// Java package org.fusesource.camel.component.sap.model.idoc; ... public interface SegmentList<S extends Segment> extends EObject, EList<S> { S add(); S add(int index); }
E1SCU_CRE
type, you could use Java code like the following:
Segment rootSegment = document.getRootSegment(); Segment E1SCU_CRE_Segment = rootSegment.getChildren("E1SCU_CRE").add();
How an IDoc is related to a Document object
- Control record
- The control record (which contains the meta-data for the IDoc document) is represented by the attributes on the
Document
object—see Table 123.1, “IDoc Document Attributes” for details. - Data records
- The data records are represented by the
Segment
objects, which are constructed as a nested hierarchy of segments. You can access the root segment through theDocument.getRootSegment
method. - Status records
- In the Camel SAP component, the status records are not represented by the document model. But you do have access to the latest status value through the
status
attribute on the control record.
Example of creating a Document instance
FLCUSTOMER_CREATEFROMDATA01
, using the IDoc model API in Java.
Example 123.1. Creating an IDoc Document in Java
// Java import org.fusesource.camel.component.sap.model.idoc.Document; import org.fusesource.camel.component.sap.model.idoc.Segment; import org.fusesource.camel.component.sap.util.IDocUtil; import org.fusesource.camel.component.sap.model.idoc.Document; import org.fusesource.camel.component.sap.model.idoc.DocumentList; import org.fusesource.camel.component.sap.model.idoc.IdocFactory; import org.fusesource.camel.component.sap.model.idoc.IdocPackage; import org.fusesource.camel.component.sap.model.idoc.Segment; import org.fusesource.camel.component.sap.model.idoc.SegmentChildren; ... // // Create a new IDoc instance using the modelling classes // // Get the SAP Endpoint bean from the Camel context. // In this example, it's a 'sap-idoc-destination' endpoint. SapTransactionalIDocDestinationEndpoint endpoint = exchange.getContext().getEndpoint( "bean:SapEndpointBeanID", SapTransactionalIDocDestinationEndpoint.class ); // The endpoint automatically populates some required control record attributes Document document = endpoint.createDocument() // Initialize additional control record attributes document.setMessageType("FLCUSTOMER_CREATEFROMDATA"); document.setRecipientPartnerNumber("QUICKCLNT"); document.setRecipientPartnerType("LS"); document.setSenderPartnerNumber("QUICKSTART"); document.setSenderPartnerType("LS"); Segment rootSegment = document.getRootSegment(); Segment E1SCU_CRE_Segment = rootSegment.getChildren("E1SCU_CRE").add(); Segment E1BPSCUNEW_Segment = E1SCU_CRE_Segment.getChildren("E1BPSCUNEW").add(); E1BPSCUNEW_Segment.put("CUSTNAME", "Fred Flintstone"); E1BPSCUNEW_Segment.put("FORM", "Mr."); E1BPSCUNEW_Segment.put("STREET", "123 Rubble Lane"); E1BPSCUNEW_Segment.put("POSTCODE", "01234"); E1BPSCUNEW_Segment.put("CITY", "Bedrock"); E1BPSCUNEW_Segment.put("COUNTR", "US"); E1BPSCUNEW_Segment.put("PHONE", "800-555-1212"); E1BPSCUNEW_Segment.put("EMAIL", "fred@bedrock.com"); E1BPSCUNEW_Segment.put("CUSTTYPE", "P"); E1BPSCUNEW_Segment.put("DISCOUNT", "005"); E1BPSCUNEW_Segment.put("LANGU", "E");
Document attributes
Document
object.
Attribute | Length | SAP Field | Description |
---|---|---|---|
archiveKey
|
70 |
ARCKEY
|
EDI archive key
|
client
|
3 |
MANDT
|
Client
|
creationDate
|
8 |
CREDAT
|
Date IDoc was created
|
creationTime
|
6 |
CRETIM
|
Time IDoc was created
|
direction
|
1 |
DIRECT
|
Direction
|
eDIMessage
|
14 |
REFMES
|
Reference to message
|
eDIMessageGroup
|
14 |
REFGRP
|
Reference to message group
|
eDIMessageType
|
6 |
STDMES
|
EDI message type
|
eDIStandardFlag
|
1 |
STD
|
EDI standard
|
eDIStandardVersion
|
6 |
STDVRS
|
Version of EDI standard
|
eDITransmissionFile
|
14 |
REFINT
|
Reference to interchange file
|
iDocCompoundType
|
8 |
DOCTYP
|
IDoc type
|
iDocNumber
|
16 |
DOCNUM
|
IDoc number
|
iDocSAPRelease
|
4 |
DOCREL
|
SAP Release of IDoc
|
iDocType
|
30 |
IDOCTP
|
Name of basic IDoc type
|
iDocTypeExtension
|
30 |
CIMTYP
|
Name of extension type
|
messageCode
|
3 |
MESCOD
|
Logical message code
|
messageFunction
|
3 |
MESFCT
|
Logical message function
|
messageType
|
30 |
MESTYP
|
Logical message type
|
outputMode
|
1 |
OUTMOD
|
Output mode
|
recipientAddress
|
10 |
RCVSAD
|
Receiver address (SADR)
|
recipientLogicalAddress
|
70 |
RCVLAD
|
Logical address of receiver
|
recipientPartnerFunction
|
2 |
RCVPFC
|
Partner function of receiver
|
recipientPartnerNumber
|
10 |
RCVPRN
|
Partner number of receiver
|
recipientPartnerType
|
2 |
RCVPRT
|
Partner type of receiver
|
recipientPort
|
10 |
RCVPOR
|
Receiver port (SAP System, EDI subsystem)
|
senderAddress
|
SNDSAD
|
Sender address (SADR)
|
|
senderLogicalAddress
|
70 |
SNDLAD
|
Logical address of sender
|
senderPartnerFunction
|
2 |
SNDPFC
|
Partner function of sender
|
senderPartnerNumber
|
10 |
SNDPRN
|
Partner number of sender
|
senderPartnerType
|
2 |
SNDPRT
|
Partner type of sender
|
senderPort
|
10 |
SNDPOR
|
Sender port (SAP System, EDI subsystem)
|
serialization
|
20 |
SERIAL
|
EDI/ALE: Serialization field
|
status
|
2 |
STATUS
|
Status of IDoc
|
testFlag
|
1 |
TEST
|
Test flag
|
Setting document attributes in Java
name
attribute can be accessed through the getName
and setName
methods, for getting and setting the attribute value. For example, the iDocType
, iDocTypeExtension
, and messageType
attributes can be set as follows on a Document
object:
// Java document.setIDocType("FLCUSTOMER_CREATEFROMDATA01"); document.setIDocTypeExtension(""); document.setMessageType("FLCUSTOMER_CREATEFROMDATA");
Setting document attributes in XML
idoc:Document
element. For example, the iDocType
, iDocTypeExtension
, and messageType
attributes can be set as follows:
<?xml version="1.0" encoding="ASCII"?> <idoc:Document ... iDocType="FLCUSTOMER_CREATEFROMDATA01" iDocTypeExtension="" messageType="FLCUSTOMER_CREATEFROMDATA" ... > ... </idoc:Document>
123.5. Transaction Support
BAPI transaction model
true
will, if necessary, initiate a stateful session on the outbound connection of the endpoint and register a Camel Synchronization object with the exchange. This synchronization object will call the BAPI service method BAPI_TRANSACTION_COMMIT
and end the stateful session when the processing of the message exchange is complete. If the processing of the message exchange fails, the synchronization object will call the BAPI server method BAPI_TRANSACTION_ROLLBACK
and end the stateful session.
123.6. XML Serialization for RFC
Overview
XML namespace
http://sap.fusesource.org/rfc/<Repository Name>/<RFC Name>
http://sap.fusesource.org/rfc
prefix followed by the name of the repository in which the RFC’s metadata is defined. The final component in the URL is the name of the RFC itself.
Request and response XML documents
<?xml version="1.0" encoding="ASCII"?> <BOOK_FLIGHT:Request xmlns:BOOK_FLIGHT="http://sap.fusesource.org/rfc/nplServer/BOOK_FLIGHT"> ... </BOOK_FLIGHT:Request>
<?xml version="1.0" encoding="ASCII"?> <BOOK_FLIGHT:Response xmlns:BOOK_FLIGHT="http://sap.fusesource.org/rfc/nplServer/BOOK_FLIGHT"> ... </BOOK_FLIGHT:Response>
Structure fields
<BOOK_FLIGHT:FLTINFO xmlns:BOOK_FLIGHT="http://sap.fusesource.org/rfc/nplServer/BOOK_FLIGHT"> ... </BOOK_FLIGHT:FLTINFO>
<xs:schema targetNamespace="http://sap.fusesource.org/rfc/nplServer/BOOK_FLIGHT"> xmlns:xs="http://www.w3.org/2001/XMLSchema"> ... <xs:complexType name="FLTINFO_STRUCTURE”> ... </xs:complexType> ... </xs:schema>
Table fields
<BOOK_FLIGHT:CONNINFO xmlns:BOOK_FLIGHT="http://sap.fusesource.org/rfc/nplServer/BOOK_FLIGHT"> <row ... > ... </row> ... <row ... > ... </row> </BOOK_FLIGHT:CONNINFO>
_TABLE
. The type name of the table row element in the RFC name corresponds to the name of the record meta data object which defines the row structure of the table, as in the following example:
<xs:schema targetNamespace="http://sap.fusesource.org/rfc/nplServer/BOOK_FLIGHT"> xmlns:xs="http://www.w3.org/2001/XMLSchema"> ... <xs:complextType name="CONNECTION_INFO_STRUCTURE_TABLE”> <xs:sequence> <xs:element name="row” minOccures="0” maxOccurs="unbounded” type="CONNECTION_INFO_STRUCTURE”/> ... <xs:sequence> </xs:sequence> </xs:complexType> <xs:complextType name="CONNECTION_INFO_STRUCTURE”> ... </xs:complexType> ... </xs:schema>
Elementary fields
<?xml version="1.0" encoding="ASCII"?> <BOOK_FLIGHT:Request xmlns:BOOK_FLIGHT="http://sap.fusesource.org/rfc/nplServer/BOOK_FLIGHT" CUSTNAME="James Legrand" PASSFORM="Mr" PASSNAME="Travelin Joe" PASSBIRTH="1990-03-17T00:00:00.000-0500" FLIGHTDATE="2014-03-19T00:00:00.000-0400" TRAVELAGENCYNUMBER="00000110" DESTINATION_FROM="SFO" DESTINATION_TO="FRA"/>
Date and time formats
yyyy-MM-dd'T'HH:mm:ss.SSSZ
DEPDATE="2014-03-19T00:00:00.000-0400"
DEPTIME="1970-01-01T16:00:00.000-0500"
123.7. XML Serialization for IDoc
Overview
XML namespace
http://sap.fusesource.org/idoc/repositoryName/idocType/idocTypeExtension/systemRelease/applicationRelease
repositoryName
(name of the remote SAP meta-data repository) and the idocType
(IDoc document type) are mandatory, but the other components of the namespace can be left blank. For example, you could have an XML namespace like the following:
http://sap.fusesource.org/idoc/MY_REPO/FLCUSTOMER_CREATEFROMDATA01///
Built-in type converter
Document
object or a DocumentList
object to and from a String
type.
Document
object to an XML string, you can simply add the following line to a route in XML DSL:
<convertBodyTo type="java.lang.String"/>
Document
object. For example, given that the current message body is a serialized XML string, you can convert it back into a Document
object by adding the following line to a route in XML DSL:
<convertBodyTo type="org.fusesource.camel.component.sap.model.idoc.Document"/>
Sample IDoc message body in XML format
String
, it is serialized into an XML document, where the root element is either idoc:Document
(for a single document) or idoc:DocumentList
(for a list of documents). Example 123.2, “IDoc Message Body in XML” shows a single IDoc document that has been serialized to an idoc:Document
element.
Example 123.2. IDoc Message Body in XML
<?xml version="1.0" encoding="ASCII"?> <idoc:Document xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:FLCUSTOMER_CREATEFROMDATA01---="http://sap.fusesource.org/idoc/XXX/FLCUSTOMER_CREATEFROMDATA01///" xmlns:idoc="http://sap.fusesource.org/idoc" creationDate="2015-01-28T12:39:13.980-0500" creationTime="2015-01-28T12:39:13.980-0500" iDocType="FLCUSTOMER_CREATEFROMDATA01" iDocTypeExtension="" messageType="FLCUSTOMER_CREATEFROMDATA" recipientPartnerNumber="QUICKCLNT" recipientPartnerType="LS" senderPartnerNumber="QUICKSTART" senderPartnerType="LS"> <rootSegment xsi:type="FLCUSTOMER_CREATEFROMDATA01---:ROOT" document="/"> <segmentChildren parent="//@rootSegment"> <E1SCU_CRE parent="//@rootSegment" document="/"> <segmentChildren parent="//@rootSegment/@segmentChildren/@E1SCU_CRE.0"> <E1BPSCUNEW parent="//@rootSegment/@segmentChildren/@E1SCU_CRE.0" document="/" CUSTNAME="Fred Flintstone" FORM="Mr." STREET="123 Rubble Lane" POSTCODE="01234" CITY="Bedrock" COUNTR="US" PHONE="800-555-1212" EMAIL="fred@bedrock.com" CUSTTYPE="P" DISCOUNT="005" LANGU="E"/> </segmentChildren> </E1SCU_CRE> </segmentChildren> </rootSegment> </idoc:Document>
123.8. Example 1: Reading Data from SAP
Overview
FlightCustomer
business object data from SAP. The route invokes the FlightCustomer
BAPI method, BAPI_FLCUST_GETLIST
, using an SAP synchronous RFC destination endpoint to retrieve the data.
Java DSL for route
from("direct:getFlightCustomerInfo") .to("bean:createFlightCustomerGetListRequest") .to("sap-srfc-destination:nplDest:BAPI_FLCUST_GETLIST") .to("bean:returnFlightCustomerInfo");
XML DSL for route
<route> <from uri="direct:getFlightCustomerInfo"/> <to uri="bean:createFlightCustomerGetListRequest"/> <to uri="sap-srfc-destination:nplDest:BAPI_FLCUST_GETLIST"/> <to uri="bean:returnFlightCustomerInfo"/> </route>
createFlightCustomerGetListRequest bean
createFlightCustomerGetListRequest
bean is responsible for building an SAP request object in its exchange method that is used in the RFC call of the subsequent SAP endpoint . The following code snippet demonstrates the sequence of operations to build the request object:
public void create(Exchange exchange) throws Exception { // Get SAP Endpoint to be called from context. SAPEndpoint endpoint = exchange.getContext().getEndpoint("bean:returnFlightCustomerInfo", SAPEndpoint.class); // Retrieve bean from message containing Flight Customer name to // look up. BookFlightRequest bookFlightRequest = exchange.getIn().getBody(BookFlightRequest.class); // Create SAP Request object from target endpoint. Structure request = endpoint.getRequest(); // Add Customer Name to request if set if (bookFlightRequest.getCustomerName() != null && bookFlightRequest.getCustomerName().length() > 0) { request.put("CUSTOMER_NAME", bookFlightRequest.getCustomerName()); } } else { throw new Exception("No Customer Name"); } // Put request object into body of exchange message. exchange.getIn().setBody(request); }
returnFlightCustomerInfo bean
returnFlightCustomerInfo
bean is responsible for extracting data from the SAP response object in its exchange method that it receives from the previous SAP endpoint . The following code snippet demonstrates the sequence of operations to extract the data from the response object:
public void createFlightCustomerInfo(Exchange exchange) throws Exception { // Retrieve SAP response object from body of exchange message. Structure flightCustomerGetListResponse = exchange.getIn().getBody(Structure.class); if (flightCustomerGetListResponse == null) { throw new Exception("No Flight Customer Get List Response"); } // Check BAPI return parameter for errors @SuppressWarnings("unchecked") Table<Structure> bapiReturn = flightCustomerGetListResponse.get("RETURN", Table.class); Structure bapiReturnEntry = bapiReturn.get(0); if (bapiReturnEntry.get("TYPE", String.class) != "S") { String message = bapiReturnEntry.get("MESSAGE", String.class); throw new Exception("BAPI call failed: " + message); } // Get customer list table from response object. @SuppressWarnings("unchecked") Table<? extends Structure> customerList = flightCustomerGetListResponse.get("CUSTOMER_LIST", Table.class); if (customerList == null || customerList.size() == 0) { throw new Exception("No Customer Info."); } // Get Flight Customer data from first row of table. Structure customer = customerList.get(0); // Create bean to hold Flight Customer data. FlightCustomerInfo flightCustomerInfo = new FlightCustomerInfo(); // Get customer id from Flight Customer data and add to bean. String customerId = customer.get("CUSTOMERID", String.class); if (customerId != null) { flightCustomerInfo.setCustomerNumber(customerId); } ... // Put bean into body of exchange message. exchange.getIn().setHeader("flightCustomerInfo", flightCustomerInfo); }
123.9. Example 2: Writing Data to SAP
Overview
FlightTrip
business object instance in SAP. The route invokes the FlightTrip
BAPI method, BAPI_FLTRIP_CREATE
, using a destination endpoint to create the object.
Java DSL for route
from("direct:createFlightTrip") .to("bean:createFlightTripRequest") .to("sap-srfc-destination:nplDest:BAPI_FLTRIP_GETLIST?transacted=true") .to("bean:returnFlightTripResponse");
XML DSL for route
<route> <from uri="direct:createFlightTrip"/> <to uri="bean:createFlightTripRequest"/> <to uri="sap-srfc-destination:nplDest:BAPI_FLTRIP_GETLIST?transacted=true"/> <to uri="bean:returnFlightTripResponse"/> </route>
Transaction support
transacted
option set to true
. As discussed in Section 123.5, “Transaction Support”, when this option is enabled the endpoint ensures that an SAP transaction session has been initiated before invoking the RFC call. Because this endpoint’s RFC creates new data in SAP, this options is necessary to make the route's changes permanent in SAP.
Populating request parameters
createFlightTripRequest
and returnFlightTripResponse
beans are responsible for populating request parameters into the SAP request and extracting response parameters from the SAP response respectively following the same sequence of operations as demonstrated in the previous example.
123.10. Example 3: Handling Requests from SAP
Overview
BOOK_FLIGHT
RFC, which is implemented by the route. In addition, it demonstrates the component's XML serialization support, using JAXB to unmarshal and marshal SAP request objects and response objects to custom beans.
FlightTrip
business object on behalf of a travel agent, FlightCustomer
. The route first unmarshals the SAP request object received by the SAP server endpoint into a custom JAXB bean. This custom bean is then multicasted in the exchange to three sub-routes, which gather the travel agent, flight connection and passenger information required to create the flight trip. The final sub-route creates the flight trip object in SAP as demonstrated in the previous example. The final sub-route also creates and returns a custom JAXB bean which is marshaled into an SAP response object and returned by the server endpoint.
Java DSL for route
DataFormat jaxb = new JaxbDataFormat("org.fusesource.sap.example.jaxb"); from("sap-srfc-server:nplserver:BOOK_FLIGHT") .unmarshal(jaxb) .multicast() .to("direct:getFlightConnectionInfo", "direct:getFlightCustomerInfo", "direct:getPassengerInfo") .end() .to("direct:createFlightTrip") .marshal(jaxb);
XML DSL for route
<route> <from uri="sap-srfc-server:nplserver:BOOK_FLIGHT"/> <unmarshal> <jaxb contextPath="org.fusesource.sap.example.jaxb"/> </unmarshal> <multicast> <to uri="direct:getFlightConnectionInfo"/> <to uri="direct:getFlightCustomerInfo"/> <to uri="direct:getPassengerInfo"/> </multicast> <to uri="direct:createFlightTrip"/> <marshal> <jaxb contextPath="org.fusesource.sap.example.jaxb"/> </marshal> </route>
BookFlightRequest bean
BOOK_FLIGHT
request object:
@XmlRootElement(name="Request", namespace="http://sap.fusesource.org/rfc/nplServer/BOOK_FLIGHT") @XmlAccessorType(XmlAccessType.FIELD) public class BookFlightRequest { @XmlAttribute(name="CUSTNAME") private String customerName; @XmlAttribute(name="FLIGHTDATE") @XmlJavaTypeAdapter(DateAdapter.class) private Date flightDate; @XmlAttribute(name="TRAVELAGENCYNUMBER") private String travelAgencyNumber; @XmlAttribute(name="DESTINATION_FROM") private String startAirportCode; @XmlAttribute(name="DESTINATION_TO") private String endAirportCode; @XmlAttribute(name="PASSFORM") private String passengerFormOfAddress; @XmlAttribute(name="PASSNAME") private String passengerName; @XmlAttribute(name="PASSBIRTH") @XmlJavaTypeAdapter(DateAdapter.class) private Date passengerDateOfBirth; @XmlAttribute(name="CLASS") private String flightClass; ... }
BookFlightResponse bean
BOOK_FLIGHT
response object:
@XmlRootElement(name="Response", namespace="http://sap.fusesource.org/rfc/nplServer/BOOK_FLIGHT") @XmlAccessorType(XmlAccessType.FIELD) public class BookFlightResponse { @XmlAttribute(name="TRIPNUMBER") private String tripNumber; @XmlAttribute(name="TICKET_PRICE") private BigDecimal ticketPrice; @XmlAttribute(name="TICKET_TAX") private BigDecimal ticketTax; @XmlAttribute(name="CURRENCY") private String currency; @XmlAttribute(name="PASSFORM") private String passengerFormOfAddress; @XmlAttribute(name="PASSNAME") private String passengerName; @XmlAttribute(name="PASSBIRTH") @XmlJavaTypeAdapter(DateAdapter.class) private Date passengerDateOfBirth; @XmlElement(name="FLTINFO") private FlightInfo flightInfo; @XmlElement(name="CONNINFO") private ConnectionInfoTable connectionInfo; ... }
FlightInfo bean
FLTINFO
:
@XmlRootElement(name="FLTINFO", namespace="http://sap.fusesource.org/rfc/nplServer/BOOK_FLIGHT") @XmlAccessorType(XmlAccessType.FIELD) public class FlightInfo { @XmlAttribute(name="FLIGHTTIME") private String flightTime; @XmlAttribute(name="CITYFROM") private String cityFrom; @XmlAttribute(name="DEPDATE") @XmlJavaTypeAdapter(DateAdapter.class) private Date departureDate; @XmlAttribute(name="DEPTIME") @XmlJavaTypeAdapter(DateAdapter.class) private Date departureTime; @XmlAttribute(name="CITYTO") private String cityTo; @XmlAttribute(name="ARRDATE") @XmlJavaTypeAdapter(DateAdapter.class) private Date arrivalDate; @XmlAttribute(name="ARRTIME") @XmlJavaTypeAdapter(DateAdapter.class) private Date arrivalTime; ... }
ConnectionInfoTable bean
CONNINFO
. Note that the name of the root element type of the JAXB bean corresponds to the name of the row structure type suffixed with _TABLE
and the bean contains a list of row elements.
@XmlRootElement(name="CONNINFO_TABLE", namespace="http://sap.fusesource.org/rfc/nplServer/BOOK_FLIGHT") @XmlAccessorType(XmlAccessType.FIELD) public class ConnectionInfoTable { @XmlElement(name="row") List<ConnectionInfo> rows; ... }
ConnectionInfo bean
@XmlRootElement(name="CONNINFO", namespace="http://sap.fusesource.org/rfc/nplServer/BOOK_FLIGHT") @XmlAccessorType(XmlAccessType.FIELD) public class ConnectionInfo { @XmlAttribute(name="CONNID") String connectionId; @XmlAttribute(name="AIRLINE") String airline; @XmlAttribute(name="PLANETYPE") String planeType; @XmlAttribute(name="CITYFROM") String cityFrom; @XmlAttribute(name="DEPDATE") @XmlJavaTypeAdapter(DateAdapter.class) Date departureDate; @XmlAttribute(name="DEPTIME") @XmlJavaTypeAdapter(DateAdapter.class) Date departureTime; @XmlAttribute(name="CITYTO") String cityTo; @XmlAttribute(name="ARRDATE") @XmlJavaTypeAdapter(DateAdapter.class) Date arrivalDate; @XmlAttribute(name="ARRTIME") @XmlJavaTypeAdapter(DateAdapter.class) Date arrivalTime; ... }
Chapter 124. SAP NetWeaver
SAP NetWeaver Gateway component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-sap-netweaver</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
sap-netweaver:https://host:8080/path?username=foo&password=secret
?option=value&option=value&...
Prerequisites
Component and endpoint options
Name | Default Value | Description |
---|---|---|
username
|
Username for account. This is mandatory. | |
password
|
Password for account. This is mandatory. | |
json
|
true
|
Whether to return data in JSON format. If this option is false, then XML is returned in Atom format. |
jsonAsMap
|
true
|
To transform the JSON from a String to a Map in the message body. |
flatternMap
|
true
|
If the JSON Map contains only a single entry, then flattern by storing that single entry value as the message body. |
Message Headers
Name | Type | Description |
---|---|---|
CamelNetWeaverCommand
|
String
|
Mandatory: The command to execute in MS ADO.Net Data Service format. |
Examples
https://sapes1.sapdevcenter.com/sap/opu/odata/IWBEP/RMTSAMPLEFLIGHT_2/
FlightCollection(AirLineID='AA',FlightConnectionID='0017',FlightDate=datetime'2012-08-29T00%3A00%3A00')
from("direct:start") .toF("sap-netweaver:%s?username=%s&password=%s", url, username, password) .to("log:response") .to("velocity:flight-info.vm")
private String username = "P1909969254"; private String password = "TODO"; private String url = "https://sapes1.sapdevcenter.com/sap/opu/odata/IWBEP/RMTSAMPLEFLIGHT_2/"; private String command = "FlightCollection(AirLineID='AA',FlightConnectionID='0017',FlightDate=datetime'2012-08-29T00%3A00%3A00')";
<html> <body> Flight information: <p/> <br/>Airline ID: $body["AirLineID"] <br/>Aircraft Type: $body["AirCraftType"] <br/>Departure city: $body["FlightDetails"]["DepartureCity"] <br/>Departure airport: $body["FlightDetails"]["DepartureAirPort"] <br/>Destination city: $body["FlightDetails"]["DestinationCity"] <br/>Destination airport: $body["FlightDetails"]["DestinationAirPort"] </body> </html>
Flight information: Airline ID: AA Aircraft Type: 747-400 Departure city: new york Departure airport: JFK Destination city: SAN FRANCISCO Destination airport: SFO
Chapter 125. Scheduler
Scheduler component
ScheduledExecutorService
. Where as the timer uses a JDK Timer
.
URI format
scheduler:name[?options]
name
is the name of the scheduler, which is created and shared across endpoints. So if you use the same name for all your timer endpoints, only one scheduler thread pool and thread will be used - but you can configure the thread pool to allow more concurrent threads.
?option=value&option=value&...
null
. So exchange.getIn().getBody()
returns null
.
Options
Name
|
Default Value
|
Description
|
---|---|---|
initialDelay
|
1000
|
Milliseconds before the first poll starts |
period
|
1000
|
If greater than 0, generate periodic events every
period milliseconds.
|
delay
|
500
|
Milliseconds before the next poll
|
timeUnit
|
MILLISECONDS
|
time unit for initialDelay and delay options.
|
useFixedDelay
|
true
|
Controls if fixed delay or fixed rate is used. See ScheduledExecutorService in JDK for details. |
pollStrategy
|
A pluggable org.apache.camel.PollingConsumerPollingStrategy allowing you to provide your custom implementation to control error handling usually occurred during the poll operation before an Exchange have been created and being routed in Camel. In other words the error occurred while the polling was gathering information, for instance access to a file network failed so Camel cannot access it to scan for files. The default implementation will log the caused exception at WARN level and ignore it.
|
|
runLoggingLevel
|
TRACE
|
The consumer logs a start/complete log line when it polls. This option allows you to configure the logging level for that. |
sendEmptyMessageWhenIdle
|
false
|
If the polling consumer did not poll any files, you can enable this option to send an empty message (no body) instead. |
greedy
|
false
|
If greedy is enabled, then the ScheduledPollConsumer will run immediately again, if the previous run polled 1 or more messages. |
scheduler
|
Allow to plugin a custom org.apache.camel.spi.ScheduledPollConsumerScheduler to use as the scheduler for firing when the polling consumer runs. The default implementation uses theScheduledExecutorService and there is a Quartz2, and Spring based which supports CRON expressions. Notice: If using a custom scheduler then the options for initialDelay , useFixedDelay , timeUnit , andscheduledExecutorService may not be in use. Use the text quartz2 to refer to use the Quartz2 scheduler; and use the text spring to use the Spring based; and use the text #myScheduler to refer to a custom scheduler by its id in the Registry. See Quartz2 page for an example.
|
|
schedulerProperties.xxx
|
To configure additional properties when using a custom scheduler or any of the Quartz2, Spring based scheduler.
|
|
backoffMultiplier
|
0
|
To let the scheduled polling consumer backoff if there has been a number of subsequent idles/errors in a row. The multiplier is then the number of polls that will be skipped before the next actual attempt is happening again. When this option is in use then backoffIdleThreshold and/or backoffErrorThreshold must also be configured.
|
backoffIdleThreshold
|
0
|
The number of subsequent idle polls that should happen before the backoffMultipler should kick-in
|
backoffErrorThreshold
|
0
|
The number of subsequent error polls (failed due some error) that should happen before the backoffMultipler should kick-in.
|
More information
Exchange Properties
Exchange
:
Name
|
Type
|
Description
|
---|---|---|
Exchange.TIMER_NAME
|
String
|
The value of the
name option.
|
Exchange.TIMER_FIRED_TIME
|
Date
|
The time when the consumer fired.
|
Sample
from("scheduler://foo?period=60s").to("bean:myBean?method=someMethodName");
someMethodName
method on the bean called myBean
in the Registry such as JNDI or Spring.
<route> <from uri="scheduler://foo?period=60s"/> <to uri="bean:myBean?method=someMethodName"/> </route>
Forcing the scheduler to trigger immediately when completed
Forcing the scheduler to be idle
Exchange.SCHEDULER_POLLED_MESSAGES
to a boolean value of false. This will cause the consumer to indicate that there was no messages polled.
Chapter 126. Schematron
Schematron Component
URI format
schematron://path?[options]
URI options
Name
|
Default value
|
Description
|
path
|
mandatory
|
The path to the schematron rules file. Can either be in class path or location in the file system.
|
abort
|
false
|
flag to abort the route and throw a schematron validation exception.
|
Headers
Name
|
Description
|
Type
|
In/Out
|
CamelSchematronValidationStatus
|
The schematron validation status: SUCCESS / FAILED
|
String
|
IN
|
CamelSchematronValidationReport
|
The schematrion report body in XML format. See an example below
|
String
|
IN
|
URI and path syntax
from("direct:start").to("schematron://sch/schematron.sch").to("mock:result")
<route> <from uri="direct:start" /> <to uri="schematron:///usr/local/sch/schematron.sch" /> <log message="Schematron validation status: ${in.header.CamelSchematronValidationStatus}" /> <choice> <when> <simple>${in.header.CamelSchematronValidationStatus} == 'SUCCESS'</simple> <to uri="mock:success" /> </when> <otherwise> <log message="Failed schematron validation" /> <setBody> <header>CamelSchematronValidationReport</header> </setBody> <to uri="mock:failure" /> </otherwise> </choice> </route>
Schematron rules and report samples
<?xml version="1.0" encoding="UTF-8"?> <schema xmlns="http://purl.oclc.org/dsdl/schematron"> <title>Check Sections 12/07</title> <pattern id="section-check"> <rule context="section"> <assert test="title">This section has no title</assert> <assert test="para">This section has no paragraphs</assert> </rule> </pattern> </schema>
<?xml version="1.0" encoding="UTF-8"?> <svrl:schematron-output xmlns:svrl="http://purl.oclc.org/dsdl/svrl" xmlns:iso="http://purl.oclc.org/dsdl/schematron" xmlns:saxon="http://saxon.sf.net/" xmlns:schold="http://www.ascc.net/xml/schematron" xmlns:xhtml="http://www.w3.org/1999/xhtml" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsd="http://www.w3.org/2001/XMLSchema" schemaVersion="" title=""> <svrl:active-pattern document="" /> <svrl:fired-rule context="chapter" /> <svrl:failed-assert test="title" location="/doc[1]/chapter[1]"> <svrl:text>A chapter should have a title</svrl:text> </svrl:failed-assert> <svrl:fired-rule context="chapter" /> <svrl:failed-assert test="title" location="/doc[1]/chapter[2]"> <svrl:text>A chapter should have a title</svrl:text> </svrl:failed-assert> <svrl:fired-rule context="chapter" /> </svrl:schematron-output>
- Introduction to Schematron by Mulleberry technologies. An excellent document in PDF to get you started on Schematron.
- Schematron official site. This contains links to other resources
Chapter 127. SEDA
SEDA Component
CamelContext
instances (for example, communicating between Web applications), see the VM component.
URI format
seda:queueName[?options]
queueName
can be any string that uniquely identifies the endpoint within the current CamelContext.
?option=value&option=value&...
queueName
is considered and any option settings are ignored. That is, the identity of a consumer endpoint depends only on the queueName
. If you want to attach multiple consumers to the same queue, use the approach described in the section called “Using multipleConsumers”.
Options
Name | Default | Description |
---|---|---|
size
|
Unbounded | The maximum capacity of the SEDA queue (i.e., the number of messages it can hold). Notice: Mind if you use this option, then its the first endpoint being created with the queue name, that determines the size. To make sure all endpoints use same size, then configure the size option on all of them, or the first endpoint being created. From Camel 2.11 onwards, a validation is taken place to ensure if using mixed queue sizes for the same queue name, Camel would detect this and fail creating the endpoint. |
concurrentConsumers
|
1
|
Apache Camel 1.6.1/2.0: Number of concurrent threads processing exchanges. |
waitForTaskToComplete
|
IfReplyExpected
|
Option to specify whether the caller should wait for the async task to complete or not before continuing. The following three options are supported: Always , Never or IfReplyExpected . The first two values are self-explanatory. The last value, IfReplyExpected , will only wait if the message is Request Reply based. The default option is IfReplyExpected . See more information about Async messaging.
|
timeout
|
30000
|
Apache Camel 2.0: Timeout in millis a seda producer will at most waiting for an async task to complete. See waitForTaskToComplete and Async for more details. In Camel 2.2 you can now disable timeout by using 0 or a negative value.
|
multipleConsumers
|
false
|
Camel 2.2: Specifies whether multiple consumers are allowed or not. If enabled, you can use SEDA for a publish/subscribe style of messaging. Send a message to a SEDA queue and have multiple consumers receive a copy of the message. |
limitConcurrentConsumers
|
true
|
Camel 2.3: Whether to limit the concurrentConsumers to maximum 500. If its configured with a higher number an exception will be thrown. You can disable this check by turning this option off. |
blockWhenFull
|
false
|
Whether a thread that sends messages to a full SEDA queue will block until the queue's capacity is no longer exhausted. By default, an exception will be thrown stating that the queue is full. By enabling this option, the calling thread will instead block and wait until the message can be accepted. |
queueSize
|
Component only: The maximum default size (capacity of the number of messages it can hold) of the SEDA queue. This option is used if size is not in use.
|
|
pollTimeout
|
1000
|
Consumer only -- The timeout used when polling. 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. |
purgeWhenStopping
|
false
|
Whether to purge the task queue when stopping the consumer/route. This allows to stop faster, as any pending messages on the queue is discarded. |
queue
|
null
|
Define the queue instance which will be used by seda endpoint |
queueFactory
|
null
|
Define the QueueFactory which could create the queue for the seda endpoint |
failIfNoConsumers
|
false
|
Whether the producer should fail by throwing an exception, when sending to a SEDA queue with no active consumers. |
Choosing BlockingQueue implementation
<bean id="arrayQueue" class="java.util.ArrayBlockingQueue"> <constructor-arg index="0" value="10" ><!-- size --> <constructor-arg index="1" value="true" ><!-- fairness --> </bean> <!-- ... and later --> <from>seda:array?queue=#arrayQueue</from>
<bean id="priorityQueueFactory" class="org.apache.camel.component.seda.PriorityBlockingQueueFactory"> <property name="comparator"> <bean class="org.apache.camel.demo.MyExchangeComparator" /> </property> </bean> <!-- ... and later --> <from>seda:priority?queueFactory=#priorityQueueFactory&size=100</from>
Use of Request Reply
from("mina:tcp://0.0.0.0:9876?textline=true&sync=true").to("seda:input"); from("seda:input").to("bean:processInput").to("bean:createResponse");
seda:input
queue. As it is a Request Reply message, we wait for the response. When the consumer on the seda:input
queue is complete, it copies the response to the original message response.
Concurrent consumers
from("seda:stageName?concurrentConsumers=5").process(...)
Difference between thread pools and concurrent consumers
Thread pools
from("seda:stageName").thread(5).process(...)
BlockQueues
: one from the SEDA endpoint, and one from the workqueue of the thread pool, which may not be what you want. Instead, you might want to consider configuring a Direct endpoint with a thread pool, which can process messages both synchronously and asynchronously. For example:
from("direct:stageName").thread(5).process(...)
concurrentConsumers
option.
Sample
public void configure() throws Exception { from("direct:start") // send it to the seda queue that is async .to("seda:next") // return a constant response .transform(constant("OK")); from("seda:next").to("mock:result"); }
Object out = template.requestBody("direct:start", "Hello World"); assertEquals("OK", out);
mock
endpoint where we can do assertions in the unit test.
Using multipleConsumers
<!-- define the consumers as spring beans --> <bean id="consumer1" class="org.apache.camel.spring.example.FooEventConsumer"/> <bean id="consumer2" class="org.apache.camel.spring.example.AnotherFooEventConsumer"/> <camelContext xmlns="http://camel.apache.org/schema/spring"> <!-- define a shared endpoint which the consumers can refer to instead of using url --> <endpoint id="foo" uri="seda:foo?multipleConsumers=true"/> </camelContext>
public class FooEventConsumer { @EndpointInject(uri = "mock:result") private ProducerTemplate destination; @Consume(ref = "foo") public void doSomething(String body) { destination.sendBody("foo" + body); } }
Extracting queue information.
SedaEndpoint seda = context.getEndpoint("seda:xxxx"); int size = seda.getExchanges().size()
Chapter 128. SERVLET
Servlet Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-servlet</artifactId> <version>x.x.x</version> <\!-\- use the same version as your Camel core version \--> </dependency>
URI format
servlet://relative_path[?options]
?option=value&option=value&...
Options
Name | Default Value | Description |
---|---|---|
httpBindingRef
|
null
|
Reference to an org.apache.camel.component.http.HttpBinding in the Registry. A HttpBinding implementation can be used to customize how to write a response.
|
matchOnUriPrefix
|
false
|
Whether or not the CamelServlet should try to find a target consumer by matching the URI prefix, if no exact match is found.
|
servletName
|
CamelServlet
|
Specifies the servlet name that the servlet endpoint will bind to. If there is no servlet name specified, the servlet endpoint will be bind to first published Servlet. |
httpMethodRestrict
|
null
|
Camel 2.11: (Consumer only) Used to only allow consuming if the HttpMethod matches, such as GET /POST /PUT , and so on. From Camel 2.15 onwards, multiple methods can be specified, separated by a comma.
|
Message Headers
request.parameter
and request.headers
. For example, if a client request has the URL, http://myserver/myserver?orderid=123
, the exchange will contain a header named orderid
with the value 123.
Usage
Putting Camel JARs in the app server boot classpath
camel-core
, camel-servlet
, etc. in the boot classpath of your application server (eg usually in its lib directory), then mind that the servlet mapping list is now shared between multiple deployed Camel application in the app server.
web.xml
define:
<servlet> <servlet-name>MyServlet</servlet-name> <servlet-class>org.apache.camel.component.servlet.CamelHttpTransportServlet</servlet-class> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>MyServlet</servlet-name> <url-pattern>/*</url-pattern> </servlet-mapping>
<route> <from uri="servlet://foo?servletName=MyServlet"/> ... </route>
<servlet> <servlet-name>CamelServlet</servlet-name> <display-name>Camel Http Transport Servlet</display-name> <servlet-class>org.apache.camel.component.servlet.CamelHttpTransportServlet</servlet-class> <init-param> <param-name>ignoreDuplicateServletName</param-name> <param-value>true</param-value> </init-param> </servlet>
Sample
http://localhost:8080/camel/services/hello
. First, you need to publish the CamelHttpTransportServlet through the normal Web Container, or OSGi Service. Use the Web.xml
file to publish the CamelHttpTransportServlet as follows:
<web-app> <servlet> <servlet-name>CamelServlet</servlet-name> <display-name>Camel Http Transport Servlet</display-name> <servlet-class> org.apache.camel.component.servlet.CamelHttpTransportServlet </servlet-class> </servlet> <servlet-mapping> <servlet-name>CamelServlet</servlet-name> <url-pattern>/services/*</url-pattern> </servlet-mapping> </web-app>
from("servlet:///hello?matchOnUriPrefix=true").process(new Processor() { public void process(Exchange exchange) throws Exception { String contentType = exchange.getIn().getHeader(Exchange.CONTENT_TYPE, String.class); String path = exchange.getIn().getHeader(Exchange.HTTP_URI, String.class); path = path.substring(path.lastIndexOf("/")); assertEquals("Get a wrong content type", CONTENT_TYPE, contentType); // assert camel http header String charsetEncoding = exchange.getIn().getHeader(Exchange.HTTP_CHARACTER_ENCODING, String.class); assertEquals("Get a wrong charset name from the message heaer", "UTF-8", charsetEncoding); // assert exchange charset assertEquals("Get a wrong charset naem from the exchange property", "UTF-8", exchange.getProperty(Exchange.CHARSET_NAME)); exchange.getOut().setHeader(Exchange.CONTENT_TYPE, contentType + "; charset=UTF-8"); exchange.getOut().setHeader("PATH", path); exchange.getOut().setBody("<b>Hello World</b>"); } });
camel-servlet
endpoint uses the relative path to specify the endpoint's URL. A client can access the camel-servlet
endpoint through the servlet publish address: ("http://localhost:8080/camel/services") + RELATIVE_PATH("/hello")
.
Sample when using Spring 3.x
examples/camel-example-servlet-tomcat
directory. When deploying a Servlet component in the Web container, it is necessary to create a Spring application context explicitly by creating a Spring ContextLoaderListener
instance in the WEB-INF/web.xml
file.
camelContext
and route definitions) from the camel-config.xml
file, define a web.xml
file as follows:
<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"> <display-name>My Web Application</display-name> <!-- location of spring xml files --> <context-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:camel-config.xml</param-value> </context-param> <!-- the listener that kick-starts Spring --> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> <!-- Camel servlet --> <servlet> <servlet-name>CamelServlet</servlet-name> <servlet-class>org.apache.camel.component.servlet.CamelHttpTransportServlet</servlet-class> <load-on-startup>1</load-on-startup> </servlet> <!-- Camel servlet mapping --> <servlet-mapping> <servlet-name>CamelServlet</servlet-name> <url-pattern>/camel/*</url-pattern> </servlet-mapping> </web-app>
Sample when using Spring 2.x
ContextLoaderServlet
instead of ContextLoaderListener
. In that case you'll need to start ContextLoaderServlet
after CamelHttpTransportServlet like this:
<web-app> <servlet> <servlet-name>CamelServlet</servlet-name> <servlet-class> org.apache.camel.component.servlet.CamelHttpTransportServlet </servlet-class> <load-on-startup>1</load-on-startup> </servlet> <servlet> <servlet-name>SpringApplicationContext</servlet-name> <servlet-class> org.springframework.web.context.ContextLoaderServlet </servlet-class> <load-on-startup>2</load-on-startup> </servlet> <web-app>
Sample when using OSGi
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:osgi="http://www.springframework.org/schema/osgi" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/osgi http://www.springframework.org/schema/osgi/spring-osgi.xsd"> <bean id="camelServlet" class="org.apache.camel.component.servlet.CamelHttpTransportServlet"> </bean> <!-- Enlist it in OSGi service registry This will cause two things: 1) As the pax web whiteboard extender is running the CamelServlet will be registered with the OSGi HTTP Service 2) It will trigger the HttpRegistry in other bundles so the servlet is made known there too --> <osgi:service ref="camelServlet"> <osgi:interfaces> <value>javax.servlet.Servlet</value> <value>org.apache.camel.component.http.CamelServlet</value> </osgi:interfaces> <osgi:service-properties> <entry key="alias" value="/camel/services" /> <entry key="matchOnUriPrefix" value="true" /> <entry key="servlet-name" value="CamelServlet"/> </osgi:service-properties> </osgi:service> </beans>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:camel="http://camel.apache.org/schema/spring" xmlns:osgi="http://www.springframework.org/schema/osgi" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/osgi http://www.springframework.org/schema/osgi/spring-osgi.xsd http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd"> <osgi:reference id="servletref" interface="org.apache.camel.component.http.CamelServlet"> <osgi:listener bind-method="register" unbind-method="unregister"> <ref bean="httpRegistry"/> </osgi:listener> </osgi:reference> <bean id="httpRegistry" class="org.apache.camel.component.servlet.DefaultHttpRegistry"/> <bean id="servlet" class="org.apache.camel.component.servlet.ServletComponent"> <property name="httpRegistry" ref="httpRegistry" /> </bean> <bean id="servletProcessor" class="org.apache.camel.itest.osgi.servlet.ServletProcessor" /> <camelContext xmlns="http://camel.apache.org/schema/spring"> <route> <!-- notice how we can use the servlet scheme which is that osgi:reference above --> <from uri="servlet:///hello"/> <process ref="servletProcessor"/> </route> </camelContext> </beans>
Activator
to publish the CamelHttpTransportServlet on the OSGi platform
import java.util.Dictionary; import java.util.Hashtable; import org.apache.camel.component.servlet.CamelHttpTransportServlet; import org.osgi.framework.BundleActivator; import org.osgi.framework.BundleContext; import org.osgi.framework.ServiceReference; import org.osgi.service.http.HttpContext; import org.osgi.service.http.HttpService; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.osgi.context.BundleContextAware; public final class ServletActivator implements BundleActivator, BundleContextAware { private static final transient Logger LOG = LoggerFactory.getLogger(ServletActivator.class); private static boolean registerService; /** * HttpService reference. */ private ServiceReference httpServiceRef; /** * Called when the OSGi framework starts our bundle */ public void start(BundleContext bc) throws Exception { registerServlet(bc); } /** * Called when the OSGi framework stops our bundle */ public void stop(BundleContext bc) throws Exception { if (httpServiceRef != null) { bc.ungetService(httpServiceRef); httpServiceRef = null; } } protected void registerServlet(BundleContext bundleContext) throws Exception { httpServiceRef = bundleContext.getServiceReference(HttpService.class.getName()); if (httpServiceRef != null && !registerService) { LOG.info("Register the servlet service"); final HttpService httpService = (HttpService)bundleContext.getService(httpServiceRef); if (httpService != null) { // create a default context to share between registrations final HttpContext httpContext = httpService.createDefaultHttpContext(); // register the hello world servlet final Dictionary<String, String> initParams = new Hashtable<String, String>(); initParams.put("matchOnUriPrefix", "false"); initParams.put("servlet-name", "CamelServlet"); httpService.registerServlet("/camel/services", // alias new CamelHttpTransportServlet(), // register servlet initParams, // init params httpContext // http context ); registerService = true; } } } public void setBundleContext(BundleContext bc) { try { registerServlet(bc); } catch (Exception e) { LOG.error("Cannot register the servlet, the reason is " + e); } } }
Chapter 129. ServletListener Component
ServletListener Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-servletlistener</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
Using
org.apache.camel.component.servletlistener.CamelServletContextListener
.
JndiCamelServletContextListener
which uses theJndiRegistry
to leverage JNDI for its registry.SimpleCamelServletContextListener
which uses theSimpleRegistry
to leverage ajava.util.Map
as its registry.
org.apache.camel.component.servletlistener.CamelServletContextListener
in the WEB-INF/web.xml
file as shown below:
<web-app> <!-- the test parameter is only to be used for unit testing --> <!-- you should not use this option for production usage --> <context-param> <param-name>test</param-name> <param-value>true</param-value> </context-param> <!-- you can configure any of the properties on CamelContext, eg setName will be configured as below --> <context-param> <param-name>name</param-name> <param-value>MyCamel</param-value> </context-param> <!-- configure a route builder to use --> <!-- Camel will pickup any parameter names that start with routeBuilder (case ignored) --> <context-param> <param-name>routeBuilder-MyRoute</param-name> <param-value>org.apache.camel.component.servletlistener.MyRoute</param-value> </context-param> <!-- register Camel as a listener so we can bootstrap Camel when the web application starts --> <listener> <listener-class>org.apache.camel.component.servletlistener.SimpleCamelServletContextListener</listener-class> </listener> </web-app>
Options
org.apache.camel.component.servletlistener.CamelServletContextListener
supports the following options which can be configured as context-param in the web.xml file.
Option | Type | Description |
---|---|---|
propertyPlaceholder.XXX | To configure property placeholders in Camel. You should prefix the option with "propertyPlaceholder.", for example to configure the location, use propertyPlaceholder.location as name. You can configure all the options from the Properties component. | |
jmx.XXX |
To configure JMX. You should prefix the option with "jmx.", for example to disable JMX, use jmx.disabled as name. You can configure all the options from org.apache.camel.spi.ManagementAgent . As well the options mentioned on the JMX page.
|
|
name |
String
|
To configure the name of the CamelContext. |
messageHistory |
Boolean
|
Camel 2.12.2: Whether to enable or disable Message History (enabled by default). |
streamCache |
Boolean
|
Whether to enable Stream Caching. |
trace |
Boolean
|
Whether to enable Tracer. |
delayer |
Long
|
To set a delay value for Delay Interceptor. |
handleFault |
Boolean
|
Whether to enable handle fault. |
errorHandlerRef |
String
|
Refers to a context scoped Error Handler to be used. |
autoStartup |
Boolean
|
Whether to start all routes when starting Camel. |
useMDCLogging |
Boolean
|
Whether to use MDC Logging. |
useBreadcrumb |
Boolean
|
Whether to use breadcrumb. |
managementNamePattern |
String
|
To set a custom naming pattern for JMX MBeans. |
threadNamePattern |
String
|
To set a custom naming pattern for threads. |
properties.XXX |
To set custom properties on CamelContext.getProperties . This is seldom in use.
|
|
routebuilder.XXX | To configure routes to be used. See below for more details. | |
CamelContextLifecycle |
Refers to a FQN classname of an implementation of org.apache.camel.component.servletlistener.CamelContextLifecycle . Which allows to execute custom code before and after CamelContext has been started or stopped. See below for further details.
|
|
XXX | To set any option on CamelContext. |
Examples
Configuring routes
Using a RouteBuilder class
<context-param> <param-name>routeBuilder-MyRoute</param-name> <param-value>org.apache.camel.component.servletlistener.MyRoute</param-value> </context-param>
<context-param> <param-name>routeBuilder-routes</param-name> <!-- we can define multiple values separated by comma --> <param-value> org.apache.camel.component.servletlistener.MyRoute, org.apache.camel.component.servletlistener.routes.BarRouteBuilder </param-value> </context-param>
Using package scanning
<context-param> <param-name>routeBuilder-MyRoute</param-name> <!-- define the routes using package scanning by prefixing with packagescan: --> <param-value>packagescan:org.apache.camel.component.servletlistener.routes</param-value> </context-param>
Using a XML file
<context-param> <param-name>routeBuilder-MyRoute</param-name> <param-value>classpath:routes/myRoutes.xml</param-value> </context-param>
<?xml version="1.0" encoding="UTF-8"?> <!-- the xmlns="http://camel.apache.org/schema/spring" is needed --> <routes xmlns="http://camel.apache.org/schema/spring"> <route id="foo"> <from uri="direct:foo"/> <to uri="mock:foo"/> </route> <route id="bar"> <from uri="direct:bar"/> <to uri="mock:bar"/> </route> </routes>
Configuring propert placeholders
myproperties.properties
from the classpath
<!-- setup property placeholder to load properties from classpath --> <!-- we do this by setting the param-name with propertyPlaceholder. as prefix and then any options such as location, cache etc --> <context-param> <param-name>propertyPlaceholder.location</param-name> <param-value>classpath:myproperties.properties</param-value> </context-param> <!-- for example to disable cache on properties component, you do --> <context-param> <param-name>propertyPlaceholder.cache</param-name> <param-value>false</param-value> </context-param>
Configuring JMX
<!-- configure JMX by using names that is prefixed with jmx. --> <!-- in this example we disable JMX --> <context-param> <param-name>jmx.disabled</param-name> <param-value>true</param-value> </context-param>
JNDI or Simple as Camel Registry
org.apache.camel.component.servletlistener.CamelContextLifecycle
.
Using custom CamelContextLifecycle
beforeStart
and afterStop
to enlist our custom bean in the Simple Registry, and as well to cleanup when we stop.
/** * Our custom {@link CamelContextLifecycle} which allows us to enlist beans in the {@link JndiContext} * so the Camel application can lookup the beans in the {@link org.apache.camel.spi.Registry}. * <p/> * We can of course also do other kind of custom logic as well. */ public class MyLifecycle implements CamelContextLifecycle<SimpleRegistry> { @Override public void beforeStart(ServletCamelContext camelContext, SimpleRegistry registry) throws Exception { // enlist our bean(s) in the registry registry.put("myBean", new HelloBean()); } @Override public void afterStart(ServletCamelContext camelContext, SimpleRegistry registry) throws Exception { // noop } @Override public void beforeStop(ServletCamelContext camelContext, SimpleRegistry registry) throws Exception { // noop } @Override public void afterStop(ServletCamelContext camelContext, SimpleRegistry registry) throws Exception { // unbind our bean when Camel has been stopped registry.remove("myBean"); } }
org.apache.camel.component.servletlistener.CamelContextLifecycle
interface.
<context-param> <param-name>CamelContextLifecycle</param-name> <param-value>org.apache.camel.component.servletlistener.MyLifecycle</param-value> </context-param>
public class MyBeanRoute extends RouteBuilder { @Override public void configure() throws Exception { from("seda:foo").routeId("foo") .to("bean:myBean") .to("mock:foo"); } }
org.apache.camel.component.servletlistener.JndiCamelServletContextListener
then the CamelContextLifecycle
must use the JndiRegistry
as well. And likewise if the servlet is org.apache.camel.component.servletlistener.SimpleCamelServletContextListener
then the CamelContextLifecycle
must use the SimpleRegistry
Chapter 130. Shiro Security
Shiro Security Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-shiro</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
Shiro Security Basics
[users] # user 'ringo' with password 'starr' and the 'sec-level1' role ringo = starr, sec-level1 george = harrison, sec-level2 john = lennon, sec-level3 paul = mccartney, sec-level3 [roles] # 'sec-level3' role has all permissions, indicated by the # wildcard '*' sec-level3 = * # The 'sec-level2' role can do anything with access of permission # readonly (*) to help sec-level2 = zone1:* # The 'sec-level1' role can do anything with access of permission # readonly sec-level1 = zone1:readonly:*
Instantiating a ShiroSecurityPolicy Object
private final String iniResourcePath = "classpath:shiro.ini"; private final byte[] passPhrase = { (byte) 0x08, (byte) 0x09, (byte) 0x0A, (byte) 0x0B, (byte) 0x0C, (byte) 0x0D, (byte) 0x0E, (byte) 0x0F, (byte) 0x10, (byte) 0x11, (byte) 0x12, (byte) 0x13, (byte) 0x14, (byte) 0x15, (byte) 0x16, (byte) 0x17}; List<permission> permissionsList = new ArrayList<permission>(); Permission permission = new WildcardPermission("zone1:readwrite:*"); permissionsList.add(permission); final ShiroSecurityPolicy securityPolicy = new ShiroSecurityPolicy(iniResourcePath, passPhrase, true, permissionsList);
ShiroSecurityPolicy Options
Name | Default Value | Type | Description |
---|---|---|---|
iniResourcePath or ini
|
none
|
Resource String or Ini Object | A mandatory Resource String for the iniResourcePath or an instance of an Ini object must be passed to the security policy. Resources can be acquired from the file system, classpath, or URLs when prefixed with "file:, classpath:, or url:" respectively. For e.g "classpath:shiro.ini" |
passPhrase
|
An AES 128 based key
|
byte[] | A passPhrase to decrypt ShiroSecurityToken(s) sent along with Message Exchanges |
alwaysReauthenticate
|
true
|
boolean | Setting to ensure re-authentication on every individual request. If set to false, the user is authenticated and locked such than only requests from the same user going forward are authenticated. |
permissionsList
|
none
|
List<Permission> | A List of permissions required in order for an authenticated user to be authorized to perform further action i.e continue further on the route. If no Permissions list is provided to the ShiroSecurityPolicy object, then authorization is deemed as not required |
cipherService
|
AES
|
org.apache.shiro.crypto.CipherService | Shiro ships with AES & Blowfish based CipherServices. You may use one these or pass in your own Cipher implementation |
base64
|
false
|
boolean
|
Camel 2.12: To use base64 encoding for the security token header, which allows transferring the header over JMS etc. This option must also be set on ShiroSecurityTokenInjector as well.
|
Applying Shiro Authentication on a Camel Route
protected RouteBuilder createRouteBuilder() throws Exception { final ShiroSecurityPolicy securityPolicy = new ShiroSecurityPolicy("classpath:shiro.ini", passPhrase); return new RouteBuilder() { public void configure() { onException(UnknownAccountException.class). to("mock:authenticationException"); onException(IncorrectCredentialsException.class). to("mock:authenticationException"); onException(LockedAccountException.class). to("mock:authenticationException"); onException(AuthenticationException.class). to("mock:authenticationException"); from("direct:secureEndpoint"). to("log:incoming payload"). policy(securityPolicy). to("mock:success"); } }; }
Applying Shiro Authorization on a Camel Route
protected RouteBuilder createRouteBuilder() throws Exception { final ShiroSecurityPolicy securityPolicy = new ShiroSecurityPolicy("./src/test/resources/securityconfig.ini", passPhrase); return new RouteBuilder() { public void configure() { onException(UnknownAccountException.class). to("mock:authenticationException"); onException(IncorrectCredentialsException.class). to("mock:authenticationException"); onException(LockedAccountException.class). to("mock:authenticationException"); onException(AuthenticationException.class). to("mock:authenticationException"); from("direct:secureEndpoint"). to("log:incoming payload"). policy(securityPolicy). to("mock:success"); } }; }
Creating a ShiroSecurityToken and injecting it into a Message Exchange
ShiroSecurityToken shiroSecurityToken = new ShiroSecurityToken("ringo", "starr"); ShiroSecurityTokenInjector shiroSecurityTokenInjector = new ShiroSecurityTokenInjector(shiroSecurityToken, passPhrase); from("direct:client"). process(shiroSecurityTokenInjector). to("direct:secureEndpoint");
Sending Messages to routes secured by a ShiroSecurityPolicy
@Test public void testSuccessfulShiroAuthenticationWithNoAuthorization() throws Exception { //Incorrect password ShiroSecurityToken shiroSecurityToken = new ShiroSecurityToken("ringo", "stirr"); // TestShiroSecurityTokenInjector extends ShiroSecurityTokenInjector TestShiroSecurityTokenInjector shiroSecurityTokenInjector = new TestShiroSecurityTokenInjector(shiroSecurityToken, passPhrase); successEndpoint.expectedMessageCount(1); failureEndpoint.expectedMessageCount(0); template.send("direct:secureEndpoint", shiroSecurityTokenInjector); successEndpoint.assertIsSatisfied(); failureEndpoint.assertIsSatisfied(); }
Sending Messages to routes secured by a ShiroSecurityPolicy (much easier from Camel 2.12 onwards)
Using ShiroSecurityToken
ShiroSecurityConstants.SHIRO_SECURITY_TOKEN
of the type org.apache.camel.component.shiro.security.ShiroSecurityToken
that contains the username and password. For example:
ShiroSecurityToken shiroSecurityToken = new ShiroSecurityToken("ringo", "starr"); template.sendBodyAndHeader("direct:secureEndpoint", "Beatle Mania", ShiroSecurityConstants.SHIRO_SECURITY_TOKEN, shiroSecurityToken);
Map<String, Object> headers = new HashMap<String, Object>(); headers.put(ShiroSecurityConstants.SHIRO_SECURITY_USERNAME, "ringo"); headers.put(ShiroSecurityConstants.SHIRO_SECURITY_PASSWORD, "starr"); template.sendBodyAndHeaders("direct:secureEndpoint", "Beatle Mania", headers);
ShiroSecurityToken
instance, of a base64 representation as a String (the latter is when you have set base64=true).
Chapter 131. Sip
SIP Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-sip</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
sip://johndoe@localhost:99999[?options] sips://johndoe@localhost:99999/[?options]
?option=value&option=value&...
Options
Name | Default Value | Description |
---|---|---|
stackName
|
NAME_NOT_SET
|
Name of the SIP Stack instance associated with an SIP Endpoint. |
transport
|
tcp
|
Setting for choice of transport potocol. Valid choices are "tcp" or "udp". |
fromUser
|
Username of the message originator. Mandatory setting unless a registry based custom FromHeader is specified. | |
fromHost
|
Hostname of the message originator. Mandatory setting unless a registry based FromHeader is specified | |
fromPort
|
Port of the message originator. Mandatory setting unless a registry based FromHeader is specified | |
toUser
|
Username of the message receiver. Mandatory setting unless a registry based custom ToHeader is specified. | |
toHost
|
Hostname of the message receiver. Mandatory setting unless a registry based ToHeader is specified | |
toPort
|
Portname of the message receiver. Mandatory setting unless a registry based ToHeader is specified | |
maxforwards
|
0 | the number of intermediaries that may forward the message to the message receiver. Optional setting. May alternatively be set using as registry based MaxForwardsHeader |
eventId
|
Setting for a String based event Id. Mandatory setting unless a registry based FromHeader is specified | |
eventHeaderName
|
Setting for a String based event Id. Mandatory setting unless a registry based FromHeader is specified | |
maxMessageSize
|
1048576
|
Setting for maximum allowed Message size in bytes. |
cacheConnections
|
false
|
Should connections be cached by the SipStack to reduce cost of connection creation. This is useful if the connection is used for long running conversations. |
consumer
|
false
|
This setting is used to determine whether the kind of header (FromHeader,ToHeader etc) that needs to be created for this endpoint |
automaticDialogSupport
|
off
|
Setting to specify whether every communication should be associated with a dialog. |
contentType
|
text
|
Setting for contentType can be set to any valid MimeType. |
contentSubType
|
xml
|
Setting for contentSubType can be set to any valid MimeSubType. |
receiveTimeoutMillis
|
10000
|
Setting for specifying amount of time to wait for a Response and/or Acknowledgement can be received from another SIP stack |
useRouterForAllUris
|
false
|
This setting is used when requests are sent to the Presence Agent via a proxy. |
msgExpiration
|
3600
|
The amount of time a message received at an endpoint is considered valid |
presenceAgent
|
false
|
This setting is used to distingish between a Presence Agent & a consumer. This is due to the fact that the SIP Camel component ships with a basic Presence Agent (for testing purposes only). Consumers have to set this flag to true. |
Registry based Options
Name | Description |
---|---|
fromHeader
|
a custom Header object containing message originator settings. Must implement the type javax.sip.header.FromHeader |
toHeader
|
a custom Header object containing message receiver settings. Must implement the type javax.sip.header.ToHeader |
viaHeaders
|
List of custom Header objects of the type javax.sip.header.ViaHeader. Each ViaHeader containing a proxy address for request forwarding. (Note this header is automatically updated by each proxy when the request arrives at its listener) |
contentTypeHeader
|
a custom Header object containing message content details. Must implement the type javax.sip.header.ContentTypeHeader |
callIdHeader
|
a custom Header object containing call details. Must implement the type javax.sip.header.CallIdHeader |
maxForwardsHeader
|
a custom Header object containing details on maximum proxy forwards. This header places a limit on the viaHeaders possible. Must implement the type javax.sip.header.MaxForwardsHeader |
eventHeader
|
a custom Header object containing event details. Must implement the type javax.sip.header.EventHeader |
contactHeader
|
an optional custom Header object containing verbose contact details (email, phone number etc). Must implement the type javax.sip.header.ContactHeader |
expiresHeader
|
a custom Header object containing message expiration details. Must implement the type javax.sip.header.ExpiresHeader |
extensionHeader
|
a custom Header object containing user/application specific details. Must implement the type javax.sip.header.ExtensionHeader |
Sending Messages to/from a SIP endpoint
Creating a Camel SIP Publisher
- using a SIP Stack named client
- using a registry based eventHeader called evtHdrName
- using a registry based eventId called evtId
- from a SIP Stack with Listener set up as user2@localhost:3534
- The Event being published is EVENT_A
- A Mandatory Header called REQUEST_METHOD is set to Request.Publish thereby setting up the endpoint as a Event publisher"
producerTemplate.sendBodyAndHeader( "sip://agent@localhost:5152?stackName=client&eventHeaderName=evtHdrName&eventId=evtid&fromUser=user2&fromHost=localhost&fromPort=3534", "EVENT_A", "REQUEST_METHOD", Request.PUBLISH);
Creating a Camel SIP Subscriber
- using a SIP Stack named Subscriber
- registering with a Presence Agent user called agent@localhost:5152
- using a registry based eventHeader called evtHdrName. The evtHdrName contains the Event which is se to "Event_A"
- using a registry based eventId called evtId
@Override protected RouteBuilder createRouteBuilder() throws Exception { return new RouteBuilder() { @Override public void configure() throws Exception { // Create PresenceAgent from("sip://agent@localhost:5152?stackName=PresenceAgent&presenceAgent=true&eventHeaderName=evtHdrName&eventId=evtid") .to("mock:neverland"); // Create Sip Consumer(Event Subscriber) from("sip://johndoe@localhost:5154?stackName=Subscriber&toUser=agent&toHost=localhost&toPort=5152&eventHeaderName=evtHdrName&eventId=evtid") .to("log:ReceivedEvent?level=DEBUG") .to("mock:notification"); } }; }
Chapter 132. SJMS
SJMS Component
- Standard Queue and Topic Support (Durable & Non-Durable)
- InOnly & InOut MEP Support
- Asynchronous Producer and Consumer Processing
- Internal JMS Transaction Support
- Plugable Connection Resource Management
- Session, Consumer, & Producer Pooling & Caching Management
- Batch Consumers and Producers
- Transacted Batch Consumers & Producers
- Support for Customizable Transaction Commit Strategies (Local JMS Transactions only)
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-sjms</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
sjms:[queue:|topic:]destinationName[?options]
destinationName
is a JMS queue or topic name. By default, the destinationName
is interpreted as a queue name. For example, to connect to the queue, FOO.BAR
use:
sjms:FOO.BAR
queue:
prefix, if you prefer:
sjms:queue:FOO.BAR
topic:
prefix. For example, to connect to the topic, Stocks.Prices
, use:
sjms:topic:Stocks.Prices
?option=value&option=value&...
Component Options and Configurations
Option | Required | Default Value | Description |
---|---|---|---|
connectionCount
|
1
|
The maximum number of connections available to endpoints started under this component | |
connectionFactory
|
(/) |
null
|
A ConnectionFactory is required to enable the SjmsComponent. It can be set directly or set set as part of a ConnectionResource. |
connectionResource
|
null
|
A ConnectionResource is an interface that allows for customization and container control of the ConnectionFactory. See Plugable Connection Resource Management for further details. | |
headerFilterStrategy
|
DefaultJmsKeyFormatStrategy
|
||
keyFormatStrategy
|
DefaultJmsKeyFormatStrategy
|
||
transactionCommitStrategy
|
null
|
||
DestinationCreationStrategy
|
DefaultDestinationCreationStrategy
|
Camel 2.15.0: Enables you to set a custom DestinationCreationStrategy on the SJMS Component.
|
SjmsComponent component = new SjmsComponent(); component.setConnectionFactory(new ActiveMQConnectionFactory("tcp://localhost:61616")); getContext().addComponent("sjms", component);
ConnectionFactoryResource connectionResource = new ConnectionFactoryResource(); connectionResource.setConnectionFactory(new ActiveMQConnectionFactory("tcp://localhost:61616")); connectionResource.setClientId("myclient-id"); SjmsComponent component = new SjmsComponent(); component.setConnectionResource(connectionResource); component.setMaxConnections(1);
Producer Configuration Options
Option | Default Value | Description |
---|---|---|
acknowledgementMode
|
AUTO_ACKNOWLEDGE
|
The JMS acknowledgement name, which is one of: SESSION_TRANSACTED , AUTO_ACKNOWLEDGE or DUPS_OK_ACKNOWLEDGE . CLIENT_ACKNOWLEDGE is not supported at this time.
|
consumerCount
|
1
|
InOut only. Defines the number of MessageListener instances that for response consumers. |
exchangePattern
|
InOnly
|
Sets the Producers message exchange pattern. |
namedReplyTo
|
null
|
InOut only. Specifies a named reply to destination for responses. |
persistent
|
true
|
Whether a message should be delivered with persistence enabled. |
producerCount
|
1
|
Defines the number of MessageProducer instances. |
responseTimeOut
|
5000
|
InOut only. Specifies the amount of time an InOut Producer will wait for its response. |
synchronous
|
true
|
Sets whether the Endpoint will use synchronous or asynchronous processing. |
transacted
|
false
|
If the endpoint should use a JMS Session transaction. |
ttl
|
-1
|
Disabled by default. Sets the Message time to live header. |
prefillPool
|
true
|
Camel 2.14: Whether to prefill the producer connection pool on startup, or create connections lazy when needed. |
allowNullBody
|
true
|
Camel 2.15.1: Whether to allow sending messages with no body. If false and the message body is null , a JMSException is thrown.
|
Producer Usage
InOnly Producer - (Default)
from("direct:start") .to("sjms:queue:bar");
InOut Producer
exchangePattern
attribute to the URI. By default it will use a dedicated TemporaryQueue for each consumer.
from("direct:start") .to("sjms:queue:bar?exchangePattern=InOut");
namedReplyTo
though which can provide a better monitor point.
from("direct:start") .to("sjms:queue:bar?exchangePattern=InOut&namedReplyTo=my.reply.to.queue");
Consumers Configuration Options
Option | Default Value | Description |
---|---|---|
acknowledgementMode
|
AUTO_ACKNOWLEDGE
|
The JMS acknowledgement name, which is one of: TRANSACTED , AUTO_ACKNOWLEDGE or DUPS_OK_ACKNOWLEDGE . CLIENT_ACKNOWLEDGE is not supported at this time.
|
consumerCount
|
1
|
Defines the number of MessageListener instances. |
durableSubscriptionId
|
null
|
Required for a durable subscriptions. |
exchangePattern
|
InOnly
|
Sets the Consumers message exchange pattern. |
messageSelector
|
null
|
Sets the message selector. |
synchronous
|
true
|
Sets whether the Endpoint will use synchronous or asynchronous processing. |
transacted
|
false
|
If the endpoint should use a JMS Session transaction. |
transactionBatchCount
|
1
|
The number of exchanges to process before committing a local JMS transaction. The transacted property must also be set to true or this property will be ignored.
|
transactionBatchTimeout
|
5000
|
The amount of time a the transaction will stay open between messages before committing what has already been consumed. Minimum value is 1000ms. |
ttl
|
\-1
|
Disabled by default. Sets the Message time to live header. |
Consumer Usage
InOnly Consumer - (Default)
from("sjms:queue:bar") .to("mock:result");
InOut Consumer
exchangePattern
attribute to the URI.
from("sjms:queue:in.out.test?exchangePattern=InOut") .transform(constant("Bye Camel"));
Advanced Usage Notes
Plugable Connection Resource Management
public class AMQConnectionResource implements ConnectionResource { private PooledConnectionFactory pcf; public AMQConnectionResource(String connectString, int maxConnections) { super(); pcf = new PooledConnectionFactory(connectString); pcf.setMaxConnections(maxConnections); pcf.start(); } public void stop() { pcf.stop(); } @Override public Connection borrowConnection() throws Exception { Connection answer = pcf.createConnection(); answer.start(); return answer; } @Override public Connection borrowConnection(long timeout) throws Exception { // SNIPPED... } @Override public void returnConnection(Connection connection) throws Exception { // Do nothing since there isn't a way to return a Connection // to the instance of PooledConnectionFactory log.info("Connection returned"); } }
CamelContext camelContext = new DefaultCamelContext(); AMQConnectionResource pool = new AMQConnectionResource("tcp://localhost:33333", 1); SjmsComponent component = new SjmsComponent(); component.setConnectionResource(pool); camelContext.addComponent("sjms", component);
Session, Consumer, and Producer Pooling and Caching Management
Batch Message Support
List<BatchMessage<String>> messages = new ArrayList<BatchMessage<String>>(); for (int i = 1; i <= messageCount; i++) { String body = "Hello World " + i; BatchMessage<String> message = new BatchMessage<String>(body, null); messages.add(message); }
template.sendBody("sjms:queue:batch.queue", messages);
Customizable Transaction Commit Strategies (Local JMS Transactions only)
Transacted Batch Consumers and Producers
transacted
parameter to true and then adding the transactionBatchCount
and setting it to any value that is greater than 0. For example the following configuration will commit the Session every 10 messages:
sjms:queue:transacted.batch.consumer?transacted=true&transactionBatchCount=10
transactionBatchTimeout
parameter.
sjms:queue:transacted.batch.consumer?transacted=true&transactionBatchCount=10&transactionBatchTimeout=2000
List<BatchMessage<String>> messages = new ArrayList<BatchMessage<String>>(); for (int i = 1; i <= messageCount; i++) { String body = "Hello World " + i; BatchMessage<String> message = new BatchMessage<String>(body, null); messages.add(message); }
template.sendBody("sjms:queue:batch.queue?transacted=true", messages);
Additional Notes
Message Header Format
- is replaced by DOT and the reverse replacement when Camel consumes the message.
- is replaced by HYPHEN and the reverse replacement when Camel consumes the message. See also the option jmsKeyFormatStrategy, which allows use of your own custom strategy for formatting keys.
Message Content
Clustering
Transaction Support
Does Springless Mean I Can't Use Spring?
<route id="inout.named.reply.to.producer.route"> <from uri="direct:invoke.named.reply.to.queue" /> <to uri="sjms:queue:named.reply.to.queue?namedReplyTo=my.response.queue&xchangePattern=InOut" /> </route>
Chapter 133. SMPP
SMPP Component
ReplaceSm
, QuerySm
, SubmitMulti
, CancelSm
and DataSm
.
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-smpp</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
SMS limitations
- Reliability: although the SMPP standard offers a range of feedback mechanisms to indicate errors, non-delivery and confirmation of delivery it is not uncommon for mobile networks to hide or simulate these responses. For example, some networks automatically send a delivery confirmation for every message even if the destination number is invalid or not switched on. Some networks silently drop messages if they think they are spam. Spam detection rules in the network may be very crude, sometimes more than 100 messages per day from a single sender may be considered spam.
- Security: there is basic encryption for the last hop from the radio tower down to the recipient handset. SMS messages are not encrypted or authenticated in any other part of the network. Some operators allow staff in retail outlets or call centres to browse through the SMS message histories of their customers. Message sender identity can be easily forged. Regulators and even the mobile telephone industry itself has cautioned against the use of SMS in two-factor authentication schemes and other purposes where security is important.
Data coding, alphabet and international character sets
- The data coding specified in a header,
- The alphabet specified in a header,
- The data coding specified in the endpoint configuration ( URI parameter).
String
cannot be represented in the chosen alphabet, they may be replaced by the question mark, ?
, symbol. Users of the API may want to consider checking if their message body can be converted to ISO-8859-1 before passing it to the component and if not, setting the alphabet header to request UCS-2 encoding. If the alphabet and data coding options are not specified at all then the component may try to detect the required encoding and set the data coding for you.
Message splitting and throttling
String
to a byte
array, the Camel component is also responsible for splitting the message into parts (within the 140 byte SMS size limit) before passing it to JSMPP. This is completed automatically.
URI format
smpp://[username@]hostname[:port][?options] smpps://[username@]hostname[:port][?options]
smppclient
. If no port number is provided, then Apache Camel will provide the default value 2775
.Camel 2.3: If the protocol name is smpps
, camel-smpp with try to use SSLSocket to init a connection to the server.
?option=value&option=value&...
URI Options
Name | Default Value | Description |
---|---|---|
password
|
password
|
Specifies the password to use to log in to the SMSC. |
systemType
|
cp
|
This parameter is used to categorize the type of ESME (External Short Message Entity) that is binding to the SMSC (max. 13 characters). |
dataCoding
|
0
|
Camel 2.11 Defines the data coding according the SMPP 3.4 specification, section 5.2.19. (Prior to Camel 2.9, this option is also supported.) Example data encodings are:
|
alphabet
|
0
|
Camel 2.5 Defines encoding of data according the SMPP 3.4 specification, section 5.2.19. This option is mapped to
Alphabet.java and used to create the byte[] which is send to the SMSC. Example alphabets are: 0 : SMSC Default Alphabet 4 : 8 bit Alphabet 8 : UCS2 Alphabet
|
encoding
|
ISO-8859-1
|
only for SubmitSm, ReplaceSm and SubmitMulti Defines the encoding scheme of the short message user data. |
enquireLinkTimer
|
5000
|
Defines the interval in milliseconds between the confidence checks. The confidence check is used to test the communication path between an ESME and an SMSC. |
transactionTimer
|
10000
|
Defines the maximum period of inactivity allowed after a transaction, after which an SMPP entity may assume that the session is no longer active. This timer may be active on either communicating SMPP entity (i.e. SMSC or ESME). |
initialReconnectDelay
|
5000
|
Defines the initial delay in milliseconds after the consumer/producer tries to reconnect to the SMSC, after the connection was lost. |
reconnectDelay
|
5000
|
Defines the interval in milliseconds between the reconnect attempts, if the connection to the SMSC was lost and the previous was not succeed. |
registeredDelivery
|
1
|
only for SubmitSm, ReplaceSm, SubmitMulti and DataSm Is used to request an SMSC delivery receipt and/or SME originated acknowledgements. The following values are defined:
0 : No SMSC delivery receipt requested. 1 : SMSC delivery receipt requested where final delivery outcome is success or failure. 2 : SMSC delivery receipt requested where the final delivery outcome is delivery failure.
|
serviceType
|
CMT
|
The service type parameter can be used to indicate the SMS Application service associated with the message. The following generic service_types are defined:
|
sourceAddr
|
1616
|
Defines the address of SME (Short Message Entity) which originated this message. |
destAddr
|
1717
|
only for SubmitSm, SubmitMulti, CancelSm and DataSm Defines the destination SME address. For mobile terminated messages, this is the directory number of the recipient MS. |
sourceAddrTon
|
0
|
Defines the type of number (TON) to be used in the SME originator address parameters. The following TON values are defined:
|
destAddrTon
|
0
|
only for SubmitSm, SubmitMulti, CancelSm and DataSm Defines the type of number (TON) to be used in the SME destination address parameters. The following TON values are defined:
|
sourceAddrNpi
|
0
|
Defines the numeric plan indicator (NPI) to be used in the SME originator address parameters. The following NPI values are defined:
|
destAddrNpi
|
0
|
only for SubmitSm, SubmitMulti, CancelSm and DataSm Defines the numeric plan indicator (NPI) to be used in the SME destination address parameters. The following NPI values are defined:
|
priorityFlag
|
1
|
only for SubmitSm and SubmitMulti Allows the originating SME to assign a priority level to the short message. Four Priority Levels are supported:
|
replaceIfPresentFlag
|
0
|
only for SubmitSm and SubmitMulti Used to request the SMSC to replace a previously submitted message, that is still pending delivery. The SMSC will replace an existing message provided that the source address, destination address and service type match the same fields in the new message. The following replace if present flag values are defined:
|
dataCoding
|
0
|
Camel 2.5 onwarts Defines encoding of data according the SMPP 3.4 specification, section 5.2.19. Example data encodings are:
0 : SMSC Default Alphabet 4 : 8 bit Alphabet 8 : UCS2 Alphabet
|
typeOfNumber
|
0
|
Defines the type of number (TON) to be used in the SME. The following TON values are defined:
|
numberingPlanIndicator
|
0
|
Defines the numeric plan indicator (NPI) to be used in the SME. The following NPI values are defined:
|
lazySessionCreation
|
false
|
Camel 2.8 onwards Sessions can be lazily created to avoid exceptions, if the SMSC is not available when the Camel producer is started. Camel 2.11 onwards Camel will check the in message headers 'CamelSmppSystemId' and 'CamelSmppPassword' of the first exchange. If they are present, Camel will use these data to connect to the SMSC.
|
httpProxyHost
|
null
|
Camel 2.9.1: If you need to tunnel SMPP through a HTTP proxy, set this attribute to the hostname or ip address of your HTTP proxy. |
httpProxyPort
|
3128
|
Camel 2.9.1: If you need to tunnel SMPP through a HTTP proxy, set this attribute to the port of your HTTP proxy. |
httpProxyUsername
|
null
|
Camel 2.9.1: If your HTTP proxy requires basic authentication, set this attribute to the username required for your HTTP proxy. |
httpProxyPassword
|
null
|
Camel 2.9.1: If your HTTP proxy requires basic authentication, set this attribute to the password required for your HTTP proxy. |
sessionStateListener
|
null
|
Camel 2.9.3: You can refer to a org.jsmpp.session.SessionStateListener in the Registry to receive callbacks when the session state changed.
|
addressRange
|
""
|
Camel 2.11: You can specify the address range for the SmppConsumer as defined in section 5.2.7 of the SMPP 3.4 specification. The SmppConsumer will receive messages only from SMSC's which target an address (MSISDN or IP address) within this range.
|
splittingPolicy
|
ALLOW
|
Camel 2.14.1 and 2.15.0: You can specify a policy for handling long messages, as follows:
|
smpp://smppclient@localhost:2775?password=password&enquireLinkTimer=3000&transactionTimer=5000&systemType=consumer
Producer Message Headers
Header | Type | Description |
---|---|---|
CamelSmppDestAddr
|
List/String
|
only for SubmitSm, SubmitMulti, CancelSm and DataSm Defines the destination SME address(es). For mobile terminated messages, this is the directory number of the recipient MS. Is must be a List<String> for SubmitMulti and a String otherwise.
|
CamelSmppDestAddrTon
|
Byte
|
only for SubmitSm, SubmitMulti, CancelSm and DataSm Defines the type of number (TON) to be used in the SME destination address parameters. The following TON values are defined:
|
CamelSmppDestAddrNpi
|
Byte
|
only for SubmitSm, SubmitMulti, CancelSm and DataSm Defines the numeric plan indicator (NPI) to be used in the SME destination address parameters. The following NPI values are defined:
|
CamelSmppSourceAddr
|
String
|
Defines the address of SME (Short Message Entity) which originated this message. |
CamelSmppSourceAddrTon
|
Byte
|
Defines the type of number (TON) to be used in the SME originator address parameters. The following TON values are defined:
|
CamelSmppSourceAddrNpi
|
Byte
|
Defines the numeric plan indicator (NPI) to be used in the SME originator address parameters. The following NPI values are defined:
|
CamelSmppServiceType
|
String
|
The service type parameter can be used to indicate the SMS Application service associated with the message. The following generic service_types are defined:
|
CamelSmppRegisteredDelivery
|
Byte
|
only for SubmitSm, ReplaceSm, SubmitMulti and DataSm Is used to request an SMSC delivery receipt and/or SME originated acknowledgements. The following values are defined:
|
CamelSmppPriorityFlag
|
Byte
|
only for SubmitSm and SubmitMulti Allows the originating SME to assign a priority level to the short message. Four Priority Levels are supported:
|
CamelSmppValidityPeriod
|
String /{{Date}}
|
only for SubmitSm, SubmitMulti and ReplaceSm The validity period parameter indicates the SMSC expiration time, after which the message should be discarded if not delivered to the destination. If it's provided as Date , it's interpreted as absolute time. Camel 2.9.1 onwards: It can be defined in absolute time format or relative time format if you provide it as String as specified in chapter 7.1.1 in the smpp specification v3.4.
|
CamelSmppReplaceIfPresentFlag
|
Byte
|
only for SubmitSm and SubmitMulti The replace if present flag parameter is used to request the SMSC to replace a previously submitted message, that is still pending delivery. The SMSC will replace an existing message provided that the source address, destination address and service type match the same fields in the new message. The following values are defined:
|
CamelSmppAlphabet / CamelSmppDataCoding
|
Byte
|
Camel 2.5For SubmitSm, SubmitMulti and ReplaceSm (Prior to Camel 2.9 use CamelSmppDataCoding instead of CamelSmppAlphabet .) The data coding according to the SMPP 3.4 specification, section 5.2.19. Use the URI option alphabet settings above.
|
CamelSmppOptionalParameters
|
Map<String, String>
|
Deprecated and will be removed in Camel 2.13.0/3.0.0Camel 2.10.5 and 2.11.1 onwards and only for SubmitSm, SubmitMulti and DataSm The optional parameters send back by the SMSC.
|
CamelSmppOptionalParameter
|
Map<Short, Object>
|
Camel 2.10.7 and 2.11.2 onwards and only for SubmitSm, SubmitMulti and DataSm The optional parameter which are send to the SMSC. The value is converted in the following way:
String -> org.jsmpp.bean.OptionalParameter.COctetString byte[] -> org.jsmpp.bean.OptionalParameter.OctetString Byte -> org.jsmpp.bean.OptionalParameter.Byte Integer -> org.jsmpp.bean.OptionalParameter.Int Short -> org.jsmpp.bean.OptionalParameter.Short null -> org.jsmpp.bean.OptionalParameter.Null
|
CamelSmppEncoding
|
String
|
Camel 2.14.1 and Camel 2.15.0: and only for
SubmitSm , SubmitMulti and DataSm . Specifies the encoding (character set name) of the bytes in the message body. If the message body is a string then this is not relevant because Java strings are always Unicode. If the body is a byte array then this header can be used to indicate that it is ISO-8859-1 or some other value. Default value is specified by the endpoint configuration parameter encoding.
|
CamelSmppSplittingPolicy
|
String
|
Camel 2.14.1 and Camel 2.15.0: and only for
SubmitSm , SubmitMulti and DataSm . Specifies the policy for message splitting for this exchange. Possible values are described in the endpoint configuration parameter splittingPolicy .
|
Header | Type | Description |
---|---|---|
CamelSmppId
|
List<String> /{{String}}
|
The id to identify the submitted short message(s) for later use. From Camel 2.9.0: In case of a ReplaceSm, QuerySm, CancelSm and DataSm this header vaule is a String . In case of a SubmitSm or SubmitMultiSm this header vaule is a List<String> .
|
CamelSmppSentMessageCount
|
Integer
|
From Camel 2.9 onwards only for SubmitSm and SubmitMultiSm The total number of messages which has been sent. |
CamelSmppError
|
Map<String, List<Map<String, Object>>>
|
From Camel 2.9 onwards only for SubmitMultiSm The errors which occurred by sending the short message(s) the form Map<String, List<Map<String, Object>>> (messageID : (destAddr : address, error : errorCode)).
|
CamelSmppOptionalParameters
|
Map<String, String>
|
Deprecated and will be removed in Camel 2.13.0/3.0.0From Camel 2.11.1 onwards only for DataSm The optional parameters which are returned from the SMSC by sending the message.
|
CamelSmppOptionalParameter
|
Map<Short, Object>
|
From Camel 2.10.7, 2.11.2 onwards only for DataSm The optional parameter which are returned from the SMSC by sending the message. The key is the
Short code for the optional parameter. The value is converted in the following way: org.jsmpp.bean.OptionalParameter.COctetString -> String org.jsmpp.bean.OptionalParameter.OctetString -> byte[] org.jsmpp.bean.OptionalParameter.Byte -> Byte org.jsmpp.bean.OptionalParameter.Int -> Integer org.jsmpp.bean.OptionalParameter.Short -> Short org.jsmpp.bean.OptionalParameter.Null -> null
|
Consumer Message Headers
Header | Type | Description |
---|---|---|
CamelSmppSequenceNumber
|
Integer
|
only for AlertNotification, DeliverSm and DataSm A sequence number allows a response PDU to be correlated with a request PDU. The associated SMPP response PDU must preserve this field. |
CamelSmppCommandId
|
Integer
|
only for AlertNotification, DeliverSm and DataSm The command id field identifies the particular SMPP PDU. For the complete list of defined values see chapter 5.1.2.1 in the smpp specification v3.4. |
CamelSmppSourceAddr
|
String
|
only for AlertNotification, DeliverSm and DataSm Defines the address of SME (Short Message Entity) which originated this message. |
CamelSmppSourceAddrNpi
|
Byte
|
only for AlertNotification and DataSm Defines the numeric plan indicator (NPI) to be used in the SME originator address parameters. The following NPI values are defined:
|
CamelSmppSourceAddrTon
|
Byte
|
only for AlertNotification and DataSm Defines the type of number (TON) to be used in the SME originator address parameters. The following TON values are defined:
|
CamelSmppEsmeAddr
|
String
|
only for AlertNotification Defines the destination ESME address. For mobile terminated messages, this is the directory number of the recipient MS. |
CamelSmppEsmeAddrNpi
|
Byte
|
only for alert notification: Defines the numeric plan indicator (NPI) to be used in the ESME originator address parameters. The following NPI values are defined:
|
CamelSmppEsmeAddrTon
|
Byte
|
only for alert notification: Defines the type of number (TON) to be used in the ESME originator address parameters. The following TON values are defined:
|
CamelSmppId
|
String
|
only for smsc DeliveryReceipt and DataSm The message ID allocated to the message by the SMSC when originally submitted. |
CamelSmppDelivered
|
Integer
|
only for smsc DeliveryReceipt Number of short messages delivered. This is only relevant where the original message was submitted to a distribution list.The value is padded with leading zeros if necessary. |
CamelSmppDoneDate
|
Date
|
only for smsc DeliveryReceipt The time and date at which the short message reached it's final state. The format is as follows: YYMMDDhhmm. |
CamelSmppFinalStatus
|
DeliveryReceiptState
|
only for smsc DeliveryReceipt: The final status of the message. The following values are defined:
DELIVRD : Message is delivered to destination EXPIRED : Message validity period has expired. DELETED : Message has been deleted. UNDELIV : Message is undeliverable ACCEPTD : Message is in accepted state (i.e. has been manually read on behalf of the subscriber by customer service) UNKNOWN : Message is in invalid state REJECTD : Message is in a rejected state
|
CamelSmppCommandStatus
|
Integer
|
only for DataSm The Command status of the message. |
CamelSmppError
|
String
|
only for smsc DeliveryReceipt Where appropriate this may hold a Network specific error code or an SMSC error code for the attempted delivery of the message. These errors are Network or SMSC specific and are not included here. |
CamelSmppSubmitDate
|
Date
|
only for smsc DeliveryReceipt The time and date at which the short message was submitted. In the case of a message which has been replaced, this is the date that the original message was replaced. The format is as follows: YYMMDDhhmm. |
CamelSmppSubmitted
|
Integer
|
only for smsc DeliveryReceipt Number of short messages originally submitted. This is only relevant when the original message was submitted to a distribution list.The value is padded with leading zeros if necessary. |
CamelSmppDestAddr
|
String
|
only for DeliverSm and DataSm: Defines the destination SME address. For mobile terminated messages, this is the directory number of the recipient MS. |
CamelSmppScheduleDeliveryTime
|
String
|
only for DeliverSm: This parameter specifies the scheduled time at which the message delivery should be first attempted. It defines either the absolute date and time or relative time from the current SMSC time at which delivery of this message will be attempted by the SMSC. It can be specified in either absolute time format or relative time format. The encoding of a time format is specified in Section 7.1.1. in the smpp specification v3.4. |
CamelSmppValidityPeriod
|
String
|
only for DeliverSm The validity period parameter indicates the SMSC expiration time, after which the message should be discarded if not delivered to the destination. It can be defined in absolute time format or relative time format. The encoding of absolute and relative time format is specified in Section 7.1.1 in the smpp specification v3.4. |
CamelSmppServiceType
|
String
|
only for DeliverSm and DataSm The service type parameter can be used to indicate the SMS Application service associated with the message. The following generic service_types are defined:
|
CamelSmppRegisteredDelivery
|
Byte
|
only for DataSm Is used to request an SMSC delivery receipt and/or SME originated acknowledgements. The following values are defined:
|
CamelSmppDestAddrNpi
|
Byte
|
only for DataSm Defines the numeric plan indicator (NPI) to be used in the SME destination address parameters. The following NPI values are defined:
|
CamelSmppDestAddrTon
|
Byte
|
only for DataSm Defines the type of number (TON) to be used in the SME destination address parameters. The following TON values are defined:
|
CamelSmppMessageType
|
String
|
Camel 2.6 onwards: Identifies the type of an incoming message:
AlertNotification : an SMSC alert notification DataSm : an SMSC data short message DeliveryReceipt : an SMSC delivery receipt DeliverSm : an SMSC deliver short message
|
CamelSmppOptionalParameters
|
Map<String, Object>
|
Deprecated and will be removed in Camel 2.13.0/3.0.0Camel 2.10.5 onwards and only for DeliverSm The optional parameters send back by the SMSC.
|
CamelSmppOptionalParameter
|
Map<Short, Object>
|
Camel 2.10.7, 2.11.2 onwards and only for DeliverSm The optional parameters send back by the SMSC. The key is the
Short code for the optional parameter. The value is converted in the following way: org.jsmpp.bean.OptionalParameter.COctetString -> String org.jsmpp.bean.OptionalParameter.OctetString -> byte[] org.jsmpp.bean.OptionalParameter.Byte -> Byte org.jsmpp.bean.OptionalParameter.Int -> Integer org.jsmpp.bean.OptionalParameter.Short -> Short org.jsmpp.bean.OptionalParameter.Null -> null
|
Exception handling
SubmitSm
(the default action), the org.apache.camel.component.smpp.SmppException
is thrown with a nested exception, org.jsmpp.extra.NegativeResponseException
. Call NegativeResponseException.getCommandStatus()
to obtain the exact SMPP negative response code, the values are explained in the SMPP specification 3.4, section 5.1.3.
DeliverSm
or DataSm
short message and the processing of these messages fails, you can also throw a ProcessRequestException
instead of handle the failure. In this case, this exception is forwarded to the underlying JSMPP library which will return the included error code to the SMSC. This feature is useful to e.g. instruct the SMSC to resend the short message at a later time. This could be done with the following lines of code:
from("smpp://smppclient@localhost:2775?password=password&enquireLinkTimer=3000&transactionTimer=5000&systemType=consumer") .doTry() .to("bean:dao?method=updateSmsState") .doCatch(Exception.class) .throwException(new ProcessRequestException("update of sms state failed", 100)) .end();
Samples
from("direct:start") .to("smpp://smppclient@localhost:2775?password=password&enquireLinkTimer=3000&transactionTimer=5000&systemType=producer");
<route> <from uri="direct:start"/> <to uri="smpp://smppclient@localhost:2775?password=password&nquireLinkTimer=3000&ransactionTimer=5000&ystemType=producer"/> </route>
from("smpp://smppclient@localhost:2775?password=password&enquireLinkTimer=3000&transactionTimer=5000&systemType=consumer") .to("bean:foo");
<route> <from uri="smpp://smppclient@localhost:2775?password=password&nquireLinkTimer=3000&ransactionTimer=5000&ystemType=consumer"/> <to uri="bean:foo"/> </route>
Debug logging
log4j.logger.org.apache.camel.component.smpp=DEBUG
Chapter 134. SNMP
SNMP Component
URI format
snmp://hostname[:port][?Options]
?option=value&option=value&...
Options
Name | Default Value | Description |
---|---|---|
type
|
none |
The type of action you want to perform. Actually you can enter here POLL or TRAP . The value POLL will instruct the endpoint to poll a given host for the supplied OID keys. If you put in TRAP you will setup a listener for SNMP Trap Events.
|
address
|
none |
This is the IP address and the port of the host to poll or where to setup the Trap Receiver. Example: 127.0.0.1:162
|
protocol
|
udp
|
Here you can select which protocol to use. You can use either udp or tcp .
|
retries
|
2
|
Defines how often a retry is made before canceling the request. |
timeout
|
1500
|
Sets the timeout value for the request in millis. |
snmpVersion
|
0 (which means SNMPv1)
|
Sets the SNMP version for the request. |
snmpCommunity
|
public
|
Sets the community octet string for the snmp request. |
delay
|
60000
|
Defines the delay in milliseconds between two poll cycles. Note that in previous releases, this option was specified in units of seconds. |
oids
|
none |
Defines which values you are interested in. Please have a look at the Wikipedia to get a better understanding. You may provide a single OID or a coma separated list of OIDs. Example: oids="1.3.6.1.2.1.1.3.0,1.3.6.1.2.1.25.3.2.1.5.1,1.3.6.1.2.1.25.3.5.1.1.1,1.3.6.1.2.1.43.5.1.1.11.1"
|
The result of a poll
1.3.6.1.2.1.1.3.0 1.3.6.1.2.1.25.3.2.1.5.1 1.3.6.1.2.1.25.3.5.1.1.1 1.3.6.1.2.1.43.5.1.1.11.1
<?xml version="1.0" encoding="UTF-8"?> <snmp> <entry> <oid>1.3.6.1.2.1.1.3.0</oid> <value>6 days, 21:14:28.00</value> </entry> <entry> <oid>1.3.6.1.2.1.25.3.2.1.5.1</oid> <value>2</value> </entry> <entry> <oid>1.3.6.1.2.1.25.3.5.1.1.1</oid> <value>3</value> </entry> <entry> <oid>1.3.6.1.2.1.43.5.1.1.11.1</oid> <value>6</value> </entry> <entry> <oid>1.3.6.1.2.1.1.1.0</oid> <value>My Very Special Printer Of Brand Unknown</value> </entry> </snmp>
Examples
snmp:192.168.178.23:161?protocol=udp&type=POLL&oids=1.3.6.1.2.1.1.5.0
snmp:127.0.0.1:162?protocol=udp&type=TRAP
from("snmp:192.168.178.23:161?protocol=udp&type=POLL&oids=1.3.6.1.2.1.1.5.0"). convertBodyTo(String.class). to("activemq:snmp.states");
Chapter 135. Solr
Solr Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-solr</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
solr://host[:port]/solr?[options] solrs://host[:port]/solr ?[options] solrCloud://host[:port]/solr?[options]
Endpoint Options
name | default value | description |
---|---|---|
maxRetries
|
0
|
maximum number of retries to attempt in the event of transient errors |
soTimeout
|
1000
|
read timeout on the underlying HttpConnectionManager. This is desirable for queries, but probably not for indexing |
connectionTimeout
|
100
|
connectionTimeout on the underlying HttpConnectionManager |
defaultMaxConnectionsPerHost
|
2
|
maxConnectionsPerHost on the underlying HttpConnectionManager |
maxTotalConnections
|
20
|
maxTotalConnection on the underlying HttpConnectionManager |
followRedirects
|
false
|
indicates whether redirects are used to get to the Solr server |
allowCompression
|
false
|
server side must support gzip or deflate for this to have any effect |
requestHandler
|
/update (xml) | set the request handler to be used |
streamingThreadCount
|
2
|
Camel 2.9.2 set the number of threads for the StreamingUpdateSolrServer |
streamingQueueSize
|
10
|
Camel 2.9.2 set the queue size for the StreamingUpdateSolrServer |
zkhost
|
null
|
Camel 2.14.0 set the zoo keeper host information which the solrCloud could use, such as "zkhost=localhost:8123".
|
collection
|
null
|
Camel 2.14.0 set the collection name which the solrCloud server could use
|
Message Operations
SolrOperation
and a value set to one of the following. Some operations also require the message body to be set.
- the
INSERT
operations use the CommonsHttpSolrServer
operation | message body | description |
---|---|---|
INSERT/INSERT_STREAMING
|
n/a | adds an index using message headers (must be prefixed with "SolrField.") |
INSERT/INSERT_STREAMING
|
File | adds an index using the given File (using ContentStreamUpdateRequest) |
INSERT/INSERT_STREAMING
|
SolrInputDocument | Camel 2.9.2 updates index based on the given SolrInputDocument |
INSERT/INSERT_STREAMING
|
String XML | Camel 2.9.2 updates index based on the given XML (must follow SolrInputDocument format) |
ADD_BEAN
|
bean instance | adds an index based on values in an annotated bean |
ADD_BEANS
|
collection<bean> | Camel 2.15 adds index based on a collection of annotated bean |
DELETE_BY_ID
|
index id to delete | delete a record by ID |
DELETE_BY_QUERY
|
query string | delete a record by a query |
COMMIT
|
n/a | performs a commit on any pending index changes |
ROLLBACK
|
n/a | performs a rollback on any pending index changes |
OPTIMIZE
|
n/a | performs a commit on any pending index changes and then runs the optimize command |
Example
INSERT
, DELETE
and COMMIT
example
from("direct:insert") .setHeader(SolrConstants.OPERATION, constant(SolrConstants.OPERATION_INSERT)) .setHeader(SolrConstants.FIELD + "id", body()) .to("solr://localhost:8983/solr"); from("direct:delete") .setHeader(SolrConstants.OPERATION, constant(SolrConstants.OPERATION_DELETE_BY_ID)) .to("solr://localhost:8983/solr"); from("direct:commit") .setHeader(SolrConstants.OPERATION, constant(SolrConstants.OPERATION_COMMIT)) .to("solr://localhost:8983/solr");
<route> <from uri="direct:insert"/> <setHeader headerName="SolrOperation"> <constant>INSERT</constant> </setHeader> <setHeader headerName="SolrField.id"> <simple>${body}</simple> </setHeader> <to uri="solr://localhost:8983/solr"/> </route> <route> <from uri="direct:delete"/> <setHeader headerName="SolrOperation"> <constant>DELETE_BY_ID</constant> </setHeader> <to uri="solr://localhost:8983/solr"/> </route> <route> <from uri="direct:commit"/> <setHeader headerName="SolrOperation"> <constant>COMMIT</constant> </setHeader> <to uri="solr://localhost:8983/solr"/> </route>
template.sendBody("direct:insert", "1234"); template.sendBody("direct:commit", null); template.sendBody("direct:delete", "1234"); template.sendBody("direct:commit", null);
Querying Solr
//define the route to perform a basic query from("direct:query") .recipientList(simple("http://localhost:8983/solr/select/?q=${body}")) .convertBodyTo(String.class); ... //query for an id of '1234' (url encoded) String responseXml = (String) template.requestBody("direct:query", "id%3A1234");
Chapter 136. Splunk
Splunk Component
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-splunk</artifactId> <version>${camel-version}</version> </dependency>
URI format
splunk://[endpoint]?[options]
Producer Endpoints:
Endpoint
|
Description
|
---|---|
stream
|
Streams data to a named index or the default if not specified. When using stream mode be aware of that Splunk has some internal buffer (about 1MB or so) before events gets to the index. If you need realtime, better use submit or tcp mode.
|
submit
|
submit mode. Uses Splunk rest api to publish events to a named index or the default if not specified.
|
tcp
|
tcp mode. Streams data to a tcp port, and requires a open receiver port in Splunk.
|
from("direct:start").convertBodyTo(SplunkEvent.class) .to("splunk://submit?username=user&password=123&index=myindex&sourceType=someSourceType&source=mySource")...
Consumer Endpoints:
Endpoint
|
Description
|
---|---|
normal
|
Performs normal search and requires a search query in the search option.
|
savedsearch
|
Performs search based on a search query saved in splunk and requires the name of the query in the savedSearch option.
|
from("splunk://normal?delay=5s&username=user&password=123&initEarliestTime=-10s&search=search index=myindex sourcetype=someSourcetype") .to("direct:search-result");
URI Options
Name
|
Default Value
|
Context
|
Description
|
---|---|---|---|
host
|
localhost
|
Both
|
Splunk host.
|
port
|
8089
|
Both
|
Splunk port
|
username
|
null
|
Both
|
Username for Splunk
|
password
|
null
|
Both
|
Password for Splunk
|
connectionTimeout
|
5000
|
Both
|
Timeout in MS when connecting to Splunk server
|
useSunHttpsHandler
|
false
|
Both
|
Use sun.net.www.protocol.https.Handler Https hanlder to establish the Splunk Connection. Can be useful when running in application servers to avoid app. server https handling.
|
index
|
null
|
Producer
|
Splunk index to write to
|
sourceType
|
null
|
Producer
|
Splunk sourcetype arguement
|
source
|
null
|
Producer
|
Splunk source arguement
|
tcpReceiverPort
|
0
|
Producer
|
Splunk tcp receiver port when using tcp producer endpoint.
|
initEarliestTime
|
null
|
Consumer
|
Initial start offset of the first search. Required
|
earliestTime
|
null
|
Consumer
|
Earliest time of the search time window.
|
latestTime
|
null
|
Consumer
|
Latest time of the search time window.
|
count
|
0
|
Consumer
|
A number that indicates the maximum number of entities to return. Note this is not the same as maxMessagesPerPoll which currently is unsupported
|
search
|
null
|
Consumer
|
The Splunk query to run
|
savedSearch
|
null
|
Consumer
|
The name of the query saved in Splunk to run
|
streaming
|
false
|
Consumer
|
Camel 2.14.0 : Stream exchanges as they are received from Splunk, rather than returning all of them in one batch. This has the benefit of receiving results faster, as well as requiring less memory as exchanges aren't buffered in the component.
|
Message body
Use Cases
from("twitter://search?type=polling&keywords=music&delay=10&consumerKey=abc&consumerSecret=def&accessToken=hij&accessTokenSecret=xxx") .convertBodyTo(SplunkEvent.class) .to("splunk://submit?username=foo&password=bar&index=camel-tweets&sourceType=twitter&source=music-tweets");
@Converter public class Tweet2SplunkEvent { @Converter public static SplunkEvent convertTweet(Status status) { SplunkEvent data = new SplunkEvent("twitter-message", null); //data.addPair("source", status.getSource()); data.addPair("from_user", status.getUser().getScreenName()); data.addPair("in_reply_to", status.getInReplyToScreenName()); data.addPair(SplunkEvent.COMMON_START_TIME, status.getCreatedAt()); data.addPair(SplunkEvent.COMMON_EVENT_ID, status.getId()); data.addPair("text", status.getText()); data.addPair("retweet_count", status.getRetweetCount()); if (status.getPlace() != null) { data.addPair("place_country", status.getPlace().getCountry()); data.addPair("place_name", status.getPlace().getName()); data.addPair("place_street", status.getPlace().getStreetAddress()); } if (status.getGeoLocation() != null) { data.addPair("geo_latitude", status.getGeoLocation().getLatitude()); data.addPair("geo_longitude", status.getGeoLocation().getLongitude()); } return data; } }
from("splunk://normal?username=foo&password=bar&initEarliestTime=-2m&search=search index=camel-tweets sourcetype=twitter") .log("${body}");
Other comments
See Also
Chapter 137. SpringBatch
Spring Batch Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-spring-batch</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
spring-batch:jobName[?options]
from()
statement.
Options
Name | Default Value | Description |
---|---|---|
jobLauncherRef
|
null
|
Deprecated and will be removed in Camel 3.0!Camel 2.10: Use jobLauncher=#theName instead. |
jobLauncher
|
null
|
Camel 2.11.1: Explicitly specifies a JobLauncher to be used from the Camel Registry.
|
Usage
org.springframework.batch.core.launch.JobLaucher
instance resolved according to the following algorithm:
- if
JobLauncher
is manually set on the component, then use it. - if
jobLauncherRef
option is set on the component, then search Camel Registry for theJobLauncher
with the given name. Deprecated and will be removed in Camel 3.0! - if there is
JobLauncher
registered in the Camel Registry under jobLauncher name, then use it. - if none of the steps above allow to resolve the
JobLauncher
and there is exactly oneJobLauncher
instance in the Camel Registry, then use it.
JobLauncher
as job parameters. String
, Long
, Double
and java.util.Date
values are copied to the org.springframework.batch.core.JobParametersBuilder
- other data types are converted to Strings.
Examples
from("direct:startBatch").to("spring-batch:myJob");
JobLauncher
set explicitly.
from("direct:startBatch").to("spring-batch:myJob?jobLauncherRef=myJobLauncher");
JobExecution
instance returned by the JobLauncher
is forwarded by the SpringBatchProducer
as the output message. You can use the JobExecution
instance to perform some operations using the Spring Batch API directly.
from("direct:startBatch").to("spring-batch:myJob").to("mock:JobExecutions"); ... MockEndpoint mockEndpoint = ...; JobExecution jobExecution = mockEndpoint.getExchanges().get(0).getIn().getBody(JobExecution.class); BatchStatus currentJobStatus = jobExecution.getStatus();
Support classes
CamelItemReader
CamelItemReader
can be used to read batch data directly from the Camel infrastructure.
<bean id="camelReader" class="org.apache.camel.component.spring.batch.support.CamelItemReader"> <constructor-arg ref="consumerTemplate"/> <constructor-arg value="jms:dataQueue"/> </bean> <batch:job id="myJob"> <batch:step id="step"> <batch:tasklet> <batch:chunk reader="camelReader" writer="someWriter" commit-interval="100"/> </batch:tasklet> </batch:step> </batch:job>
CamelItemWriter
CamelItemWriter
has similar purpose as CamelItemReader
, but it is dedicated to write chunk of the processed data.
<bean id="camelwriter" class="org.apache.camel.component.spring.batch.support.CamelItemWriter"> <constructor-arg ref="producerTemplate"/> <constructor-arg value="jms:dataQueue"/> </bean> <batch:job id="myJob"> <batch:step id="step"> <batch:tasklet> <batch:chunk reader="someReader" writer="camelwriter" commit-interval="100"/> </batch:tasklet> </batch:step> </batch:job>
CamelItemProcessor
CamelItemProcessor
is the implementation of Spring Batch org.springframework.batch.item.ItemProcessor
interface. The latter implementation relays on Request Reply pattern to delegate the processing of the batch item to the Camel infrastructure. The item to process is sent to the Camel endpoint as the body of the message.
<camel:camelContext> <camel:route> <camel:from uri="direct:processor"/> <camel:setExchangePattern pattern="InOut"/> <camel:setBody> <camel:simple>Processed ${body}</camel:simple> </camel:setBody> </camel:route> </camel:camelContext> <bean id="camelProcessor" class="org.apache.camel.component.spring.batch.support.CamelItemProcessor"> <constructor-arg ref="producerTemplate"/> <constructor-arg value="direct:processor"/> </bean> <batch:job id="myJob"> <batch:step id="step"> <batch:tasklet> <batch:chunk reader="someReader" writer="someWriter" processor="camelProcessor" commit-interval="100"/> </batch:tasklet> </batch:step> </batch:job>
CamelJobExecutionListener
CamelJobExecutionListener
is the implementation of the org.springframework.batch.core.JobExecutionListener
interface sending job execution events to the Camel endpoint.
org.springframework.batch.core.JobExecution
instance produced by the Spring Batch is sent as a body of the message. To distinguish between before- and after-callbacks SPRING_BATCH_JOB_EVENT_TYPE
header is set to the BEFORE
or AFTER
value.
<bean id="camelJobExecutionListener" class="org.apache.camel.component.spring.batch.support.CamelJobExecutionListener"> <constructor-arg ref="producerTemplate"/> <constructor-arg value="jms:batchEventsBus"/> </bean> <batch:job id="myJob"> <batch:step id="step"> <batch:tasklet> <batch:chunk reader="someReader" writer="someWriter" commit-interval="100"/> </batch:tasklet> </batch:step> <batch:listeners> <batch:listener ref="camelJobExecutionListener"/> </batch:listeners> </batch:job>
Chapter 138. SpringIntegration
Spring Integration Component
URI format
spring-integration:defaultChannelName[?options]
inputChannel
name for the Spring Integration consumer and the outputChannel
name for the Spring Integration provider.
?option=value&option=value&...
Options
Name | Description | Example | Required | Default Value |
---|---|---|---|---|
inputChannel
|
The Spring integration input channel name that this endpoint wants to consume from, where the specified channel name is defined in the Spring context. |
inputChannel=requestChannel
|
No | |
outputChannel
|
The Spring integration output channel name that is used to send messages to the Spring integration context. |
outputChannel=replyChannel
|
No | |
inOut
|
The exchange pattern that the Spring integration endpoint should use. |
inOut=true
|
No |
inOnly for the Spring integration consumer and outOnly for the Spring integration provider
|
consumer.delay
|
Delay in milliseconds between each poll. |
consumer.delay=60000
|
No |
500
|
consumer.initialDelay
|
Milliseconds before polling starts. |
consumer.initialDelay=10000
|
No |
1000
|
consumer.userFixedDelay
|
Specify true to use fixed delay between polls, otherwise fixed rate is used. See the ScheduledExecutorService class for details.
|
consumer.userFixedDelay=false
|
No |
false
|
Usage
Using the Spring integration endpoint
<beans:beans xmlns="http://www.springframework.org/schema/integration" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:beans="http://www.springframework.org/schema/beans" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration.xsd http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd"> <channel id="inputChannel"/> <channel id="outputChannel"/> <channel id="onewayChannel"/> <service-activator input-channel="inputChannel" ref="helloService" method="sayHello"/> <service-activator input-channel="onewayChannel" ref="helloService" method="greet"/> <beans:bean id="helloService" class="org.apache.camel.component.spring.integration.HelloWorldService"/> <camelContext id="camel" xmlns="http://camel.apache.org/schema/spring"> <route> <from uri="direct:twowayMessage"/> <!-- Using the &as the separator of & --> <to uri="spring-integration:inputChannel?inOut=true&nputChannel=outputChannel"/> </route> <route> <from uri="direct:onewayMessage"/> <to uri="spring-integration:onewayChannel?inOut=false"/> </route> </camelContext>
<channel id="requestChannel"/> <channel id="responseChannel"/> <beans:bean id="myProcessor" class="org.apache.camel.component.spring.integration.MyProcessor"/> <camelContext id="camel" xmlns="http://camel.apache.org/schema/spring"> <route> <!-- Using the &as the separator of & --> <from uri="spring-integration://requestChannel?outputChannel=responseChannel&nOut=true"/> <process ref="myProcessor"/> </route> </camelContext>
<beans:beans xmlns="http://www.springframework.org/schema/integration" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:beans="http://www.springframework.org/schema/beans" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration.xsd http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd"> <channel id="outputChannel"/> <camelContext id="camel" xmlns="http://camel.apache.org/schema/spring"> <route> <!-- camel will create a spring integration endpoint automatically --> <from uri="outputChannel"/> <to uri="mock:result"/> </route> </camelContext>
The Source and Target adapter
<beans:beans xmlns="http://www.springframework.org/schema/integration" xmlns:beans="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:camel-si="http://camel.apache.org/schema/spring/integration" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration.xsd http://camel.apache.org/schema/spring/integration http://camel.apache.org/schema/spring/integration/camel-spring-integration.xsd http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd ">
<!-- Create the camel context here --> <camelContext id="camelTargetContext" xmlns="http://camel.apache.org/schema/spring"> <route> <from uri="direct:EndpointA" /> <to uri="mock:result" /> </route> <route> <from uri="direct:EndpointC"/> <process ref="myProcessor"/> </route> </camelContext> <!-- We can bind the camelTarget to the camel context's endpoint by specifying the camelEndpointUri attribute --> <camel-si:camelTarget id="camelTargetA" camelEndpointUri="direct:EndpointA" expectReply="false"> <camel-si:camelContextRef>camelTargetContext</camel-si:camelContextRef> </camel-si:camelTarget> <camel-si:camelTarget id="camelTargetB" camelEndpointUri="direct:EndpointC" replyChannel="channelC" expectReply="true"> <camel-si:camelContextRef>camelTargetContext</camel-si:camelContextRef> </camel-si:camelTarget> <camel-si:camelTarget id="camelTargetD" camelEndpointUri="direct:EndpointC" expectReply="true"> <camel-si:camelContextRef>camelTargetContext</camel-si:camelContextRef> </camel-si:camelTarget> <beans:bean id="myProcessor" class="org.apache.camel.component.spring.integration.MyProcessor"/>
<!-- spring integration channels --> <channel id="channelA"/> <channel id="channelB"/> <channel id="channelC"/> <!-- spring integration service activator --> <service-activator input-channel="channelB" output-channel="channelC" ref="helloService" method="sayHello"/> <!-- custom bean --> <beans:bean id="helloService" class="org.apache.camel.component.spring.integration.HelloWorldService"/> <camelContext id="camelSourceContext" xmlns="http://camel.apache.org/schema/spring"> <route> <from uri="direct:OneWay"/> <to uri="direct:EndpointB" /> </route> <route> <from uri="direct:TwoWay"/> <to uri="direct:EndpointC" /> </route> </camelContext> <!-- camelSource will redirect the message coming for direct:EndpointB to the spring requestChannel channelA --> <camel-si:camelSource id="camelSourceA" camelEndpointUri="direct:EndpointB" requestChannel="channelA" expectReply="false"> <camel-si:camelContextRef>camelSourceContext</camel-si:camelContextRef> </camel-si:camelSource> <!-- camelSource will redirect the message coming for direct:EndpointC to the spring requestChannel channelB then it will pull the response from channelC and put the response message back to direct:EndpointC --> <camel-si:camelSource id="camelSourceB" camelEndpointUri="direct:EndpointC" requestChannel="channelB" replyChannel="channelC" expectReply="true"> <camel-si:camelContextRef>camelSourceContext</camel-si:camelContextRef> </camel-si:camelSource>
Chapter 139. Spring Event
Spring Event Component
ApplicationEvent
objects. This allows you to publish ApplicationEvent
objects to a Spring ApplicationContext
or to consume them. You can then use Enterprise Integration Patterns to process them such as Message Filter.
URI format
spring-event://default[?options]
Chapter 140. Spring LDAP
Spring LDAP Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-spring-ldap</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
spring-ldap:springLdapTemplate[?options]
Options
Name | Type | Description |
---|---|---|
operation
|
String |
The LDAP operation to be performed. Must be one of search , bind , or unbind .
|
scope
|
String |
The scope of the search operation. Must be one of object , onelevel , or subtree , see also http://en.wikipedia.org/wiki/Lightweight_Directory_Access_Protocol#Search_and_Compare
|
Usage
UnsupportedOperationException
. The body of the message must be a map (an instance of java.util.Map
). This map must contain at least an entry with the key dn
that specifies the root node for the LDAP operation to be performed. Other entries of the map are operation-specific (see below).
bind
and unbind
operations. For the search
operation, the body is set to the result of the search, see http://static.springsource.org/spring-ldap/site/apidocs/org/springframework/ldap/core/LdapTemplate.html#search%28java.lang.String,%20java.lang.String,%20int,%20org.springframework.ldap.core.AttributesMapper%29.
Search
filter
. The value must be a String representing a valid LDAP filter, see http://en.wikipedia.org/wiki/Lightweight_Directory_Access_Protocol#Search_and_Compare.
Bind
attributes
. The value must be an instance of javax.naming.directory.Attributes This entry specifies the LDAP node to be created.
Unbind
dn
is deleted.
org.apache.camel.springldap.SpringLdapProducer
:
- public static final String DN = "dn"
- public static final String FILTER = "filter"
- public static final String ATTRIBUTES = "attributes"
Chapter 141. Spring Redis
Spring Redis Component
URI Format
spring-redis://host:port[?options]
?options=value&option2=value&...
URI Options
Name | Default Value | Context | Description |
---|---|---|---|
host
|
null
|
Both | The host where Redis server is running. |
port
|
null
|
Both | Redis port number. |
command
|
SET
|
Both | Default command, which can be overridden by message header. |
channels
|
SET
|
Consumer | List of topic names or name patterns to subscribe to. |
redisTemplate
|
null
|
Producer |
Reference to a pre-configured org.springframework.data.redis.core.RedisTemplate instance in the Registry.
|
connectionFactory
|
null
|
Both |
Reference to an org.springframework.data.redis.connection.RedisConnectionFactory instance in the Registry.
|
listenerContainer
|
null
|
Consumer |
Reference to an org.springframework.data.redis.listener.RedisMessageListenerContainer instance in the Registry instance in the Registry.
|
serializer
|
null
|
Consumer |
Reference to an org.springframework.data.redis.serializer.RedisSerializer instance in the Registry.
|
Usage
Message headers evaluated by the Redis producer
Hash Commands | Description | Parameters | Result |
---|---|---|---|
HSET
|
Set the string value of a hash field | CamelRedis.Key (String), CamelRedis.Field (String), CamelRedis.Value (Object) | void |
HGET
|
Get the value of a hash field | CamelRedis.Key (String), CamelRedis.Field (String) | String |
HSETNX
|
Set the value of a hash field, only if the field does not exist | CamelRedis.Key (String), CamelRedis.Field (String), CamelRedis.Value (Object) | void |
HMSET
|
Set multiple hash fields to multiple values | CamelRedis.Key (String), CamelRedis.Values(Map<String, Object>) | void |
HMGET
|
Get the values of all the given hash fields | CamelRedis.Key (String), CamelRedis.Fields (Collection<String>) | Collection<Object> |
HINCRBY
|
Increment the integer value of a hash field by the given number | CamelRedis.Key (String), CamelRedis.Field (String), CamelRedis.Value (Long) | Long |
HEXISTS
|
Determine if a hash field exists | CamelRedis.Key (String), CamelRedis.Field (String) | Boolean |
HDEL
|
Delete one or more hash fields | CamelRedis.Key (String), CamelRedis.Field (String) | void |
HLEN
|
Get the number of fields in a hash | CamelRedis.Key (String) | Long |
HKEYS
|
Get all the fields in a hash | CamelRedis.Key (String) | Set<String> |
HVALS
|
Get all the values in a hash | CamelRedis.Key (String) | Collection<Object> |
HGETALL
|
Get all the fields and values in a hash | CamelRedis.Key (String) | Map<String, Object> |
List Commands | Description | Parameters | Result |
---|---|---|---|
RPUSH
|
Append one or multiple values to a list | CamelRedis.Key (String), CamelRedis.Value (Object) | Long |
RPUSHX
|
Append a value to a list, only if the list exists | CamelRedis.Key (String), CamelRedis.Value (Object) | Long |
LPUSH
|
Prepend one or multiple values to a list | CamelRedis.Key (String), CamelRedis.Value (Object) | Long |
LLEN
|
Get the length of a list | CamelRedis.Key (String) | Long |
LRANGE
|
Get a range of elements from a list | CamelRedis.Key (String), CamelRedis.Start (Long), CamelRedis.End (Long) | List<Object> |
LTRIM
|
Trim a list to the specified range | CamelRedis.Key (String), CamelRedis.Start (Long), CamelRedis.End (Long) | void |
LINDEX
|
Get an element from a list by its index | CamelRedis.Key (String), CamelRedis.Index (Long) | String |
LINSERT
|
Insert an element before or after another element in a list | CamelRedis.Key (String), CamelRedis.Value (Object), CamelRedis.Pivot (String), CamelRedis.Position (String) | Long |
LSET
|
Set the value of an element in a list by its index | CamelRedis.Key (String), CamelRedis.Value (Object), CamelRedis.Index (Long) | void |
LREM
|
Remove elements from a list | CamelRedis.Key (String), CamelRedis.Value (Object), CamelRedis.Count (Long) | Long |
LPOP
|
Remove and get the first element in a list | CamelRedis.Key (String) | Object |
RPOP
|
Remove and get the last element in a list | CamelRedis.Key (String) | String |
RPOPLPUSH
|
Remove the last element in a list, append it to another list and return it | CamelRedis.Key (String), CamelRedis.Destination (String) | Object |
BRPOPLPUSH
|
Pop a value from a list, push it to another list and return it; or block until one is available | CamelRedis.Key (String), CamelRedis.Destination (String), CamelRedis.Timeout (Long) | Object |
BLPOP
|
Remove and get the first element in a list, or block until one is available | CamelRedis.Key (String), CamelRedis.Timeout (Long) | Object |
BRPOP
|
Remove and get the last element in a list, or block until one is available | CamelRedis.Key (String), CamelRedis.Timeout (Long) | String |
Set Commands | Description | Parameters | Result |
---|---|---|---|
SADD
|
Add one or more members to a set | CamelRedis.Key (String), CamelRedis.Value (Object) | Boolean |
SMEMBERS
|
Get all the members in a set | CamelRedis.Key (String) | Set<Object> |
SREM
|
Remove one or more members from a set | CamelRedis.Key (String), CamelRedis.Value (Object) | Boolean |
SPOP
|
Remove and return a random member from a set | CamelRedis.Key (String) | String |
SMOVE
|
Move a member from one set to another | CamelRedis.Key (String), CamelRedis.Value (Object), CamelRedis.Destination (String) | Boolean |
SCARD
|
Get the number of members in a set | CamelRedis.Key (String) | Long |
SISMEMBER
|
Determine if a given value is a member of a set | CamelRedis.Key (String), CamelRedis.Value (Object) | Boolean |
SINTER
|
Intersect multiple sets | CamelRedis.Key (String), CamelRedis.Keys (String) | Set<Object> |
SINTERSTORE
|
Intersect multiple sets and store the resulting set in a key | CamelRedis.Key (String), CamelRedis.Keys (String), CamelRedis.Destination (String) | void |
SUNION
|
Add multiple sets | CamelRedis.Key (String), CamelRedis.Keys (String) | Set<Object> |
SUNIONSTORE
|
Add multiple sets and store the resulting set in a key | CamelRedis.Key (String), CamelRedis.Keys (String), CamelRedis.Destination (String) | void |
SDIFF
|
Subtract multiple sets | CamelRedis.Key (String), CamelRedis.Keys (String) | Set<Object> |
SDIFFSTORE
|
Subtract multiple sets and store the resulting set in a key | CamelRedis.Key (String), CamelRedis.Keys (String), CamelRedis.Destination (String) | void |
SRANDMEMBER
|
Get one or multiple random members from a set | CamelRedis.Key (String) | String |
Ordered set Commands | Description | Parameters | Result |
---|---|---|---|
ZADD
|
Add one or more members to a sorted set, or update its score if it already exists | CamelRedis.Key (String), CamelRedis.Value (Object), CamelRedis.Score (Double) | Boolean |
ZRANGE
|
Return a range of members in a sorted set, by index | CamelRedis.Key (String), CamelRedis.Start (Long), CamelRedis.End (Long), CamelRedis.WithScore (Boolean) | Object |
ZREM
|
Remove one or more members from a sorted set | CamelRedis.Key (String), CamelRedis.Value (Object) | Boolean |
ZINCRBY
|
Increment the score of a member in a sorted set | CamelRedis.Key (String), CamelRedis.Value (Object), CamelRedis.Increment (Double) | Double |
ZRANK
|
Determine the index of a member in a sorted set | CamelRedis.Key (String), CamelRedis.Value (Object) | Long |
ZREVRANK
|
Determine the index of a member in a sorted set, with scores ordered from high to low | CamelRedis.Key (String), CamelRedis.Value (Object) | Long |
ZREVRANGE
|
Return a range of members in a sorted set, by index, with scores ordered from high to low | CamelRedis.Key (String), CamelRedis.Start (Long), CamelRedis.End (Long), CamelRedis.WithScore (Boolean) | Object |
ZCARD
|
Get the number of members in a sorted set | CamelRedis.Key (String), | Long |
ZCOUNT
|
Count the members in a sorted set with scores within the given values | CamelRedis.Key (String), CamelRedis.Min (Double), CamelRedis.Max (Double) | Long |
ZRANGEBYSCORE
|
Return a range of members in a sorted set, by score | CamelRedis.Key (String), CamelRedis.Min (Double), CamelRedis.Max (Double) | Set<Object> |
ZREVRANGEBYSCORE
|
Return a range of members in a sorted set, by score, with scores ordered from high to low | CamelRedis.Key (String), CamelRedis.Min (Double), CamelRedis.Max (Double) | Set<Object> |
ZREMRANGEBYRANK
|
Remove all members in a sorted set within the given indexes | CamelRedis.Key (String), CamelRedis.Start (Long), CamelRedis.End (Long) | void |
ZREMRANGEBYSCORE
|
Remove all members in a sorted set within the given scores | CamelRedis.Key (String), CamelRedis.Start (Long), CamelRedis.End (Long) | void |
ZUNIONSTORE
|
Add multiple sorted sets and store the resulting sorted set in a new key | CamelRedis.Key (String), CamelRedis.Keys (String), CamelRedis.Destination (String) | void |
ZINTERSTORE
|
Intersect multiple sorted sets and store the resulting sorted set in a new key | CamelRedis.Key (String), CamelRedis.Keys (String), CamelRedis.Destination (String) | void |
String Commands | Description | Parameters | Result |
---|---|---|---|
SET
|
Set the string value of a key | CamelRedis.Key (String), CamelRedis.Value (Object) | void |
GET
|
Get the value of a key | CamelRedis.Key (String) | Object |
STRLEN
|
Get the length of the value stored in a key | CamelRedis.Key (String) | Long |
APPEND
|
Append a value to a key | CamelRedis.Key (String), CamelRedis.Value (String) | Integer |
SETBIT
|
Sets or clears the bit at offset in the string value stored at key | CamelRedis.Key (String), CamelRedis.Offset (Long), CamelRedis.Value (Boolean) | void |
GETBIT
|
Returns the bit value at offset in the string value stored at key | CamelRedis.Key (String), CamelRedis.Offset (Long) | Boolean |
SETRANGE
|
Overwrite part of a string at key starting at the specified offset | CamelRedis.Key (String), CamelRedis.Value (Object), CamelRedis.Offset (Long) | void |
GETRANGE
|
Get a substring of the string stored at a key | CamelRedis.Key (String), CamelRedis.Start (Long), CamelRedis.End (Long) | String |
SETNX
|
Set the value of a key, only if the key does not exist | CamelRedis.Key (String), CamelRedis.Value (Object) | Boolean |
SETEX
|
Set the value and expiration of a key | CamelRedis.Key (String), CamelRedis.Value (Object), CamelRedis.Timeout (Long), SECONDS | void |
DECRBY
|
Decrement the integer value of a key by the given number | CamelRedis.Key (String), CamelRedis.Value (Long) | Long |
DECR
|
Decrement the integer value of a key by one | CamelRedis.Key (String), | Long |
INCRBY
|
Increment the integer value of a key by the given amount | CamelRedis.Key (String), CamelRedis.Value (Long) | Long |
INCR
|
Increment the integer value of a key by one | CamelRedis.Key (String) | Long |
MGET
|
Get the values of all the given keys | CamelRedis.Fields (Collection<String>) | List<Object> |
MSET
|
Set multiple keys to multiple values | CamelRedis.Values(Map<String, Object>) | void |
MSETNX
|
Set multiple keys to multiple values, only if none of the keys exist | CamelRedis.Key (String), CamelRedis.Value (Object) | void |
GETSET
|
Set the string value of a key and return its old value | CamelRedis.Key (String), CamelRedis.Value (Object) | Object |
Key Commands | Description | Parameters | Result |
---|---|---|---|
EXISTS
|
Determine if a key exists | CamelRedis.Key (String) | Boolea |
DEL
|
Delete a key | CamelRedis.Keys (String) | void |
TYPE
|
Determine the type stored at key | CamelRedis.Key (String) | DataType |
KEYS
|
Find all keys matching the given pattern | CamelRedis.Pattern (String) | Collection<String> |
RANDOMKEY
|
Return a random key from the keyspace | CamelRedis.Pattern (String), CamelRedis.Value (String) | String |
RENAME
|
Rename a key | CamelRedis.Key (String) | void |
RENAMENX
|
Rename a key, only if the new key does not exist | CamelRedis.Key (String), CamelRedis.Value (String) | Boolean |
EXPIRE
|
Set a key's time to live in seconds | CamelRedis.Key (String), CamelRedis.Timeout (Long) | Boolean |
SORT
|
Sort the elements in a list, set or sorted set | CamelRedis.Key (String) | List<Object> |
PERSIST
|
Remove the expiration from a key | CamelRedis.Key (String) | Boolean |
EXPIREAT
|
Set the expiration for a key as a UNIX timestamp | CamelRedis.Key (String), CamelRedis.Timestamp (Long) | Boolean |
PEXPIRE
|
Set a key's time to live in milliseconds | CamelRedis.Key (String), CamelRedis.Timeout (Long) | Boolean |
PEXPIREAT
|
Set the expiration for a key as a UNIX timestamp specified in milliseconds | CamelRedis.Key (String), CamelRedis.Timestamp (Long) | Boolean |
TTL
|
Get the time to live for a key | CamelRedis.Key (String) | Long |
MOVE
|
Move a key to another database | CamelRedis.Key (String), CamelRedis.Db (Integer) | Boolean |
Other Command | Description | Parameters | Result |
---|---|---|---|
MULTI
|
Mark the start of a transaction block | none | void |
DISCARD
|
Discard all commands issued after MULTI | none | void |
EXEC
|
Execute all commands issued after MULTI | none | void |
WATCH
|
Watch the given keys to determine execution of the MULTI/EXEC block | CamelRedis.Keys (String) | void |
UNWATCH
|
Forget about all watched keys | none | void |
ECHO
|
Echo the given string | CamelRedis.Value (String) | String |
PING
|
Ping the server | none | String |
QUIT
|
Close the connection | none | void |
PUBLISH
|
Post a message to a channel | CamelRedis.Channel (String), CamelRedis.Message (Object) | void |
Redis consumer
SUBSCRIBE
or a string pattern using PSUBSCRIBE
commands. When a message is sent to the channel using PUBLISH command, it will be consumed and the message will be available as Camel message body. The message is also serialized using configured serializer or the default JdkSerializationRedisSerializer.
Header | Type | Description |
---|---|---|
CamelRedis.Channel
|
String
|
The channel name, where the message was received. |
CamelRedis.Pattern
|
String
|
The pattern matching the channel, where the message was received. |
Dependencies
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-spring-redis</artifactId> <version>${camel-version}</version> </dependency>
${camel-version}
must be replaced by the actual version of Camel (2.11 or higher).
Chapter 142. Spring Web Services
Spring Web Services Component
camel-spring-ws
on Spring 2.5.x you need to add the spring-webmvc
module from Spring 2.5.x. In order to run Spring-WS 1.5.9 on Spring 3.0.x you need to exclude the OXM module from Spring 3.0.x as this module is also included in Spring-WS 1.5.9 (see this post)
URI format
spring-ws:[mapping-type:]address[?options]
mapping-type
needs to be set to one of the following values:
Mapping type | Description |
---|---|
rootqname
|
Offers the option to map web service requests based on the qualified name of the root element contained in the message. |
soapaction
|
Used to map web service requests based on the SOAP action specified in the header of the message. |
uri
|
In order to map web service requests that target a specific URI. |
xpathresult
|
Used to map web service requests based on the evaluation of an XPath expression against the incoming message. The result of the evaluation should match the XPath result specified in the endpoint URI.
|
beanname
|
Allows you to reference a org.apache.camel.component.spring.ws.bean.CamelEndpointDispatcher in order to integrate with existing (legacy) endpoint mappings like PayloadRootQNameEndpointMapping , SoapActionEndpointMapping , etc
|
address
should contain a value relevant to the specified mapping-type (e.g. a SOAP action, XPath expression). As a producer the address should be set to the URI of the web service you are calling upon.
?option=value&option=value&...
.
Options
Name | Required? | Description |
---|---|---|
soapAction
|
No | SOAP action to include inside a SOAP request when accessing remote web services |
wsAddressingAction
|
No |
WS-Addressing 1.0 action header to include when accessing web services. The To header is set to the address of the web service as specified in the endpoint URI (default Spring-WS behavior).
|
expression
|
Only when mapping-type is xpathresult
|
XPath expression to use in the process of mapping web service requests, should match the result specified by xpathresult
|
timeout
|
No |
Camel 2.10: Sets the socket read timeout (in milliseconds) while invoking a webservice using the producer, see URLConnection.setReadTimeout() and CommonsHttpMessageSender.setReadTimeout(). his option works when using the built-in message sender implementations: CommonsHttpMessageSender nd HttpUrlConnectionMessageSender. ne of these implementations will be used by default for HTTP based services unless you customize the Spring WS configuration options supplied to the component. f you are using a non-standard sender, it is assumed that you will handle your own timeout configuration. Camel 2.12: he built-in message sender HttpComponentsMessageSender s considered instead of CommonsHttpMessageSender hich has been deprecated, see HttpComponentsMessageSender.setReadTimeout().
|
sslContextParameters
|
No |
Camel 2.10: eference to an
org.apache.camel.util.jsse.SSLContextParameters in he Registry. ee Using the JSSE Configuration Utility. his option works when using the built-in message sender implementations: CommonsHttpMessageSender nd HttpUrlConnectionMessageSender. ne of these implementations will be used by default for HTTP based services unless you customize the Spring WS configuration options supplied to the component. f you are using a non-standard sender, it is assumed that you will handle your own TLS configuration. Camel 2.12: he built-in message sender HttpComponentsMessageSender s considered instead of CommonsHttpMessageSender hich has been deprecated.
|
Registry based options
#beanID
notation.
Name | Required? | Description |
---|---|---|
webServiceTemplate
|
No | Option to provide a custom WebServiceTemplate. This allows for full control over client-side web services handling; like adding a custom interceptor or specifying a fault resolver, message sender or message factory. |
messageSender
|
No | Option to provide a custom WebServiceMessageSender. For example to perform authentication or use alternative transports |
messageFactory
|
No | Option to provide a custom WebServiceMessageFactory. For example when you want Apache Axiom to handle web service messages instead of SAAJ |
transformerFactory
|
No |
Option to override the default TransformerFactory . The provided transformer factory must be of type javax.xml.transform.TransformerFactory
|
endpointMapping
|
Only when mapping-type is rootqname , soapaction , uri or xpathresult
|
Reference to org.apache.camel.component.spring.ws.bean.CamelEndpointMapping in the Registry/ApplicationContext. Only one bean is required in the registry to serve all Camel/Spring-WS endpoints. This bean is auto-discovered by the MessageDispatcher and used to map requests to Camel endpoints based on characteristics specified on the endpoint (like root QName, SOAP action, etc)
|
messageFilter
|
No | Option to provide a custom MessageFilter since 2.10.3. For example when you want to process your headers or attachments by your own. |
Message headers
Name | Type | Description |
---|---|---|
CamelSpringWebserviceEndpointUri
|
String
|
URI of the web service you are accessing as a client; overrides the address part of the endpoint URI. |
CamelSpringWebserviceSoapAction
|
String
|
Header to specify the SOAP action of the message; overrides the soapAction option, if present
|
CamelSpringWebserviceAddressingAction
|
URI
|
Use this header to specify the WS-Addressing action of the message; overrides the wsAddressingAction option, if present
|
CamelSpringWebserviceSoapHeader
|
Source | Camel 2.11.1: Use this header to specify/access the SOAP headers of the message. |
Accessing web services
web service
simply define a route:
from("direct:example").to("spring-ws:http://foo.com/bar")
template.requestBody("direct:example", "<foobar xmlns=\"http://foo.com\"><msg>test message</msg></foobar>");
Sending SOAP and WS-Addressing action headers
from("direct:example") .to("spring-ws:http://foo.com/bar?soapAction=http://foo.com&wsAddressingAction=http://bar.com")
template.requestBodyAndHeader("direct:example", "<foobar xmlns=\"http://foo.com\"><msg>test message</msg></foobar>", SpringWebserviceConstants.SPRING_WS_SOAP_ACTION, "http://baz.com");
Using SOAP headers
String body = ... String soapHeader = "<h:Header xmlns:h=\"http://www.webserviceX.NET/\"><h:MessageID>1234567890</h:MessageID><h:Nested><h:NestedID>1111</h:NestedID></h:Nested></h:Header>";
exchange.getIn().setBody(body); exchange.getIn().setHeader(SpringWebserviceConstants.SPRING_WS_SOAP_HEADER, soapHeader);
spring-ws
endpoint to call the Web Service.
The header and attachment propagation
BasicMessageFilter
) to propagate the exchange headers and attachments into WebServiceMessage
response. Now you can use
exchange.getOut().getHeaders().put("myCustom","myHeaderValue") exchange.getIn().addAttachment("myAttachment", new DataHandler(...))
How to use MTOM attachments
<bean id="axiomMessageFactory" class="org.springframework.ws.soap.axiom.AxiomSoapMessageFactory"> <property name="payloadCaching" value="false" /> <property name="attachmentCaching" value="true" /> <property name="attachmentCacheThreshold" value="1024" /> </bean>
<dependency> <groupId>org.apache.ws.commons.axiom</groupId> <artifactId>axiom-api</artifactId> <version>1.2.13</version> </dependency> <dependency> <groupId>org.apache.ws.commons.axiom</groupId> <artifactId>axiom-impl</artifactId> <version>1.2.13</version> <scope>runtime</scope> </dependency>
private class Attachement implements Processor { public void process(Exchange exchange) throws Exception { exchange.getOut().copyFrom(exchange.getIn()); File file = new File("testAttachment.txt"); exchange.getOut().addAttachment("test", new DataHandler(new FileDataSource(file))); } }
from("direct:send") .process(new Attachement()) .to("spring-ws:http://localhost:8089/mySoapService?soapAction=mySoap&messageFactory=axiomMessageFactory");
The custom header and attachment filtering
<bean id="messageFilter" class="your.domain.myMessageFiler" scope="singleton" />
to("spring-ws:http://yourdomain.com?messageFilter=#myEndpointSpecificMessageFilter");
protected void doProcessSoapHeader(Message inOrOut, SoapMessage soapMessage) {your code /*no need to call super*/ } protected void doProcessSoapAttachements(Message inOrOut, SoapMessage response) { your code /*no need to call super*/ }
Using a custom MessageSender and MessageFactory
from("direct:example") .to("spring-ws:http://foo.com/bar?messageFactory=#messageFactory&messageSender=#messageSender")
<!-- authenticate using HTTP Basic Authentication --> <bean id="messageSender" class="org.springframework.ws.transport.http.HttpComponentsMessageSender"> <property name="credentials"> <bean class="org.apache.commons.httpclient.UsernamePasswordCredentials"> <constructor-arg index="0" value="admin"/> <constructor-arg index="1" value="secret"/> </bean> </property> </bean> <!-- force use of Sun SAAJ implementation, http://static.springsource.org/spring-ws/sites/1.5/faq.html#saaj-jboss --> <bean id="messageFactory" class="org.springframework.ws.soap.saaj.SaajSoapMessageFactory"> <property name="messageFactory"> <bean class="com.sun.xml.messaging.saaj.soap.ver1_1.SOAPMessageFactory1_1Impl"></bean> </property> </bean>
Exposing web services
MessageDispatcherServlet
configured in web.xml
.
MessageDispatcherServlet
will look for a Spring XML named /WEB-INF/spring-ws-servlet.xml
. To use Camel with Spring-WS the only mandatory bean in that XML file is CamelEndpointMapping
. This bean allows the MessageDispatcher
to dispatch web service requests to your routes.
<web-app> <servlet> <servlet-name>spring-ws</servlet-name> <servlet-class>org.springframework.ws.transport.http.MessageDispatcherServlet</servlet-class> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>spring-ws</servlet-name> <url-pattern>/*</url-pattern> </servlet-mapping> </web-app>
<bean id="endpointMapping" class="org.apache.camel.component.spring.ws.bean.CamelEndpointMapping" /> <bean id="wsdl" class="org.springframework.ws.wsdl.wsdl11.DefaultWsdl11Definition"> <property name="schema"> <bean class="org.springframework.xml.xsd.SimpleXsdSchema"> <property name="xsd" value="/WEB-INF/foobar.xsd"/> </bean> </property> <property name="portTypeName" value="FooBar"/> <property name="locationUri" value="/"/> <property name="targetNamespace" value="http://example.com/"/> </bean>
Endpoint mapping in routes
GetFoo
within the http://example.com/
namespace:
from("spring-ws:rootqname:{http://example.com/}GetFoo?endpointMapping=#endpointMapping") .convertBodyTo(String.class).to(mock:example)
http://example.com/GetFoo
SOAP action:
from("spring-ws:soapaction:http://example.com/GetFoo?endpointMapping=#endpointMapping") .convertBodyTo(String.class).to(mock:example)
http://example.com/foobar
:
from("spring-ws:uri:http://example.com/foobar?endpointMapping=#endpointMapping") .convertBodyTo(String.class).to(mock:example)
<foobar>abc</foobar>
anywhere inside the message (and the default namespace).
from("spring-ws:xpathresult:abc?expression=//foobar&endpointMapping=#endpointMapping") .convertBodyTo(String.class).to(mock:example)
Alternative configuration, using existing endpoint mappings
beanname
one bean of type CamelEndpointDispatcher
with a corresponding name is required in the Registry/ApplicationContext. This bean acts as a bridge between the Camel endpoint and an existing endpoint mapping like PayloadRootQNameEndpointMapping
.
beanname
mapping-type is primarily meant for (legacy) situations where you're already using Spring-WS and have endpoint mappings defined in a Spring XML file. The beanname
mapping-type allows you to wire your Camel route into an existing endpoint mapping. When you're starting from scratch it's recommended to define your endpoint mappings as Camel URI's (as illustrated above with endpointMapping
) since it requires less configuration and is more expressive. Alternatively you could use vanilla Spring-WS with the help of annotations.
beanname
:
<camelContext xmlns="http://camel.apache.org/schema/spring"> <route> <from uri="spring-ws:beanname:QuoteEndpointDispatcher" /> <to uri="mock:example" /> </route> </camelContext> <bean id="legacyEndpointMapping" class="org.springframework.ws.server.endpoint.mapping.PayloadRootQNameEndpointMapping"> <property name="mappings"> <props> <prop key="{http://example.com/}GetFuture">FutureEndpointDispatcher</prop> <prop key="{http://example.com/}GetQuote">QuoteEndpointDispatcher</prop> </props> </property> </bean> <bean id="QuoteEndpointDispatcher" class="org.apache.camel.component.spring.ws.bean.CamelEndpointDispatcher" /> <bean id="FutureEndpointDispatcher" class="org.apache.camel.component.spring.ws.bean.CamelEndpointDispatcher" />
POJO (un)marshalling
JaxbDataFormat jaxb = new JaxbDataFormat(false); jaxb.setContextPath("com.example.model"); from("direct:example").marshal(jaxb).to("spring-ws:http://foo.com/bar").unmarshal(jaxb);
from("spring-ws:rootqname:{http://example.com/}GetFoo?endpointMapping=#endpointMapping").unmarshal(jaxb) .to("mock:example").marshal(jaxb);
Chapter 143. SQL Component
SQL Component
spring-jdbc
behind the scenes for the actual SQL handling.
- a JDBC based repository for the Idempotent Consumer EIP pattern. See further below.
- a JDBC based repository for the Aggregator EIP pattern. See further below.
URI format
from()
) and producer endpoints (e. g. to()
).In previous versions, it could only act as a producer.
sql:select * from table where id=# order by name[?options]
#name_of_the_parameter
style as shown:
sql:select * from table where id=:#myId order by name[?options]
java.util.Map
2. from message headers
sql:select * from table where id=:#${property.myId} order by name[?options]
?
symbol that denotes the parameters to an SQL query is substituted with the #
symbol, because the ?
symbol is used to specify options for the endpoint. The ?
symbol replacement can be configured on endpoint basis.
?option=value&option=value&...
Options
Option | Type | Default | Description |
---|---|---|---|
batch
|
boolean
|
false
|
Camel 2.7.5, 2.8.4 and 2.9: Execute SQL batch update statements. See notes below on how the treatment of the inbound message body changes if this is set to true .
|
dataSourceRef
|
String
|
null
|
Deprecated and will be removed in Camel 3.0: Reference to a DataSource to look up in the registry. Use dataSource=#theName instead.
|
dataSource
|
String
|
null
|
Camel 2.11: Reference to a DataSource to look up in the registry.
|
placeholder
|
String
|
#
|
Camel 2.4: Specifies a character that will be replaced to ? in SQL query. Notice, that it is simple String.replaceAll() operation and no SQL parsing is involved (quoted strings will also change)
|
template.<xxx>
|
null
|
Sets additional options on the Spring JdbcTemplate that is used behind the scenes to execute the queries. For instance, template.maxRows=10 . For detailed documentation, see the JdbcTemplate javadoc documentation.
|
|
allowNamedParameters
|
boolean
|
true
|
Camel 2.11: Whether to allow using named parameters in the queries. |
processingStrategy
|
Camel 2.11:SQL consumer only: Allows to plugin to use a custom org.apache.camel.component.sql.SqlProcessingStrategy to execute queries when the consumer has processed the rows/batch.
|
||
prepareStatementStrategy
|
Camel 2.11: Allows to plugin to use a custom org.apache.camel.component.sql.SqlPrepareStatementStrategy to control preparation of the query and prepared statement.
|
||
consumer.delay
|
long
|
500
|
Camel 2.11:SQL consumer only: Delay in milliseconds between each poll. |
consumer.initialDelay
|
long
|
1000
|
Camel 2.11:SQL consumer only: Milliseconds before polling starts. |
consumer.useFixedDelay
|
boolean
|
false
|
Camel 2.11:SQL consumer only: Set to true to use fixed delay between polls, otherwise fixed rate is used. See ScheduledExecutorService in JDK for details.
|
maxMessagesPerPoll
|
int
|
0
|
Camel 2.11:SQL consumer only: An integer value to define the maximum number of messages to gather per poll. By default, no maximum is set. |
consumer.useIterator
|
boolean
|
true
|
Camel 2.11:SQL consumer only: If true each row returned when polling will be processed individually. If false the entire java.util.List of data is set as the IN body.
|
consumer.routeEmptyResultSet
|
boolean
|
false
|
Camel 2.11:SQL consumer only: Whether to route a single empty Exchange if there was no data to poll. |
consumer.onConsume
|
String
|
null
|
Camel 2.11:SQL consumer only: After processing each row then this query can be executed, if the Exchange was processed successfully, for example to mark the row as processed. The query can have parameter. |
consumer.onConsumeFailed
|
String
|
null
|
Camel 2.11:SQL consumer only: After processing each row then this query can be executed, if the Exchange failed, for example to mark the row as failed. The query can have parameter. |
consumer.onConsumeBatchComplete
|
String
|
null
|
Camel 2.11:SQL consumer only: After processing the entire batch, this query can be executed to bulk update rows etc. The query cannot have parameters. |
consumer.expectedUpdateCount
|
int
|
\-1
|
Camel 2.11:SQL consumer only: If using consumer.onConsume then this option can be used to set an expected number of rows being updated. Typically you may set this to 1 to expect one row to be updated.
|
consumer.breakBatchOnConsumeFail
|
boolean
|
false
|
Camel 2.11:SQL consumer only: If using consumer.onConsume and it fails, then this option controls whether to break out of the batch or continue processing the next row from the batch.
|
alwaysPopulateStatement
|
boolean
|
false
|
Camel 2.11:SQL producer only: If enabled then the populateStatement method from org.apache.camel.component.sql.SqlPrepareStatementStrategy is always invoked, also if there is no expected parameters to be prepared. When this is false then the populateStatement is only invoked if there is 1 or more expected parameters to be set; for example this avoids reading the message body/headers for SQL queries with no parameters.
|
separator
|
char
|
,
|
Camel 2.11.1: The separator to use when parameter values is taken from message body (if the body is a String type), to be inserted at # placeholders. Notice if you use named parameters, then a Map type is used instead.
|
outputType
|
String
|
SelectList
|
Camel 2.12.0: Make the output of consumer or producer to
SelectList as List of Map, or SelectOne as single Java object in the following way: a) If the query has only single column, then that JDBC Column object is returned. (such as SELECT COUNT( * ) FROM PROJECT will return a Long object. b) If the query has more than one column, then it will return a Map of that result. c) If the outputClass is set, then it will convert the query result into an Java bean object by calling all the setters that match the column names. It will assume your class has a default constructor to create instance with. d) If the query resulted in more than one rows, it throws an non-unique result exception.
From Camel 2.14.1 onwards, the
SelectList also supports mapping each row to a Java object as the SelectOne does (only step c).
|
outputClass
|
String
|
null
|
Camel 2.12.0: Specify the full package and class name to use as conversion when outputType=SelectOne .
|
outputHeader
|
String
|
null
|
Camel 2.15: To store the result as a header instead of the message body. This allows to preserve the existing message body as-is. |
parametersCount
|
int
|
0
|
Camel 2.11.2/2.12.0 If set greater than zero, then Camel will use this count value of parameters to replace instead of querying via JDBC metadata API. This is useful if the JDBC vendor could not return correct parameters count, then user may override instead. |
noop
|
boolean
|
false
|
Camel 2.12.0 If set, will ignore the results of the SQL query and use the existing IN message as the OUT message for the continuation of processing |
Treatment of the message body
java.util.Iterator
type and then uses this iterator to fill the query parameters (where each query parameter is represented by a #
symbol, or other configured placeholder, in the endpoint URI). If the message body is not an array or collection, the conversion results in an iterator that iterates over only one object, which is the body itself.
java.util.List
, the first item in the list is substituted into the first occurrence of #
in the SQL query, the second item in the list is substituted into the second occurrence of #
, and so on.
batch
is set to true
, then the interpretation of the inbound message body changes slightly - instead of an iterator of parameters, the component expects an iterator that contains the parameter iterators; the size of the outer iterator determines the batch size.
Result of the query
select
operations, the result is an instance of List<Map<String, Object>>
type, as returned by the JdbcTemplate.queryForList() method. For update
operations, the result is the number of updated rows, returned as an Integer
.
outputHeader
parameter is set, the result is placed in the header. This is an alternative to using a full message enrichment pattern to add headers, it provides a concise syntax for querying a sequence or some other small value into a header. It is convenient to use outputHeader
and outputType
together, for example:
from("jms:order.inbox") .to("sql:select order_seq.nextval from dual?outputHeader=OrderId&outputType=SelectOne") .to("jms:order.booking");
Header values
update
operations, the SQL Component stores the update count in the following message headers:
Header | Description |
---|---|
CamelSqlUpdateCount
|
Apache Camel 2.0: The number of rows updated for update operations, returned as an Integer object.
|
CamelSqlRowCount
|
Apache Camel 2.0: The number of rows returned for select operations, returned as an Integer object.
|
CamelSqlQuery
|
Camel 2.8: Query to execute. This query takes precedence over the query specified in the endpoint URI. Note that query parameters in the header are represented by a ? instead of a # symbol
|
insert
operations, the SQL Component stores the rows with the generated keys and number of these rown in the following message headers (Available as of Camel 2.12.4, 2.13.1):
Header
|
Description
|
CamelSqlGeneratedKeysRowCount
|
The number of rows in the header that contains generated keys.
|
CamelSqlGeneratedKeyRows
|
Rows that contains the generated keys (a list of maps of keys).
|
Generated keys
CamelSqlRetrieveGeneratedKeys=true
. Then the generated keys will be provided as headers with the keys listed in the table above.
Configuration
DataSource
in the URI directly:
sql:select * from table where id=# order by name?dataSourceRef=myDS
Sample
List
of rows, where each row is a Map<String, Object
and the key is the column name.
// this is the database we create with some initial data for our unit test db = new EmbeddedDatabaseBuilder() .setType(EmbeddedDatabaseType.DERBY).addScript("sql/createAndPopulateDatabase.sql").build();
createAndPopulateDatabase.sql
we execute looks like as described below:
create table projects (id integer primary key, project varchar(10), license varchar(5)); insert into projects values (1, 'Camel', 'ASF'); insert into projects values (2, 'AMQ', 'ASF'); insert into projects values (3, 'Linux', 'XXX');
sql
component. Notice that we use a direct
endpoint in front of the sql
endpoint. This allows us to send an exchange to the direct
endpoint with the URI, direct:simple
, which is much easier for the client to use than the long sql:
URI. Note that the DataSource
is looked up up in the registry, so we can use standard Spring XML to configure our DataSource
.
from("direct:simple") .to("sql:select * from projects where license = # order by id?dataSourceRef=jdbc/myDataSource") .to("mock:result");
direct
endpoint that will route it to our sql
component that queries the database.
MockEndpoint mock = getMockEndpoint("mock:result"); mock.expectedMessageCount(1); // send the query to direct that will route it to the sql where we will execute the query // and bind the parameters with the data from the body. The body only contains one value // in this case (XXX) but if we should use multi values then the body will be iterated // so we could supply a List<String> instead containing each binding value. template.sendBody("direct:simple", "XXX"); mock.assertIsSatisfied(); // the result is a List List<?> received = assertIsInstanceOf(List.class, mock.getReceivedExchanges().get(0).getIn().getBody()); // and each row in the list is a Map Map<?, ?> row = assertIsInstanceOf(Map.class, received.get(0)); // and we should be able the get the project from the map that should be Linux assertEquals("Linux", row.get("PROJECT"));
DataSource
in Spring XML as follows:
<jee:jndi-lookup id="myDS" jndi-name="jdbc/myDataSource"/>
Using named parameters
from("direct:projects") .setHeader("lic", constant("ASF")) .setHeader("min", constant(123)) .to("sql:select * from projects where license = :#lic and id > :#min order by id")
java.util.Map
then the named parameters will be taken from the body.
from("direct:projects") .to("sql:select * from projects where license = :#lic and id > :#min order by id")
Using expression parameters
from("direct:projects") .setBody(constant("ASF")) .setProperty("min", constant(123)) .to("sql:select * from projects where license = :#${body} and id > :#${property.min} order by id")
Using the JDBC based idempotent repository
org.apache.camel.processor.idempotent.jdbc.AbstractJdbcMessageIdRepository
you can extend to build custom JDBC idempotent repository.
createdAt
column:
CREATE TABLE CAMEL_MESSAGEPROCESSED ( processorName VARCHAR(255), messageId VARCHAR(100), createdAt TIMESTAMP )
javax.sql.DataSource
in the spring XML file:
<jdbc:embedded-database id="dataSource" type="DERBY" />
<bean id="messageIdRepository" class="org.apache.camel.processor.idempotent.jdbc.JdbcMessageIdRepository"> <constructor-arg ref="dataSource" /> <constructor-arg value="myProcessorName" /> </bean> <camel:camelContext> <camel:errorHandler id="deadLetterChannel" type="DeadLetterChannel" deadLetterUri="mock:error"> <camel:redeliveryPolicy maximumRedeliveries="0" maximumRedeliveryDelay="0" logStackTrace="false" /> </camel:errorHandler> <camel:route id="JdbcMessageIdRepositoryTest" errorHandlerRef="deadLetterChannel"> <camel:from uri="direct:start" /> <camel:idempotentConsumer messageIdRepositoryRef="messageIdRepository"> <camel:header>messageId</camel:header> <camel:to uri="mock:result" /> </camel:idempotentConsumer> </camel:route> </camel:camelContext>
Customize the JdbcMessageIdRepository
org.apache.camel.processor.idempotent.jdbc.JdbcMessageIdRepository
for your needs:
Parameter | Default Value | Description |
---|---|---|
createTableIfNotExists | true | Defines whether or not Camel should try to create the table if it doesn't exist. |
tableExistsString | SELECT 1 FROM CAMEL_MESSAGEPROCESSED WHERE 1 = 0 | This query is used to figure out whether the table already exists or not. It must throw an exception to indicate the table doesn't exist. |
createString | CREATE TABLE CAMEL_MESSAGEPROCESSED (processorName VARCHAR(255), messageId VARCHAR(100), createdAt TIMESTAMP) | The statement which is used to create the table. |
queryString | SELECT COUNT(*) FROM CAMEL_MESSAGEPROCESSED WHERE processorName = ? AND messageId = ? |
The query which is used to figure out whether the message already exists in the repository (the result is not equals to '0'). It takes two parameters. This first one is the processor name (String ) and the second one is the message id (String ).
|
insertString | INSERT INTO CAMEL_MESSAGEPROCESSED (processorName, messageId, createdAt) VALUES (?, ?, ?) |
The statement which is used to add the entry into the table. It takes three parameter. The first one is the processor name (String ), the second one is the message id (String ) and the third one is the timestamp (java.sql.Timestamp ) when this entry was added to the repository.
|
deleteString | DELETE FROM CAMEL_MESSAGEPROCESSED WHERE processorName = ? AND messageId = ? |
The statement which is used to delete the entry from the database. It takes two parameter. This first one is the processor name (String ) and the second one is the message id (String ).
|
org.apache.camel.processor.idempotent.jdbc.JdbcMessageIdRepository
could look like:
<bean id="messageIdRepository" class="org.apache.camel.processor.idempotent.jdbc.JdbcMessageIdRepository"> <constructor-arg ref="dataSource" /> <constructor-arg value="myProcessorName" /> <property name="tableExistsString" value="SELECT 1 FROM CUSTOMIZED_MESSAGE_REPOSITORY WHERE 1 = 0" /> <property name="createString" value="CREATE TABLE CUSTOMIZED_MESSAGE_REPOSITORY (processorName VARCHAR(255), messageId VARCHAR(100), createdAt TIMESTAMP)" /> <property name="queryString" value="SELECT COUNT(*) FROM CUSTOMIZED_MESSAGE_REPOSITORY WHERE processorName = ? AND messageId = ?" /> <property name="insertString" value="INSERT INTO CUSTOMIZED_MESSAGE_REPOSITORY (processorName, messageId, createdAt) VALUES (?, ?, ?)" /> <property name="deleteString" value="DELETE FROM CUSTOMIZED_MESSAGE_REPOSITORY WHERE processorName = ? AND messageId = ?" /> </bean>
Using the JDBC based aggregation repository
camel-jdbc-aggregator
component. From Camel 2.7 onwards, the JdbcAggregationRepository
is provided in the camel-sql
component.
JdbcAggregationRepository
is an AggregationRepository
which on the fly persists the aggregated messages. This ensures that you will not loose messages, as the default aggregator will use an in memory only AggregationRepository
. The JdbcAggregationRepository
allows together with Camel to provide persistent support for the Aggregator.
Option | Type | Description |
---|---|---|
dataSource
|
DataSource
|
Mandatory: The javax.sql.DataSource to use for accessing the database.
|
repositoryName
|
String
|
Mandatory: The name of the repository. |
transactionManager
|
TransactionManager
|
Mandatory: The org.springframework.transaction.PlatformTransactionManager to mange transactions for the database. The TransactionManager must be able to support databases.
|
lobHandler
|
LobHandler
|
A org.springframework.jdbc.support.lob.LobHandler to handle Lob types in the database. Use this option to use a vendor specific LobHandler, for example when using Oracle.
|
returnOldExchange
|
boolean |
Whether the get operation should return the old existing Exchange if any existed. By default this option is false to optimize as we do not need the old exchange when aggregating.
|
useRecovery
|
boolean |
Whether or not recovery is enabled. This option is by default true . When enabled the Camel Aggregator automatic recover failed aggregated exchange and have them resubmitted.
|
recoveryInterval
|
long | If recovery is enabled then a background task is run every x'th time to scan for failed exchanges to recover and resubmit. By default this interval is 5000 millis. |
maximumRedeliveries
|
int |
Allows you to limit the maximum number of redelivery attempts for a recovered exchange. If enabled then the Exchange will be moved to the dead letter channel if all redelivery attempts failed. By default this option is disabled. If this option is used then the deadLetterUri option must also be provided.
|
deadLetterUri
|
String |
An endpoint uri for a Dead Letter Channel where exhausted recovered Exchanges will be moved. If this option is used then the maximumRedeliveries option must also be provided.
|
storeBodyAsText
|
boolean |
Camel 2.11: Whether to store the message body as String which is human readable. By default this option is false storing the body in binary format.
|
headersToStoreAsText
|
List<String>
|
Camel 2.11: Allows to store headers as String which is human readable. By default this option is disabled, storing the headers in binary format. |
optimisticLocking
|
false
|
Camel 2.12: To turn on optimistic locking, which often would be needed in clustered environments where multiple Camel applications shared the same JDBC based aggregation repository. |
jdbcOptimisticLockingExceptionMapper
|
Camel 2.12: Allows to plugin a custom org.apache.camel.processor.aggregate.jdbc.JdbcOptimisticLockingExceptionMapper to map vendor specific error codes to an optimistick locking error, for Camel to perform a retry. This requires optimisticLocking to be enabled.
|
What is preserved when persisting
JdbcAggregationRepository
will only preserve any Serializable
compatible data types. If a data type is not such a type its dropped and a WARN
is logged. And it only persists the Message
body and the Message
headers. The Exchange
properties are not persisted.
Recovery
JdbcAggregationRepository
will by default recover any failed Exchange. It does this by having a background tasks that scans for failed Exchanges in the persistent store. You can use the checkInterval
option to set how often this task runs. The recovery works as transactional which ensures that Camel will try to recover and redeliver the failed Exchange. Any Exchange which was found to be recovered will be restored from the persistent store and resubmitted and send out again.
Header | Type | Description |
---|---|---|
Exchange.REDELIVERED
|
Boolean | Is set to true to indicate the Exchange is being redelivered. |
Exchange.REDELIVERY_COUNTER
|
Integer | The redelivery attempt, starting from 1. |
confirm
method is invoked on the AggregationRepository
. This means if the same Exchange fails again it will be kept retried until it success.
maximumRedeliveries
to limit the maximum number of redelivery attempts for a given recovered Exchange. You must also set the deadLetterUri
option so Camel knows where to send the Exchange when the maximumRedeliveries
was hit.
Database
"_COMPLETED"
. The name must be configured in the Spring bean with the RepositoryName
property. In the following example aggregation will be used.
"aggregation"
with your aggregator repository name.
CREATE TABLE aggregation ( id varchar(255) NOT NULL, exchange blob NOT NULL, constraint aggregation_pk PRIMARY KEY (id) ); CREATE TABLE aggregation_completed ( id varchar(255) NOT NULL, exchange blob NOT NULL, constraint aggregation_completed_pk PRIMARY KEY (id) );
Storing body and headers as text
JdbcAggregationRepository
to store message body and select(ed) headers as String in separate columns. For example to store the body, and the following two headers companyName
and accountName
use the following SQL:
CREATE TABLE aggregationRepo3 ( id varchar(255) NOT NULL, exchange blob NOT NULL, body varchar(1000), companyName varchar(1000), accountName varchar(1000), constraint aggregationRepo3_pk PRIMARY KEY (id) ); CREATE TABLE aggregationRepo3_completed ( id varchar(255) NOT NULL, exchange blob NOT NULL, body varchar(1000), companyName varchar(1000), accountName varchar(1000), constraint aggregationRepo3_completed_pk PRIMARY KEY (id) );
<bean id="repo3" class="org.apache.camel.processor.aggregate.jdbc.JdbcAggregationRepository"> <property name="repositoryName" value="aggregationRepo3"/> <property name="transactionManager" ref="txManager3"/> <property name="dataSource" ref="dataSource3"/> <!-- configure to store the message body and following headers as text in the repo --> <property name="storeBodyAsText" value="true"/> <property name="headersToStoreAsText"> <list> <value>companyName</value> <value>accountName</value> </list> </property> </bean>
Codec (Serialization)
JdbcCodec
class. One detail of the code requires your attention: the ClassLoadingAwareObjectInputStream
.
ClassLoadingAwareObjectInputStream
has been reused from the Apache ActiveMQ project. It wraps an ObjectInputStream
and use it with the ContextClassLoader
rather than the currentThread
one. The benefit is to be able to load classes exposed by other bundles. This allows the exchange body and headers to have custom types object references.
Transaction
PlatformTransactionManager
is required to orchestrate transaction.
Service (Start/Stop)
start
method verify the connection of the database and the presence of the required tables. If anything is wrong it will fail during starting.
Aggregator configuration
lobHandler
property.
<bean id="lobHandler" class="org.springframework.jdbc.support.lob.OracleLobHandler"> <property name="nativeJdbcExtractor" ref="nativeJdbcExtractor"/> </bean> <bean id="nativeJdbcExtractor" class="org.springframework.jdbc.support.nativejdbc.CommonsDbcpNativeJdbcExtractor"/> <bean id="repo" class="org.apache.camel.processor.aggregate.jdbc.JdbcAggregationRepository"> <property name="transactionManager" ref="transactionManager"/> <property name="repositoryName" value="aggregation"/> <property name="dataSource" ref="dataSource"/> <!-- Only with Oracle, else use default --> <property name="lobHandler" ref="lobHandler"/> </bean>
Optimistic locking
optimisticLocking
and use this JDBC based aggregation repository in a clustered environment where multiple Camel applications shared the same database for the aggregation repository. If there is a race condition there JDBC driver will throw a vendor specific exception which the JdbcAggregationRepository
can react upon. To know which caused exceptions from the JDBC driver is regarded as an optimistick locking error we need a mapper to do this. Therefore there is a org.apache.camel.processor.aggregate.jdbc.JdbcOptimisticLockingExceptionMapper
allows you to implement your custom logic if needed. There is a default implementation org.apache.camel.processor.aggregate.jdbc.DefaultJdbcOptimisticLockingExceptionMapper
which works as follows:
- If the caused exception is an
SQLException
then the SQLState is checked if starts with 23. - If the caused exception is a
DataIntegrityViolationException
- If the caused exception class name has "ConstraintViolation" in its name.
- optional checking for FQN class name matches if any class names has been configured
<bean id="repo" class="org.apache.camel.processor.aggregate.jdbc.JdbcAggregationRepository"> <property name="transactionManager" ref="transactionManager"/> <property name="repositoryName" value="aggregation"/> <property name="dataSource" ref="dataSource"/> <property name"jdbcOptimisticLockingExceptionMapper" ref="myExceptionMapper"/> </bean> <!-- use the default mapper with extra FQN class names from our JDBC driver --> <bean id="myExceptionMapper" class="org.apache.camel.processor.aggregate.jdbc.DefaultJdbcOptimisticLockingExceptionMapper"> <property name="classNames"> <util:set> <value>com.foo.sql.MyViolationExceptoion</value> <value>com.foo.sql.MyOtherViolationExceptoion</value> </util:set> </property> </bean>
Chapter 144. SSH
SSH
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-ssh</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
ssh:[username[:password]@]host[:port][?options]
Options
Name | Default Value | Description |
---|---|---|
host
|
Hostname of SSH Server | |
port
|
22
|
Port of the SSH Server |
username
|
Username used for authenticating with SSH Server. | |
password
|
Password used for authenticating with SSH Server. Used if keyPairProvider is null.
|
|
keyPairProvider
|
Refers to a org.apache.sshd.common.KeyPairProvider to use for loading keys for authentication. If this option is used, then password is not used.
|
|
keyType
|
ssh-rsa
|
Refers to a key type to load from keyPairProvider . The key types can for example be "ssh-rsa" or "ssh-dss".
|
certResource
|
null
|
Camel 2.11: Path reference to a public key certificate. Prefix path with classpath: , file: , or http: .
|
certFilename
|
null
|
@deprecated: Use certResource instead. Refers to a filename to use within file based keyPairProvider .
|
timeout
|
30000
|
Milliseconds to wait beforing timing out connection to SSH Server. |
Consumer Only Options
Name | Default Value | Description |
---|---|---|
initialDelay
|
1000
|
Milliseconds before polling the SSH server starts. |
delay
|
500
|
Milliseconds before the next poll of the SSH Server. |
useFixedDelay
|
true
|
Controls if fixed delay or fixed rate is used. See ScheduledExecutorService in JDK for details.
|
pollCommand
|
null
|
Command to send to SSH Server during each poll cycle. You may need to end your command with a newline, and that must be URL encoded %0A .
|
Usage as a Producer endpoint
.to("ssh://...")
), it will send the message body as the command to execute on the remote SSH server.
&10;
).
<route id="camel-example-ssh-producer"> <from uri="direct:exampleSshProducer"/> <setBody> <constant>features:list </constant> </setBody> <to uri="ssh://karaf:karaf@localhost:8101"/> <log message="${body}"/> </route>
Authentication
- First, it will look to see if the
certResource
option has been set, and if so, use it to locate the referenced Public Key certificate and use that for authentication. - If
certResource
is not set, it will look to see if akeyPairProvider
has been set, and if so, it will use that to for certificate based authentication. - If neither
certResource
norkeyPairProvider
are set, it will use theusername
andpassword
options for authentication.
<route> <from uri="ssh://scott@localhost:8101?certResource=classpath:test_rsa&seFixedDelay=true&elay=5000&ollCommand=features:list%0A"/> <log message="${body}"/> </route>
from("ssh://scott@localhost:8101?certResource=classpath:test_rsa&useFixedDelay=true&delay=5000&pollCommand=features:list%0A") .log("${body}");
examples/camel-example-ssh-security
.
Certificate Dependencies
<dependency> <groupId>org.apache.sshd</groupId> <artifactId>sshd-core</artifactId> <version>0.8.0</version> </dependency> <dependency> <groupId>org.bouncycastle</groupId> <artifactId>bcpg-jdk15on</artifactId> <version>1.47</version> </dependency> <dependency> <groupId>org.bouncycastle</groupId> <artifactId>bcpkix-jdk15on</artifactId> <version>1.47</version> </dependency>
Example
examples/camel-example-ssh
and examples/camel-example-ssh-security
in the Camel distribution.
Chapter 145. StAX
StAX Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-stax</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
stax:content-handler-class
stax:org.superbiz.FooContentHandler
org.xml.sax.ContentHandler
bean from the Registry using the # syntax as shown:
stax:#myHandler
Usage of a content handler as StAX parser
from("file:target/in") .to("stax:org.superbiz.handler.CountingHandler") // CountingHandler implements org.xml.sax.ContentHandler or extends org.xml.sax.helpers.DefaultHandler .process(new Processor() { @Override public void process(Exchange exchange) throws Exception { CountingHandler handler = exchange.getIn().getBody(CountingHandler.class); // do some great work with the handler } });
Iterate over a collection using JAXB and StAX
import java.util.ArrayList; import java.util.List; import javax.xml.bind.annotation.XmlAccessType; import javax.xml.bind.annotation.XmlAccessorType; import javax.xml.bind.annotation.XmlElement; import javax.xml.bind.annotation.XmlRootElement; @XmlAccessorType(XmlAccessType.FIELD) @XmlRootElement(name = "records") public class Records { @XmlElement(required = true) protected List<Record> record; public List<Record> getRecord() { if (record == null) { record = new ArrayList<Record>(); } return record; } }
import javax.xml.bind.annotation.XmlAccessType; import javax.xml.bind.annotation.XmlAccessorType; import javax.xml.bind.annotation.XmlAttribute; import javax.xml.bind.annotation.XmlType; @XmlAccessorType(XmlAccessType.FIELD) @XmlType(name = "record", propOrder = { "key", "value" }) public class Record { @XmlAttribute(required = true) protected String key; @XmlAttribute(required = true) protected String value; public String getKey() { return key; } public void setKey(String key) { this.key = key; } public String getValue() { return value; } public void setValue(String value) { this.value = value; } }
<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <records> <record value="v0" key="0"/> <record value="v1" key="1"/> <record value="v2" key="2"/> <record value="v3" key="3"/> <record value="v4" key="4"/> <record value="v5" key="5"/> </record>
StAXBuilder
which can be used when iterating XML elements with the Camel Splitter
from("file:target/in") .split(stax(Record.class)).streaming() .to("mock:records");
stax
is a static method on org.apache.camel.component.stax.StAXBuilder
which you can static import in the Java code. The stax builder is by default namespace aware on the XMLReader it uses. From Camel 2.11.1 onwards you can turn this off by setting the boolean parameter to false, as shown below:
from("file:target/in") .split(stax(Record.class, false)).streaming() .to("mock:records");
The previous example with XML DSL
<!-- use STaXBuilder to create the expression we want to use in the route below for splitting the XML file --> <!-- notice we use the factory-method to define the stax method, and to pass in the parameter as a constructor-arg --> <bean id="staxRecord" class="org.apache.camel.component.stax.StAXBuilder" factory-method="stax"> <!-- FQN class name of the POJO with the JAXB annotations --> <constructor-arg index="0" value="org.apache.camel.component.stax.model.Record"/> </bean> <camelContext xmlns="http://camel.apache.org/schema/spring"> <route> <!-- pickup XML files --> <from uri="file:target/in"/> <split streaming="true"> <!-- split the file using StAX (ref to bean above) --> <!-- and use streaming mode in the splitter --> <ref>staxRecord</ref> <!-- and send each splitted to a mock endpoint, which will be a Record POJO instance --> <to uri="mock:records"/> </split> </route> </camelContext>
Chapter 146. Stomp
Stomp Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-stomp</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
stomp:queue:destination[?options]
Options
Property | Default | Description |
---|---|---|
brokerURL
|
tcp://localhost:61613
|
The URI of the Stomp broker to connect to |
login
|
The username | |
passcode
|
The password |
?option=value&option=value&...
Samples
from("direct:foo").to("stomp:queue:test");
from("stomp:queue:test").transform(body().convertToString()).to("mock:result")
Chapter 147. Stream
Stream Component
System.in
, System.out
and System.err
streams as well as allowing streaming of file and URL.
URI format
stream:in[?options] stream:out[?options] stream:err[?options] stream:header[?options]
file
and url
endpoint URIs are supported in Apache Camel 2.0:
stream:file?fileName=/foo/bar.txt stream:url[?options]
stream:header
URI is specified, the stream
header is used to find the stream to write to. This option is available only for stream producers (that is, it cannot appear in from()
).
?option=value&option=value&...
Options
Name | Default Value | Description |
---|---|---|
delay
|
0
|
Initial delay in milliseconds before consuming or producing the stream. |
encoding
|
JVM Default |
As of 1.4, you can configure the encoding (is a charset name) to use text-based streams (for example, message body is a String object). If not provided, Apache Camel uses the JVM default Charset.
|
promptMessage
|
null
|
Apache Camel 2.0: Message prompt to use when reading from stream:in ; for example, you could set this to Enter a command:
|
promptDelay
|
0
|
Apache Camel 2.0: Optional delay in milliseconds before showing the message prompt. |
initialPromptDelay
|
2000
|
Apache Camel 2.0: Initial delay in milliseconds before showing the message prompt. This delay occurs only once. Can be used during system startup to avoid message prompts being written while other logging is done to the system out. |
fileName
|
null
|
Apache Camel 2.0: When using the stream:file URI format, this option specifies the filename to stream to/from.
|
url
|
null
|
When using the stream:url URI format, this option specifies the URL to stream to/from. The input/output stream will be opened using the JDK URLConnection facility.
|
scanStream
|
false
|
Apache Camel 2.0: To be used for continuously reading a stream such as the unix
tail command. Camel 2.4 to Camel 2.6: will retry opening the file if it is overwritten, somewhat like tail --retry
|
retry
|
false
|
Camel 2.7: will retry opening the file if it's overwritten, somewhat like tail --retry
|
scanStreamDelay
|
0
|
Apache Camel 2.0: Delay in milliseconds between read attempts when using scanStream .
|
groupLines
|
0
|
Camel 2.5: To group X number of lines in the consumer. For example to group 10 lines and therefore only spit out an Exchange with 10 lines, instead of 1 Exchange per line. |
autoCloseCount
|
0
|
Camel 2.10.0: (2.9.3 and 2.8.6) Number of messages to process before closing stream on Producer side. Never close stream by default (only when Producer is stopped). If more messages are sent, the stream is reopened for another autoCloseCount batch.
|
closeOnDone
|
false
|
Camel 2.11.0: This option is used in combination with Splitter and streaming to the same file. The idea is to keep the stream open and only close when the Splitter is done, to improve performance. Mind this requires that you only stream to the same file, and not 2 or more files. |
Message content
String
or byte[]
for writing to streams. Just add either String
or byte[]
content to the message.in.body
. Messages sent to the stream: producer in binary mode are not followed by the newline character (as opposed to the String
messages). Message with null
body will not be appended to the output stream.
Samples
direct:in
endpoint to the System.out
stream:
// Route messages to the standard output. from("direct:in").to("stream:out"); // Send String payload to the standard output. // Message will be followed by the newline. template.sendBody("direct:in", "Hello Text World"); // Send byte[] payload to the standard output. // No newline will be added after the message. template.sendBody("direct:in", "Hello Bytes World".getBytes());
MyOutputStream
.
private OutputStream mystream = new MyOutputStream(); private StringBuffer sb = new StringBuffer(); @Test public void testStringContent() { template.sendBody("direct:in", "Hello"); // StreamProducer appends \n in text mode assertEquals("Hello\n", sb.toString()); } @Test public void testBinaryContent() { template.sendBody("direct:in", "Hello".getBytes()); // StreamProducer is in binary mode so no \n is appended assertEquals("Hello", sb.toString()); } protected RouteBuilder createRouteBuilder() { return new RouteBuilder() { public void configure() { from("direct:in").setHeader("stream", constant(mystream)). to("stream:header"); } }; } private class MyOutputStream extends OutputStream { public void write(int b) throws IOException { sb.append((char)b); } }
tail
command):
from("stream:file?fileName=/server/logs/server.log&scanStream=true&scanStreamDelay=1000").to("bean:logService?method=parseLogLine");
scanStream
and retry
is that the file will be re-opened and scanned with each iteration of scanStreamDelay
. Until NIO2 is available, we cannot reliably detect when a file is deleted or recreated.
Chapter 148. StringTemplate
String Template
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-stringtemplate</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
string-template:templateName[?options]
?option=value&option=value&...
Options
Option | Default | Description |
---|---|---|
contentCache
|
false
|
Cache for the resource content when its loaded. Note : as of Camel 2.9 cached resource content can be cleared via JMX using the endpoint's clearContentCache operation.
|
delimiterStart
|
null
|
Since Camel 2.11.1, configuring the variable start delimiter |
delimiterStop
|
null
|
Since Camel 2.11.1, configuring the variable end delimiter |
Headers
org.apache.camel.stringtemplate.resource
. The Resource is an org.springframework.core.io.Resource
object.
Hot reloading
contentCache=true
, Apache Camel loads the resource only once and hot-reloading is not possible. This scenario can be used in production when the resource never changes.
StringTemplate Attributes
java.util.Map
) to the string template. The Exchange is transfered as:
key | value |
---|---|
exchange
|
The Exchange itself. |
headers
|
The headers of the In message. |
camelContext
|
The Camel Context. |
request
|
The In message. |
in
|
The In message. |
body
|
The In message body. |
out
|
The Out message (only for InOut message exchange pattern). |
response
|
The Out message (only for InOut message exchange pattern). |
Map<String, Object> variableMap = new HashMap<String, Object>(); Map<String, Object> headersMap = new HashMap<String, Object>(); headersMap.put("name", "Willem"); variableMap.put("headers", headersMap); variableMap.put("body", "Monday"); variableMap.put("exchange", exchange); exchange.getIn().setHeader("CamelStringTemplateVariableMap", variableMap);
Samples
from("activemq:My.Queue"). to("string-template:com/acme/MyResponse.tm");
The Email Sample
StringTemplate
as: This example works for camel 2.11.0. If your camel version is less than 2.11.0, the variables should be started and ended with $.
Dear <headers.lastName>, <headers.firstName> Thanks for the order of <headers.item>. Regards Camel Riders Bookstore <body>
private Exchange createLetter() { Exchange exchange = context.getEndpoint("direct:a").createExchange(); Message msg = exchange.getIn(); msg.setHeader("firstName", "Claus"); msg.setHeader("lastName", "Ibsen"); msg.setHeader("item", "Camel in Action"); msg.setBody("PS: Next beer is on me, James"); return exchange; } @Test public void testVelocityLetter() throws Exception { MockEndpoint mock = getMockEndpoint("mock:result"); mock.expectedMessageCount(1); mock.expectedBodiesReceived("Dear Ibsen, Claus! Thanks for the order of Camel in Action. Regards Camel Riders Bookstore PS: Next beer is on me, James"); template.send("direct:a", createLetter()); mock.assertIsSatisfied(); } protected RouteBuilder createRouteBuilder() throws Exception { return new RouteBuilder() { public void configure() throws Exception { from("direct:a").to("string-template:org/apache/camel/component/stringtemplate/letter.tm").to("mock:result"); } }; }
Chapter 149. Stub
Stub Component
URI format
stub:someUri
someUri
can be any URI with any query parameters.
Examples
- stub:smtp://somehost.foo.com?user=whatnot&something=else
- stub:http://somehost.bar.com/something
Chapter 150. Swagger
Abstract
150.1. Overview
camel-swagger
component, which is used for exposing REST services and their APIs using Swagger.
Dependencies
pom.xml
file to use this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-swagger</artifactId> <version>x.x.x</version> <!-- Use the same version as your Camel core version --> <dependency>
Selecting the Swagger servlet
- Camel 2.15.x
org.apache.camel.component.swagger.DefaultCamelSwaggerServlet
NoteThis default servlet integrates with any environment, using JMX to discover the CamelContext(s) to use. It replaces both Camel 2.14.x servlets, which are deprecated from Camel 2.15 onwards. - Camel 2.14.xThe Swagger servlet is integrated with either Spring or the
servletListener
component:- Spring
org.apache.camel.component.swagger.spring.SpringRestSwaggerApiDeclarationServlet
servletListener
componentorg.apache.camel.component.swagger.servletlistener.ServletListenerRestSwaggerApiDelarationServlet
Servlet configuration parameters
Parameter | Type | Description |
---|---|---|
api.contact | String | Specifies an email used for API-related correspondence |
api.description | String | [Required] Provides a short description of the application |
api.license | String | Specifies the name of the license used for the API |
api.licenseUrl | String | Specifies the URL of the license used for the API |
api.path | String |
[Required] Specifies the location at which the API is available.
|
api.termsOfServiceUrl | String | Specifies the URL to the Terms of Service of the API |
api.title | String | [Required] Specifies the title of the application |
api.version | String | Specifies the version of the API. The default is 0.0.0 . |
base.path | String |
[Required] Specifies the location at which the REST services are available.
|
cors | Boolean |
Specifies whether to enable CORS. This parameter enables CORS for the API browser only. It does not enable access to the REST services. The default is
false .
Using the CorsFilter (see x) is recommended instead of using this parameter.
|
swagger.version | String | Specifies the version of the Swagger Specification. The default is 1.2 . |
Using the CorsFilter
- Access-Control-Allow-Origin = *
- Access-Control-Allow-Methods = GET, HEAD, POST, PUT, DELETE, TRACE, OPTIONS, CONNECT, PATCH
- Access-Control-Max-Age = 3600
- Access-Control-Allow-Headers = Origin, Accept, X-Requested-With, Content-Type, Access-Control-Request-Method, Access-Control-Request-Headers
org.apache.camel.component.swagger.RestSwaggerCorsFilter
to your WEB-INF/web.xml
file. For example:
<!-- Use CORs filter so people can use Swagger UI to browse and test the APIs --> <filter> <filter-name>RestSwaggerCorsFilter</filter-name <filter-class>org.apache.camel.component.swagger.RestSwaggerCorsFilter</filter-class> </filter> <filter-mapping> <filter-name>RestSwaggerCorsFilter</filter-name> <url-pattern>/api-docs/*</url-pattern> <url-pattern>/rest/*</url-pattern> </filter-mapping>
150.2. Configuring WAR deployments
WEB-INF/web.xml
file.
Camel 2.15.x
... <servlet> <servlet-name>ApiDeclarationServlet</servlet-name> <servlet-class>org.apache.camel.component.swagger.DefaultCamelSwaggerServlet</servlet-class> <!-- Specify the base.path and the api.path values using relative notation because the actual paths will be calculated at runtime as http://server:port/contextpath/rest and http://server:port/contextpath/api-docs, respectively --> <init-param> <param-name>base.path</param-name> <param-value>rest</param-value> </init-param> <init-param> <param-name>api.path</param-name> <param-value>api-docs</param-value> </init-param> <init-param> <param-name>api.version</param-name> <param-value>1.2.3</param-value> </init-param> <init-param> <param-name>api.title</param-name> <param-value>User Services</param-value> </init-param> <init-param> <param-name>api.description</param-name> <param-value>Camel Rest Example with Swagger that provides a User Rest service</param-value> </init-param> <load-on-startup>2</load-on-startup> </servlet> <!-- swagger api declaration --> <servlet-mapping> <servlet-name>ApiDeclarationServlet</servlet-name> <url-pattern>/api-docs/*</url-pattern> </servlet-mapping>
Camel 2.14.x
org.apache.camel.component.swagger.spring.SpringRestSwaggerApiDeclarationServlet
and org.apache.camel.component.swagger.servletlistener.ServletListenerRestSwaggerApiDelarationServlet
, support the same options.
... <servlet> <servlet-name>ApiDeclarationServlet</servlet-name> <servlet-class>org.apache.camel.component.swagger.spring.SpringRestSwaggerApiDeclarationServlet</servlet-class> <init-param> <param-name>base.path</param-name> <param-value>http://localhost:8080/rest</param-value> </init-param> <init-param> <param-name>api.path</param-name> <param-value>http://localhost:8080/api-docs</param-value> </init-param> <init-param> <param-name>api.version</param-name> <param-value>1.2.3</param-value> </init-param> <init-param> <param-name>api.title</param-name> <param-value>User Services</param-value> </init-param> <init-param> <param-name>api.description</param-name> <param-value>Camel Rest Example with Swagger that provides a User Rest service</param-value> </init-param> <load-on-startup>2</load-on-startup> </servlet> <!-- swagger api declaration --> <servlet-mapping> <servlet-name>ApiDeclarationServlet</servlet-name> <url-pattern>/api-docs/*</url-pattern> </servlet-mapping>
150.3. Configuring OSGi deployments
org.apache.camel.component.swagger.DefaultCamelSwaggerServlet
supports the options described in the section called “Servlet configuration parameters”.
blueprint.xml
file; for example:
<?xml version="1.0" encoding="UTF-8"?> <blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.osgi.org/xmlns/blueprint/v1.0.0 http://www.osgi.org/xmlns/blueprint/v1.0.0/blueprint.xsd http://camel.apache.org/schema/blueprint http://camel.apache.org/schema/blueprint/camel-blueprint.xsd"> <service interface="javax.servlet.http.HttpServlet"> <service-properties> <entry key="alias" value="/api-docs/*"/> <entry key="init-prefix" value="init."/> <entry key="init.base.path" value="//localhost:8080/"/> <entry key="init.api.path" value="//localhost:8181/api-docs"/> <entry key="init.api.title" value="Camel Rest Example API"/> <entry key="init.api.version" value="1.2"/> <entry key="init.api.description" value="Camel Rest Example with Swagger that provides an User REST service"/> </service-properties> <bean class="org.apache.camel.component.swagger.DefaultCamelSwaggerServlet" /> </service> <!-- The namespace for the camelContext element in Blueprint is 'http://camel.apache.org/schema/blueprint'. While it is not required to assign id's to the <camelContext/> and <route/> elements, it is a good idea to set those for runtime management purposes (logging, JMX MBeans, ...) --> <camelContext id="log-example-context" xmlns="http://camel.apache.org/schema/blueprint"> <restConfiguration component="jetty" port="8080"/> <rest path="/say"> <get uri="/hello"> <to uri="direct:hello"/> </get> <get uri="/bye" consumes="application/json"> <to uri="direct:bye"/> </get> <post uri="/bye"> <to uri="mock:update"/> </post> </rest> <route id="rte1-log-example"> <from uri="direct:hello"/> <transform> <constant>Hello World</constant> </transform> </route> <route id="rte2-log-example"> <from uri="direct:bye"/> <transform> <constant>Bye World</constant> </transform> </route> </camelContext> </blueprint>
service
- The
service
element exposes the camel swagger servlet (<bean class="org.apache.camel.component.swagger.DefaultCamelSwaggerServlet"/>
) and initializes several servlet properties. alias
- The
alias
property binds the camel swagger servlet to/api-docs/*
. init-prefix
- The
init-prefix
property sets the prefix for all camel swagger servlet properties toinit.
. This is analogous to usinginit-param
elements in theweb.xml
configuration in WAR implementations. restConfiguration
- In the camelContext, the
restConfiguration
element specifies Jetty as the web servlet on port 8080. rest
- In the camelContext, the
rest
element sets two REST endpoints and routes them to the camel endpoints defined in the following tworoute
elements.
Chapter 151. Test
Test Component
pom.xml
for this component when using Camel 2.8 or older:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-spring</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
test:expectedMessagesEndpointUri
URI Options
Name | Default Value | Description |
---|---|---|
timeout
|
2000
|
Camel 2.12: The timeout to use when polling for message bodies from the URI. |
Example
from("seda:someEndpoint"). to("test:file://data/expectedOutput?noop=true");
Chapter 152. Timer
Timer Component
URI format
timer:name[?options]
name
is the name of the Timer
object, which is created and shared across endpoints. So if you use the same name for all your timer endpoints, only one Timer
object and thread will be used.
?option=value&option=value&...
null
. So exchange.getIn().getBody()
returns null
.
Options
Name | Default Value | Description |
---|---|---|
time
|
null
|
A java.util.Date the first event should be generated. If using the URI, the pattern expected is: yyyy-MM-dd HH:mm:ss or yyyy-MM-dd'T'HH:mm:ss .
|
pattern
|
null
|
Allows you to specify a custom Date pattern to use for setting the time option using URI syntax.
|
period
|
1000
|
If greater than 0, generate periodic events every period milliseconds.
|
delay
|
1000
|
The number of milliseconds to wait before the first event is generated. Should not be used in conjunction with the time option. The default value has been changed to 1000 from Camel 2.11 onwards. In older releases the default value is 0 .
|
fixedRate
|
false
|
Events take place at approximately regular intervals, separated by the specified period. |
daemon
|
true
|
Specifies whether or not the thread associated with the timer endpoint runs as a daemon. |
repeatCount
|
0
|
Camel 2.8: Specifies a maximum limit of number of fires. So if you set it to 1, the timer will only fire once. If you set it to 5, it will only fire five times. A value of zero or negative means fire forever. |
Exchange Properties
Exchange
:
Name | Type | Description |
---|---|---|
Exchange.TIMER_NAME
|
String
|
The value of the name option.
|
Exchange.TIMER_TIME
|
Date
|
The value of the time option.
|
Exchange.TIMER_PERIOD
|
long
|
The value of the period option.
|
Exchange.TIMER_FIRED_TIME
|
Date
|
The time when the consumer fired. |
Exchange.TIMER_COUNTER
|
Long
|
Camel 2.8: The current fire counter. Starts from 1. |
Message Headers
Name | Type | Description |
---|---|---|
Exchange.TIMER_FIRED_TIME
|
java.util.Date
|
The time when the consumer fired |
Sample
from("timer://foo?fixedRate=true&period=60000").to("bean:myBean?method=someMethodName");
period=60s
.
someMethodName
method on the bean called myBean
in the Registry such as JNDI or Spring.
<route> <from uri="timer://foo?fixedRate=true&period=60000"/> <to uri="bean:myBean?method=someMethodName"/> </route>
Firing only once
repeatCount
option as follows:
<route> <from uri="timer://foo?repeatCount=1"/> <to uri="bean:myBean?method=someMethodName"/> </route>
Chapter 153. Twitter
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-twitter</artifactId> <version>${camel-version}</version> </dependency>
URI format
twitter://endpoint[?options]
TwitterComponent:
Option | Description |
---|---|
consumerKey
|
The consumer key |
consumerSecret
|
The consumer secret |
accessToken
|
The access token |
accessTokenSecret
|
The access token secret |
Consumer Endpoints:
List
through one single route exchange, camel-twitter
creates one route exchange per returned object. As an example, if timeline/home
results in five statuses, the route will be executed five times (once for each Status
).
Endpoint | Context | Body Type | Notice |
---|---|---|---|
directmessage
|
direct, polling |
twitter4j.DirectMessage
|
|
search
|
direct, polling |
twitter4j.Tweet
|
|
streaming/filter
|
event, polling |
twitter4j.Status
|
|
streaming/sample
|
event, polling |
twitter4j.Status
|
|
timeline/home
|
direct, polling |
twitter4j.Status
|
|
timeline/mentions
|
direct, polling |
twitter4j.Status
|
|
timeline/public
|
direct, polling |
twitter4j.Status
|
@deprecated. Use timeline/home or direct/home instead. Removed from Camel 2.11 onwards. |
timeline/retweetsofme
|
direct, polling |
twitter4j.Status
|
|
timeline/user
|
direct, polling |
twitter4j.Status
|
|
trends/daily
|
Camel 2.10.1: direct, polling | twitter4j.Status | @deprecated. Removed from Camel 2.11 onwards. |
trends/weekly
|
Camel 2.10.1: direct, polling | twitter4j.Status | @deprecated. Removed from Camel 2.11 onwards. |
Producer Endpoints:
Endpoint | Body Type |
---|---|
directmessage
|
String
|
search
|
List<twitter4j.Tweet>
|
timeline/user
|
String
|
URI Options
Name | Default Value | Description |
---|---|---|
type
|
direct
|
direct, event, or polling |
delay
|
60
|
in seconds |
consumerKey
|
null
|
Consumer Key. Can also be configured on the TwitterComponent level instead.
|
consumerSecret
|
null
|
Consumer Secret. Can also be configured on the TwitterComponent level instead.
|
accessToken
|
null
|
Access Token. Can also be configured on the TwitterComponent level instead.
|
accessTokenSecret
|
null
|
Access Token Secret. Can also be configured on the TwitterComponent level instead.
|
user
|
null
|
Username, used for user timeline consumption, direct message production, etc. |
locations
|
null
|
'lat,lon;lat,lon;...' Bounding boxes, created by pairs of lat/lons. Can be used for streaming/filter |
keywords
|
null
|
'foo1,foo2,foo3...' Can be used for search and streaming/filter. See Advanced search for keywords syntax for searching with for example OR. |
userIds
|
null
|
'username,username...' Can be used for streaming/filter |
filterOld
|
true
|
Filter out old tweets, that has previously been polled. This state is stored in memory only, and based on last tweet id. Since Camel 2.11.0 The search producer supports this option |
sinceId
|
1
|
Camel 2.11.0: The last tweet id which will be used for pulling the tweets. It is useful when the camel route is restarted after a long running. |
lang
|
null
|
Camel 2.11.0: The lang string ISO_639-1 which will be used for searching |
count
|
null
|
Camel 2.11.0: Limiting number of results per page. |
numberOfPages
|
1
|
Camel 2.11.0: The number of pages result which you want camel-twitter to consume. |
httpProxyHost
|
null
|
Camel 2.12.3: The http proxy host which can be used for the camel-twitter.
|
httpProxyPort
|
null
|
Camel 2.12.3: The http proxy port which can be used for the camel-twitter.
|
httpProxyUser
|
null
|
Camel 2.12.3: The http proxy user which can be used for the camel-twitter.
|
httpProxyPassword
|
null
|
Camel 2.12.3: The http proxy password which can be used for the camel-twitter.
|
useSSL
|
true
|
Camel 2.12.3: Using the SSL to connect the api.twitter.com if the option is true.
|
Message header
Name | Description |
---|---|
CamelTwitterKeywords
|
This header is used by the search producer to change the search key words dynamically. |
CamelTwitterSearchLanguage
|
Camel 2.11.0: This header can override the option of lang which set the search language for the search endpoint dynamically
|
CamelTwitterCount
|
Camel 2.11.0 This header can override the option of count which sets the max twitters that will be returned.
|
CamelTwitterNumberOfPages
|
Camel 2.11.0 This header can converrid the option of numberOfPages which sets how many pages we want to twitter returns.
|
Message body
To create a status update within your Twitter profile, send this producer a String body.
from("direct:foo") .to("twitter://timeline/user?consumerKey=[s]&consumerSecret=[s]&accessToken=[s]&accessTokenSecret=[s]);
To poll, every 5 sec., all statuses on your home timeline:
from("twitter://timeline/home?type=polling&delay=5&consumerKey=[s]&consumerSecret=[s]&accessToken=[s]&accessTokenSecret=[s]") .to("bean:blah");
To search for all statuses with the keyword 'camel':
from("twitter://search?type=direct&keywords=camel&consumerKey=[s]&consumerSecret=[s]&accessToken=[s]&accessTokenSecret=[s]") .to("bean:blah");
Searching using a producer with static keywords
from("direct:foo") .to("twitter://search?keywords=camel&consumerKey=[s]&consumerSecret=[s]&accessToken=[s]&accessTokenSecret=[s]");
Searching using a producer with dynamic keywords from header
CamelTwitterKeywords
header.
from("direct:foo") .setHeader("CamelTwitterKeywords", header("bar")) .to("twitter://search?consumerKey=[s]&consumerSecret=[s]&accessToken=[s]&accessTokenSecret=[s]");
Example
Chapter 154. Validation
Validation Component
URI format
validator:someLocalOrRemoteResource
msv:org/foo/bar.xsd
msv:file:../foo/bar.xsd
validator:com/mypackage/myschema.xsd
pom.xml
for this component when using Camel 2.8 or older:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-spring</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
Options
Option | Default | Description |
---|---|---|
resourceResolver
|
null
|
Camel 2.9: Reference to a org.w3c.dom.ls.LSResourceResolver in the Registry.
|
useDom
|
false
|
Apache Camel 2.0: Whether DOMSource /{{DOMResult}} or SaxSource /{{SaxResult}} should be used by the validator.
|
useSharedSchema
|
true
|
Camel 2.3: Whether the Schema instance should be shared or not. This option is introduced to work around a JDK 1.6.x bug. Xerces should not have this issue.
|
failOnNullBody
|
true
|
Camel 2.9.5/2.10.3: Whether to fail if no body exists. |
headerName
|
null
|
Camel 2.11: To validate against a header instead of the message body. |
failOnNullHeader
|
true
|
Camel 2.11: Whether to fail if no header exists when validating against a header. |
Example
<route> <from uri="direct:start"/> <doTry> <to uri="validator:org/apache/camel/component/validator/schema.xsd"/> <to uri="mock:valid"/> <doCatch> <exception>org.apache.camel.ValidationException</exception> <to uri="mock:invalid"/> </doCatch> <doFinally> <to uri="mock:finally"/> </doFinally> </doTry> </route>
Chapter 155. Velocity
Velocity
URI format
velocity:templateName[?options]
file://folder/myfile.vm
).
?option=value&option=value&...
Options
Option | Default | Description |
---|---|---|
loaderCache
|
true
|
Velocity based file loader cache. |
contentCache
|
true
|
Cache for the resource content when it is loaded. Note : as of Camel 2.9 cached resource content can be cleared via JMX using the endpoint's clearContentCache operation.
|
encoding
|
null
|
Character encoding of the resource content. |
propertiesFile
|
null
|
New option in Camel 2.1: The URI of the properties file which is used for VelocityEngine initialization. |
Message headers
Header | Description |
---|---|
CamelVelocityResourceUri | The templateName as a String object. |
fruit
in the Velocity template, template.tm
:
$in.setHeader("fruit", "Apple")
fruit
header is now accessible from the message.out.headers
.
Velocity Context
Map
). The Exchange
is transfered as:
key | value |
---|---|
exchange
|
The Exchange itself.
|
exchange.properties
|
The Exchange properties.
|
headers
|
The headers of the In message. |
camelContext
|
The Camel Context instance. |
request
|
The In message. |
in
|
The In message. |
body
|
The In message body. |
out
|
The Out message (only for InOut message exchange pattern). |
response
|
The Out message (only for InOut message exchange pattern). |
VelocityContext velocityContext = new VelocityContext(variableMap); exchange.getIn().setHeader("CamelVelocityContext", velocityContext);
Hot reloading
contentCache=true
, Apache Camel will only load the resource once, and thus hot reloading is not possible. This scenario can be used in production, when the resource never changes.
Dynamic templates
Header | Type | Description |
---|---|---|
CamelVelocityResourceUri | String | Camel 2.1: A URI for the template resource to use instead of the endpoint configured. |
CamelVelocityTemplate | String | Camel 2.1: The template to use instead of the endpoint configured. |
Samples
from("activemq:My.Queue"). to("velocity:com/acme/MyResponse.vm");
JMSReplyTo
header).
from("activemq:My.Queue"). to("velocity:com/acme/MyResponse.vm"). to("activemq:Another.Queue");
.vm
template never changes:
from("activemq:My.Queue"). to("velocity:com/acme/MyResponse.vm?contentCache=true"). to("activemq:Another.Queue");
from("activemq:My.Queue"). to("velocity:file://myfolder/MyResponse.vm?contentCache=true"). to("activemq:Another.Queue");
from("direct:in"). setHeader("CamelVelocityResourceUri").constant("path/to/my/template.vm"). to("velocity:dummy");
from("direct:in"). setHeader("CamelVelocityTemplate").constant("Hi this is a velocity template that can do templating ${body}"). to("velocity:dummy");
The Email Sample
Dear ${headers.lastName}, ${headers.firstName} Thanks for the order of ${headers.item}. Regards Camel Riders Bookstore ${body}
private Exchange createLetter() { Exchange exchange = context.getEndpoint("direct:a").createExchange(); Message msg = exchange.getIn(); msg.setHeader("firstName", "Claus"); msg.setHeader("lastName", "Ibsen"); msg.setHeader("item", "Camel in Action"); msg.setBody("PS: Next beer is on me, James"); return exchange; } @Test public void testVelocityLetter() throws Exception { MockEndpoint mock = getMockEndpoint("mock:result"); mock.expectedMessageCount(1); mock.expectedBodiesReceived("Dear Ibsen, Claus\n\nThanks for the order of Camel in Action.\n\nRegards Camel Riders Bookstore\nPS: Next beer is on me, James"); template.send("direct:a", createLetter()); mock.assertIsSatisfied(); } protected RouteBuilder createRouteBuilder() throws Exception { return new RouteBuilder() { public void configure() throws Exception { from("direct:a").to("velocity:org/apache/camel/component/velocity/letter.vm").to("mock:result"); } }; }
Chapter 156. Vertx
Vertx Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-vertx</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
vertx:channelName[?options]
Options
Name
|
Default Value
|
Description
|
pubSub
|
false
|
Camel 2.12.3: Whether to use publish/subscribe instead of point to point when sending to a vertx endpoint.
|
You can append query options to the URI in the following format, ?option=value&option=value&...
Chapter 157. VM
VM Component
camel-core.jar
is on the system/boot
classpath).
URI format
vm:queueName[?options]
queueName
can be any string to uniquely identify the endpoint within the JVM (or at least within the classloader that loaded camel-core.jar)
?option=value&option=value&...
queueName
portion of the URI is identical. For example:
from("direct:foo").to("vm:bar?concurrentConsumers=5"); from("vm:bar?concurrentConsumers=5").to("file://output");
bar
, we could rewrite the previous exmple as follows:
from("direct:foo").to("vm:bar"); from("vm:bar?concurrentConsumers=5").to("file://output");
Options
Samples
order.email
:
from("direct:in").bean(MyOrderBean.class).to("vm:order.email");
.war
application):
from("vm:order.email").bean(MyOrderEmailSender.class);
Chapter 158. Weather
Weather Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-weather</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
weather://<unused name>[?options]
Options
Property | Default | Description |
---|---|---|
location
|
null
|
If null Camel will try and determine your current location using the geolocation of your ip address, else specify the city,country. For well known city names, Open Weather Map will determine the best fit, but multiple results may be returned. Hence specifying and country as well will return more accurate data. If you specify "current" as the location then the component will try to get the current latitude and longitude and use that to get the weather details. You can use lat and lon options instead of location. |
lat
|
null
|
Latitude of location. You can use lat and lon options instead of location. |
lon
|
null
|
Longitude of location. You can use lat and lon options instead of location. |
period
|
null
|
If null, the current weather will be returned, else use values of 5, 7, 14 days. Only the numeric value for the forecast period is actually parsed, so spelling, capitalisation of the time period is up to you (its ignored) |
headerName
|
null
|
To store the weather result in this header instead of the message body. This is useable if you want to keep current message body as-is. |
mode
|
JSON
|
The output format of the weather data. The possible values are HTML , JSON or XML
|
units
|
METRIC
|
The units for temperature measurement. The possible values are IMPERIAL or METRIC
|
consumer.delay
|
3600000
|
Delay in millis between each poll (default is 1 hour) |
consumer.initialDelay
|
1000
|
Millis before polling starts. |
consumer.userFixedDelay
|
false
|
If true , use fixed delay between polls, otherwise fixed rate is used. See ScheduledExecutorService in JDK for details.
|
?option=value&option=value&...
Exchange data format
mode
option above).
Message Headers
Header | Description |
---|---|
CamelWeatherQuery
|
The original query URL sent to the Open Weather Map site |
CamelWeatherLocation
|
Used by the producer to override the endpoint location and use the location from this header instead. |
Samples
from("weather:foo?location=Madrid,Spain&period=7 days").to("jms:queue:weather");
from("weather:foo").to("jms:queue:weather");
from("direct:start") .to("weather:foo?location=Madrid,Spain");
String json = template.requestBodyAndHeader("direct:start", "", "CamelWeatherLocation", "Paris,France", String.class);
String json = template.requestBodyAndHeader("direct:start", "", "CamelWeatherLocation", "current", String.class);
Chapter 159. Websocket
Websocket Component
URI format
websocket://hostname[:port][/resourceUri][?options]
?option=value&option=value&...
Component Options
WebsocketComponent
can be configured prior to use, to setup host, to act as a websocket server.
Option | Default | Description |
---|---|---|
host
|
0.0.0.0 | The hostname. |
port
|
9292 | The port number. |
staticResources
|
null
|
Path for static resources such as index.html files etc. If this option has been configured, then a server is started on the given hostname and port, to service the static resources, eg such as an index.html file. If this option has not been configured, then no server is started. |
sslContextParameters
|
Reference to a org.apache.camel.util.jsse.SSLContextParameters in the Registry. This reference overrides any configured SSLContextParameters at the component level. See Using the JSSE Configuration Utility.
|
|
enableJmx
|
false
|
If this option is true, Jetty JMX support will be enabled for this endpoint. |
sslKeyPassword
|
null
|
Consumer only: The password for the keystore when using SSL. |
sslPassword
|
null
|
Consumer only: The password when using SSL. |
sslKeystore
|
null
|
Consumer only: The path to the keystore. |
minThreads
|
null
|
Consumer only: To set a value for minimum number of threads in server thread pool. |
maxThreads
|
null
|
Consumer only: To set a value for maximum number of threads in server thread pool. |
threadPool
|
null
|
Consumer only: To use a custom thread pool for the server. |
Endpoint Options
WebsocketEndpoint
can be configured prior to use
Option | Default | Description |
---|---|---|
sslContextParametersRef
|
Deprecated and will be removed in Camel 3.0: Reference to a org.apache.camel.util.jsse.SSLContextParameters in the Registry. This reference overrides any configured SSLContextParameters at the component level. See Using the JSSE Configuration Utility. Use the sslContextParameters option instead
|
|
sslContextParameters
|
Camel 2.11.1: Reference to a org.apache.camel.util.jsse.SSLContextParameters in the Registry. This reference overrides any configured SSLContextParameters at the component level. See Using the JSSE Configuration Utility.
|
|
sendToAll
|
null
|
Producer only: To send to all websocket subscribers. Can be used to configure on endpoint level, instead of having to use the WebsocketConstants.SEND_TO_ALL header on the message.
|
staticResources
|
null
|
The root directory for the web resources or classpath. Use the protocol file: or classpath: depending if you want that the component loads the resource from file system or classpath. |
sslContextParameters
|
|
Reference to a
org.apache.camel.util.jsse.SSLContextParameters in the Registry. This reference overrides any configured SSLContextParameters at the component level. See Using the JSSE Configuration Utility.
|
enableJmx
|
false
|
If this option is true, Jetty JMX support will be enabled for this endpoint. See Jetty JMX support for more details.
|
sslKeyPassword
|
null
|
Consumer only: The password for the keystore when using SSL.
|
sslPassword
|
null
|
Consumer only: The password when using SSL.
|
sslKeystore
|
null
|
Consumer only: The path to the keystore.
|
minThreads
|
null
|
Consumer only: To set a value for minimum number of threads in server thread pool.
|
maxThreads
|
null
|
Consumer only: To set a value for maximum number of threads in server thread pool.
|
threadPool
|
null
|
Consumer only: To use a custom thread pool for the server.
|
Message Headers
Key | Description |
---|---|
WebsocketConstants.SEND_TO_ALL
|
Sends the message to all clients which are currently connected. You can use the sendToAll option on the endpoint instead of using this header.
|
WebsocketConstants.CONNECTION_KEY
|
Sends the message to the client with the given connection key. |
Usage
0.0.0.0:9292
. The example will send back an echo of the input. To send back a message, we need to send the transformed message to the same endpoint "websocket://echo"
. This is needed because by default the messaging is InOnly.
// expose a echo websocket client, that sends back an echo from("websocket://echo") .log(">>> Message received from WebSocket Client : ${body}") .transform().simple("${body}${body}") // send back to the client, by sending the message to the same endpoint // this is needed as by default messages is InOnly // and we will by default send back to the current client using the provided connection key .to("websocket://echo");
from("activemq:topic:newsTopic") .routeId("fromJMStoWebSocket") .to("websocket://localhost:8443/newsTopic?sendToAll=true&staticResources=classpath:webapp");
Setting up SSL for WebSocket Component
Using the JSSE Configuration Utility
Programmatic configuration of the component
KeyStoreParameters ksp = new KeyStoreParameters(); ksp.setResource("/users/home/server/keystore.jks"); ksp.setPassword("keystorePassword"); KeyManagersParameters kmp = new KeyManagersParameters(); kmp.setKeyStore(ksp); kmp.setKeyPassword("keyPassword"); TrustManagersParameters tmp = new TrustManagersParameters(); tmp.setKeyStore(ksp); SSLContextParameters scp = new SSLContextParameters(); scp.setKeyManagers(kmp); scp.setTrustManagers(tmp); CometdComponent commetdComponent = getContext().getComponent("cometds", CometdComponent.class); commetdComponent.setSslContextParameters(scp);
Spring DSL based configuration of endpoint
... <camel:sslContextParameters id="sslContextParameters"> <camel:keyManagers keyPassword="keyPassword"> <camel:keyStore resource="/users/home/server/keystore.jks" password="keystorePassword"/> </camel:keyManagers> <camel:trustManagers> <camel:keyStore resource="/users/home/server/keystore.jks" password="keystorePassword"/> </camel:trustManagers> </camel:sslContextParameters>... ... <to uri="websocket://127.0.0.1:8443/test?sslContextParameters=#sslContextParameters"/>...
Java DSL based configuration of endpoint
... protected RouteBuilder createRouteBuilder() throws Exception { return new RouteBuilder() { public void configure() { String uri = "websocket://127.0.0.1:8443/test?sslContextParameters=#sslContextParameters"; from(uri) .log(">>> Message received from WebSocket Client : ${body}") .to("mock:client") .loop(10) .setBody().constant(">> Welcome on board!") .to(uri); ...
- Twitter Websocket Example demonstrates how to poll a constant feed of twitter searches and publish results in real time using web socket to a web page.
Chapter 160. XmlRpc
XmlRpc Component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-xmlrpc</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
XmlRpc Overview
<?xml version="1.0"?> <methodCall> <methodName>examples.getStateName</methodName> <params> <param> <value><i4>40</i4></value> </param> </params> </methodCall>
<?xml version="1.0"?> <methodResponse> <params> <param> <value><string>South Dakota</string></value> </param> </params> </methodResponse>
<?xml version="1.0"?> <methodResponse> <fault> <value> <struct> <member> <name>faultCode</name> <value><int>4</int></value> </member> <member> <name>faultString</name> <value><string>Too many parameters.</string></value> </member> </struct> </value> </fault> </methodResponse>
URI format
xmlrpc://serverUri[?options]
Options
Property | Default | Description |
---|---|---|
basicEncoding
|
null
|
Sets the encoding for basic authentication, null means UTF-8 is chosen. |
basicUserName
|
null
|
The user name for basic authentication. |
basicPassword
|
null
|
The password for basic authentication. |
clientConfigurer
|
null
|
The reference id of the XmlRpcClient configurer which implement the interface of XmlRpcClientConfigurer to setup the XmlRpcClient as user wants. The value should be start with "#" such as "#myConfigurer" |
connectionTimeout
|
0
|
Set the connection timeout in milliseconds, 0 is to disable it |
contentLengthOptional
|
false
|
whether a "Content-Length" header may be omitted. The XML-RPC specification demands, that such a header be present. |
enabledForExceptions
|
false
|
whether the response should contain a "faultCause" element in case of errors. The "faultCause" is an exception, which the server has trapped and written into a byte stream as a serializable object. |
enabledForExtensions
|
false
|
whether extensions are enabled. By default, the client or server is strictly compliant to the XML-RPC specification and extensions are disabled. |
encoding
|
null
|
Sets the requests encoding, null means UTF-8 is chosen. |
gzipCompressing
|
false
|
Whether gzip compression is being used for transmitting the request. |
gzipRequesting
|
false
|
Whether gzip compression is being used for transmitting the request. |
replyTimeout
|
0
|
Set the reply timeout in milliseconds, 0 is to disable it. |
userAgent
|
null
|
The http user agent header to set when doing xmlrpc requests |
Message Headers
Header | Description |
---|---|
CamelXmlRpcMethodName
|
The XmlRpc method name which will be use for invoking the XmlRpc server. |
Using the XmlRpc data format
<camelContext id="camel" xmlns="http://camel.apache.org/schema/spring"> <!-- we define the xml rpc data formats to be used --> <dataFormats> <xmlrpc id="xmlrpcRequest" request="true"/> <xmlrpc id="xmlrpcResponse" request="false"/> </dataFormats> <route> <from uri="direct:request"/> <marshal ref="xmlrpcRequest"/> <unmarshal> <xmlrpc request="true"/> </unmarshal> <to uri="mock:request" /> </route> <route> <from uri="direct:response"/> <marshal> <xmlrpc request="false"/> </marshal> <unmarshal ref="xmlrpcResponse"/> <to uri="mock:response" /> </route> </camelContext>
Invoke XmlRpc Service from Client
String response = template.requestBodyAndHeader(xmlRpcServiceAddress, new Object[]{"me"}, XmlRpcConstants.METHOD_NAME, "hello", String.class);
How to configure the XmlRpcClient with Java code
import org.apache.xmlrpc.client.XmlRpcClient; import org.apache.xmlrpc.client.XmlRpcClientConfigImpl; public class MyClientConfigurer implements XmlRpcClientConfigurer { @Override public void configureXmlRpcClient(XmlRpcClient client) { // get the configure first XmlRpcClientConfigImpl clientConfig = (XmlRpcClientConfigImpl)client.getClientConfig(); // change the value of clientConfig clientConfig.setEnabledForExtensions(true); // set the option on the XmlRpcClient client.setMaxThreads(10); } }
Chapter 161. XML Security component
XML Security component
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-xmlsecurity</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
XML Signature wrapping modes
<[parent element]> ... <!-- Signature element is added as last child of the parent element--> <Signature Id="generated_unique_signature_id"> <SignedInfo> <Reference URI=""> <Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/> (<Transform>)* <!-- By default "http://www.w3.org/2006/12/xml-c14n11" is added to the transforms --> <DigestMethod> <DigestValue> </Reference> (<Reference URI="#[keyinfo_Id]"> <Transform Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/> <DigestMethod> <DigestValue> </Reference>)? <!-- further references possible, see option 'properties' below --> </SignedInfo> <SignatureValue> (<KeyInfo Id="[keyinfo_id]">)? <!-- Object elements possible, see option 'properties' below --> </Signature> </[parent element]>
<Signature Id="generated_unique_signature_id"> <SignedInfo> <Reference URI="#generated_unique_object_id" type="[optional_type_value]"> (<Transform>)* <!-- By default "http://www.w3.org/2006/12/xml-c14n11" is added to the transforms --> <DigestMethod> <DigestValue> </Reference> (<Reference URI="#[keyinfo_id]"> <Transform Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/> <DigestMethod> <DigestValue> </Reference>)? <!-- further references possible, see option 'properties' below --> </SignedInfo> <SignatureValue> (<KeyInfo Id="[keyinfo_id]">)? <Object Id="generated_unique_object_id"/> <!-- The Object element contains the in-message body --> <!-- The object ID can either be generated or set by the option parameter "contentObjectId" --> <!-- Further Object elements possible, see option 'properties' below --> </Signature>
(<[signed element] Id="[id_value]"> <!-- signed element must have an attribute of type ID --> ... </[signed element]> <other sibling/>* <!-- between the signed element and the corresponding signature element, there can be other siblings. Signature element is added as last sibling. --> <Signature Id="generated_unique_ID"> <SignedInfo> <CanonicalizationMethod> <SignatureMethod> <Reference URI="#[id_value]" type="[optional_type_value]"> <!-- reference URI contains the ID attribute value of the signed element --> (<Transform>)* <!-- By default "http://www.w3.org/2006/12/xml-c14n11" is added to the transforms --> <DigestMethod> <DigestValue> </Reference> (<Reference URI="#[generated_keyinfo_Id]"> <Transform Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/> <DigestMethod> <DigestValue> </Reference>)? </SignedInfo> <SignatureValue> (<KeyInfo Id="[generated_keyinfo_id]">)? </Signature>)+
URI format
xmlsecurity:sign:name[?options] xmlsecurity:verify:name[?options]
- With the signer endpoint, you can generate a XML signature for the body of the in-message which can be either a XML document or a plain text. The enveloped enveloping, or detached (as of Camel 12.14) XML signature(s) will be set to the body of the out-message.
- With the verifier endpoint, you can validate an enveloped or enveloping XML signature or even several detached (as of Camel 2.14.0) XML signatures contained in the body of the in-message; if the validation is successful, then the original content is extracted from the XML signature and set to the body of the out-message.
- The
name
part in the URI can be chosen by the user to distinguish between different signer/verifier endpoints within the camel context.
Basic Example
from("direct:enveloping").to("xmlsecurity:sign://enveloping?keyAccessor=#accessor", "xmlsecurity:verify://enveloping?keySelector=#selector","mock:result")
<from uri="direct:enveloping" /> <to uri="xmlsecurity:sign://enveloping?keyAccessor=#accessor" /> <to uri="xmlsecurity:verify://enveloping?keySelector=#selector" /> <to uri="mock:result" />
org.apache.camel.component.xmlsecurity.api
contains the default implementation class DefaultKeyAccessor which reads the private key from a Java keystore.
org.apache.camel.component.xmlsecurity.api
contains the default implementation class DefaultKeySelector which reads the public key from a keystore.
http://www.w3.org/2000/09/xmldsig#rsa-sha1
is used. You can set the signature algorithm of your choice by the option signatureAlgorithm
(see below). The signer endpoint creates an enveloping XML signature. If you want to create an enveloped XML signature then you must specify the parent element of the Signature element; see option parentLocalName
for more details.
Common Signing and Verifying Options
Name | Type | Default | Description |
---|---|---|---|
uriDereferencer | javax.xml.crypto.URIDereferencer | null | URI dereferencer. You can specify here your own URI dereferencer, if you want to restrict the dereferencing or have special requirements for dereferencing. |
baseUri | String | null | Base URI used in the URI dereferencer. Relative URIs are concatenated with the base URI. |
cryptoContextProperties | Map<String, ? extends Object> | null |
Crypto context properties. See javax.xml.crypto.XMLCryptoContext.setProperty(String, Object) . The properties can depend on the provider. For example, the JDK provider XMLDSig has the property org.jcp.xml.dsig.validateManifests for enabling manifest validation. The following properties are set by default to the value Boolean.TRUE for the XML verifier: org.jcp.xml.dsig.validateManifests , javax.xml.crypto.dsig.cacheReference . If the secureValidation option is true , additionally the properties org.apache.jcp.xml.dsig.secureValidation and org.jcp.xml.dsig.secureValidation are set to Boolean.TRUE for the XML verifier. If you want to switch these features off you must set the property values to Boolean.FALSE .
|
disallowDoctypeDecl | Boolean | Boolean.TRUE | Indicator whether DTD DOCTYPE declarations shall be disallowed in the incoming XML message. |
omitXmlDeclaration | Boolean | Boolean.FALSE | Indicator whether the XML declaration header shall be omitted in the output XML message. |
clearHeaders | Boolean | Boolean.TRUE | Indicator whether the XML signature message headers defined in XmlSignatureConstants shall be deleted at the end of the signer or verifier processing. |
schemaResourceUri | String | null |
Since Camel 2.14.0. Classpath to the XML Schema file. If set, the XML document is validated against the XML schema. Must be set in the case of detached signatures in order to determine the attributes of type ID. This value can be overwritten by the header CamelXmlSignatureSchemaResourceUri . For further information, see the section called “Detached XML Signatures as Siblings of the Signed Elements”.
|
outputXmlEncoding | String | null | Since Camel 2.15.0. Character encoding of the output XML document. If null then UTF-8 is used. |
Signing Options
Name | Type | Default | Description |
---|---|---|---|
keyAccessor | KeyAccessor | null | Provides the signing key and the KeyInfo instance. There is an example implementation which uses a keystore, see DefaultKeyAccessor |
addKeyInfoReference | Boolean | Boolean.TRUE |
Indicates whether a Reference element referring to the KeyInfo element provided by the key accessor should be added to the XML signature.
|
signatureAlgorithm | String |
http://www.w3.org/2000/09/xmldsig#rsa-sha1
|
signature algorithm consisting of a digest and encryption algorithm. The digest algorithm is used to calculate the digest of the SignedInfo element and the encryption algorithm is used to sign this digest. Possible values: http://www.w3.org/2000/09/xmldsig#dsa-sha1 , http://www.w3.org/2000/09/xmldsig#rsa-sha1 , http://www.w3.org/2001/04/xmldsig-more#rsa-sha256 , http://www.w3.org/2001/04/xmldsig-more#rsa-sha384 , http://www.w3.org/2001/04/xmldsig-more#rsa-sha512
|
digestAlgorithm | String | see description |
Digest algorithm for calculating the digest of the in-message body. If not specified then the digest algorithm of the signature algorithm is used. Possible values: http://www.w3.org/2000/09/xmldsig#sha1 , http://www.w3.org/2001/04/xmlenc#sha256 , http://www.w3.org/2001/04/xmldsig-more#sha384 , http://www.w3.org/2001/04/xmlenc#sha512 .
|
parentLocalName | String | null |
Local name of the parent of the Signature element. The Signature element will be added at the end of the children of the parent. Necessary for enveloped XML signature. If this option and the parentXpath option are null , an enveloping XML signature is created. See also option parentNamespace . Alternatively you can specify the parent via the option parentXpath .
|
parentNamespace | String | null |
Namespace of the parent of the Signature element. See option parentLocalName
|
parentXpath | XPathFilterParameterSpec | null |
Since Camel 2.15.0. XPath to the parent of the Signature element. The Signature element will be added at the end of the children of the parent. Necessary for enveloped XML signature. If this option and the parentLocalName option are null , an enveloping XML signature is created. Alternatively, you can specify the parent via the option parentLocalName . Example: /p1:root/SecurityItem[last()] . This example will select the last sibling with the name SecurityItem . Such kind of selection is not possible with the option parentLocalName .
|
canonicalizationMethod | javax.xml.crypto.AlgorithmMethod | C14n | Canonicalization method used to canonicalize the SignedInfo element before the digest is calculated. You can use the helper methods XmlSignatureHelper.getCanonicalizationMethod(String algorithm) or getCanonicalizationMethod(String algorithm, List<String> inclusiveNamespacePrefixes) to create a canonicalization method. |
transformMethods | List<javax.xml.crypto.AlgorithmMethod> | see description |
Transforms which are executed on the message body before the digest is calculated. By default, C14n is added and in the case of enveloped signature (see option parentLocalName ) also http://www.w3.org/2000/09/xmldsig#enveloped-signature is added at position 0 of the list. Use methods in XmlSignatureHelper to create the transform methods.
|
prefixForXmlSignatureNamespace | String |
ds
|
Prefix for the XML signature namespace. If null is specified or an empty string then no prefix is used for the signature namespace.
|
contentReferenceUri | String | See description |
The URI of the reference to the signed content (in-message body). If null and we are in the enveloped XML signature case then the URI is set to an empty string. If null and we are in the enveloping XML signature case then the URI is set to generated_object_id , which means that the reference points to the Object element containing the in-message body. You can use this option to reference a specific part in your in-message body if you do not want to sign the complete in-message body. This value can be overwritten by the header CamelXmlSignatureContentReferenceUri . Please be aware, if you want to use a value of an XML ID attribute (example: #ID_value ), you must provide the information about the ID attribute via a doctype definition contained in the input XML document. This option is ignored in the case of detached signature, when the option xpathsToIdAttributes is set.
|
contentReferenceType | String | null | Value of the type attribute of the content reference. This value can be overwritten by the header "CamelXmlSignatureContentReferenceType" |
plainText | Boolean | Boolean.FALSE |
Indicates whether the in-message body contains plain text. Normally, the signature generator treats the incoming message body as XML. If the message body is plain text, then you must set this option to true . The value can be overwritten by the header CamelXmlSignatureMessageIsPlainText .
|
plainTextEncoding | String | null |
Only used when the option plainText is set to true . Then you can specify the encoding of the plain text. If null then UTF-8 is used. The value can be overwritten by the header "CamelXmlSignatureMessageIsPlainTextEncoding".
|
properties | XmlSignatureProperties | null | For adding additional References and Objects to the XML signature which contain additional properties, you can provide a bean which implements the XmlSignatureProperties interface. |
contentObjectId | String | null |
Value of the Id attribute of the Object element. Only used in the enveloping XML signature case. If null , a unique value is generated. Available as of 2.12.2
|
xpathsToIdAttributes
|
List<XPathFilterParameterSpec>
|
empty list
|
Since 2.14.0. List of XPATH expressions to ID attributes of elements to be signed. Used for the detached XML Signatures. Can only be used in combination with the option
schemaResourceUri . The value can be overwritten by the header "CamelXmlSignatureXpathsToIdAttributes ". If the option parentLocalNam e is set at the same time then an exception is thrown. The class XPathFilterParameterSpec has the package javax.xml.crypto.dsig.spec . For further information, see sub-chapter "Detached XML Signatures as Siblings of the Signed Elements".
|
signatureId
|
String
|
null
|
Since 2.14.0. Value of the Id attribute of the Signature element. If
null then a unique Id is generated. If the value is the empty string ("") then no Id attribute is added to the Signature element.
|
Verifying Options
Name | Type | Default | Description |
---|---|---|---|
keySelector | javax.xml.crypto.KeySelector | null | Provides the key for validating the XML signature. There is an example implementation which uses a keystore, see DefaultKeySelector. |
xmlSignatureChecker | XmlSignatureChecker | null | This interface allows the application to check the XML signature before the validation is executed. This step is recommended in http://www.w3.org/TR/xmldsig-bestpractices/#check-what-is-signed |
validationFailedHandler | ValidationFailedHandler | DefaultValidationFailedHandler |
Handles the different validation failed situations. The default implementation throws specific exceptions for the different situations (All exceptions have the package name org.apache.camel.component.xmlsecurity.api and are a sub-class of XmlSignatureInvalidException . If the signature value validation fails, a XmlSignatureInvalidValueException is thrown. If a reference validation fails, a XmlSignatureInvalidContentHashException is thrown. For more detailed information, see the JavaDoc.
|
xmlSignature2Message | XmlSignature2Message | DefaultXmlSignature2Message |
Bean which maps the XML signature to the ouput-message after the validation. How this mapping should be done can be configured by the options outputNodeSearchType , outputNodeSearch , and removeSignatureElements . The default implementation offers three possibilities which are related to the three output node search types "Default", "ElementName", and "XPath". The default implementation determines a node which is then serialized and set to the body of the ouput message. If the search type is "ElementName" then the ouput node (which must be in this case an element) is determined by the local name and namespace defined in the search value (see option outputNodeSearch ). If the search type is "XPath" then the output node is determined by the XPath specified in the search value (in this case the ouput node can be of type "Element", "TextNode" or "Document"). If the output node search type is "Default" then the following rules apply: In the enveloped XML signature case (there is a reference with URI="" and transform "http://www.w3.org/2000/09/xmldsig#enveloped-signature"), the incoming XML document without the Signature element is set to the output message body. In the non-enveloped XML signature case, the message body is determined from a referenced Object; this is explained in more detail in chapter "Output Node Determination in Enveloping XML Signature Case".
|
outputNodeSearchType | String | "Default" |
Determines the type of the search of the output node. See option xmlSignature2Message . The default implementation DefaultXmlSignature2Message supports the three search types "Default", "ElementName", and "XPath".
|
outputNodeSearch | Object | null |
Search value of the output node search. The type depends on the search type. For the default search implementation DefaultXmlSignature2Message the following values can be supplied. If the search type is "Default", then the search value is not used. If the search type is "ElementName", then the search value contains the namespace and local name of the output element. The namespace must be embraced in brackets. If the search type is "XPath", the search value contains an instance of javax.xml.crypto.dsig.spec.XPathFilterParameterSpec which represents an XPath. You can create such an instance via the method XmlSignatureHelper.getXpathFilter(String xpath, Map<String, String> namespaceMap) . The XPath determines the output node which can be of type Element, TextNode, or Document.
|
removeSignatureElements | Boolean | Boolean.FALSE |
Indicator for removing Signature elements in the output message in the enveloped XML signature case. Used in the XmlSignature2Message instance. The default implementation does use this indicator for the two search types "ElementName" and "XPath".
|
secureValidation | Boolean | Boolean.TRUE | Enables secure validation. If true then secure validation is enabled - see here for more information. |
Output Node Determination in Enveloping XML Signature Case
xmlSignature2Message
):
- Only same document references are taken into account (URI must start with '#')
- Also indirect same document references to an object via manifest are taken into account.
- The resulting number of Object references must be 1.
<Signature> <SignedInfo> <Reference URI="#object"/> <!-- further references possible but they must not point to an Object or Manifest containing an object reference --> ... </SignedInfo> <Object Id="object"> <!-- contains one XML element which is extracted to the message body --> <Object> <!-- further object elements possible which are not referenced--> ... (<KeyInfo>)? </Signature>
<Signature> <SignedInfo> <Reference URI="#manifest"/> <!-- further references are possible but they must not point to an Object or other manifest containing an object reference --> ... </SignedInfo> <Object > <Manifest Id="manifest"> <Reference URI=#object/> </Manifest> </Objet> <Object Id="object"> <!-- contains the DOM node which is extracted to the message body --> </Object> <!-- further object elements possible which are not referenced --> ... (<KeyInfo>)? </Signature>
Detached XML Signatures as Siblings of the Signed Elements
Example 161.1. Example Detached XML Signatures
<?xml version="1.0" encoding="UTF-8" ?> <root> <A ID="IDforA"> <B> <C ID="IDforC"> <D>dvalue</D> </C> <ds:Signature xmlns:ds="http://www.w3.org/2000/09/xmldsig#" Id="_6bf13099-0568-4d76-8649-faf5dcb313c0"> <ds:SignedInfo> <ds:CanonicalizationMethod Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315" /> <ds:SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1" /> <ds:Reference URI="#IDforC"> ... </ds:Reference> </ds:SignedInfo> <ds:SignatureValue>aUDFmiG71</ds:SignatureValue> </ds:Signature> </B> </A> <ds:Signature xmlns:ds="http://www.w3.org/2000/09/xmldsig#"Id="_6b02fb8a-30df-42c6-ba25-76eba02c8214"> <ds:SignedInfo> <ds:CanonicalizationMethod Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315" /> <ds:SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1" /> <ds:Reference URI="#IDforA"> ... </ds:Reference> </ds:SignedInfo> <ds:SignatureValue>q3tvRoGgc8cMUqUSzP6C21zb7tt04riPnDuk=</ds:SignatureValue> </ds:Signature> <root>
Example 161.2. Java DSL Example
from("direct:detached") .to("xmlsecurity:sign://detached?keyAccessor=#keyAccessorBeant&xpathsToIdAttributes=#xpathsToIdAttributesBean&schemaResourceUri=Test.xsd") .to("xmlsecurity:verify://detached?keySelector=#keySelectorBean&schemaResourceUri=org/apache/camel/component/xmlsecurity/Test.xsd") .to("mock:result");
Example 161.3. Spring Example
<bean id="xpathsToIdAttributesBean" class="java.util.ArrayList"> <constructor-arg type="java.util.Collection"> <list> <bean class="org.apache.camel.component.xmlsecurity.api.XmlSignatureHelper" factory-method="getXpathFilter"> <constructor-arg type="java.lang.String" value="/ns:root/a/@ID" /> <constructor-arg> <map key-type="java.lang.String" value-type="java.lang.String"> <entry key="ns" value="http://test" /> </map> </constructor-arg> </bean> </list> </constructor-arg> </bean> ... <from uri="direct:detached" /> <to uri="xmlsecurity:sign://detached?keyAccessor=#keyAccessorBean&xpathsToIdAttributes=#xpathsToIdAttributesBean&schemaResourceUri=Test.xsd" /> <to uri="xmlsecurity:verify://detached?keySelector=#keySelectorBean&schemaResourceUri=Test.xsd" /> <to uri="mock:result" />
XAdES-BES/EPES for the Signer Endpoint
<QualifyingProperties Target> <SignedProperties> <SignedSignatureProperties> (SigningTime)? (SigningCertificate)? (SignaturePolicyIdentifier) (SignatureProductionPlace)? (SignerRole)? </SignedSignatureProperties> <SignedDataObjectProperties> (DataObjectFormat)? (CommitmentTypeIndication)? </SignedDataObjectProperties> </SignedProperties> </QualifyingProperties> |
SignaturePolicyIdentifier
property is not part of XAdES-BES.
org.apache.camel.component.xmlsecurity.api.XAdESSignatureProperties
or org.apache.camel.component.xmlsecurity.api.DefaultXAdESSignatureProperties. XAdESSignatureProperties
does support all properties mentioned above except the SigningCertificate
property. To get the SigningCertificate
property, you must overwrite either the method XAdESSignatureProperties.getSigningCertificate()
or XAdESSignatureProperties.getSigningCertificateChain().
The class DefaultXAdESSignatureProperties
overwrites the method getSigningCertificate()
and allows you to specify the signing certificate via a keystore and alias. The following example shows all parameters you can specify. If you do not need certain parameters you can just omit them.
Keystore keystore = ... // load a keystore DefaultKeyAccessor accessor = new DefaultKeyAccessor(); accessor.setKeyStore(keystore); accessor.setPassword("password"); accessor.setAlias("cert_alias"); // signer key alias DefaultXAdESSignatureProperties props = new DefaultXAdESSignatureProperties(); props.setNamespace("http://uri.etsi.org/01903/v1.3.2#"); // sets the namespace for the XAdES elements; the namspace is related to the XAdES version, default value is "http://uri.etsi.org/01903/v1.3.2#", other possible values are "http://uri.etsi.org/01903/v1.1.1#" and "http://uri.etsi.org/01903/v1.2.2#" props.setPrefix("etsi"); // sets the prefix for the XAdES elements, default value is "etsi" // signing certificate props.setKeystore(keystore)); props.setAlias("cert_alias"); // specify the alias of the signing certificate in the keystore = signer key alias props.setDigestAlgorithmForSigningCertificate(DigestMethod.SHA256); // possible values for the algorithm are "http://www.w3.org/2000/09/xmldsig#sha1", "http://www.w3.org/2001/04/xmlenc#sha256", "http://www.w3.org/2001/04/xmldsig-more#sha384", "http://www.w3.org/2001/04/xmlenc#sha512", default value is "http://www.w3.org/2001/04/xmlenc#sha256" props.setSigningCertificateURIs(Collections.singletonList("http://certuri")); // signing time props.setAddSigningTime(true); // policy props.setSignaturePolicy(XAdESSignatureProperties.SIG_POLICY_EXPLICIT_ID); // also the values XAdESSignatureProperties.SIG_POLICY_NONE ("None"), and XAdESSignatureProperties.SIG_POLICY_IMPLIED ("Implied")are possible, default value is XAdESSignatureProperties.SIG_POLICY_EXPLICIT_ID ("ExplicitId") // For "None" and "Implied" you must not specify any further policy parameters props.setSigPolicyId("urn:oid:1.2.840.113549.1.9.16.6.1"); props.setSigPolicyIdQualifier("OIDAsURN"); //allowed values are empty string, "OIDAsURI", "OIDAsURN"; default value is empty string props.setSigPolicyIdDescription("invoice version 3.1"); props.setSignaturePolicyDigestAlgorithm(DigestMethod.SHA256);// possible values for the algorithm are "http://www.w3.org/2000/09/xmldsig#sha1", http://www.w3.org/2001/04/xmlenc#sha256", "http://www.w3.org/2001/04/xmldsig-more#sha384", "http://www.w3.org/2001/04/xmlenc#sha512", default value is http://www.w3.org/2001/04/xmlenc#sha256" props.setSignaturePolicyDigestValue("Ohixl6upD6av8N7pEvDABhEL6hM="); // you can add qualifiers for the signature policy either by specifying text or an XML fragment with the root element "SigPolicyQualifier" props.setSigPolicyQualifiers(Arrays .asList(new String[] { "<SigPolicyQualifier xmlns=\"http://uri.etsi.org/01903/v1.3.2#\"><SPURI>http://test.com/sig.policy.pdf</SPURI><SPUserNotice><ExplicitText>display text</ExplicitText>" + "</SPUserNotice></SigPolicyQualifier>", "category B" })); props.setSigPolicyIdDocumentationReferences(Arrays.asList(new String[] {"http://test.com/policy.doc.ref1.txt", "http://test.com/policy.doc.ref2.txt" })); // production place props.setSignatureProductionPlaceCity("Munich"); props.setSignatureProductionPlaceCountryName("Germany"); props.setSignatureProductionPlacePostalCode("80331"); props.setSignatureProductionPlaceStateOrProvince("Bavaria"); //role // you can add claimed roles either by specifying text or an XML fragment with the root element "ClaimedRole" props.setSignerClaimedRoles(Arrays.asList(new String[] {"test", "<a:ClaimedRole xmlns:a=\"http://uri.etsi.org/01903/v1.3.2#\"><TestRole>TestRole</TestRole></a:ClaimedRole>" })); props.setSignerCertifiedRoles(Collections.singletonList(new XAdESEncapsulatedPKIData("Ahixl6upD6av8N7pEvDABhEL6hM=", "http://uri.etsi.org/01903/v1.2.2#DER", "IdCertifiedRole"))); // data object format props.setDataObjectFormatDescription("invoice"); props.setDataObjectFormatMimeType("text/xml"); props.setDataObjectFormatIdentifier("urn:oid:1.2.840.113549.1.9.16.6.2"); props.setDataObjectFormatIdentifierQualifier("OIDAsURN"); //allowed values are empty string, "OIDAsURI", "OIDAsURN"; default value is empty string props.setDataObjectFormatIdentifierDescription("identifier desc"); props.setDataObjectFormatIdentifierDocumentationReferences(Arrays.asList(new String[] { "http://test.com/dataobject.format.doc.ref1.txt", "http://test.com/dataobject.format.doc.ref2.txt" })); //commitment props.setCommitmentTypeId("urn:oid:1.2.840.113549.1.9.16.6.4"); props.setCommitmentTypeIdQualifier("OIDAsURN"); //allowed values are empty string, "OIDAsURI", "OIDAsURN"; default value is empty string props.setCommitmentTypeIdDescription("description for commitment type ID"); props.setCommitmentTypeIdDocumentationReferences(Arrays.asList(new String[] {"http://test.com/commitment.ref1.txt", "http://test.com/commitment.ref2.txt" })); // you can specify a commitment type qualifier either by simple text or an XML fragment with root element "CommitmentTypeQualifier" props.setCommitmentTypeQualifiers(Arrays.asList(new String[] {"commitment qualifier", "<c:CommitmentTypeQualifier xmlns:c=\"http://uri.etsi.org/01903/v1.3.2#\"><C>c</C></c:CommitmentTypeQualifier>" })); beanRegistry.bind("xmlSignatureProperties",props); beanRegistry.bind("keyAccessorDefault",keyAccessor); // you must reference the properties bean in the "xmlsecurity" URI from("direct:xades").to("xmlsecurity:sign://xades?keyAccessor=#keyAccessorDefault&properties=#xmlSignatureProperties") .to("mock:result"); |
... <from uri="direct:xades" /> <to uri="xmlsecurity:sign://xades?keyAccessor=#accessorRsa&properties=#xadesProperties" /> <to uri="mock:result" /> ... <bean id="xadesProperties" class="org.apache.camel.component.xmlsecurity.api.XAdESSignatureProperties"> <!-- For more properties see the the previous Java DSL example. If you want to have a signing certificate then use the bean class DefaultXAdESSignatureProperties (see the previous Java DSL example). --> <property name="signaturePolicy" value="ExplicitId" /> <property name="sigPolicyId" value="http://www.test.com/policy.pdf" /> <property name="sigPolicyIdDescription" value="factura" /> <property name="signaturePolicyDigestAlgorithm" value="http://www.w3.org/2000/09/xmldsig#sha1" /> <property name="signaturePolicyDigestValue" value="Ohixl6upD6av8N7pEvDABhEL1hM=" /> <property name="signerClaimedRoles" ref="signerClaimedRoles_XMLSigner" /> <property name="dataObjectFormatDescription" value="Factura electrónica" /> <property name="dataObjectFormatMimeType" value="text/xml" /> </bean> <bean class="java.util.ArrayList" id="signerClaimedRoles_XMLSigner"> <constructor-arg> <list> <value>Emisor</value> <value><ClaimedRole xmlns="http://uri.etsi.org/01903/v1.3.2#"><test xmlns="http://test.com/">test</test></ClaimedRole></value> </list> </constructor-arg> </bean> |
Headers
Header | Type | Description |
---|---|---|
CamelXmlSignatureXAdESQualifyingPropertiesId
|
String |
for the 'Id' attribute value of QualifyingProperties element
|
CamelXmlSignatureXAdESSignedDataObjectPropertiesId
|
String |
for the 'Id' attribute value of SignedDataObjectProperties element
|
CamelXmlSignatureXAdESSignedSignaturePropertiesId
|
String |
for the 'Id' attribute value of SignedSignatureProperties element
|
CamelXmlSignatureXAdESDataObjectFormatEncoding
|
String |
for the value of the Encoding element of the DataObjectFormat element
|
CamelXmlSignatureXAdESNamespace
|
String | overwrites the XAdES namespace parameter value |
CamelXmlSignatureXAdESPrefix
|
String | overwrites the XAdES prefix parameter value |
Limitations with regard to XAdES version 1.4.2
- No support for signature form XAdES-T and XAdES-C
- Only signer part implemented. Verifier part currently not available.
- No support for the '
QualifyingPropertiesReference
' element (see section 6.3.2 of spec). - No support for the
Transforms
element contained in theSignaturePolicyId
element contained in theSignaturePolicyIdentifier element
- No support of the
CounterSignature
element --> no support for theUnsignedProperties
element - At most one
DataObjectFormat
element. More than oneDataObjectFormat
element makes no sense because we have only one data object which is signed (this is the incoming message body to the XML signer endpoint). - At most one
CommitmentTypeIndication
element. More than oneCommitmentTypeIndication
element makes no sense because we have only one data object which is signed (this is the incoming message body to the XML signer endpoint). - A
CommitmentTypeIndication
element contains always theAllSignedDataObjects
element. TheObjectReference
element withinCommitmentTypeIndication
element is not supported. - The
AllDataObjectsTimeStamp
element is not supported - The
IndividualDataObjectsTimeStamp
element is not supported
See Also
Chapter 162. XMPP
XMPP Component
URI format
xmpp://[login@]hostname[:port][/participant][?Options]
?option=value&option=value&...
Options
Name | Description |
---|---|
room
|
If this option is specified, the component will connect to MUC (Multi User Chat). Usually, the domain name for MUC is different from the login domain. For example, if you are superman@jabber.org and want to join the krypton room, then the room URL is krypton@conference.jabber.org . Note the conference part.
|
user
|
User name (without server name). If not specified, anonymous login will be attempted. |
password
|
Password. |
resource
|
XMPP resource. The default is Camel .
|
createAccount
|
If true , an attempt to create an account will be made. Default is false .
|
participant
|
JID (Jabber ID) of person to receive messages. room parameter has precedence over participant .
|
nickname
|
Use nickname when joining room. If room is specified and nickname is not, user will be used for the nickname.
|
serviceName
|
The name of the service you are connecting to. For Google Talk, this would be gmail.com .
|
testConnectionOnStartup
|
*Camel 2.11* Specifies whether to test the connection on startup. This is used to ensure that the XMPP client has a valid connection to the XMPP server when the route starts. Camel throws an exception on startup if a connection cannot be established. When this option is set to false, Camel will attempt to establish a "lazy" connection when needed by a producer, and will poll for a consumer connection until the connection is established. Default is true .
|
connectionPollDelay
|
*Camel 2.11* The amount of time in seconds between polls to verify the health of the XMPP connection, or between attempts to establish an initial consumer connection. Camel will try to re-establish a connection if it has become inactive. Default is 10 seconds .
|
pubsub
|
Camel 2.15: Accept pubsub packets on input. Default is false .
|
doc
|
Camel 2.15: Set a doc header on the In message containing a Document form of the incoming packet; default is true , if presence or pubsub are true, otherwise false .
|
Headers and setting Subject or Language
HeaderFilterStategy
if you need custom filtering of headers.The Subject and Language of the XMPP message are also set if they are provided as IN headers.
Examples
superman
to join room krypton
at jabber
server with password, secret
:
xmpp://superman@jabber.org/?room=krypton@conference.jabber.org&password=secret
superman
to send messages to joker
:
xmpp://superman@jabber.org/joker@jabber.org?password=secret
from("timer://kickoff?period=10000"). setBody(constant("I will win!\n Your Superman.")). to("xmpp://superman@jabber.org/joker@jabber.org?password=secret");
joker
into the queue, evil.talk
.
from("xmpp://superman@jabber.org/joker@jabber.org?password=secret"). to("activemq:evil.talk");
from("xmpp://superman@jabber.org/?password=secret&room=krypton@conference.jabber.org"). to("activemq:krypton.talk");
from("xmpp://superman@jabber.org/?password=secret&room=krypton"). to("activemq:krypton.talk");
serviceName
as well as your credentials:
// send a message from fromuser@gmail.com to touser@gmail.com from("direct:start"). to("xmpp://talk.google.com:5222/touser@gmail.com?serviceName=gmail.com&user=fromuser&password=secret"). to("mock:result");
Chapter 163. XQuery Endpoint
XQuery
URI format
xquery:templateName
from("activemq:My.Queue"). to("xquery:com/acme/mytransform.xquery");
JMSReplyTo
header).
from("activemq:My.Queue"). to("xquery:com/acme/mytransform.xquery"). to("activemq:Another.Queue");
Chapter 164. XSLT
XSLT
URI format
xslt:templateName[?options]
?option=value&option=value&...
URI | Description |
---|---|
xslt:com/acme/mytransform.xsl
|
Refers to the file, com/acme/mytransform.xsl , on the classpath.
|
xslt:file:///foo/bar.xsl
|
Refers to the file, /foo/bar.xsl .
|
xslt:http://acme.com/cheese/foo.xsl
|
Refers to the remote HTTP resource. |
Options
Name | Default Value | Description |
---|---|---|
converter
|
null
|
Option to override default XmlConverter. Will lookup for the converter in the Registry. The provided converted must be of type org.apache.camel.converter.jaxp.XmlConverter. |
transformerFactory
|
null
|
Option to override default TransformerFactory. Will lookup for the transformerFactory in the Registry. The provided transformer factory must be of type javax.xml.transform.TransformerFactory .
|
transformerFactoryClass
|
null
|
Option to override default TransformerFactory. Will create a TransformerFactoryClass instance and set it to the converter.
|
uriResolver
|
null
|
Camel 2.3: Allows you to use a custom javax.xml.transformation.URIResolver . Camel will by default use its own implementation org.apache.camel.builder.xml.XsltUriResolver which is capable of loading from classpath.
|
resultHandlerFactory
|
null
|
Camel 2.3: Allows you to use a custom org.apache.camel.builder.xml.ResultHandlerFactory which is capable of using custom org.apache.camel.builder.xml.ResultHandler types.
|
failOnNullBody
|
true
|
Camel 2.3: Whether or not to throw an exception if the input body is null. |
deleteOutputFile
|
false
|
Camel 2.6: If you have output=file then this option dictates whether or not the output file should be deleted when the Exchange is done processing. For example suppose the output file is a temporary file, then it can be a good idea to delete it after use.
|
output
|
string
|
Camel 2.3: Option to specify which output type to use. Possible values are: string, bytes, DOM, file . The first three options are all in memory based, where as file is streamed directly to a java.io.File . For file you must specify the filename in the IN header with the key Exchange.XSLT_FILE_NAME which is also CamelXsltFileName . Also any paths leading to the filename must be created beforehand, otherwise an exception is thrown at runtime.
|
contentCache
|
true
|
Camel 2.6: Cache for the resource content (the stylesheet file) when it is loaded. If set to false Camel will reloader the stylesheet file on each message processing. This is good for development.
|
allowStAX
|
true
|
Camel 2.8.3/2.9: Whether to allow using StAX as the javax.xml.transform.Source .
|
transformerCacheSize
|
0
|
Camel 2.9.3/2.10.1: The number of javax.xml.transform.Transformer object that are cached for reuse to avoid calls to Template.newTransformer() .
|
saxon
|
false
|
Camel 2.11: Whether to use Saxon as the transformerFactoryClass . If enabled then the class net.sf.saxon.TransformerFactoryImpl . You would need to add Saxon to the classpath.
|
errorListener
|
Camel 2.14: Allows to configure to use a custom javax.xml.transform.ErrorListener . Beware when doing this then the default error listener which captures any errors or fatal errors and store information on the Exchange as properties is not in use. So only use this option for special use-cases.
|
Using XSLT endpoints
from("activemq:My.Queue"). to("xslt:com/acme/mytransform.xsl");
JMSReplyTo
header).
from("activemq:My.Queue"). to("xslt:com/acme/mytransform.xsl"). to("activemq:Another.Queue");
Getting Parameters into the XSLT to work with
<setHeader headerName="myParam"><constant>42</constant></setHeader> <to uri="xslt:MyTransform.xsl"/>
<xsl: ...... > <xsl:param name="myParam"/> <xsl:template ...>
Spring XML versions
<camelContext xmlns="http://activemq.apache.org/camel/schema/spring"> <route> <from uri="activemq:My.Queue"/> <to uri="xslt:org/apache/camel/spring/processor/example.xsl"/> <to uri="activemq:Another.Queue"/> </route> </camelContext>
Using xsl:include
URIResolver
which allows Camel to load included files from the classpath and more intelligent than before.
<xsl:include href="staff_template.xsl"/>
.to("xslt:org/apache/camel/component/xslt/staff_include_relative.xsl")
org/apache/camel/component/xslt/staff_template.xsl
. This allows you to use xsl include and have xsl files located in the same folder such as we do in the example org/apache/camel/component/xslt
.
classpath:
or file:
to instruct Camel to look either in classpath or file system. If you omit the prefix then Camel uses the prefix from the endpoint configuration. If that neither has one, then classpath is assumed.
<xsl:include href="../staff_other_template.xsl"/>
org/apache/camel/component
.
Using xsl:include and default prefix
<xsl:include href="staff_template.xsl"/>
.to("xslt:file:etc/xslt/staff_include_relative.xsl")
<xsl:include href="file:staff_template.xsl"/>
<xsl:include href="staff_template.xsl"/>
Dynamic stylesheets
.recipientList
command in the Java DSL.
Accessing warnings, errors and fatalErrors from XSLT ErrorListener
Exchange.XSLT_ERROR
, Exchange.XSLT_FATAL_ERROR
, or Exchange.XSLT_WARNING
which allows end users to get hold of any errors happening during transformation.
<xsl:template match="/"> <html> <body> <xsl:for-each select="staff/programmer"> <p>Name: <xsl:value-of select="name"/><br /> <xsl:if test="dob=''"> <xsl:message terminate="yes">Error: DOB is an empty string!</xsl:message> </xsl:if> </p> </xsl:for-each> </body> </html> </xsl:template>
getMessage()
method on the exception. The exception is stored on the Exchange as a warning with the key Exchange.XSLT_WARNING.
Chapter 165. Yammer
Yammer
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-yammer</artifactId> <version>${camel-version}</version> </dependency>
URI format
yammer:[function]?[options]
YammerComponent
Option | Description |
---|---|
consumerKey | The consumer key |
consumerSecret | The consumer secret |
accessToken | The access token |
Consuming messages
URI | Description |
---|---|
yammer:messages?options | All public messages in the user's (whose access token is being used to make the API call) Yammer network. Corresponds to "All" conversations in the Yammer web interface. |
yammer:my_feed?options | The user's feed, based on the selection they have made between "Following" and "Top" conversations. |
yammer:algo?options | The algorithmic feed for the user that corresponds to "Top" conversations, which is what the vast majority of users will see in the Yammer web interface. |
yammer:following?options | The "Following" feed which is conversations involving people, groups and topics that the user is following. |
yammer:sent?options | All messages sent by the user. |
yammer:private?options | Private messages received by the user. |
yammer:received?options | Camel 2.12.1: All messages received by the user |
URI Options for consuming messages
Name | Default Value | Description |
---|---|---|
useJson |
false
|
Set to true if you want to use raw JSON rather than converting to POJOs. |
delay |
5000
|
in milliseconds |
consumerKey |
null
|
Consumer Key. Can also be configured on the YammerComponent level instead.
|
consumerSecret |
null
|
Consumer Secret. Can also be configured on the YammerComponent level instead.
|
accessToken |
null
|
Access Token. Can also be configured on the YammerComponent level instead.
|
limit |
-1
|
Return only the specified number of messages. Works for threaded=true and threaded=extended. |
threaded |
null
|
threaded=true will only return the first message in each thread. This parameter is intended for apps which display message threads collapsed. threaded=extended will return the thread starter messages in order of most recently active as well as the two most recent messages, as they are viewed in the default view on the Yammer web interface. |
olderThan |
-1
|
Returns messages older than the message ID specified as a numeric string. This is useful for paginating messages. For example, if you're currently viewing 20 messages and the oldest is number 2912, you could append "?olderThan=2912? to your request to get the 20 messages prior to those you're seeing. |
newerThan |
-1
|
Returns messages newer than the message ID specified as a numeric string. This should be used when polling for new messages. If you're looking at messages, and the most recent message returned is 3516, you can make a request with the parameter "?newerThan=3516? to ensure that you do not get duplicate copies of messages already on your page. |
Message format
from("yammer:messages?consumerKey=aConsumerKey&consumerSecret=aConsumerSecretKey&accessToken=aAccessToken").to("mock:result");
{ "messages":[ { "replied_to_id":null, "network_id":7654, "url":"https://www.yammer.com/api/v1/messages/305298242", "thread_id":305298242, "id":305298242, "message_type":"update", "chat_client_sequence":null, "body":{ "parsed":"Testing yammer API...", "plain":"Testing yammer API...", "rich":"Testing yammer API..." }, "client_url":"https://www.yammer.com/", "content_excerpt":"Testing yammer API...", "created_at":"2013/06/25 18:14:45 +0000", "client_type":"Web", "privacy":"public", "sender_type":"user", "liked_by":{ "count":1, "names":[ { "permalink":"janstey", "full_name":"Jonathan Anstey", "user_id":1499642294 } ] }, "sender_id":1499642294, "language":null, "system_message":false, "attachments":[ ], "direct_message":false, "web_url":"https://www.yammer.com/redhat.com/messages/305298242" }, { "replied_to_id":null, "network_id":7654, "url":"https://www.yammer.com/api/v1/messages/294326302", "thread_id":294326302, "id":294326302, "message_type":"system", "chat_client_sequence":null, "body":{ "parsed":"(Principal Software Engineer) has [[tag:14658]] the redhat.com network. Take a moment to welcome Jonathan.", "plain":"(Principal Software Engineer) has #joined the redhat.com network. Take a moment to welcome Jonathan.", "rich":"(Principal Software Engineer) has #joined the redhat.com network. Take a moment to welcome Jonathan." }, "client_url":"https://www.yammer.com/", "content_excerpt":"(Principal Software Engineer) has #joined the redhat.com network. Take a moment to welcome Jonathan.", "created_at":"2013/05/10 19:08:29 +0000", "client_type":"Web", "sender_type":"user", "privacy":"public", "liked_by":{ "count":0, "names":[ ] } } ] }
Exchange exchange = mock.getExchanges().get(0); Messages messages = exchange.getIn().getBody(Messages.class); assertEquals(2, messages.getMessages().size()); assertEquals("Testing yammer API...", messages.getMessages().get(0).getBody().getPlain()); assertEquals("(Principal Software Engineer) has #joined the redhat.com network. Take a moment to welcome Jonathan.", messages.getMessages().get(1).getBody().getPlain());
Creating messages
yammer:messages?[options]
from("direct:start").to("yammer:messages?consumerKey=aConsumerKey&consumerSecret=aConsumerSecretKey&accessToken=aAccessToken").to("mock:result");
template.sendBody("direct:start", "Hi from Camel!");
Exchange exchange = mock.getExchanges().get(0); Messages messages = exchange.getIn().getBody(Messages.class); assertEquals(1, messages.getMessages().size()); assertEquals("Hi from Camel!", messages.getMessages().get(0).getBody().getPlain());
Retrieving user relationships
yammer:relationships?[options]
URI Options for retrieving relationships
Name | Default Value | Description |
---|---|---|
useJson |
false
|
Set to true if you want to use raw JSON rather than converting to POJOs. |
delay |
5000
|
in milliseconds |
consumerKey |
null
|
Consumer Key. Can also be configured on the YammerComponent level instead.
|
consumerSecret |
null
|
Consumer Secret. Can also be configured on the YammerComponent level instead.
|
accessToken |
null
|
Access Token. Can also be configured on the YammerComponent level instead.
|
userId |
current user
|
To view the relationships for a user other than the current user. |
Retrieving users
URI | Description |
---|---|
yammer:users?[options]
|
Retrieve users in the current user's Yammer network. |
yammer:current?[options]
|
View data about the current user. |
URI Options for retrieving users
Name | Default Value | Description |
---|---|---|
useJson |
false
|
Set to true if you want to use raw JSON rather than converting to POJOs. |
delay |
5000
|
in milliseconds |
consumerKey |
null
|
Consumer Key. Can also be configured on the YammerComponent level instead.
|
consumerSecret |
null
|
Consumer Secret. Can also be configured on the YammerComponent level instead.
|
accessToken |
null
|
Access Token. Can also be configured on the YammerComponent level instead.
|
Using an enricher
from("direct:start").pollEnrich("yammer:current?consumerKey=aConsumerKey&consumerSecret=aConsumerSecretKey&accessToken=aAccessToken").to("mock:result");
Chapter 166. Zookeeper
ZooKeeper
- Creation of nodes in any of the ZooKeeper create modes.
- Get and Set the data contents of arbitrary cluster nodes.
- Create and retrieve the list the child nodes attached to a particular node.
- A Distributed RoutePolicy that leverages a Leader election coordinated by ZooKeeper to determine if exchanges should get processed.
pom.xml
for this component:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-zookeeper</artifactId> <version>x.x.x</version> <!-- use the same version as your Camel core version --> </dependency>
URI format
zookeeper://zookeeper-server[:port][/path][?options]
Options
Name | Default Value | Description |
---|---|---|
path
|
The node in the ZooKeeper server (aka znode) | |
listChildren
|
false
|
Whether the children of the node should be listed |
repeat
|
false
|
Should changes to the znode be 'watched' and repeatedly processed. |
backoff
|
5000
|
The time interval to backoff for after an error before retrying. |
timeout
|
5000
|
The time interval to wait on connection before timing out. |
create
|
false
|
Should the endpoint create the node if it does not currently exist. |
createMode
|
EPHEMERAL
|
The create mode that should be used for the newly created node (see below). |
sendEmptyMessageOnDelete
|
true
|
Camel 2.10: Upon the delete of a znode, should an empty message be send to the consumer |
Use cases
Reading from a znode.
from("zookeeper://localhost:39913/somepath/somenode").to("mock:result");
from("zookeeper://localhost:39913/somepath/somenode?awaitCreation=true").to("mock:result");
Reading from a znode - (additional Camel 2.10 onwards)
Writing to a znode.
from("direct:write-to-znode").to("zookeeper://localhost:39913/somepath/somenode");
Exchange e = createExchangeWithBody(testPayload); template.sendBodyAndHeader("direct:write-to-znode", e, "CamelZooKeeperNode", "/somepath/someothernode");
from("direct:create-and-write-to-znode").to("zookeeper://localhost:39913/somepath/somenode?create=true");
from("direct:delete-znode").setHeader(ZooKeeperMessage.ZOOKEEPER_OPERATION, constant("DELETE")).to("zookeeper://localhost:39913/somepath/somenode");
<route> <from uri="direct:delete-znode" /> <setHeader headerName="CamelZookeeperOperation"> <constant>DELETE</constant> </setHeader> <to uri="zookeeper://localhost:39913/somepath/somenode" /> </route>
PERSISTENT
PERSISTENT_SEQUENTIAL
EPHEMERAL
EPHEMERAL_SEQUENTIAL
from("direct:create-and-write-to-persistent-znode").to("zookeeper://localhost:39913/somepath/somenode?create=true&createMode=PERSISTENT");
Exchange e = createExchangeWithBody(testPayload); template.sendBodyAndHeader("direct:create-and-write-to-persistent-znode", e, "CamelZooKeeperCreateMode", "PERSISTENT");
ZooKeeper enabled Route policy.
ZooKeeperRoutePolicy policy = new ZooKeeperRoutePolicy("zookeeper:localhost:39913/someapp/somepolicy", 1); from("direct:policy-controlled").routePolicy(policy).to("mock:controlled");
Legal Notice
Trademark Disclaimer