This is an automated email from the ASF dual-hosted git repository.
acosentino pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel-karaf.git
The following commit(s) were added to refs/heads/master by this push:
new 616e003 Regen
616e003 is described below
commit 616e0039cedfc6399da6fb388905a5480d863528
Author: Andrea Cosentino <anco...@gmail.com>
AuthorDate: Mon Apr 27 08:18:25 2020 +0200
Regen
---
docs/modules/ROOT/pages/components.adoc | 238 ++++++++++++++++----------------
1 file changed, 119 insertions(+), 119 deletions(-)
diff --git a/docs/modules/ROOT/pages/components.adoc
b/docs/modules/ROOT/pages/components.adoc
index 97e3793..dccf62d 100644
--- a/docs/modules/ROOT/pages/components.adoc
+++ b/docs/modules/ROOT/pages/components.adoc
@@ -264,163 +264,163 @@ Number of Camel components: 207 in 207 JAR artifacts (1
deprecated)
`guava-eventbus:eventBusRef` | 2.10 | Send and receive messages to/from Guava
EventBus.
| xref:components::hdfs-component.adoc[HDFS] (camel-hdfs) +
-`hdfs:hostName:port/path` | 2.14 | For reading/writing from/to an HDFS
filesystem using Hadoop 2.x.
+`hdfs:hostName:port/path` | 2.14 | Read and write from/to an HDFS filesystem
using Hadoop 2.x.
| xref:components::hipchat-component.adoc[Hipchat] (camel-hipchat) +
-`hipchat:protocol:host:port` | 2.15 | The hipchat component supports producing
and consuming messages from/to Hipchat service.
+`hipchat:protocol:host:port` | 2.15 | Send and receive messages to/from
Hipchat service.
| xref:components::http-component.adoc[HTTP] (camel-http) +
-`http:httpUri` | 2.3 | For calling out to external HTTP servers using Apache
HTTP Client 4.x.
+`http:httpUri` | 2.3 | Send requests to external HTTP servers using Apache
HTTP Client 4.x.
| xref:components::influxdb-component.adoc[InfluxDB] (camel-influxdb) +
-`influxdb:connectionBean` | 2.18 | The influxdb component allows you to
interact with InfluxDB, a time series database.
+`influxdb:connectionBean` | 2.18 | Interact with InfluxDB, a time series
database.
| xref:components::iota-component.adoc[IOTA] (camel-iota) +
-`iota:name` | 2.23 | Component for integrate IOTA DLT
+`iota:name` | 2.23 | Manage financial transactions using IOTA distributed
ledger.
| xref:components::irc-component.adoc[IRC] (camel-irc) +
-`irc:hostname:port` | 1.1 | The irc component implements an IRC (Internet
Relay Chat) transport.
+`irc:hostname:port` | 1.1 | Send and receive messages to/from and IRC chat.
| xref:components::ironmq-component.adoc[IronMQ] (camel-ironmq) +
-`ironmq:queueName` | 2.17 | The ironmq provides integration with IronMQ an
elastic and durable hosted message queue as a service.
+`ironmq:queueName` | 2.17 | Send and receive messages to/from IronMQ an
elastic and durable hosted message queue as a service.
| xref:components::websocket-jsr356-component.adoc[Javax Websocket]
(camel-websocket-jsr356) +
-`websocket-jsr356:uri` | 2.23 | Camel WebSocket using JSR356 (javax)
+`websocket-jsr356:uri` | 2.23 | Expose websocket endpoints using JSR356.
| xref:components::jbpm-component.adoc[JBPM] (camel-jbpm) +
-`jbpm:connectionURL` | 2.6 | The jbpm component provides integration with jBPM
(Business Process Management).
+`jbpm:connectionURL` | 2.6 | Interact with jBPM workflow engine over REST.
| xref:components::jcache-component.adoc[JCache] (camel-jcache) +
-`jcache:cacheName` | 2.17 | The jcache component enables you to perform
caching operations using JSR107/JCache as cache implementation.
+`jcache:cacheName` | 2.17 | Perform caching operations against JSR107/JCache.
| xref:components::jclouds-component.adoc[JClouds] (camel-jclouds) +
-`jclouds:command:providerId` | 2.9 | For interacting with cloud compute &
blobstore service via jclouds.
+`jclouds:command:providerId` | 2.9 | Interact with jclouds compute & blobstore
service.
| xref:components::jcr-component.adoc[JCR] (camel-jcr) +
-`jcr:host/base` | 1.3 | The jcr component allows you to add/read nodes to/from
a JCR compliant content repository.
+`jcr:host/base` | 1.3 | Read and write nodes to/from a JCR compliant content
repository.
| xref:components::jdbc-component.adoc[JDBC] (camel-jdbc) +
-`jdbc:dataSourceName` | 1.2 | The jdbc component enables you to access
databases through JDBC, where SQL queries are sent in the message body.
+`jdbc:dataSourceName` | 1.2 | Access databases through SQL and JDBC.
| xref:components::jetty-component.adoc[Jetty] (camel-jetty) +
-`jetty:httpUri` | 1.2 | To use Jetty as a HTTP server as consumer for Camel
routes.
+`jetty:httpUri` | 1.2 | Expose HTTP endpoints using Jetty 9.
| xref:components::websocket-component.adoc[Jetty Websocket] (camel-websocket)
+
-`websocket:host:port/resourceUri` | 2.10 | The websocket component provides
websocket endpoints with Jetty for communicating with clients using websocket.
+`websocket:host:port/resourceUri` | 2.10 | Expose websocket endpoints using
Jetty.
| xref:components::jing-component.adoc[Jing] (camel-jing) +
-`jing:resourceUri` | 1.1 | Validates the payload of a message using RelaxNG
Syntax using Jing library.
+`jing:resourceUri` | 1.1 | Validate XML against a RelaxNG schema (XML Syntax
or Compact Syntax) using Jing library.
| xref:components::jms-component.adoc[JMS] (camel-jms) +
-`jms:destinationType:destinationName` | 1.0 | The jms component allows
messages to be sent to (or consumed from) a JMS Queue or Topic.
+`jms:destinationType:destinationName` | 1.0 | Sent and receive messages
to/from a JMS Queue or Topic.
| xref:components::jmx-component.adoc[JMX] (camel-jmx) +
-`jmx:serverURL` | 2.6 | The jmx component allows to receive JMX notifications.
+`jmx:serverURL` | 2.6 | Receive JMX notifications.
| xref:components::jolt-component.adoc[JOLT] (camel-jolt) +
-`jolt:resourceUri` | 2.16 | The jolt component allows you to process a JSON
messages using an JOLT specification (such as JSON-JSON transformation).
+`jolt:resourceUri` | 2.16 | JSON to JSON transformation using JOLT.
| xref:components::jooq-component.adoc[JOOQ] (camel-jooq) +
-`jooq:entityType` | 3.0 | The jooq component enables you to store and retrieve
entities from databases using JOOQ
+`jooq:entityType` | 3.0 | Store and retrieve Java objects from an SQL database
using JOOQ.
| xref:components::jpa-component.adoc[JPA] (camel-jpa) +
-`jpa:entityType` | 1.0 | The jpa component enables you to store and retrieve
Java objects from databases using JPA.
+`jpa:entityType` | 1.0 | Store and retrieve Java objects from databases using
Java Persistence API (JPA).
| xref:components::jslt-component.adoc[JSLT] (camel-jslt) +
-`jslt:resourceUri` | 3.1 | The jslt component allows you to process a JSON
messages using an JSLT transformations.
+`jslt:resourceUri` | 3.1 | Query or transform JSON payloads using an JSLT.
| xref:components::json-validator-component.adoc[JSON Schema Validator]
(camel-json-validator) +
-`json-validator:resourceUri` | 2.20 | Validates the payload of a message using
NetworkNT JSON Schema library.
+`json-validator:resourceUri` | 2.20 | Validate JSON payloads using NetworkNT
JSON Schema.
| xref:components::jt400-component.adoc[JT400] (camel-jt400) +
-`jt400:userID:password/systemName/objectPath.type` | 1.5 | The jt400 component
allows you to exchanges messages with an AS/400 system using data queues or
program call.
+`jt400:userID:password/systemName/objectPath.type` | 1.5 | Exchanges messages
with an AS/400 system using data queues or program call.
| xref:components::kafka-component.adoc[Kafka] (camel-kafka) +
-`kafka:topic` | 2.13 | The kafka component allows messages to be sent to (or
consumed from) Apache Kafka brokers.
+`kafka:topic` | 2.13 | Sent and receive messages to/from an Apache Kafka
broker.
| xref:components::kudu-component.adoc[Kudu] (camel-kudu) +
-`kudu:host:port/tableName` | 3.0 | Represents a Kudu endpoint. A kudu endpoint
allows you to interact with Apache Kudu, a free and open source column-oriented
data store of the Apache Hadoop ecosystem.
+`kudu:host:port/tableName` | 3.0 | Interact with Apache Kudu, a free and open
source column-oriented data store of the Apache Hadoop ecosystem.
| xref:components::language-component.adoc[Language] (camel-language) +
-`language:languageName:resourceUri` | 2.5 | The language component allows you
to send a message to an endpoint which executes a script by any of the
supported Languages in Camel.
+`language:languageName:resourceUri` | 2.5 | Execute scripts in any of the
languages supported by Camel.
| xref:components::ldap-component.adoc[LDAP] (camel-ldap) +
-`ldap:dirContextName` | 1.5 | The ldap component allows you to perform
searches in LDAP servers using filters as the message payload.
+`ldap:dirContextName` | 1.5 | Perform searches on LDAP servers.
| xref:components::ldif-component.adoc[LDIF] (camel-ldif) +
-`ldif:ldapConnectionName` | 2.20 | The ldif component allows you to do updates
on an LDAP server from a LDIF body content.
+`ldif:ldapConnectionName` | 2.20 | Perform updates on an LDAP server from an
LDIF body content.
| xref:components::log-component.adoc[Log] (camel-log) +
-`log:loggerName` | 1.1 | The log component logs message exchanges to the
underlying logging mechanism.
+`log:loggerName` | 1.1 | Log messages to the underlying logging mechanism.
| xref:components::lucene-component.adoc[Lucene] (camel-lucene) +
-`lucene:host:operation` | 2.2 | To insert or query from Apache Lucene
databases.
+`lucene:host:operation` | 2.2 | Perform inserts or queries against Apache
Lucene databases.
| xref:components::lumberjack-component.adoc[Lumberjack] (camel-lumberjack) +
-`lumberjack:host:port` | 2.18 | The lumberjack retrieves logs sent over the
network using the Lumberjack protocol.
+`lumberjack:host:port` | 2.18 | Receive logs messages using the Lumberjack
protocol.
| xref:components::master-component.adoc[Master] (camel-master) +
-`master:namespace:delegateUri` | 2.20 | Represents an endpoint which only
becomes active when the CamelClusterView has the leadership.
+`master:namespace:delegateUri` | 2.20 | Have only a single consumer in a
cluster consuming from a given endpoint; with automatic failover if the JVM
dies.
| xref:components::metrics-component.adoc[Metrics] (camel-metrics) +
-`metrics:metricsType:metricsName` | 2.14 | To collect various metrics directly
from Camel routes using the DropWizard metrics library.
+`metrics:metricsType:metricsName` | 2.14 | Collect various metrics directly
from Camel routes using the DropWizard metrics library.
| xref:components::micrometer-component.adoc[Micrometer] (camel-micrometer) +
-`micrometer:metricsType:metricsName` | 2.22 | To collect various metrics
directly from Camel routes using the Micrometer library.
+`micrometer:metricsType:metricsName` | 2.22 | Collect various metrics directly
from Camel routes using the Micrometer library.
| xref:components::mina-component.adoc[Mina] (camel-mina) +
-`mina:protocol:host:port` | 2.10 | Socket level networking using TCP or UDP
with the Apache Mina 2.x library.
+`mina:protocol:host:port` | 2.10 | Socket level networking using TCP or UDP
with Apache Mina 2.x.
| xref:components::mllp-component.adoc[MLLP] (camel-mllp) +
-`mllp:hostname:port` | 2.17 | Provides functionality required by Healthcare
providers to communicate with other systems using the MLLP protocol.
+`mllp:hostname:port` | 2.17 | Communicate with external systems using the MLLP
protocol.
| xref:components::mock-component.adoc[Mock] (camel-mock) +
-`mock:name` | 1.0 | The mock component is used for testing routes and
mediation rules using mocks.
+`mock:name` | 1.0 | Test routes and mediation rules using mocks.
| xref:components::mongodb-component.adoc[MongoDB] (camel-mongodb) +
-`mongodb:connectionBean` | 2.19 | Component for working with documents stored
in MongoDB database.
+`mongodb:connectionBean` | 2.19 | Perform operations on MongoDB documents and
collections.
| xref:components::mongodb-gridfs-component.adoc[MongoDB GridFS]
(camel-mongodb-gridfs) +
-`mongodb-gridfs:connectionBean` | 2.18 | Component for working with MongoDB
GridFS.
+`mongodb-gridfs:connectionBean` | 2.18 | Interact with MongoDB GridFS.
| xref:components::msv-component.adoc[MSV] (camel-msv) +
-`msv:resourceUri` | 1.1 | Validates the payload of a message using the MSV
Library.
+`msv:resourceUri` | 1.1 | Validate XML payloads using Multi-Schema Validator
(MSV).
| xref:components::mustache-component.adoc[Mustache] (camel-mustache) +
-`mustache:resourceUri` | 2.12 | Transforms the message using a Mustache
template.
+`mustache:resourceUri` | 2.12 | Transform messages using a Mustache template.
| xref:components::mvel-component.adoc[MVEL] (camel-mvel) +
-`mvel:resourceUri` | 2.12 | Transforms the message using a MVEL template.
+`mvel:resourceUri` | 2.12 | Transform messages using an MVEL template.
| xref:components::mybatis-component.adoc[MyBatis] (camel-mybatis) +
`mybatis:statement` | 2.7 | Performs a query, poll, insert, update or delete
in a relational database using MyBatis.
| xref:components::nagios-component.adoc[Nagios] (camel-nagios) +
-`nagios:host:port` | 2.3 | To send passive checks to Nagios using JSendNSCA.
+`nagios:host:port` | 2.3 | Send passive checks to Nagios using JSendNSCA.
| xref:components::nats-component.adoc[Nats] (camel-nats) +
-`nats:topic` | 2.17 | The nats component allows you produce and consume
messages from NATS.
+`nats:topic` | 2.17 | Send and receive messages from NATS messaging system.
| xref:components::netty-component.adoc[Netty] (camel-netty) +
-`netty:protocol:host:port` | 2.14 | Socket level networking using TCP or UDP
with the Netty 4.x library.
+`netty:protocol:host:port` | 2.14 | Socket level networking using TCP or UDP
with the Netty 4.x.
| xref:components::netty-http-component.adoc[Netty HTTP] (camel-netty-http) +
-`netty-http:protocol:host:port/path` | 2.14 | Netty HTTP server and client
using the Netty 4.x library.
+`netty-http:protocol:host:port/path` | 2.14 | Netty HTTP server and client
using the Netty 4.x.
| xref:components::nitrite-component.adoc[Nitrite] (camel-nitrite) +
-`nitrite:database` | 3.0 | Used for integrating Camel with Nitrite databases.
+`nitrite:database` | 3.0 | Access Nitrite databases.
| xref:components::nsq-component.adoc[NSQ] (camel-nsq) +
-`nsq:topic` | 2.23 | Represents a nsq endpoint.
+`nsq:topic` | 2.23 | Send and receive messages from NSQ realtime distributed
messaging platform.
| xref:components::olingo2-component.adoc[Olingo2] (camel-olingo2) +
-`olingo2:apiName/methodName` | 2.14 | Communicates with OData 2.0 services
using Apache Olingo.
+`olingo2:apiName/methodName` | 2.14 | Communicate with OData 2.0 services
using Apache Olingo.
| xref:components::olingo4-component.adoc[Olingo4] (camel-olingo4) +
-`olingo4:apiName/methodName` | 2.19 | Communicates with OData 4.0 services
using Apache Olingo OData API.
+`olingo4:apiName/methodName` | 2.19 | Communicate with OData 4.0 services
using Apache Olingo OData API.
| xref:components::optaplanner-component.adoc[OptaPlanner] (camel-optaplanner)
+
-`optaplanner:configFile` | 2.13 | Solves the planning problem contained in a
message with OptaPlanner.
+`optaplanner:configFile` | 2.13 | Solve planning problems with OptaPlanner.
| xref:camel-karaf::eventadmin-component.adoc[OSGi EventAdmin]
(camel-eventadmin) +
`eventadmin:topic` | 2.6 | The eventadmin component can be used in an OSGi
environment to receive OSGi EventAdmin events and process them.
@@ -429,208 +429,208 @@ Number of Camel components: 207 in 207 JAR artifacts (1
deprecated)
`paxlogging:appender` | 2.6 | The paxlogging component can be used in an OSGi
environment to receive PaxLogging events and process them.
| xref:components::paho-component.adoc[Paho] (camel-paho) +
-`paho:topic` | 2.16 | Component for communicating with MQTT message brokers
using Eclipse Paho MQTT Client.
+`paho:topic` | 2.16 | Communicate with MQTT message brokers using Eclipse Paho
MQTT Client.
| xref:components::pdf-component.adoc[PDF] (camel-pdf) +
-`pdf:operation` | 2.16 | The pdf components provides the ability to create,
modify or extract content from PDF documents.
+`pdf:operation` | 2.16 | Create, modify or extract content from PDF documents.
| xref:components::pgevent-component.adoc[PostgresSQL Event] (camel-pgevent) +
-`pgevent:host:port/database/channel` | 2.15 | The pgevent component allows for
producing/consuming PostgreSQL events related to the listen/notify commands.
+`pgevent:host:port/database/channel` | 2.15 | Send and receive PostgreSQL
events via LISTEN and NOTIFY commands.
| xref:components::pg-replication-slot-component.adoc[PostgresSQL Replication
Slot] (camel-pg-replication-slot) +
-`pg-replication-slot:host:port/database/slot:outputPlugin` | 3.0 | Consumer
endpoint to receive from PostgreSQL Replication Slot.
+`pg-replication-slot:host:port/database/slot:outputPlugin` | 3.0 | Poll for
PostgreSQL Write-Ahead Log (WAL) records using Streaming Replication Slots.
| xref:components::pubnub-component.adoc[PubNub] (camel-pubnub) +
-`pubnub:channel` | 2.19 | To send and receive messages to PubNub data stream
network for connected devices.
+`pubnub:channel` | 2.19 | Send and receive messages to/from PubNub data stream
network for connected devices.
| xref:components::pulsar-component.adoc[Pulsar] (camel-pulsar) +
-`pulsar:persistence://tenant/namespace/topic` | 2.24 | Camel Apache Pulsar
Component
+`pulsar:persistence://tenant/namespace/topic` | 2.24 | Send and receive
messages from/to Apache Pulsar messaging system.
| xref:components::quartz-component.adoc[Quartz] (camel-quartz) +
-`quartz:groupName/triggerName` | 2.12 | Provides a scheduled delivery of
messages using the Quartz 2.x scheduler.
+`quartz:groupName/triggerName` | 2.12 | Schedule sending of messages using the
Quartz 2.x scheduler.
| xref:components::quickfix-component.adoc[QuickFix] (camel-quickfix) +
-`quickfix:configurationName` | 2.1 | The quickfix component allows to send
Financial Interchange (FIX) messages to the QuickFix engine.
+`quickfix:configurationName` | 2.1 | Open a Financial Interchange (FIX)
session using an embedded QuickFix/J engine.
| xref:components::rabbitmq-component.adoc[RabbitMQ] (camel-rabbitmq) +
-`rabbitmq:exchangeName` | 2.12 | The rabbitmq component allows you produce and
consume messages from RabbitMQ instances.
+`rabbitmq:exchangeName` | 2.12 | Send and receive messages from RabbitMQ
instances.
| xref:components::reactive-streams-component.adoc[Reactive Streams]
(camel-reactive-streams) +
-`reactive-streams:stream` | 2.19 | Reactive Camel using reactive streams
+`reactive-streams:stream` | 2.19 | Exchange messages with reactive stream
processing libraries compatible with the reactive streams standard.
| xref:components::ref-component.adoc[Ref] (camel-ref) +
-`ref:name` | 1.2 | The ref component is used for lookup of existing endpoints
bound in the Registry.
+`ref:name` | 1.2 | Route messages to an endpoint looked up dynamically by name
in the Camel Registry.
| xref:components::rest-component.adoc[REST] (camel-rest) +
-`rest:method:path:uriTemplate` | 2.14 | The rest component is used for either
hosting REST services (consumer) or calling external REST services (producer).
+`rest:method:path:uriTemplate` | 2.14 | Expose REST services or call external
REST services.
| xref:components::rest-openapi-component.adoc[REST OpenApi]
(camel-rest-openapi) +
-`rest-openapi:specificationUri#operationId` | 3.1 | An awesome REST endpoint
backed by OpenApi specifications.
+`rest-openapi:specificationUri#operationId` | 3.1 | Configure REST producers
based on an OpenAPI specification document delegating to a component
implementing the RestProducerFactory interface.
| xref:components::rest-swagger-component.adoc[REST Swagger]
(camel-rest-swagger) +
-`rest-swagger:specificationUri#operationId` | 2.19 | An awesome REST endpoint
backed by Swagger specifications.
+`rest-swagger:specificationUri#operationId` | 2.19 | Configure REST producers
based on a Swagger (OpenAPI) specification document delegating to a component
implementing the RestProducerFactory interface.
| xref:components::robotframework-component.adoc[Robot Framework]
(camel-robotframework) +
-`robotframework:resourceUri` | 3.0 | Represents a RobotFramework endpoint.
+`robotframework:resourceUri` | 3.0 | Pass camel exchanges to acceptence test
written in Robot DSL.
| xref:components::rss-component.adoc[RSS] (camel-rss) +
-`rss:feedUri` | 2.0 | The rss component is used for consuming RSS feeds.
+`rss:feedUri` | 2.0 | Poll RSS feeds.
| xref:components::saga-component.adoc[Saga] (camel-saga) +
-`saga:action` | 2.21 | The saga component provides access to advanced options
for managing the flow in the Saga EIP.
+`saga:action` | 2.21 | Execute custom actions within a route using the Saga
EIP.
| xref:components::salesforce-component.adoc[Salesforce] (camel-salesforce) +
-`salesforce:operationName:topicName` | 2.12 | The salesforce component is used
for integrating Camel with the massive Salesforce API.
+`salesforce:operationName:topicName` | 2.12 | Communicate with Salesforce
using Java DTOs.
| xref:components::sap-netweaver-component.adoc[SAP NetWeaver]
(camel-sap-netweaver) +
-`sap-netweaver:url` | 2.12 | The sap-netweaver component integrates with the
SAP NetWeaver Gateway using HTTP transports.
+`sap-netweaver:url` | 2.12 | Send requests to SAP NetWeaver Gateway using HTTP.
| xref:components::scheduler-component.adoc[Scheduler] (camel-scheduler) +
-`scheduler:name` | 2.15 | The scheduler component is used for generating
message exchanges when a scheduler fires.
+`scheduler:name` | 2.15 | Generate messages in specified intervals using
java.util.concurrent.ScheduledExecutorService.
| xref:components::schematron-component.adoc[Schematron] (camel-schematron) +
-`schematron:path` | 2.15 | Validates the payload of a message using the
Schematron Library.
+`schematron:path` | 2.15 | Validate XML payload using the Schematron Library.
| xref:components::seda-component.adoc[SEDA] (camel-seda) +
`seda:name` | 1.1 | Asynchronously call another endpoint from any Camel
Context in the same JVM.
| xref:components::service-component.adoc[Service] (camel-service) +
-`service:delegateUri` | 2.22 | Represents an endpoint which is registered to a
Service Registry such as Consul, Etcd.
+`service:delegateUri` | 2.22 | Register a Camel endpoint to a Service Registry
(such as Consul, Etcd) and delegate to it.
| xref:components::servicenow-component.adoc[ServiceNow] (camel-servicenow) +
-`servicenow:instanceName` | 2.18 | The servicenow component is used to
integrate Camel with ServiceNow cloud services.
+`servicenow:instanceName` | 2.18 | Interact with ServiceNow via its REST API.
| xref:components::servlet-component.adoc[Servlet] (camel-servlet) +
-`servlet:contextPath` | 2.0 | To use a HTTP Servlet as entry for Camel routes
when running in a servlet container.
+`servlet:contextPath` | 2.0 | Serve HTTP requests by a Servlet.
| xref:components::sjms-component.adoc[Simple JMS] (camel-sjms) +
-`sjms:destinationType:destinationName` | 2.11 | The sjms component (simple
jms) allows messages to be sent to (or consumed from) a JMS Queue or Topic
(uses JMS 1.x API).
+`sjms:destinationType:destinationName` | 2.11 | Send and receive messages
to/from a JMS Queue or Topic using plain JMS 1.x API.
| xref:components::sjms2-component.adoc[Simple JMS2] (camel-sjms2) +
-`sjms2:destinationType:destinationName` | 2.19 | The sjms2 component (simple
jms) allows messages to be sent to (or consumed from) a JMS Queue or Topic
(uses JMS 2.x API).
+`sjms2:destinationType:destinationName` | 2.19 | Send and receive messages
to/from a JMS Queue or Topic using plain JMS 2.x API.
| xref:components::sip-component.adoc[SIP] (camel-sip) +
-`sip:uri` | 2.5 | To send and receive messages using the SIP protocol (used in
telco and mobile).
+`sip:uri` | 2.5 | Send and receive messages using the SIP protocol (used in
telecommunications).
| xref:components::slack-component.adoc[Slack] (camel-slack) +
-`slack:channel` | 2.16 | The slack component allows you to send messages to
Slack.
+`slack:channel` | 2.16 | Send and receive messages to/from Slack.
| xref:components::smpp-component.adoc[SMPP] (camel-smpp) +
-`smpp:host:port` | 2.2 | To send and receive SMS using a SMSC (Short Message
Service Center).
+`smpp:host:port` | 2.2 | Send and receive SMS messages using a SMSC (Short
Message Service Center).
| xref:components::snmp-component.adoc[SNMP] (camel-snmp) +
-`snmp:host:port` | 2.1 | The snmp component gives you the ability to poll SNMP
capable devices or receiving traps.
+`snmp:host:port` | 2.1 | Receive traps and poll SNMP (Simple Network
Management Protocol) capable devices.
| xref:components::solr-component.adoc[Solr] (camel-solr) +
-`solr:url` | 2.9 | The solr component allows you to interface with an Apache
Lucene Solr server.
+`solr:url` | 2.9 | Perform operations against Apache Lucene Solr.
| xref:components::soroush-component.adoc[Soroush] (camel-soroush) +
-`soroush:action` | 3.0 | To integrate with the Soroush chat bot.
+`soroush:action` | 3.0 | Send and receive messages as a Soroush chat bot.
| xref:components::splunk-component.adoc[Splunk] (camel-splunk) +
-`splunk:name` | 2.13 | The splunk component allows to publish or search for
events in Splunk.
+`splunk:name` | 2.13 | Publish or search for events in Splunk.
| xref:components::spring-batch-component.adoc[Spring Batch]
(camel-spring-batch) +
-`spring-batch:jobName` | 2.10 | The spring-batch component allows to send
messages to Spring Batch for further processing.
+`spring-batch:jobName` | 2.10 | Send messages to Spring Batch for further
processing.
| xref:components::spring-ldap-component.adoc[Spring LDAP] (camel-spring-ldap)
+
-`spring-ldap:templateName` | 2.11 | The spring-ldap component allows you to
perform searches in LDAP servers using filters as the message payload.
+`spring-ldap:templateName` | 2.11 | Perform searches in LDAP servers using
filters as the message payload.
| xref:components::spring-redis-component.adoc[Spring Redis]
(camel-spring-redis) +
-`spring-redis:host:port` | 2.11 | The spring-redis component allows sending
and receiving messages from Redis.
+`spring-redis:host:port` | 2.11 | Send and receive messages from Redis.
| xref:components::spring-ws-component.adoc[Spring WebService]
(camel-spring-ws) +
-`spring-ws:type:lookupKey:webServiceEndpointUri` | 2.6 | The spring-ws
component is used for SOAP WebServices using Spring WebServices.
+`spring-ws:type:lookupKey:webServiceEndpointUri` | 2.6 | Access external web
services as a client or expose your own web services.
| xref:components::sql-component.adoc[SQL] (camel-sql) +
-`sql:query` | 1.4 | The sql component allows you to work with databases using
JDBC SQL queries.
+`sql:query` | 1.4 | Perform SQL queries using Spring JDBC.
| xref:components::ssh-component.adoc[SSH] (camel-ssh) +
-`ssh:host:port` | 2.10 | The ssh component enables access to SSH servers such
that you can send an SSH command, and process the response.
+`ssh:host:port` | 2.10 | Execute commands on remote hosts using SSH.
| xref:components::stax-component.adoc[StAX] (camel-stax) +
-`stax:contentHandlerClass` | 2.9 | The stax component allows messages to be
process through a SAX ContentHandler.
+`stax:contentHandlerClass` | 2.9 | Process XML payloads by a SAX
ContentHandler.
| xref:components::stomp-component.adoc[Stomp] (camel-stomp) +
-`stomp:destination` | 2.12 | The stomp component is used for communicating
with Stomp compliant message brokers.
+`stomp:destination` | 2.12 | Send and rececive messages to/from STOMP (Simple
Text Oriented Messaging Protocol) compliant message brokers.
| xref:components::stream-component.adoc[Stream] (camel-stream) +
-`stream:kind` | 1.3 | The stream: component provides access to the system-in,
system-out and system-err streams as well as allowing streaming of file.
+`stream:kind` | 1.3 | Read from system-in and write to system-out and
system-err streams.
| xref:components::string-template-component.adoc[String Template]
(camel-stringtemplate) +
-`string-template:resourceUri` | 1.2 | Transforms the message using a String
template.
+`string-template:resourceUri` | 1.2 | Transform messages using StringTemplate
engine.
| xref:components::stub-component.adoc[Stub] (camel-stub) +
-`stub:name` | 2.10 | The stub component provides a simple way to stub out any
physical endpoints while in development or testing.
+`stub:name` | 2.10 | Stub out any physical endpoints while in development or
testing.
| xref:components::telegram-component.adoc[Telegram] (camel-telegram) +
-`telegram:type` | 2.18 | The telegram component provides access to the
Telegram Bot API.
+`telegram:type` | 2.18 | Send and receive messages acting as a Telegram Bot
Telegram Bot API.
| xref:components::thrift-component.adoc[Thrift] (camel-thrift) +
-`thrift:host:port/service` | 2.20 | The Thrift component allows to call and
expose remote procedures (RPC) with Apache Thrift data format and serialization
mechanism
+`thrift:host:port/service` | 2.20 | Call and expose remote procedures (RPC)
with Apache Thrift data format and serialization mechanism.
| xref:components::tika-component.adoc[Tika] (camel-tika) +
-`tika:operation` | 2.19 | This component integrates with Apache Tika to
extract content and metadata from thousands of file types.
+`tika:operation` | 2.19 | Parse documents and extract metadata and text using
Apache Tika.
| xref:components::timer-component.adoc[Timer] (camel-timer) +
-`timer:timerName` | 1.0 | The timer component is used for generating message
exchanges when a timer fires.
+`timer:timerName` | 1.0 | Generate messages in specified intervals using
java.util.Timer.
| xref:components::twilio-component.adoc[Twilio] (camel-twilio) +
-`twilio:apiName/methodName` | 2.20 | The Twilio component allows you to
interact with the Twilio REST APIs using Twilio Java SDK.
+`twilio:apiName/methodName` | 2.20 | Interact with Twilio REST APIs using
Twilio Java SDK.
| xref:components::validator-component.adoc[Validator] (camel-validator) +
-`validator:resourceUri` | 1.1 | Validates the payload of a message using XML
Schema and JAXP Validation.
+`validator:resourceUri` | 1.1 | Validate the payload using XML Schema and JAXP
Validation.
| xref:components::velocity-component.adoc[Velocity] (camel-velocity) +
-`velocity:resourceUri` | 1.2 | Transforms the message using a Velocity
template.
+`velocity:resourceUri` | 1.2 | Transform messages using a Velocity template.
| xref:components::vertx-component.adoc[Vert.x] (camel-vertx) +
-`vertx:address` | 2.12 | The vertx component is used for sending and receive
messages from a vertx event bus.
+`vertx:address` | 2.12 | Send and receive messages to/from Vert.x Event Bus.
| xref:components::vm-component.adoc[VM] (camel-vm) +
-`vm:name` | 1.1 | The vm component provides asynchronous call to another
endpoint from the same CamelContext.
+`vm:name` | 1.1 | Call another endpoint in the same CamelContext
asynchronously.
| xref:components::weather-component.adoc[Weather] (camel-weather) +
-`weather:name` | 2.12 | Polls the weather information from Open Weather Map.
+`weather:name` | 2.12 | Poll the weather information from Open Weather Map.
| xref:components::web3j-component.adoc[Web3j Ethereum Blockchain]
(camel-web3j) +
-`web3j:nodeAddress` | 2.22 | The web3j component uses the Web3j client API and
allows you to add/read nodes to/from a web3j compliant content repositories.
+`web3j:nodeAddress` | 2.22 | Interact with Ethereum nodes using web3j client
API.
| xref:components::webhook-component.adoc[Webhook] (camel-webhook) +
-`webhook:endpointUri` | 3.0 | The webhook component allows other Camel
components that can receive push notifications to expose webhook endpoints and
automatically register them with their own webhook provider.
+`webhook:endpointUri` | 3.0 | Expose webhook endpoints to receive push
notifications for other Camel components.
| xref:components::wordpress-component.adoc[Wordpress] (camel-wordpress) +
-`wordpress:operation` | 2.21 | Integrates Camel with Wordpress.
+`wordpress:operation` | 2.21 | Manage posts and users using Wordpress API.
| xref:components::workday-component.adoc[Workday] (camel-workday) +
-`workday:entity:path` | 3.1 | Represents a Workday endpoint.
+`workday:entity:path` | 3.1 | Detect and parse documents using Workday.
| xref:components::xchange-component.adoc[XChange] (camel-xchange) +
-`xchange:name` | 2.21 | The camel-xchange component provide access to many
bitcoin and altcoin exchanges for trading and accessing market data.
+`xchange:name` | 2.21 | Access market data and trade on Bitcoin and Altcoin
exchanges.
| xref:components::xj-component.adoc[XJ] (camel-xj) +
-`xj:resourceUri` | 3.0 | Transforms json/xml message back and forth using a
XSLT.
+`xj:resourceUri` | 3.0 | Transform JSON and XML message using a XSLT.
| xref:components::xmpp-component.adoc[XMPP] (camel-xmpp) +
-`xmpp:host:port/participant` | 1.0 | To send and receive messages from a XMPP
(chat) server.
+`xmpp:host:port/participant` | 1.0 | Send and receive messages to/from an XMPP
chat server.
| xref:components::xslt-component.adoc[XSLT] (camel-xslt) +
-`xslt:resourceUri` | 1.3 | Transforms the message using a XSLT template.
+`xslt:resourceUri` | 1.3 | Transforms XML payload using an XSLT template.
| xref:components::xslt-saxon-component.adoc[XSLT Saxon] (camel-xslt-saxon) +
-`xslt-saxon:resourceUri` | 3.0 | Transforms the message using a XSLT template
using Saxon.
+`xslt-saxon:resourceUri` | 3.0 | Transform XML payloads using an XSLT template
using Saxon.
| xref:components::yammer-component.adoc[Yammer] (camel-yammer) +
-`yammer:function` | 2.12 | The yammer component allows you to interact with
the Yammer enterprise social network.
+`yammer:function` | 2.12 | Interact with the Yammer enterprise social network.
| xref:components::zendesk-component.adoc[Zendesk] (camel-zendesk) +
-`zendesk:methodName` | 2.19 | Allows producing messages to manage Zendesk
ticket, user, organization, etc.
+`zendesk:methodName` | 2.19 | Manage Zendesk tickets, users, organizations,
etc.
| xref:components::zookeeper-component.adoc[ZooKeeper] (camel-zookeeper) +
-`zookeeper:serverUrls/path` | 2.9 | The zookeeper component allows interaction
with a ZooKeeper cluster.
+`zookeeper:serverUrls/path` | 2.9 | Manage ZooKeeper clusters.
| xref:components::zookeeper-master-component.adoc[ZooKeeper Master]
(camel-zookeeper-master) +
-`zookeeper-master:groupName:consumerEndpointUri` | 2.19 | Represents an
endpoint which only becomes active when it obtains the master lock
+`zookeeper-master:groupName:consumerEndpointUri` | 2.19 | Have only a single
consumer in a cluster consuming from a given endpoint; with automatic failover
if the JVM dies.
|===
// components: END
