| ftp | ✅ | cameleer-protocols. Polling consumer (noop/delete/move/preMove/moveFailed, include/exclude/ant, recursive, sortBy, idempotent) and producer (fileExist strategies, tempFileName, doneFileName); passive/active mode, MLSD/LIST parsing; readLock = changed (SIZE/MDTM stable across readLockCheckInterval, readLockTimeout, readLockMinLength, readLockMinAge), rename (exclusive rename probe), idempotent, idempotent-changed, idempotent-rename. localWorkDirectory (downloads streamed to a local file, header CamelFileLocalWorkPath, removed after the exchange), resumeDownload (a partial <name>.inprogress local work file is continued with REST <size>; the embedded FtpServer implements REST), streamDownload (body = a one-shot stream handle from cameleer_tls::stream_body backed by a temp/local work file — Value has no stream variant — consumed chunked by the http producer or materialised on demand, released after the exchange). ftps ✅: explicit (AUTH TLS) and implicit (isImplicit=true) mode, PBSZ/PROT P protected data connections (execPbsz, execProt, disableSecureDataChannelDefaults), securityProtocol, sslContextParameters; data connections resume the control connection's TLS session (works with vsftpd require_ssl_reuse=YES-style servers; the embedded FtpServer::set_require_ssl_reuse enforces it). sftp ❌ (no SSH here). |
| smtp / pop3 / imap (mail) | ✅ | cameleer-protocols. SMTP AUTH PLAIN/LOGIN, headers override options, attachments via CamelAttachments; POP3/IMAP polling with MIME decoding, delete/copyTo/moveTo. smtps/pop3s/imaps (implicit TLS, ports 465/995/993) and STARTTLS/STLS on the plain schemes (mail.<protocol>.starttls.enable / .required), sslContextParameters. |
| websocket / vertx-websocket / ws | ✅ | cameleer-protocols. RFC 6455 server and client, fragmentation, ping/pong, sendToAll, connection-key routing. No compression extensions. wss:// client endpoints and wss servers (sslContextParameters on websocket/vertx-websocket). |
| mllp + hl7 data format | ✅ | cameleer-protocols. MLLP framing, auto-ACK (AA/AE), producer ACK validation and exceptions, CamelMllp* headers; HL7 v2 parsing with terser paths (hl7terser language). TLS with sslContextParameters (consumer and producer). No typed HAPI model. |
| syslog | ✅ | cameleer-protocols. RFC 5424/3164 data format, UDP/TCP component; TLS (RFC 5425) with syslog:tls:// or ssl=true + sslContextParameters (octet-counted framing). |
| kafka | ✅ | cameleer-kafka-mqtt. Built-in Kafka wire protocol client (ApiVersions, Metadata v5, Produce v3 with v2 record batches/CRC32C/headers, Fetch v4, ListOffsets v1, FindCoordinator, JoinGroup/SyncGroup/Heartbeat/LeaveGroup, OffsetCommit/OffsetFetch, CreateTopics). Producer: kafka.KEY/key, kafka.PARTITION_KEY/partitionKey, murmur2 partitioner, kafka.OVERRIDE_TOPIC, requestRequiredAcks, record headers, kafka.RECORD_META. Consumer: groupId with range assignor and rebalancing, consumersCount, committed offsets (autoCommitEnable, autoCommitIntervalMs, allowManualCommit via kafka::manual_commit), autoOffsetReset, seekTo, topicIsPattern, breakOnFirstError, maxPollRecords; kafka.TOPIC/PARTITION/OFFSET/KEY/TIMESTAMP headers. Security: securityProtocol SSL, SASL_PLAINTEXT, SASL_SSL with saslMechanism PLAIN, SCRAM-SHA-256, SCRAM-SHA-512 (saslJaasConfig credentials), AWS_MSK_IAM (registered by cameleer-cloud, see aws2-msk; custom one-step mechanisms via kafka::client::register_sasl_mechanism), sslContextParameters, sslTruststoreLocation/sslTruststorePassword/sslTruststoreType and client certificates with sslKeystoreLocation/sslKeystorePassword/sslKeyPassword/sslKeystoreType (PKCS12, JKS or PEM), sslEndpointIdentificationAlgorithm, sslProtocol. Embedded test broker testing::KafkaBroker (with TLS and SASL modes). No GSSAPI/OAUTHBEARER, transactions, idempotent producer, compression on send (gzip batches are decoded), or Avro/schema registry. |
| paho / paho-mqtt5 (MQTT) | ✅ | cameleer-kafka-mqtt. MQTT 3.1.1 and 5.0 client: username/password, keep-alive, QoS 0/1/2 flows, +/# wildcards, retained, clean/persistent sessions, will (willTopic...), automatic reconnect with re-subscription. Headers CamelMqttTopic, CamelMqttQoS, CamelMqttRetained, CamelPahoOverrideTopic (+ CamelPahoQos/CamelPahoRetained on the producer). ssl:///mqtts:// broker urls (TLS, sslContextParameters - client certificates from its key material, httpsHostnameVerificationEnabled). Embedded test broker testing::MqttBroker (optionally TLS). No ws:///wss:// transports, no MQTT 5 topic aliases, enhanced auth or shared subscriptions. |
| direct | ✅ | Synchronous. Fails with DirectConsumerNotAvailableException when no consumer is running. |
| seda / vm / stub | ✅ | size, concurrentConsumers, waitForTaskToComplete, timeout, multipleConsumers, blockWhenFull, discardWhenFull, offerTimeout, purgeWhenStopping, failIfNoConsumers, discardIfNoConsumers. Supports polling consumers. |
| timer | ✅ | period, delay, repeatCount, fixedRate, includeMetadata, time (local time of the default time zone; a trailing Z, offset or [Europe/Paris] selects another zone). Sets the CamelTimerCounter property. |
| scheduler | ✅ | Scheduled poll consumer options, including scheduler=quartz&scheduler.cron=... (also for the file consumer). |
| cron, quartz | ✅ | Built-in cron engine (component/cron_expr.rs): Quartz 6/7-field and Unix 5-field syntax, L, W, #, names, macros (@daily...), time zones (timeZone=GMT+02:00 or region ids such as Europe/Paris read from the system zoneinfo database, TZif v1-v3 with POSIX footer rules; default: the process time zone). DST gaps and overlaps behave like Quartz: a fire time in a spring-forward gap fires once, shifted forward; one in a fall-back overlap fires once (standard time). quartz: cron and simple triggers (trigger.repeatInterval/repeatCount, fireNow, triggerStartDelay). Quartz headers (fireTime, scheduledFireTime, ...) carry epoch millis. No job store, clustering or calendars; missed fires are skipped. |
| mustache | ✅ | Variables, sections, inverted sections, comments, partials, set-delimiter, standalone lines; allowTemplateFromHeader, contentCache, startDelimiter/endDelimiter. No lambdas. |
| string-template, velocity, freemarker | ✅ | Real engines in cameleer-core. Velocity (VTL 2): references with properties/methods/indexes, quiet refs, #set, #if/#elseif/#else, #foreach ($foreach.*), #break, #stop, #macro (+ block macros), #include, #parse, #evaluate, #define, comments, escapes, Velocity arithmetic/logic. FreeMarker (FTL 2.3): interpolations, if/list/items/sep/assign/global/local/macro/nested/function/return/include/import/switch/attempt/recover/compress/noparse/escape/outputformat/autoesc/setting, user directives, lambdas, ranges, slices, defaults !/??, the string/number/boolean/sequence/hash/loop built-ins, square-bracket syntax; FreeMarker's strict missing-value errors (no date/time built-ins). StringTemplate 4: attributes, properties, anonymous sub-templates with it/i/i0, zipped/chained application, separators, if/elseif/else, functions first last rest trunc strip length reverse trim strlen, custom delimiters (delimiterStart/delimiterStop; template groups are not supported). Data model as in Camel (body, headers, exchange, variables, request/in, camelContext with allowContextMapAll), Java method calls on values, allowTemplateFromHeader headers, CamelVelocityContext/CamelVelocitySupplementalContext, CamelFreemarkerDataModel, contentCache. |
| mvel | ✅ | cameleer-script (mvel:template.mvel, registered by cameleer_script::register): renders MVEL 2 templates (orb tags, see the MVEL language row) against Camel's template data model (body, headers, exchange, request/in, variables; Java-like exchange accessors), with allowTemplateFromHeader (CamelMvelTemplate / CamelMvelResourceUri), contentCache, allowContextMapAll; literal @include{}s resolve relative to the template. |
| json-validator | ✅ | Built-in JSON Schema validator (draft-04 to 07 subset incl. $ref to local definitions, combinators, formats); JsonValidationException lists all errors. No remote $ref. |
| validator (XML) | ✅ | cameleer-xml (cameleer-core alone: well-formedness only): XML Schema subset — global/local elements, ref, minOccurs/maxOccurs, sequence/choice/all, model groups, any, mixed and empty content, simpleContent/complexContent extension and restriction, attributes (use=required, fixed, anyAttribute, attribute groups), simple types with enumeration, pattern, (min/max)Length, min/max Inclusive/Exclusive, totalDigits, fractionDigits, list, union, built-in types (string family, boolean, decimal, integer family, float/double, date, dateTime, time, duration, g*, binary), include/import, xsi:nil, identity constraints (unique/key/keyref with the restricted selector/field XPath: .//, child::, @/attribute::, *, p:*, ., ` |
| xslt, xslt-saxon | ✅ | cameleer-xml: XSLT 1.0 processor — templates with match patterns and priorities, modes, built-in rules, apply-templates/call-template with params, value-of, for-each, if/choose, sort (text/number, order, case-order, lang (accent folding, Nordic alphabets) and collation (codepoint, UCA/Saxon strength=primary|secondary|tertiary)), copy/copy-of, element/attribute/text/comment/processing-instruction, attribute sets, variables (RTFs usable as node-sets, exsl:node-set), key(), number (incl. letter-value alphabetic/traditional and lang: Greek, Cyrillic, Hebrew alphabets, Greek/Hebrew traditional numerals), format-number + decimal-format, document(), include/import/apply-imports, strip-space, namespace-alias, message, xsl:output method xml/html/text (html adds the <META http-equiv="Content-Type"> after <head>; include-content-type="no"), indent (xalan:indent-amount), cdata-section-elements, doctype, disable-output-escaping. version="2.0" stylesheets (xslt-saxon) are compiled with XPath 2.0 (if/for/some/every, sequences, to, value comparisons, intersect/except, ` |
| xj | ✅ | cameleer-xml: xj:identity or xj:file:x.xsl with transformDirection=XML2JSON|JSON2XML. JSON → XML uses Camel's xj representation (<object xj:name=".." xj:type="object|array|string|int|float|boolean|null">); XML → JSON honours xj annotations, otherwise element names become keys (repeated names → arrays, attributes @name, mixed text #text), keeping document order. |
| xmlsecurity-sign, xmlsecurity-verify | ✅ | cameleer-xml: XML Signature with RSA-SHA256 or ECDSA-SHA256 (cameleer-tls crypto), SHA-256 digests (SHA-1/512 accepted on verify), exclusive (default) or inclusive C14N. Signature types as in Camel: enveloped (parentLocalName/parentNamespace or parentXpath; default: the document element), detached (xpathsToIdAttributes: one reference per selected Id, signature after the last signed element or in the given parent) and enveloping (contentObjectId / envelopingSignature=true: content in ds:Object; verify returns the object content). Transforms: enveloped, C14N variants, XPath Filter (xpathFilter) and XPath Filter 2.0 (xpath2Filter=intersect:expr;subtract:expr, xpathNamespaces) via node-set canonicalization. KeyInfo: X509Data (certificate or the key store entry chain), KeyValue (addKeyValue: RSAKeyValue / dsig11:ECKeyValue), KeyName (keyName); signatureId, prefixForXmlSignatureNamespace, omitXmlDeclaration. Keys: PEM privateKey/certificate/publicKey (file, ref: bean, inline) or key stores via cameleer-tls keystore (keyStore = PKCS#12/JKS/JCEKS file or #bean KeyStore, keyStorePassword, keyPassword, alias; also keyAccessor/keySelector): verify matches the X509Certificate against the store, KeyName against aliases, else tries every key; trustKeyInfoCertificate trusts the embedded certificate or key value. Errors XmlSignatureFormatException, XmlSignatureInvalidContentHashException, XmlSignatureInvalidValueException, XmlSignatureInvalidKeyException. Not supported: ds:Manifest, external references, XSLT transforms. |
| slack | ✅ | cameleer-saas: producer via incoming webhook (webhookUrl, username, iconUrl, iconEmoji) or Web API chat.postMessage (token; object bodies are sent as the payload, ok:false → ApiException); consumer polling conversations.history (channel resolved by name, maxResults, naturalOrder, conversationType). serverUrl overrides the API. Mock: testing::SlackMock. |
| telegram | ✅ | cameleer-saas: telegram:bots?authorizationToken=..: sendMessage (chatId / CamelTelegramChatId, parseMode), multipart sendPhoto/sendAudio/sendVideo/sendDocument (CamelTelegramMediaType, caption header), object bodies; getUpdates long-poll consumer (timeout, limit, offsets confirmed); webhook support (setWebhook/deleteWebhook). baseUri overrides the API. Mock: testing::TelegramMock. |
| github | ✅ | cameleer-saas: consumers pullRequest, issue, commit/<branch> (startingSha), tag, event (repository events; body = event type, headers CamelGitHubEventPayload, GitHubEvent, GitHubEventId); producers createIssue (GitHubIssueTitle), pullRequestComment (GitHubPullRequest, GitHubInResponseTo), issueComment, pullRequestState, pullRequestFiles (list of changed file objects), getCommitFile (body = commit file / blob sha → decoded content, encoding=base64 keeps base64), closePullRequest; oauthToken; repository webhooks via webhook:github:.... serverUrl overrides the API. Mock: testing::GithubMock. |
| twilio | ✅ | cameleer-saas: all REST 2010-04-01 resources of Camel's twilio component as twilio:<api>/<method> — account, address (+ dependent phone numbers), application, available-phone-number-country (+ local/mobile/toll-free), call (+ feedback, feedback summary, notifications, recordings), conference (+ participants), connect-app, incoming-phone-number (+ local/mobile/toll-free), key, new-key, message (+ feedback, media), notification, outgoing-caller-id, queue (+ members), recording (+ add-on results, payloads, transcriptions), short-code, signing-key, new-signing-key, sip credential lists / credentials / domains / mappings / IP access control lists / IP addresses, token, transcription, usage-record (all time / daily / last month / monthly / this month / today / yearly / yesterday), usage-trigger, validation-request — with methods create/read/fetch/update/delete (and the creator/reader/... aliases; unsupported combinations rejected). Parameters from endpoint options or CamelTwilio.<param> headers, path* parameters (pathSid, pathAccountSid, pathCallSid, pathQueueSid...) build the resource path, the rest become capitalised form fields (lists repeat), inBody; Basic auth (username/password, accountSid). serverUrl overrides the API. Mock: testing::TwilioMock (generic resource store). |
| jira | ✅ | cameleer-saas: REST v2 producers addIssue (Camel ProjectKey/IssueTypeName/IssueSummary/... headers), updateIssue, addComment, deleteIssue, fetchIssue, fetchComments, searchIssues (JQL), transitionIssue (IssueTransitionId, body = comment), attach (multipart upload, CamelFileName), watchers (IssueWatchersAdd/IssueWatchersRemove), addIssueLink (ParentIssueKey/ChildIssueKey/linkType), addWorkLog (minutesSpent); polling consumers newIssues, newComments, watchUpdates (watchedFields, sendOnlyUpdatedField, headers IssueChanged, IssueWatchedIssues); Basic (username/password) or bearer (accessToken) auth. OAuth 1.0a (consumerKey/privateKey) is accepted but not used. Mock: testing::JiraMock. |
| openai | ✅ | cameleer-saas (counterpart of langchain4j-chat/-embeddings): openai:chat-completion?model=.. (text, message-list or request-object bodies, systemMessage, temperature, maxTokens, topP, outputType=full, usage/finish-reason headers) and openai:embeddings, any OpenAI-compatible server via baseUrl, apiKey (or OPENAI_API_KEY). No streaming or tool calls. Mock: testing::OpenAiMock. |
| webhook | ✅ | cameleer-saas: webhook:<delegate uri> exposes telegram / github endpoints on platform-http (webhookPath, webhookBasePath, webhookComponentName) and registers / unregisters the hook (webhookExternalUrl, webhookAutoRegister). |
| graphql | ✅ | cameleer-saas: graphql://http(s)://host/path with query, queryFile, queryHeader, operationName, variables (JSON or #bean), variablesHeader, accessToken + jwtAuthorizationType, Basic auth, throwExceptionOnFailure; body = response JSON text. Mock: testing::GraphqlMock. |
| rss, atom | ✅ | cameleer-saas: polling feed consumers for RSS 2.0, RSS 1.0 and Atom 1.0 (cameleer-xml parser): splitEntries, filter + lastUpdate, sortEntries, throttleEntries, feedHeader (CamelRssFeed/CamelAtomFeed); feeds/entries are maps (title, link, uri, description, contents, author, dates, categories); unknown options go to the feed url. Mock: testing::FeedMock. weather ❌. |
| log | ✅ | level, showAll/showXxx, multiline, maxChars, groupSize/groupInterval, masking. BodyType: shows the Java class name Camel would show (java.lang.String...). Log timestamps use the default time zone (TZ). |
| mock | ✅ | Expectations (count, minimum count, bodies in order or any order, headers, properties, no duplicates, custom), assertPeriod, resultWaitTime, whenAnyExchangeReceived, returnReplyBody, reset. |
| file | ✅ | Consumer: noop (idempotent), delete, move/moveFailed/preMove with file-language expressions, include/exclude/ant filters, recursive, depth, sorting, read locks (changed follows Camel: marker file, two equal checks or readLockMinAge, readLockMinLength, readLockTimeout), idempotent repositories, done files. Producer: fileName expressions, fileExist (Override/Append/Fail/Ignore/Move/TryRename), temp files, done files, CamelFileNameProduced. |
| controlbus | ✅ | Route actions (start/stop/suspend/resume/restart/status/stats/fail) and language: scripts. |
| bean / class, ref, language, browse, exec, stream, dataset/dataset-test/test, dataformat | ✅ | exec runs local processes. stream handles stdin/stdout/stderr/files. |
| platform-http (aliases jetty, undertow, netty-http) | ✅ | HTTP/1.1 server: path parameters, matchOnUriPrefix, httpMethodRestrict (405), chunked encoding, keep-alive, muteException. Streaming: stream-handle (cameleer_tls::stream_body) response bodies are sent chunked without buffering; disableStreamCache=true passes request bodies as stream handles read lazily off the connection. CamelHttpResponseCode sets the status. A failure is a 500 carrying the exception text. A handled exception is a 200 with the handled body. HTTPS: jetty:https:///undertow:https:///netty-http:https://, and platform-http with ssl=true, sslContextParameters or camel.server.ssl* properties. Mutual TLS with needClientAuth=true / `clientAuth=NONE |
| http | ✅ | HTTP/1.1 and HTTP/2 client (httpVersion=HTTP/2: cameleer-grpc's HTTP/2 stack, TLS + ALPN h2 or h2c prior knowledge, one multiplexed connection per target); pooled keep-alive HTTP/1.1 connections (connectionsPerRoute, connectionClose, stale connections retried); content coding (Accept-Encoding: gzip, deflate and transparent response decoding unless contentCompressionDisabled=true, request bodies compressed when Content-Encoding is gzip/deflate); httpMethod, throwExceptionOnFailure, okStatusCodeRange, timeouts, redirects, Basic auth, bridgeEndpoint, CamelHttpMethod/Path/Query/Uri headers, HttpOperationFailedException with status code and response body. https with SNI and host name verification (sslContextParameters, useGlobalSslContextParameters; client certificates from the parameters' key store), TLS session resumption per host:port, proxies (proxyHost/proxyPort/proxyAuthUsername, useSystemProperties=true for HTTPS_PROXY/HTTP_PROXY/NO_PROXY) with CONNECT tunnelling for https. Streaming bodies (cameleer_tls::stream_body handles, as Value has no stream variant): a stream-handle body is sent with chunked transfer coding straight from its reader (e.g. an ftp streamDownload file), disableStreamCache=true returns the response as a lazily decoded stream handle (Content-Length / chunked / until-close) instead of a byte array; consumers (platform-http & co.) send stream-handle response bodies chunked and, with disableStreamCache=true, pass request bodies as stream handles read off the connection. Remaining gaps: streamed bodies are not content-(de)compressed and HTTP/2 materialises them. |
| https / TLS | ✅ | cameleer-tls: std-only TLS 1.3/1.2 client and server (interop-tested against OpenSSL, incl. the https producer against openssl s_server), NetStream (cloneable plain/TLS socket for full-duplex components), SASL PLAIN/SCRAM helpers. Used by http/https, platform-http, netty, ftps, smtps/pop3s/imaps + STARTTLS, wss, mllp, syslog, kafka, paho, rabbitmq (amqps), stomp/jms and PostgreSQL. Mutual TLS in TLS 1.3 and 1.2 (client and server, interop-tested with openssl s_server -Verify / s_client -cert), TLS 1.3 PSK resumption and TLS 1.2 session tickets/IDs (interop-tested with s_client -sess_out/-sess_in and s_server), Ed25519 certificates, CRL revocation checks, PKCS#12/JKS/JCEKS key stores (fixtures from openssl pkcs12 and keytool). Side-channel hardening: AES SubBytes is bitsliced (GF(2^8) inversion + affine map on eight 16-bit planes, no secret-indexed tables, also in the key schedule and the inverse cipher), branch-free GF multiplications; RSA private operations use base blinding (r^e / r^-1 pair squared per use), the CRT when PKCS#1 parameters are present, and verify every result before release. OCSP (cameleer_tls::ocsp): response parsing and validation (issuer or delegated OCSPSigning responder signature, SHA-1/SHA-256 CertID, thisUpdate/nextUpdate with skew, good/revoked/unknown) and stapling via status_request: clients request it with OcspMode::Request (validate when stapled) / Require (fail without a good response; TlsStream::ocsp_response()), servers staple ocsp_response(der) in the TLS 1.3 leaf certificate entry or a TLS 1.2 CertificateStatus — interop-tested with openssl ocsp responses, s_server -status_file and s_client -status. TLS 1.3 0-RTT (opt-in): servers advertise early_data(max) in tickets and accept early data only for the first PSK identity without HelloRetryRequest, with a ticket age inside the anti-replay window (early_data_window, default 10 s) and a PSK binder not seen before in that window (rejected early data is skipped); clients send it with TlsStream::connect_with_early_data (EndOfEarlyData, automatic resend after the handshake when rejected, early_data_accepted()) — interop-tested with openssl s_client -early_data. Remaining gaps: no OCSP fetching from responders (stapled responses only; servers must refresh theirs via set_ocsp_response), the 0-RTT replay cache is per server configuration (not shared across processes), our client is not interop-tested against s_server -early_data; no DTLS. |
| rest (REST DSL) | ✅ | Verbs, path/query parameters, bindingMode off/auto/json, CORS, OpenAPI 3 document, scheme("https") / scheme: https (TLS consumers), rest producer to https:// hosts. No XML binding, no clientRequestValidation. |
| netty (tcp/udp) | ✅ | Text line and raw codecs, sync request/reply. TCP TLS with ssl=true (sslContextParameters, keyStoreFile/trustStoreFile as PEM, PKCS#12 or JKS with passphrase and keyStoreFormat, hostnameVerification), needClientAuth=true with the client certificate as CamelNettySSLClientCertSubjectName/IssuerName/SerialNo/NotBefore/NotAfter headers; no DTLS. |
| sql | ✅ | cameleer-sql. Producer: :#name (body map, headers, properties), :#${simple}, :#in:name, ?/# positional (body array or separator-split string), outputType SelectList/SelectOne/StreamList, outputHeader, noop, batch, useMessageBodyForSql, parametersCount, placeholder, CamelSqlQuery, generated keys (CamelSqlRetrieveGeneratedKeys → CamelSqlGeneratedKeysRows), file:/classpath: queries. Consumer: one exchange per row or a list (useIterator), onConsume/onConsumeFailed/onConsumeBatchComplete, maxMessagesPerPoll, routeEmptyResultSet, transacted, scheduled poll options. StreamList is materialized as a list; outputClass is ignored (rows are maps). |
| jdbc | ✅ | cameleer-sql. SQL from the body, outputType, useHeadersAsParameters (:?name), readSize/statement.maxRows, CamelJdbcRowCount/UpdateCount/ColumnNames, CamelGeneratedKeysRows. resetAutoCommit=false is accepted but statements outside a JDBC transaction policy still auto-commit. |
DataSources: embedded rustsql engine, PostgreSQL client | ✅ | cameleer-sql. jdbc:rustsql:mem:<name>: in-memory SQL engine (DDL incl. ALTER TABLE ADD/DROP/RENAME COLUMN, RENAME TO, SET/DROP DEFAULT, SET/DROP NOT NULL, TYPE, ADD/DROP CONSTRAINT (primary key / unique), multi-row INSERT/RETURNING, INNER/LEFT/RIGHT/FULL OUTER/CROSS joins, GROUP BY/HAVING, subqueries, UNION, WITH [RECURSIVE] common table expressions (column lists, chained CTEs, UNION / UNION ALL recursion), window functions (ROW_NUMBER, RANK, DENSE_RANK, PERCENT_RANK, CUME_DIST, NTILE, LAG, LEAD, FIRST_VALUE, LAST_VALUE, NTH_VALUE and aggregates OVER (PARTITION BY .. ORDER BY ..) with the default RANGE frame; ranking over grouped rows; explicit frame clauses are accepted and ignored), transactions with undo-log rollback, read-uncommitted isolation, stored procedures and functions: CREATE [OR REPLACE] PROCEDURE/FUNCTION with IN/OUT/INOUT parameters and defaults, RETURNS scalar/SETOF/TABLE(...)/void/record, LANGUAGE sql bodies or a PL/pgSQL subset — DECLARE, :=, IF/ELSIF/ELSE, WHILE, LOOP, FOR over ranges and query results, labels, EXIT/CONTINUE, RETURN/RETURN NEXT/RETURN QUERY, RAISE ... USING ERRCODE, SELECT ... INTO [STRICT], RETURNING ... INTO, PERFORM, FOUND, GET DIAGNOSTICS, EXCEPTION WHEN handlers — CALL (OUT values as a row), SELECT fn(...), SELECT * FROM fn(...), DO blocks, generate_series; no overloading, cursors, triggers or transaction control inside procedures). The embedded PostgreSQL test server exposes procedures and functions over the wire. jdbc:postgresql://host:port/db: wire protocol v3 client (cleartext/MD5/SCRAM-SHA-256, simple + extended query, text format, pooled, TLS via SSLRequest with `sslmode=prefer |
| JDBC idempotent / aggregation repositories | ✅ | cameleer-sql. JdbcIdempotentRepository (CAMEL_MESSAGEPROCESSED), JdbcAggregationRepository (JSON exchange snapshots, <name>_completed table, manual scan/recover, no background recovery). |
| sql-stored | ✅ | cameleer-sql (sql_stored). Camel template syntax NAME(INTEGER ${headers.num1}, INTEGER :#num2, INOUT INTEGER ${header.x} x, OUT INTEGER resultofsub) (optional IN, quoted parameter / type names, DECIMAL(10) scale, dotted or numeric java.sql.Types; value sources: Simple expressions, :#name (body map, header, property, variable), :#${simple}, literals; IN values converted to the SQL type). Calls CALL name(?, ?, NULL) or, with function=true, SELECT * FROM name(?, ?) (the first OUT template parameter names the return value). Result: OUT/INOUT values as a map body (or outputHeader), result sets (set-returning functions, procedures selecting rows on the embedded engine) per outputType SelectList/SelectOne (#result-set-1 in the map when both), header CamelSqlStoredUpdateCount, CamelSqlStoredTemplate header override. Options dataSource, function, outputType, outputHeader, noop, batch (one call per body element, one transaction), useMessageBodyForTemplate, templateOptions.*, file:/classpath: templates; honours JDBC transaction policies. Works with the embedded engine and over the PostgreSQL protocol. Over the wire, CALL command tags carry no row count (update count 0 for procedures without OUT parameters). |
| spring-rabbitmq / rabbitmq (AMQP 0-9-1) | ✅ | cameleer-amqp, own AMQP 0-9-1 client: PLAIN auth, vhosts, heartbeats, frame-max, publisher confirms, basic.qos, ack/nack/reject. Options routingKey, queues/queue, autoDeclare/declare, exchangeType (direct/topic/fanout/headers), concurrentConsumers, acknowledgeMode (AUTO with maximumRetryAttempts/retryDelay, MANUAL, NONE) / autoAck, prefetchCount, deadLetterExchange/Queue/RoutingKey, rejectAndDontRequeue, confirm/publisherAcknowledgements, guaranteedDeliveries, arg.queue.* args; InOut request/reply over a temporary reply queue (replyTimeout/requestTimeout). Headers CamelRabbitmqRoutingKey, CamelRabbitmqExchangeName, CamelRabbitmqDeliveryTag, CamelRabbitmqRequeue, CamelSpringRabbitmqRoutingOverrideKey, properties as CamelRabbitmq*. Connection from uri/camel.component.*/spring.rabbitmq.* properties instead of a connectionFactory bean. TLS (amqps:// addresses, sslProtocol, spring.rabbitmq.ssl.enabled, spring.rabbitmq.ssl.key-store/key-store-password/key-store-type/trust-store/trust-store-password/trust-store-type for client certificates and trust, sslContextParameters). Embedded test broker testing::AmqpBroker (optionally TLS). No tx class, no streams/quorum-queue features. |
| stomp | ✅ | cameleer-amqp, own STOMP 1.2 client: brokerURL, login/passcode, host, receipts, heart-beats; STOMP headers map to Camel headers. TLS with ssl:///stomp+ssl:///stomps:// broker urls or sslContextParameters. Embedded test broker testing::StompBroker (optionally TLS). |
| jms / activemq / amqp-stomp (JMS over STOMP) | ✅ | cameleer-amqp (the STOMP flavour formerly registered as amqp; amqp is now AMQP 1.0, see below). JMS semantics on STOMP 1.2 (ActiveMQ/Artemis/RabbitMQ STOMP): jms:queue:/topic:/temp-queue:, brokerURL (or camel.component.<scheme>.brokerUrl), concurrentConsumers, selector (SQL-92 JMS selector, evaluated by the broker), replyTo, replyToType (Temporary temporary queue per producer, Shared per-request JMSCorrelationID selector on the shared queue - the default with replyTo -, Exclusive one router on the fixed queue), useMessageIDAsCorrelationID (consumers answer with the request's JMSMessageID; producers wait on a private temporary queue since STOMP brokers assign message ids), requestTimeout, disableReplyTo, deliveryPersistent/deliveryMode, timeToLive, priority, preserveMessageQos, transacted (STOMP BEGIN/COMMIT/ABORT, rollback redelivers with JMSRedelivered=true), acknowledgementModeName; durable topic subscriptions (durableSubscriptionName, or subscriptionName + subscriptionDurable, with clientId: ActiveMQ activemq.subscriptionName / Artemis durable-subscription-name headers; stopping detaches, messages are kept), JMS 2.0 shared subscriptions (subscriptionShared=true + subscriptionName, durable or not), MapMessage (map bodies or jmsMessageType=Map) and ObjectMessage (jmsMessageType=Object) as JSON with ActiveMQ's transformation: jms-map-json / jms-object-json header, mapped back to structured bodies on receipt; InOut request/reply with JMSCorrelationID; JMS* headers. XA cannot be done over STOMP (no two-phase commit): transactionManager is accepted and ignored, local transacted transactions plus idempotent consumers are the emulation. Embedded testing::StompBroker: durable and shared subscriptions, and a file journal (persistence(dir)) that recovers persistent queue messages, durable subscriptions and their messages after a restart (unacknowledged deliveries come back with redelivered:true). Not the OpenWire or AMQP 1.0 wire protocols. On Apache ActiveMQ 5 (which neither redelivers after an aborted transaction nor after a NACK - a poison ack) failed transacted / CLIENT_ACKNOWLEDGE messages are redelivered by the consumer like ActiveMQ's JMS client (jms.redeliveryPolicy.maximumRedeliveries / initialRedeliveryDelay / redeliveryDelay broker-url options, JMSXDeliveryCount, then NACK → DLQ); InOnly sends from a transacted consumer to the same broker join its transaction (all brokers); subscriptionShared is refused on ActiveMQ 5 (use virtual topics). Interop-verified against ActiveMQ 5.17.6 and the RabbitMQ 3.12 STOMP plugin (INTEROP.md); embedded broker flavours StompBrokerBuilder::activemq() / rabbitmq(). |
| amqp (AMQP 1.0 client) | ✅ | cameleer-amqp10, own OASIS AMQP 1.0 stack: full type system (all primitives, described types, list/map/array encodings), protocol header negotiation, SASL ANONYMOUS/PLAIN/EXTERNAL/SCRAM-SHA-256/512 (cameleer-tls sasl), open/begin/attach/flow/transfer/disposition/detach/end/close, sessions with incoming/outgoing windows, sender/receiver links with credit (auto top-up or manual, drain), at-most-once (pre-settled) and at-least-once settlement, outcomes accepted/rejected/released/modified, multi-frame transfers split by max-frame-size, all message sections (header, delivery/message annotations, properties, application-properties, data/amqp-value/amqp-sequence, footer), idle timeout + heartbeats, dynamic nodes, TLS (amqps), CBS put-token and management request/response. Not implemented: transactions (coordinator), rcv-settle-mode=second (accepted but settled as first), link resume/unsettled-state recovery, peer-initiated sessions/links, the AMQP TLS-layer header (AMQP 2, use amqps), WebSockets. |
| amqp | ✅ | cameleer-amqp10, Camel's AMQP component (JMS over AMQP 1.0 for Artemis/ActiveMQ/Qpid): amqp:queue:/topic:/temp-queue:, connection from remoteAddress (aliases remoteURI/brokerURL/connectionFactory.remoteURI, or host+port, also as camel.component.amqp.*) or a connection-factory bean (connectionFactory=#bean / camel.component.amqp.connectionFactory, jms::AmqpConnectionFactory with remote URI, credentials, client id, SASL mechanism, idle timeout and SslContextParameters), amqps:// or sslContextParameters, amqpws:///amqpwss:// (AMQP over WebSockets), username/password, saslMechanism, clientId, concurrentConsumers, prefetchSize, selector (apache.org:selector-filter:string), replyTo, requestTimeout, disableReplyTo, deliveryPersistent/deliveryMode, timeToLive, priority, preserveMessageQos, acknowledgementModeName (CLIENT: failures are returned with modified(delivery-failed) → JMSRedelivered), transacted/SESSION_TRANSACTED with real AMQP local transactions (coordinator link, declare/discharge, transactional dispositions and transfers: acknowledgement and reply commit together, a failure rolls back and the broker redelivers; transacted producers send in a transaction), jmsMessageType (Text/Bytes/Map/Object - ObjectMessage as an AMQP typed value, x-opt-jms-msg-type=1, so structured bodies round-trip), durable topic subscriptions (durableSubscriptionName/subscriptionDurable), JMS 2.0 shared subscriptions (subscriptionShared + subscriptionName, Qpid JMS link naming with the shared/global capabilities), includeAmqpAnnotations (JMS_AMQP_MA_*), CamelJmsDestinationName; InOut over a dynamic temporary queue or fixed replyTo. AMQP JMS mapping: JMSMessageID/JMSCorrelationID/JMSDestination/JMSReplyTo/JMSType/JMSTimestamp/JMSExpiration/JMSDeliveryMode/JMSPriority/JMSRedelivered/JMSXDeliveryCount/JMSXUserID/JMSXGroupID/JMSXGroupSeq, x-opt-jms-msg-type/-dest/-reply-to, properties with _DOT_/_HYPHEN_ keys. Client also offers rcv-settle-mode=second and AMQP over WebSockets (RFC 6455, AMQPWSB10). Embedded test broker testing::Amqp10Broker (queues, topics, selectors, credit, dispositions, transactions, shared subscriptions, settle mode second, WebSockets, SASL, TLS). Node address prefixes announced by the broker (queue-prefix / topic-prefix, ActiveMQ 5: queue:// / topic://) are applied as Qpid JMS does and stripped from JMSDestination / JMSReplyTo (topics as topic:name); subscriptionShared is refused on ActiveMQ 5; CAMEL_AMQP10_TRACE=1 traces every frame to stderr. Interop-verified against the RabbitMQ 3.12 AMQP 1.0 plugin and Apache ActiveMQ 5.17.6's AMQP transport by the live suite (INTEROP.md); an extra #[ignore]d test targets any broker via AMQP10_INTEROP_URL. Not implemented (outside Camel's option set): link recovery with unsettled-state resume and peer-initiated links. |
| azure-servicebus | ✅ | cameleer-amqp10, over AMQP 1.0 with tokens put on $cbs (refreshed at 80 % of their lifetime). connectionString (incl. UseDevelopmentEmulator=true → plain AMQP like the Service Bus emulator; amqps otherwise) or fullyQualifiedNamespace + sharedAccessName/sharedAccessKey; credentialType CONNECTION_STRING, AZURE_IDENTITY (client secret from tenantId/clientId/clientSecret/authorityHost - Cameleer options - or the AZURE_* environment, managed identity via IMDS / IDENTITY_ENDPOINT+IDENTITY_HEADER or managedIdentityEndpoint; Azure AD jwt tokens) or TOKEN_CREDENTIAL (tokenCredential=#bean, identity::TokenCredential); amqpTransportType=AMQP_WEB_SOCKETS (AMQP over WebSockets on 443, /$servicebus/websocket); serviceBusType queue/topic, subscriptionName, receiveMode PEEK_LOCK (complete on success, abandon → redelivery with delivery count / MaxDeliveryCount dead-lettering on failure, enableDeadLettering dead-letters with reason ProcessingError, disableAutoComplete) or RECEIVE_AND_DELETE, subQueue=DEAD_LETTER_QUEUE, consumerOperation receiveMessages/peekMessages (peekNumMaxMessages), sessions (sessionEnabled, sessionId, maxConcurrentCalls session workers accepting the next available session, Cameleer sessionIdleTimeout; session state through the Cameleer producer operations getSessionState/setSessionState), automatic message and session lock renewal while processing (maxAutoLockRenewDuration, com.microsoft:renew-lock / renew-session-lock), deferral (Cameleer header CamelAzureServiceBusDisposition = complete/abandon/deadLetter/defer; producer operation receiveDeferredMessages by sequence number), producerOperation sendMessages (list bodies → one message per element; Cameleer transacted=true sends them in one AMQP transaction)/scheduleMessages (scheduledEnqueueTime, com.microsoft:schedule-message), prefetchCount, binary. Headers CamelAzureServiceBusMessageId, ...CorrelationId, ...ContentType, ...Subject, ...To, ...ReplyTo, ...SessionId, ...PartitionKey, ...ApplicationProperties, ...EnqueuedTime, ...SequenceNumber, ...DeliveryCount, ...LockToken, ...LockedUntil, ...ExpiresAt, ...TimeToLive, ...DeadLetterReason/ErrorDescription/Source, ...ScheduledEnqueueTime, ...ProducerOperation, ...SessionState (times as epoch millis). Embedded emulator: Amqp10Broker::builder().azure(keyName, key) (+ azure_jwt, session_entity). Java-only objects (processorClient, serviceBusTransactionContext...) are not applicable. |
| azure-eventhubs | ✅ | cameleer-amqp10, over AMQP 1.0 with SAS or Azure AD tokens on $cbs (same credentialType / tokenCredential / amqpTransportType options and token refresh as azure-servicebus, scope https://eventhubs.azure.net/.default). azure-eventhubs:namespace/eventHubName with sharedAccessName/sharedAccessKey or connectionString (EntityPath), consumerGroupName, partitionId, partitionKey (header overrides CamelAzureEventHubsPartitionId/...PartitionKey), prefetchCount. Consumer discovers partitions via $management READ; checkpoints (offset + sequence number) to a CheckpointStore (checkpointStore=#bean; in-memory default, FileCheckpointStore with the blob checkpoint layout) every checkpointBatchSize events / checkpointBatchTimeout, resume from the last checkpoint, else eventPosition (per-partition map: 0=earliest,1=offset:42,2=sequenceNumber:7:inclusive,3=enqueuedTime:<millis> or #bean), else initialPosition earliest/latest (Cameleer). Load balancing between processor instances through the checkpoint store's ownership records (PartitionOwnership with optimistic etags; balanced strategy: renew, relinquish surplus, claim unowned/expired, steal from instances above their share; Cameleer loadBalancingUpdateInterval, partitionOwnershipExpirationInterval, ownerId, loadBalancing), receivers with epochs (com.microsoft:epoch, ownerLevel, 0 for balanced receivers, so a new owner disconnects the old one; the emulator enforces epochs with amqp:link:stolen). Headers CamelAzureEventHubsPartitionId, ...Offset, ...SequenceNumber, ...EnqueuedTime, CamelMessageTimestamp; application properties ↔ headers. Azure Blob checkpoint store: blobAccountName + blobContainerName + blobAccessKey (+ Cameleer blobEndpoint) select cameleer_cloud::azure::blob_checkpoint::BlobCheckpointStore when cameleer_cloud::register ran (factory looked up in the registry; an error otherwise); that store also keeps partition ownership like the Azure SDK (<ns>/<hub>/<group>/ownership/<partition> blobs with ownerid metadata, listed with include=metadata, claimed with If-None-Match: * / If-Match: <etag> so contested claims fail with 412/409), so blob-backed instances balance partitions between them (verified against the Azurite emulator, cameleer-cloud/tests/azure_tail.rs). |
| grpc | ✅ | cameleer-grpc, own HTTP/2 (RFC 9113, HPACK, flow control, h2c prior knowledge and TLS + ALPN h2 via cameleer-tls) and gRPC stack; services and messages come from protoFile at runtime (raw bytes without it). Producer: method, producerStrategy SIMPLE (unary → response object, server streaming → array, client streaming/bidi from an array body) or STREAMING (long-lived call, CamelGrpcEventType=onCompleted half-closes), streamRepliesTo, deadline (grpc-timeout), headers → metadata, response metadata → headers, failures as StatusRuntimeException (CODE: message). Consumer: hosts the service, consumerStrategy AGGREGATION/PROPAGATION (DELEGATION ≈ PROPAGATION), forwardOnCompleted/forwardOnError, CamelGrpcMethodName/CamelGrpcEventType/CamelGrpcUserAgent headers, metadata → headers, exceptions → status codes (IllegalArgument → INVALID_ARGUMENT, Timeout → DEADLINE_EXCEEDED, UnsupportedOperation → UNIMPLEMENTED, other → INTERNAL), server-side deadline enforcement, gzip/deflate request decompression. TLS: usePlainText=false/negotiationType=TLS with keyCertChainResource/keyResource (consumer) and trustCertCollectionResource (producer). Also maxMessageSize, maxConcurrentCallsPerConnection, flowControlWindow. Interop-tested with curl (nghttp2) and Go net/http. Mutual TLS (producer keyCertChainResource/keyResource client certificate, consumer trustCertCollectionResource requires client certificates), interceptors (clientInterceptors/serverInterceptors beans, autoDiscoverClientInterceptors/autoDiscoverServerInterceptors: add/inspect metadata, reject calls with a status), `compression=gzip |
| thrift | ✅ | cameleer-dataformats (thrift_rpc), driven by the runtime IDL (idlFile/schema) instead of generated classes: thrift://host:port/[pkg.]Service?method=... Producer: body = argument list (or object by name / single value), CamelThriftMethodName header, result = return value, declared exceptions fail with the exception struct name (struct in CamelThriftException), TApplicationExceptions, oneway calls, inherited service methods, clientTimeout, persistent connection with reconnect. Consumer: Thrift server, body = argument list + CamelThriftMethodName, return value from the body, declared exceptions from the exception kind or an @exception body, INTERNAL_ERROR/UNKNOWN_METHOD/PROTOCOL_ERROR application exceptions. exchangeProtocol BINARY (strict messages; old-style accepted) / COMPACT / JSON, transport FRAMED or BUFFERED (servers detect both), compressionType NONE/ZLIB (TZlibTransport sync-flushed stream), negotiationType PLAINTEXT/SSL (sslContextParameters). |
| Other cloud components | ✅ | All of Apache Camel's AWS / Azure / GCP components are implemented, including google-pubsub-lite (see its row); services without a Camel component (AWS Glue, SageMaker, Lex, Cognito, Neptune, Azure Cognitive Services / Monitor / Data Explorer, GCP Dataflow / Dataproc / Spanner / Bigtable...) are out of scope, as is the long tail of the 300+ non-cloud vendor connectors. Remaining gaps inside implemented components are listed in their rows. Implemented in cameleer-cloud (rows below): S3, SQS (JSON + Query protocol), SNS, DynamoDB (+ expressions) and DynamoDB Streams, Lambda, Kinesis, Firehose, EventBridge, Secrets Manager (+ refresh / context reload), SES, CloudWatch, STS, Step Functions, IAM, EC2, MSK (+ Kafka AWS_MSK_IAM), Athena, Textract, Translate, Comprehend, Polly, Rekognition, Transcribe, Bedrock (+ Agent Runtime), MQ, ECS, EKS, KMS, Timestream, CloudTrail, Config, Redshift Data; Azure Blob (+ change feed, Event Hubs blob checkpoint store) / Queue / Data Lake / Files, Key Vault (secrets, keys, certificates), Cosmos DB, Functions, Event Grid, Schema Registry, OpenAI; Cloud Storage (+ V4 signed URLs), Pub/Sub (REST + gRPC streaming pull, dead-letter policies, exactly-once acks), Pub/Sub Lite (gRPC), BigQuery (+ load / extract jobs), Secret Manager, Cloud Functions, Firestore, Sheets (+ google-sheets-stream), Gmail (+ google-mail-stream), Calendar (+ google-calendar-stream), Drive (+ file-change consumer), Vertex AI, Speech-to-Text, Text-to-Speech, OAuth refresh-token user credentials; Service Bus / Event Hubs live in cameleer-amqp10; elsewhere Kafka, JMS/AMQP, SQL/JDBC, FTP, Mail, MQTT, WebSocket, gRPC and SFTP/SSH. |
| aws2-s3 | ✅ | cameleer-cloud, S3 REST API over the std-only HTTPS client, SigV4-signed. Producer operations (operation / CamelAwsS3Operation, default putObject): putObject, getObject, getObjectRange, headObject, listObjects, deleteObject, copyObject, listBuckets, createBucket, deleteBucket, headBucket, createDownloadLink (presigned URL). multiPartUpload=true + partSize (default 25 MiB): multipart upload (aborted on failure). Streaming (Cameleer headers): CamelAwsS3SourceFile uploads a local file without loading it (streamed UNSIGNED-PAYLOAD PUT, or multipart reading one part at a time), CamelAwsS3DownloadFile streams getObject into a file. streamingUploadMode (aggregates exchanges into multipart objects; batchMessageNumber, batchSize, streamingUploadTimeout, namingStrategy progressive/random, restartingPolicy override/lastPart; pending object completed on stop). Polling consumer (prefix, delimiter, fileName, maxMessagesPerPoll, includeBody, includeFolders, deleteAfterRead default true, moveAfterRead + destinationBucket[Prefix/Suffix]) with CamelAwsS3Key/BucketName/ETag/ContentLength/LastModified/ContentType/VersionId/Metadata headers. autoCreateBucket, keyName, storageClass, forcePathStyle (virtual-host style otherwise). Common AWS options: accessKey/secretKey/sessionToken/region, useDefaultCredentialsProvider (env vars, ~/.aws/credentials profiles, ECS/EKS container credentials endpoint, EC2 instance metadata IMDSv2/v1; cached until expiry), uriEndpointOverride + overrideEndpoint, proxyHost/proxyPort/proxyProtocol (or HTTPS_PROXY/NO_PROXY), trustAllCertificates. Also deleteObjects, createUploadLink, restoreObject, object tagging / ACL operations, object lock (retention, legal hold), versioning (putBucketVersioning, getBucketVersioning, listObjectVersions, CamelAwsS3VersionId), SSE-KMS (useAwsKMS/awsKMSKeyId), SSE-S3 (useSSES3) and SSE-C (useCustomerKey/customerKeyId/customerKeyMD5/customerAlgorithm), canned ACLs / content headers / tags / conditionalWritesEnabled on putObject; consumer ignoreBody (HEAD only) and Cameleer localDirectory (objects streamed to disk, not buffered). Web identity credentials (AWS_WEB_IDENTITY_TOKEN_FILE + AWS_ROLE_ARN via STS AssumeRoleWithWebIdentity) for all AWS components. Verified against the SigV4-verifying emulator (tests/aws_gaps.rs). |
| aws2-sqs | ✅ | cameleer-cloud, SQS AWS JSON 1.0 protocol. Producer: sendMessage (user headers → message attributes, delaySeconds, FIFO messageGroupIdStrategy/messageDeduplicationIdStrategy), sendBatchMessage, deleteMessage, listQueues, purgeQueue, deleteQueue. Consumer: maxMessagesPerPoll, waitTimeSeconds (long polling), visibilityTimeout, messageAttributeNames, attributeNames, deleteAfterRead (failed messages are redelivered after the visibility timeout); headers CamelAwsSqsMessageId, CamelAwsSqsReceiptHandle, CamelAwsSqsMD5OfBody, CamelAwsSqsAttributes, CamelAwsSqsMessageAttributes + one header per attribute. queueUrl, autoCreateQueue, queueOwnerAWSAccountId. extendMessageVisibility=true (with visibilityTimeout) extends in-flight messages to 1.5× the timeout every timeout/2. protocol (Cameleer): auto (default: JSON, switching to the legacy Query protocol — form Action=...&Version=2012-11-05, XML responses — when the server rejects JSON), json, query. Also changeMessageVisibility, deleteMessageBatch, getQueueAttributes / setQueueAttributes, receiveMessage; queue attribute options (defaultVisibilityTimeout, messageRetentionPeriod, maximumMessageSize, policy, redrivePolicy dead-letter queues, receiveMessageWaitTimeSeconds, delayQueue, serverSideEncryptionEnabled + kmsMasterKeyId / kmsDataKeyReusePeriodSeconds); consumer concurrentConsumers, maxMessagesPerPoll > 10 (parallel receives, concurrentRequestLimit), sortAttributeName, deleteIfFiltered, sendEmptyMessageWhenIdle. |
| aws2-sns | ✅ | cameleer-cloud, SNS Query API, producer only: Publish with subject/CamelAwsSnsSubject, messageStructure, user headers as message attributes, FIFO group/dedup ids; CamelAwsSnsMessageId. Topic by ARN, autoCreateTopic, or ListTopics lookup. subscribeSNStoSQS + queueArn (SQS subscription at start, emulator delivers to the queue), policy, serverSideEncryptionEnabled + kmsMasterKeyId, FIFO topics with content-based deduplication, batchEnabled (PublishBatch). |
| aws2-ddb, aws2-ddbstream | ✅ | cameleer-cloud, DynamoDB JSON 1.0 producer: PutItem, GetItem, UpdateItem (AttributeUpdates PUT/DELETE or CamelAwsDdbUpdateExpression), DeleteItem, Query (KeyConditions or CamelAwsDdbKeyConditionExpression), Scan (ScanFilter), CamelAwsDdbFilterExpression, ...ConditionExpression, ...ProjectionExpression with ...ExpressionAttributeNames / ...ExpressionAttributeValues (plain values, marshalled), BatchGetItems (CamelAwsDdbBatchItems → CamelAwsDdbBatchResponse, ...UnprocessedKeys), UpdateTable (...ReadCapacity / ...WriteCapacity, Cameleer CamelAwsDdbStreamViewType), DescribeTable, DeleteTable with Camel CamelAwsDdb* headers and automatic attribute-value marshalling of plain maps; table created on start from keyAttributeName/keyAttributeType. aws2-ddbstream://table consumer over DynamoDB Streams (DescribeTable → stream ARN, DescribeStream incl. new child shards, GetShardIterator streamIteratorType FROM_LATEST / FROM_START / FROM_SEQUENCE_NUMBER + sequenceNumberProvider, GetRecords maxResultsPerRequest, expired iterator recovery); body = the record with unmarshalled Keys / NewImage / OldImage. The emulator evaluates the expression language (comparisons, BETWEEN, IN, AND/OR/NOT, attribute_exists/not_exists/type, begins_with, contains, size; SET with + / - / if_not_exists / list_append, REMOVE, ADD, DELETE). |
| aws2-lambda | ✅ | cameleer-cloud, Lambda REST producer with Camel's operation list: invokeFunction (default; CamelAwsLambdaInvocationType, function errors in CamelAwsLambdaFunctionError), listFunctions, getFunction, deleteFunction, createFunction (zip body or CamelAwsLambdaS3Bucket/S3Key, role, runtime, handler, memory, timeout, environment, tags, VPC, dead letter, tracing, KMS, publish), updateFunction (code), createEventSourceMapping / deleteEventSourceMapping / listEventSourceMapping, listTags / tagResource / untagResource, publishVersion / listVersions, createAlias / deleteAlias / getAlias / listAliases. |
| azure-storage-blob | ✅ | cameleer-cloud, Blob REST API with Shared Key signing (accessKey, credentialType=SHARED_ACCOUNT_KEY) or SAS (credentialType=AZURE_SAS, sasToken). Producer: listBlobContainers (default), createBlobContainer, deleteBlobContainer, listBlobs (prefix), uploadBlockBlob, getBlob, deleteBlob, append blobs (createAppendBlob, commitAppendBlob with createAppendBlob), page blobs (createPageBlob pageBlobSize, uploadPageBlob / clearPageBlob with CamelAzureStorageBlobPageBlobRange, resizePageBlob, getPageBlobRanges, createPageBlob), leases (Cameleer operations acquireBlobLease / renewBlobLease / releaseBlobLease / breakBlobLease, CamelAzureStorageBlobLeaseId sent on writes, leaseBlob=true + leaseDurationInSeconds lease around writes); consumer polling one blob (blobName) or the container, with deleteAfterRead (Cameleer extension). Headers CamelAzureStorageBlobBlobName, ...ContainerName, ...ETag, ...LastModified, ...ContentType, ...BlobSize, ...Metadata. Azurite-style uriEndpointOverride. Change feed: getChangeFeed (body = events, changeFeedStartTime/EndTime options or headers) and a change feed consumer (changeFeed=true, Cameleer; each event once, CamelAzureStorageBlobChangeFeedEventType / ...EventTime / blob and container headers), reading $blobchangefeed segments and Avro chunk files (cameleer-dataformats). credentialType=AZURE_IDENTITY: Entra ID bearer tokens from a client secret, workload identity federation (federatedTokenFile / AZURE_FEDERATED_TOKEN_FILE) or managed identity (IMDS or App Service endpoint, user-assigned managedIdentityClientId), verified by the emulated token endpoints + Azurite. Block lists: stageBlockBlobList (commitBlockListLater), commitBlobBlockList, getBlobBlockList (blockListType); downloadLink (read-only service SAS, downloadLinkExpiration), downloadBlobToFile (fileDir), copyBlob (same account or sourceBlobAccessKey). |
| azure-storage-queue | ✅ | cameleer-cloud, Queue REST API (Shared Key or SAS). Producer: sendMessage (default; visibilityTimeout, timeToLive, createQueue), receiveMessages, peekMessages, deleteMessage, updateMessage, clearQueue, createQueue, deleteQueue, listQueues; consumer receives maxMessages and deletes processed messages. Headers CamelAzureStorageQueueMessageId, ...PopReceipt, ...InsertionTime, ...ExpirationTime, ...TimeNextVisible, ...DequeueCount. Text sent as is (no base64), like the Azure SDK's default QueueMessageEncoding.NONE. credentialType=AZURE_IDENTITY (Entra ID client secret / workload identity / managed identity bearer tokens, verified against the emulated App Service identity endpoint + Azurite). azure-servicebus: see its row (cameleer-amqp10). |
| google-storage | ✅ | cameleer-cloud, Cloud Storage JSON API. Service account key (serviceAccountKey or GOOGLE_APPLICATION_CREDENTIALS) → RS256 JWT → OAuth2 token (cached until expiry, refreshed on 401). Producer: putObject (default upload), getObject, listObjects, deleteObject, copyObject, listBuckets, createBucket, deleteBucket; consumer with deleteAfterRead (default true), moveAfterRead/destinationBucket, includeBody, prefix; autoCreateBucket (default true). CamelGoogleCloudStorage* headers. createDownloadLink: V4 signed URLs (GOOG4-RSA-SHA256, CamelGoogleCloudStorageDownloadLinkExpirationTime). Resumable uploads (Cameleer resumableUploadThreshold default 16 MiB, resumableChunkSize in 256 KiB multiples; failed chunks resumed from the committed size). Credentials for all Google components: authorized-user files, workload identity federation (external_account files: file / url subject token sources, STS token exchange, optional service account impersonation via IAM Credentials generateAccessToken) and the metadata server (useMetadataServer / GCE_METADATA_HOST / Cameleer metadataServerUrl), all emulated. |
| google-pubsub | ✅ | cameleer-cloud, Pub/Sub REST (google-pubsub://project:destination). Producer publishes body (base64) with CamelGooglePubsubAttributes and CamelGooglePubsubOrderingKey, sets CamelGooglePubsubMessageId (list bodies → one message each). Consumer: synchronous pull (maxMessagesPerPoll), ackMode AUTO (ack on success, nack via modifyAckDeadline 0) or NONE; headers CamelGooglePubsubMessageId, ...Attributes, ...AckId, ...PublishTime, ...OrderingKey, ...DeliveryAttempt. authenticate=false + endpoint for the emulator. That is the synchronous pull consumer (synchronousPull=true); by default (synchronousPull=false, as in Camel) the consumer uses gRPC streaming pull over cameleer-grpc HTTP/2 (google.pubsub.v1.Subscriber/StreamingPull, bearer token in metadata, concurrentConsumers streams, ackDeadlineSeconds, flow control maxOutstandingMessages/maxOutstandingBytes, ack / nack on the stream, lease extension up to maxAckExtensionPeriod, reconnect with backoff, pubsubEndpoint target). Dead-letter policies and exactly-once delivery: Cameleer producer operations createTopic, deleteTopic, createSubscription (topic, deadLetterTopic + maxDeliveryAttempts 5..100, enableExactlyOnceDelivery, ackDeadlineSeconds), getSubscription, deleteSubscription; the synchronous pull consumer extends leases while processing (ackDeadlineSeconds / 3, up to maxAckExtensionPeriod) and checks acknowledgements (transient EXACTLY_ONCE_ACKID_FAILUREs retried, permanent ones logged). The emulator forwards messages to the dead-letter topic after maxDeliveryAttempts deliveries and rejects expired ack ids on exactly-once subscriptions. On the gRPC streaming path exactly-once subscriptions (announced by subscription_properties) have their acks tracked until the stream's acknowledge_confirmation: temporarily failed ack ids are re-acknowledged, invalid (expired) ones logged and redelivered (counters: pubsub_stream::exactly_once_stats); the emulator sends the confirmations and forwards nacked streaming deliveries to the dead-letter topic after maxDeliveryAttempts. |
| google-pubsub-lite | ✅ | cameleer-cloud, Pub/Sub Lite gRPC over cameleer-grpc HTTP/2 (google-pubsub-lite:projectId:location:destination, bearer tokens of the common Google credentials, pubsubEndpoint for emulators, {region}-pubsublite.googleapis.com otherwise). Producer: PublisherService/Publish streams (partition by CamelGooglePubsubLiteOrderingKey hash or round robin over AdminService/GetTopicPartitions), attributes / event time headers, CamelGooglePubsubLiteMessageId = partition:offset (list bodies → several messages); Cameleer admin operations createTopic (partitionCount), createSubscription (topic), deleteTopic, deleteSubscription, getTopicPartitions. Consumer: per partition a SubscriberService/Subscribe stream from the committed cursor with flow control (maxMessagesPerPoll, perPartitionBytes, streamIdleTimeout), ackMode AUTO commits each processed offset with CursorService/StreamingCommitCursor (failures redelivered from the committed cursor) or NONE; CamelGooglePubsubLite* headers (message id, attributes, ordering key, publish time, partition, offset). Verified against the GcpMock gRPC emulator (tests/gcp_gaps.rs). Consumers poll (a stream per partition and poll) rather than keeping long-lived streams. |
| aws2-kinesis | ✅ | cameleer-cloud, Kinesis Data Streams AWS JSON 1.1. Producer: PutRecord (CamelAwsKinesisPartitionKey required, CamelAwsKinesisSequenceNumber for ordering; sets CamelAwsKinesisSequenceNumber / CamelAwsKinesisShardId), array bodies via PutRecords (CamelAwsKinesisFailedRecordCount); Cameleer operation: createStream (shardCount), describeStream, listShards, deleteStream. Consumer: ListShards each poll (picks up resharding), one shard iterator per shard (iteratorType TRIM_HORIZON / LATEST / AT_ / AFTER_SEQUENCE_NUMBER with sequenceNumber / AT_TIMESTAMP with messageTimestamp), shardId, maxResultsPerRequest, shardClosed ignore/silent/fail; headers CamelAwsKinesisSequenceNumber, ...PartitionKey, ...ShardId, ...ApproximateArrivalTimestamp. KCL-style consumers (useKclConsumers, applicationName, workerIdentifier, failoverTimeMillis): DynamoDB lease table with conditional lease taking / renewal / failover, fair-share balancing between live workers, per-record checkpoints, parent-before-child resharding; enhanced fan-out (enhancedFanOut, consumerName: RegisterStreamConsumer + SubscribeToShard HTTP/2 event streams with continuation and child shards); resumeStrategy beans; cborEnabled (CBOR protocol). |
| aws2-kinesis-firehose | ✅ | cameleer-cloud, Firehose AWS JSON 1.1 producer: sendRecord (default, CamelAwsKinesisFirehoseRecordId), putRecordBatch (array bodies), createDeliveryStream (DirectPut), describeDeliveryStream, deleteDeliveryStream. No updateDestination. |
| aws2-eventbridge | ✅ | cameleer-cloud, EventBridge AWS JSON 1.1 producer: putRule (CamelAwsEventbridgeEventPattern or eventPatternFile), putTargets (CamelAwsEventbridgeTargets list of {id, arn, input}), removeTargets, deleteRule, enableRule, disableRule, describeRule, listRules (...RuleNamePrefix), listTargetsByRule, listRuleNamesByTarget, putEvent (...EventSource, ...EventDetailType, ...EventResources; body = entry ids). |
aws-secrets-manager + {{aws:...}} | ✅ | cameleer-cloud, Secrets Manager AWS JSON 1.1 producer: getSecret (default; CamelAwsSecretsManagerSecretId, version id), createSecret (...SecretName, binaryPayload), describeSecret, listSecrets, deleteSecret (+ force), restoreSecret, updateSecret, rotateSecret (stub against the emulator), replicateSecretToRegions. Properties function {{aws:name}}, {{aws:name/field}}, {{aws:name@version}}, {{aws:name:default}} configured with camel.vault.aws.* (accessKey, secretKey, region, defaultCredentialsProvider, profileCredentialsProvider, profileName, uriEndpointOverride). Secret refresh (Camel's CloudTrail reload trigger): camel.vault.aws.refreshEnabled, refreshPeriod, secrets (names / patterns; default: the secrets resolved through {{aws:...}}) poll CloudTrail LookupEvents for PutSecretValue / UpdateSecret / RotateSecret / UpdateSecretVersionStage / RestoreSecret and trigger a context reload (reload listeners + restart of the started routes); secretsmanager::refresh_task(ctx). No SQS-notification (useSqsNotification) variant. |
| aws2-ses | ✅ | cameleer-cloud, SES v1 Query API: SendEmail (text or CamelAwsSesHtmlEmail; to/cc/bcc/subject/returnPath/replyToAddresses/configurationSet options or CamelAwsSes* headers; CamelAwsSesMessageId), SendRawEmail for bytes bodies (MIME). |
| aws2-cw | ✅ | cameleer-cloud, CloudWatch Query API PutMetricData: name/value/unit/timestamp options or CamelAwsCwMetricName/...Value/...Unit/...Timestamp/...Namespace, dimensions from CamelAwsCwMetricDimensions (map) or ...DimensionName/...DimensionValue; array bodies send several data. |
| aws2-sts | ✅ | cameleer-cloud, STS Query API: assumeRole (CamelAwsStsRoleArn, ...RoleSessionName), getSessionToken, getFederationToken (...FederatedName), getCallerIdentity; body = {accessKeyId, secretAccessKey, sessionToken, expiration}. |
| aws2-step-functions | ✅ | cameleer-cloud, Step Functions AWS JSON 1.0: createStateMachine, deleteStateMachine, describeStateMachine, listStateMachines, startExecution, startSyncExecution, stopExecution, describeExecution, listExecutions, getExecutionHistory (CamelAwsStepFunctions* headers). Also updateStateMachine and activities: createActivity, deleteActivity, describeActivity, listActivities, getActivityTask (CamelAwsStepFunctionsTaskToken), sendTaskSuccess / sendTaskFailure / sendTaskHeartbeat (the emulator suspends executions on activity Task states). |
| aws2-iam | ✅ | cameleer-cloud, IAM Query API subset (global endpoint): createUser, getUser, deleteUser, listUsers, createGroup, deleteGroup, listGroups, addUserToGroup, removeUserFromGroup, createAccessKey, listAccessKeys, deleteAccessKey. Also updateAccessKey (inactive keys stop signing in the emulator), getGroup, roles (createRole, getRole, deleteRole, listRoles), managed policies (createPolicy, getPolicy, deletePolicy, listPolicies), attach / detach / listAttached user / group / role policies, instance profiles (create, get, delete, list, add / remove role). |
| aws2-ec2 | ✅ | cameleer-cloud, EC2 Query API (XML) subset: describeInstances (CamelAwsEC2InstancesIds), describeInstancesStatus, createAndRunInstances (...ImageId, ...InstanceType, ...InstanceMinCount/MaxCount, ...InstanceKeyPair), start/stop/terminate/rebootInstances. Also monitorInstances / unmonitorInstances, createTags / deleteTags, and createAndRunInstances options ...InstanceMonitoring, ...InstanceKernelId, ...InstanceEbsOptimized, ...InstanceSecurityGroups, ...InstancesClientToken (idempotent), ...InstancesPlacement, ...SubnetId, ...InstancesTags. |
| azure-storage-datalake | ✅ | cameleer-cloud, ADLS Gen2 DFS REST (Shared Key accountKey/accessKey or SAS): listFileSystem, createFileSystem, deleteFileSystem, listPaths (path, recursive), createFile, createDirectory, upload (create + append + flush), appendToFile / flushToFile (CamelAzureStorageDataLakeFileOffset / ...Position), getFile, deleteFile, deleteDirectory (CamelAzureStorageDataLake* headers). Also downloadToFile (fileDir), downloadLink (read-only service SAS, downloadLinkExpiration), uploadFromFile, openQueryInputStream (query acceleration: SQL expression over CSV / JSON, Avro result stream decoded; the emulator implements a SELECT / WHERE / COUNT / LIMIT subset), ACLs (permission / umask on createFile, Cameleer getAccessControl / setAccessControl with ACL, permissions, owner, group; userPrincipalNameReturned), Entra ID credentials (clientId / clientSecret / tenantId, credentialType=AZURE_IDENTITY workload / managed identity), and the consumer (the fileName file or the files under path / directoryName, recursive, regex; Cameleer deleteAfterRead). |
azure-key-vault + {{azure:...}} | ✅ | cameleer-cloud, Key Vault secrets REST (api-version=7.4) with Azure AD client credentials (clientId/clientSecret/tenantId, credentialType=AZURE_IDENTITY from AZURE_* env vars, authorityHost; token cached, refreshed after 401): getSecret (default; version header), createSecret, deleteSecret, purgeDeletedSecret, plus recoverDeletedSecret / listSecrets. Properties function {{azure:name}}, /field, @version, :default (camel.vault.azure.vaultName, clientId, clientSecret, tenantId, azureIdentityEnabled). Keys and certificates (Cameleer operations): createKey (EC/RSA, curve, size, key_ops), getKey, listKeys, deleteKey, signData / verifyData (body hashed for ES256/384/512, RS, PS; signature over the vault), createCertificate (self-issued policy, pending operation polled), getCertificate, importCertificate (PEM / PKCS#12), listCertificates, deleteCertificate; the emulator creates EC keys and P-256 certificates with cameleer-tls. Key cryptography (Azure SDK CryptographyClient operations): importKey (RSA / oct JWK), encrypt / decrypt (RSA-OAEP, RSA-OAEP-256, RSA1_5; A128/192/256GCM with IV / tag / AAD headers for oct-HSM keys) and wrapKey / unwrapKey (RSA-OAEP(-256), RSA1_5, A128/192/256KW); the emulator implements OAEP / PKCS#1 v1.5 / AES-GCM / RFC 3394 with cameleer-tls primitives (generated RSA keys share one fixed key pair). credentialType=AZURE_IDENTITY also covers workload identity federation and managed identity (IMDS / App Service endpoints, emulated). Secret refresh like Camel's EventhubsReloadTriggerTask: camel.vault.azure.refreshEnabled, refreshPeriod, secrets (patterns), eventhubConnectionString (+ blobAccountName / blobContainerName / blobAccessKey checkpoints): Key Vault SecretNewVersionCreated Event Grid events consumed with cameleer-amqp10's Event Hubs consumer trigger a reload (listeners + route restarts). |
| azure-cosmosdb | ✅ | cameleer-cloud, Cosmos DB SQL REST with master-key HMAC signing (databaseEndpoint, accountKey): listDatabases, createDatabase, queryDatabases, deleteDatabase, createContainer (containerPartitionKeyPath), listContainers, queryContainers, deleteContainer, createItem, upsertItem, replaceItem, readItem, deleteItem, readAllItems, queryItems (query, parameters map, all pages); partition keys from itemPartitionKey or derived from the item; createDatabaseIfNotExists / createContainerIfNotExists; CamelAzureCosmosDb* headers. Consumer: change feed per partition key range (continuations in memory, changeFeedStartFromBeginning). Change feed processor with a lease container (leaseContainerName, leaseDatabaseName, createLeaseContainerIfNotExists, createLeaseDatabaseIfNotExists, hostName, Cameleer leaseExpirationInterval): one etag-checked lease per partition key range with checkpointed continuations, fair-share balancing / stealing between hosts, release on stop. Throughput: throughputProperties / CamelAzureCosmosDbThroughputProperties (manual or autoscale) on creation, replaceDatabaseThroughput / replaceContainerThroughput (Offers API; Cameleer read*Throughput). credentialType=AZURE_IDENTITY (Entra ID type=aad tokens: client secret, workload or managed identity). consistencyLevel, contentResponseOnWriteEnabled. Cameleer always uses the REST gateway, so the SDK's direct (TCP) connection mode has no equivalent. |
| google-bigquery / google-bigquery-sql | ✅ | cameleer-cloud, BigQuery v2 REST. google-bigquery://project:dataset[:table]: insertAll streaming insert (map or list bodies, useAsInsertId, CamelGoogleBigQueryTableId, ...TableSuffix, ...PartitionDecorator, ...InsertId; insert errors raise BigQueryException). google-bigquery-sql://project:query (or file:): jobs.query in standard SQL with named @params from headers/body, ${header.x} substitution (CamelGoogleBigQueryTranslatedQuery), polls getQueryResults and reads all pages; body = affected rows (DML) or typed row maps; CamelGoogleBigQueryJobId. Load / extract jobs (Cameleer `operation=load |
google-secret-manager + {{gcp:...}} | ✅ | cameleer-cloud, Secret Manager REST: createSecret (+ first version), addSecretVersion, getSecretVersion (default; CamelGoogleSecretManagerVersionId, default latest), deleteSecret, listSecrets. Properties function {{gcp:name}}, /field, @version, :default (camel.vault.gcp.serviceAccountKey / useDefaultInstance, projectId). |
| google-functions | ✅ | cameleer-cloud, Cloud Functions v1 REST: callFunction (default; result body, CamelGoogleCloudFunctionsExecutionId, function errors raise ApiException), listFunctions, getFunction, deleteFunction (project, location). Also generateUploadUrl (optionally uploading a zip body to the signed URL), generateDownloadUrl, createFunction / updateFunction (CamelGoogleCloudFunctionsEntryPoint, ...Runtime, ...SourceArchiveUrl / ...SourceUploadUrl or a CloudFunction map body; long-running operation polled; body = the function). |
| google-firestore (Cameleer) | ✅ | cameleer-cloud, Firestore REST (no Camel equivalent): getDocument, listDocuments, createDocument (generated or CamelGoogleFirestoreDocumentId), setDocument, updateDocument (merge, must exist), deleteDocument, runQuery (structuredQuery passthrough or equality map + orderBy/descending/limit), sub-collections; plain maps converted to and from typed Firestore values. Batched writes: commit (atomic, preconditions for update / create) and batchWrite (independent writes, per-write status) from {op, collection, id, data} maps; transactions: beginTransaction (read-write / read-only), transactional getDocument, commit (ABORTED on a conflicting change, emulated with optimistic concurrency), rollback; snapshot-listener consumer (ADDED / MODIFIED / REMOVED changes per poll, skipInitialSnapshot; polled, not the gRPC Listen stream). |
| google-sheets | ✅ | cameleer-cloud, Sheets v4 REST with a service account (spreadsheets scope): data/get, data/update, data/append, data/clear, data/batchGet, spreadsheets/get, spreadsheets/create; options or CamelGoogleSheets.<option> headers (spreadsheetId, range, values, valueInputOption, majorDimension). OAuth refresh-token user credentials (clientId/clientSecret/refreshToken). google-sheets-stream://spreadsheetId?range=... consumer emitting appended rows (splitResults, majorDimension, valueRenderOption; Camel re-emits the whole range each poll). Also spreadsheets/batchUpdate (request list / BatchUpdateSpreadsheetRequest passed through; emulated atomically: addSheet, deleteSheet, duplicateSheet, updateSpreadsheetProperties, updateSheetProperties, findReplace, insert / deleteDimension), data/batchUpdate and data/batchClear. |
aws2-msk + kafka AWS_MSK_IAM | ✅ | cameleer-cloud, MSK REST (signing name kafka): listClusters (CamelAwsMSKClusterFilter, all pages), createCluster (CamelAwsMSKClusterName, ...ClusterKafkaVersion, ...BrokerNodesNumber, ...BrokerNodesGroupInfo), describeCluster, deleteCluster (CamelAwsMSKClusterArn), getBootstrapBrokers (Cameleer). cameleer_cloud::register adds the AWS_MSK_IAM SASL mechanism to the kafka component (securityProtocol=SASL_SSL&saslMechanism=AWS_MSK_IAM&saslJaasConfig=software.amazon.msk.auth.iam.IAMLoginModule required;): the SASL message is the aws-msk-iam-auth JSON payload of a SigV4-presigned kafka-cluster:Connect request (default credential chain, awsProfileName, or Cameleer awsAccessKeyId/awsSecretAccessKey/awsSessionToken/awsRegion JAAS options). No awsRoleArn (assume role); the test broker verifies the signature. |
| aws2-athena | ✅ | cameleer-cloud, Athena JSON 1.1: startQueryExecution (default; queryString/header/body, database, outputLocation, workGroup, encryptionOption/kmsKey, clientRequestToken; waitTimeout polling with initialDelay/delay, maxAttempts + retry = never/always/retryable/exhausted/generic), getQueryExecution, getQueryResults (outputType StreamList = all pages as rows, SelectList = one page + CamelAwsAthenaNextToken, S3Pointer), listQueryExecutions; CamelAwsAthena* headers. |
| aws2-textract | ✅ | cameleer-cloud, Textract JSON 1.1: detectDocumentText (default), analyzeDocument (CamelAwsTextractFeatureTypes), analyzeExpense on body bytes or s3Bucket/s3Object(/s3ObjectVersion); startDocumentTextDetection / startDocumentAnalysis / startExpenseAnalysis (CamelAwsTextractJobId) and the matching get* operations (...MaxResults, ...NextToken). |
| aws2-translate | ✅ | cameleer-cloud, Translate JSON 1.1 translateText: sourceLanguage/targetLanguage (or CamelAwsTranslateSourceLanguage/...TargetLanguage), autodetectSourceLanguage (detected language returned in the header), CamelAwsTranslateTerminologyNames. |
| aws2-comprehend / aws-comprehend | ✅ | cameleer-cloud, Comprehend JSON 1.1 on the body text: detectDominantLanguage (CamelAwsComprehendDetectedLanguage), detectEntities, detectKeyPhrases, detectSentiment (CamelAwsComprehendSentimentScore), detectSyntax, detectPiiEntities, containsPiiEntities, detectToxicContent, classifyDocument (endpointArn); languageCode. |
| aws2-polly | ✅ | cameleer-cloud, Polly REST: synthesizeSpeech (default; voiceId, outputFormat, textType, engine, sampleRate, languageCode, lexiconNames; audio bytes, CamelAwsPollyContentType, ...RequestCharacters), describeVoices, listLexicons/getLexicon/putLexicon/deleteLexicon, startSpeechSynthesisTask/getSpeechSynthesisTask. |
| aws2-rekognition (Cameleer) | ✅ | cameleer-cloud, Rekognition JSON 1.1 on body bytes or an S3 object: detectLabels (maxLabels, minConfidence), detectText, detectFaces, detectModerationLabels, recognizeCelebrities. Face collections (createCollection, deleteCollection, describeCollection, listCollections, indexFaces, listFaces, deleteFaces), face search (searchFaces, searchFacesByImage, compareFaces) and stored video analysis (start/get LabelDetection, FaceDetection, TextDetection, FaceSearch; all result pages). |
| aws2-transcribe | ✅ | cameleer-cloud, Transcribe JSON 1.1: startTranscriptionJob (CamelAwsTranscribeTranscriptionJobName, ...MediaUri or body, ...LanguageCode / ...IdentifyLanguage, ...MediaFormat, ...MediaSampleRateHertz, ...OutputBucketName), getTranscriptionJob, deleteTranscriptionJob, listTranscriptionJobs (all pages). Also medical transcription jobs (start/get/delete/listMedicalTranscriptionJob(s)), call analytics jobs and categories, custom vocabularies and medical vocabularies (create/get/update/delete/list), custom language models (create/describe/delete/list) and tagResource / untagResource / listTagsForResource. |
| aws-bedrock (alias aws2-bedrock), aws-bedrock-agent-runtime | ✅ | cameleer-cloud, Bedrock Runtime REST: invokeTextModel / invokeImageModel / invokeEmbeddingsModel (InvokeModel with modelId, CamelAwsBedrockContentType/...AcceptContentType; JSON bodies parsed), converse (messages from CamelAwsBedrockConverseMessages or the body, ...ConverseSystem, ...ConverseInferenceConfig; body = text, stop reason / usage / output message headers). Agent Runtime: retrieve (knowledgeBaseId, ...NumberOfResults), retrieveAndGenerate (modelId, session id, citations). Streaming: invokeTextModelStreaming / invokeImageModelStreaming / invokeEmbeddingsModelStreaming (InvokeModelWithResponseStream) and converseStream, AWS event stream framing decoded incrementally with prelude + message CRC32 checks; streamOutputMode complete / chunks, streamingChunkProcessor per-chunk callback, CamelAwsBedrockStreaming* headers. applyGuardrail (+ guardrails on invoke / converse). Agent Runtime invokeAgent (event stream of chunks / traces / citations / returnControl, session attributes, endSession). |
| aws2-mq | ✅ | cameleer-cloud, Amazon MQ REST: listBrokers (all pages), createBroker (CamelAwsMQBrokerName, ...BrokerEngine, ...BrokerEngineVersion, ...BrokerInstanceType, ...BrokerDeploymentMode, ...BrokerPubliclyAccessible, ...BrokerUsers), describeBroker, deleteBroker, rebootBroker (CamelAwsMQBrokerId). No updateBroker. |
| aws2-ecs / aws2-eks | ✅ | cameleer-cloud, ECS JSON 1.1 and EKS REST: listClusters (all pages), createCluster, describeCluster, deleteCluster (CamelAwsECSClusterName; EKS CamelAwsEKSClusterName, ...RoleARN, ...VPCConfig). |
| aws2-kms | ✅ | cameleer-cloud, KMS JSON 1.1: listKeys (CamelAwsKMSLimit, follows NextMarker), createKey (...Description), describeKey, enableKey, disableKey, scheduleKeyDeletion (...PendingWindowInDays); Cameleer encrypt / decrypt (body bytes ↔ ciphertext blob). |
| aws2-timestream | ✅ | cameleer-cloud, Timestream Write/Query JSON 1.0 with endpoint discovery (DescribeEndpoints, cached; skipped with an endpoint override). aws2-timestream://write:x: describeEndpoints, create/delete/describe/listDatabases, create/delete/describe/listTables (retention headers), writeRecords (CamelAwsTimestreamRecordList / ...Record / body, ...CommonAttributes). query:x: query (all pages, rows as maps; CamelAwsTimestreamQueryId), cancelQuery. No scheduled queries or batch load tasks. |
| aws-cloudtrail | ✅ | cameleer-cloud, polling consumer over LookupEvents (eventSource, maxResults): events after the newest one seen, oldest first, never twice; body = CloudTrail event JSON, CamelAwsCloudTrailEventId/...EventSource/...EventName/...EventUsername/...EventTime. |
| aws-config | ✅ | cameleer-cloud, AWS Config JSON 1.1: putConfigRule (CamelAwsConfigRuleName, ...RuleSourceIdentifier, ...RuleSourceOwner, input parameters, scope), removeConfigRule, describeConfigRules, describeRuleCompliance, putConformancePack / removeConformancePack / describeConformancePackCompliance. |
| aws2-redshift-data | ✅ | cameleer-cloud, Redshift Data API JSON 1.1: executeStatement (SQL header/body, parameters; Cameleer waitTimeout polling, failures raise), batchExecuteStatement, describeStatement, getStatementResult (all pages, rows as maps of typed values), cancelStatement, listStatements, listDatabases, listSchemas, listTables, describeTable; cluster (clusterIdentifier) or serverless (workgroupName), secretArn/dbUser. |
| azure-storage-files (Cameleer) | ✅ | cameleer-cloud, Azure Files REST (Shared Key / SAS): listShares, createShare, deleteShare, listDirectoriesAndFiles (default), createDirectory, deleteDirectory, uploadFile (create + 4 MiB Put Range), downloadFile, getFileProperties, deleteFile (directoryName, fileName, CamelAzureStorageFiles* headers); polling consumer of a directory (delete, maxMessagesPerPoll, ETag de-duplication). Camel azure-files (FTP-like) semantics: consumer recursive (minDepth / maxDepth), include / exclude, noop + idempotent / idempotentRepository / idempotentKey, preMove / move / moveFailed via the Rename File API, CamelFile* headers; producer fileExist (Override / Append / Fail / Ignore / Move + moveExisting), tempPrefix (upload then rename), autoCreate directories from CamelFileName, flatten, and a renameFile operation (emulator: Rename File, Set File Properties). |
| azure-functions (Cameleer) | ✅ | cameleer-cloud: invokes HTTP-triggered functions (azure-functions://app/function, httpMethod, functionKey / masterKey in x-functions-key or keyInQuery=true → code, Entra ID tokens with scope, CamelAzureFunctionsQuery); body = response (parseJson), CamelAzureFunctionsStatusCode; non-2xx → HttpResponseException. |
| azure-eventgrid | ✅ | cameleer-cloud, publishes to a topic endpoint (azure-eventgrid:https://topic.../api/events): eventSchema CloudEvent (default, CloudEvents 1.0 batch) or EventGrid; list bodies = several events; CamelAzureEventGridEventType/...Subject/...Source/...EventId/...DataVersion. Auth: accessKey (aeg-sas-key), credentialType=AZURE_SAS (sharedAccessSignature or generated aeg-sas-token), Entra ID client credentials. No consumer (Event Grid pushes to webhooks: use platform-http). |
| azure-schema-registry (Cameleer) | ✅ | cameleer-cloud, Event Hubs Schema Registry REST (2022-10, Entra ID): registerSchema, getSchemaProperties (id of a definition), getSchema (by id), getSchemaByVersion, listVersions, listGroups; format Avro / Json / Custom. No Kafka serializer integration. |
| azure-openai (Cameleer) | ✅ | cameleer-cloud, Azure OpenAI REST (apiKey or Entra ID, apiVersion): chatCompletion (text / message list / raw request body, systemMessage, temperature, maxTokens, topP; finish reason, usage, tool calls headers), embeddings. Streaming chat (streaming=true / chatCompletionStream): SSE decoded incrementally, streamOutputMode complete / chunks, streamingChunkProcessor, chunk count / finish reason / usage headers. imageGeneration (imageSize, imageCount, imageQuality, imageResponseFormat url / b64_json, revised prompts). Assistants API: create / get / list / deleteAssistant, createThread, createMessage, listMessages, createRun, getRun, runAssistant (polls until a terminal status). (Camel itself offers Azure OpenAI through LangChain4j.) |
| google-mail, google-calendar, google-drive | ✅ | cameleer-cloud, Gmail v1 / Calendar v3 / Drive v3 REST with a service account and domain-wide delegation (delegate/subject, scopes); options as URI options or CamelGoogleMail.*/CamelGoogleCalendar.*/CamelGoogleDrive.* headers. Mail: messages/send (map → MIME, text + to, or raw), messages/list/get (decoded subject/from/to/text headers)/delete/trash/untrash/modify, labels/list, threads/get. Calendar: events/list/insert/get/update/patch/delete/quickAdd, calendarList/list, calendars/get. Drive: drive-files/list/get/download/create (multipart upload)/update/copy/delete. OAuth refresh-token user credentials (clientId / clientSecret / refreshToken, authorized_user credential files, fixed accessToken; token cached and refreshed after a 401). Consumers: google-mail-stream (query default is:unread, labels, maxResults, markAsRead, raw; CamelGoogleMailStream* headers), google-calendar-stream (calendarId, query, consumeFromNow, considerLastUpdate; new and changed events), and the Drive file-change consumer on drive-files/list (created / modified / removed, consumeExisting). The remaining API names as a REST table: Gmail drafts (create / list / get / update / send / delete), history/list, attachments/get, users (getProfile, watch → Pub/Sub {emailAddress, historyId} notifications, stop), labels CRUD, threads (list / modify / trash / untrash / delete); Calendar acl CRUD, colors/get, freebusy/query, settings, calendars insert / update / delete / clear, calendarList get / insert / delete, events instances / move / import; Drive about, changes (getStartPageToken / list), permissions / comments / replies / revisions / drives (teamdrives) operations, files emptyTrash / generateIds. Push notifications: events/watch, acl/watch, calendarList/watch, settings/watch, drive-changes/watch, drive-files/watch channels (channelId / address / token or a channel map) and channels/stop / drive-channels/stop; the emulator POSTs X-Goog-Channel-* / X-Goog-Resource-State notifications. google-calendar-stream syncFlow=true: incremental syncToken polling with deleted (cancelled) events and a full resync on 410 GONE. |
| google-vertexai | ✅ | cameleer-cloud, Vertex AI Gemini REST (google-vertexai:project:location:model): generateText / generateChat / generateCode / generateMultimodal (inline bytes or gs:// URI) / countTokens; temperature, maxOutputTokens, topP, topK, candidateCount, systemInstruction; finish reason, token counts, safety ratings headers. Streaming (generateText/Chat/CodeStreaming: streamGenerateContent?alt=sse decoded incrementally, streamOutputMode, streamingChunkProcessor), generateEmbeddings (taskType, outputDimensionality), generateImage (Imagen, sampleCount, aspectRatio), partner models via rawPredict / streamRawPredict (publisher=anthropic/meta/...; text bodies wrapped into Anthropic Messages requests, Anthropic SSE deltas or OpenAI-style chunks decoded). |
| google-speech-to-text / google-text-to-speech (Cameleer) | ✅ | cameleer-cloud, Speech v1: recognize (bytes or gs://; encoding, sampleRateHertz, languageCode, model; transcript + confidence/results headers), longRunningRecognize + getOperation. Text-to-Speech v1: synthesize (text or SSML, voiceName, languageCode, ssmlGender, audioEncoding, speakingRate, pitch; audio bytes), listVoices. |
| Cloud emulators for tests | ✅ | cameleer_cloud::testing: AwsMock (S3 incl. multipart, SQS, SNS, DynamoDB subset, Lambda closures, Kinesis, Firehose, EventBridge with pattern matching to SQS targets, Secrets Manager, Step Functions Pass/Succeed/Fail machines, SES, CloudWatch, STS issuing temporary credentials, IAM, EC2, MSK, Athena with polling / failures / paging, Textract, Translate, Comprehend, Polly, Rekognition, Transcribe, Bedrock + knowledge bases, MQ, ECS, EKS, KMS envelope encryption, Timestream write/query, CloudTrail, Config, Redshift Data) and the Kafka test broker verifying AWS_MSK_IAM payloads, ImdsMock (EC2 instance metadata IMDSv2/v1 + ECS container credentials), AzuriteMock (Blob incl. append/page blobs and leases, Queue, ADLS Gen2 DFS, Azure Files), AzureMock (Azure AD client-credentials token endpoint, Key Vault, Cosmos DB SQL subset + change feed, Functions with function / master keys, Event Grid topics verifying keys / SAS tokens / bearer tokens and event schemas, Schema Registry, Azure OpenAI), GcpMock (OAuth token endpoint recording delegated subjects, Cloud Storage + V4 signed URL downloads, Pub/Sub REST and a StreamingPull gRPC server over cameleer-grpc HTTP/2 with leases / acks / nacks / redelivery / flow control, BigQuery insertAll + SQL subset with async jobs/paging, Secret Manager, Cloud Functions closures, Firestore + runQuery, Sheets values, Gmail mailboxes, Calendar, Drive with multipart uploads, Vertex AI / Speech / Text-to-Speech stand-ins) in memory on ephemeral ports; they verify SigV4 signatures (and session tokens of temporary credentials), Shared Key signatures / account SAS tokens, Azure AD bearer tokens, Cosmos DB master-key HMAC signatures and RS256 JWT assertions + bearer tokens (with scopes for Sheets). |
| sftp | ✅ | cameleer-ssh (own SSH-2 + SFTP v3 stack, interop-tested against OpenSSH 9.6). Same consumer/producer options and CamelFile* headers as ftp (noop/delete/move/preMove/moveFailed, include/exclude/ant, recursive, sortBy, idempotent, maxMessagesPerPoll, fileExist strategies, tempFileName, doneFileName, scheduler options) plus password, privateKeyFile/privateKeyUri/privateKey, knownHostsFile/knownHostsUri/knownHosts, useUserKnownHostsFile, strictHostKeyChecking (default no as in Camel, but changed/revoked host keys are always rejected), preferredAuthentications, ciphers/keyExchangeProtocols/serverHostKeys, bulkRequests (pipelining), chmod/chmodDirectory. Algorithms: curve25519-sha256, ecdh-sha2-nistp256; ssh-ed25519, ecdsa-sha2-nistp256/384, rsa-sha2-256/512; chacha20-poly1305@openssh.com, aes128/256-gcm@openssh.com, aes128/192/256-ctr + hmac-sha2-256/512(-etm); strict KEX, rekeying. SSH agent identities (useAgent, agentSocket). Passphrase-protected keys (privateKeyPassphrase): OpenSSH openssh-key-v1 with bcrypt-pbkdf (own Blowfish) and aes-ctr/cbc/gcm, chacha20-poly1305 or 3des-cbc, PKCS#8 ENCRYPTED PRIVATE KEY, legacy OpenSSL PEM (AES-CBC / DES-EDE3-CBC) — fixtures from ssh-keygen. compression (level > 0 negotiates zlib@openssh.com / zlib), OpenSSH user certificates (certificateFile) and @cert-authority host certificates (see the ssh row). Remaining gaps: no readLock, proxies. |
| ssh | ✅ | cameleer-ssh. Producer runs the body as a command (exec or channelType=shell): body = stdout, headers CamelSshStderr, CamelSshExitValue; CamelSshUsername/CamelSshPassword override credentials; pooled connection. Consumer runs pollCommand on a schedule. Options username, password, certResource/privateKeyFile (+ certResourcePassword / privateKeyPassphrase for encrypted keys), knownHostsResource, failOnUnknownHost, timeout, kex/ciphers/macs/signatures. Embedded test server cameleer_ssh::testing::SshServer (password/publickey/keyboard-interactive auth, built-in echo/cat/ls/pwd/exit commands, SFTP subsystem). SSH agent authentication (useAgent=true → SSH_AUTH_SOCK, or agentSocket; tested with OpenSSH ssh-agent), passphrase-protected keys. Port forwarding: SshClient::open_direct_tcpip, start_local_forward (ssh -L) and request_remote_forward / start_remote_forward (tcpip-forward + forwarded-tcpip, ssh -R); the embedded server accepts direct-tcpip and tcpip-forward (allow_tcp_forwarding). Compression zlib@openssh.com (delayed) and zlib (own streaming deflate/inflate keeping the window and leftover bits across packets, compressionAlgorithms). OpenSSH certificates: user certificate authentication (ClientConfig::certificates, certificateFile), host certificates verified against @cert-authority known_hosts lines (certificate host key algorithms preferred automatically), server-side trusted_user_ca_keys and host certificates. All interop-tested both ways with OpenSSH (ssh -C, ssh -L/-R, ssh-keygen -s, sshd with TrustedUserCAKeys / HostCertificate). Remaining gaps: no shellPrompt handling or keyPairProvider beans; certificate critical options other than force-command / source-address are rejected (those two are accepted but not enforced); no KRL revocation lists. |
| spring-redis | ✅ | cameleer-datastores, own RESP2/RESP3 client (AUTH incl. ACL users, SELECT, HELLO 3, pipelining, MULTI/EXEC, TLS via ssl=true/sslContextParameters). Producer runs command (header CamelRedis.Command) with arguments from CamelRedis.Key/Keys/Field/Fields/Value/Values/Timeout/Start/End/Index/Offset/Destination/Channel/Message/Pivot/Position/Count/Timestamp/Pattern/Db/Score/Min/Max/Increment/WithScore/Longitude/Latitude/Radius: key, string, hash, list (incl. blocking pops), set, sorted-set, geo (GEOADD, GEODIST, GEOHASH, GEOPOS, GEORADIUS, GEORADIUSBYMEMBER; Redis-identical 52-bit geohash scores), PUBLISH and transaction commands; unknown commands are sent generically. Consumer: SUBSCRIBE/PSUBSCRIBE on channels (headers CamelRedis.Channel, CamelRedis.Pattern). serializer: string (StringRedisSerializer), json (GenericJackson2JsonRedisSerializer), bytes (ByteArrayRedisSerializer), default text, or a #bean (RedisSerializerBean) — Java serialization (JdkSerializationRedisSerializer) is rejected. redisTemplate/connectionFactory = #bean of type RedisClient. Topologies: Redis Sentinel master discovery (sentinels, sentinelMaster; re-resolved after connection failures) and Redis Cluster (cluster=true: CRC16 key slots, slot cache, MOVED/ASK redirections); the embedded server can act as sentinel or cluster node. |
| Redis idempotent / aggregation repositories | ✅ | cameleer-datastores. RedisIdempotentRepository (a set per processor: SADD/SISMEMBER/SREM), RedisAggregationRepository (hash <name> + ordered keys + <name>-completed, scan/recover). |
| mongodb | ✅ | cameleer-datastores, own BSON codec (ObjectId, dates, Decimal128, binary, regex, timestamps; Extended JSON/shell syntax bodies) and OP_MSG client with SCRAM-SHA-256, SCRAM-SHA-1 (MD5 password digest) and MONGODB-X509 (TLS client certificate, $external) authentication and TLS (tls=true, sslContextParameters). Connection: mongodb:<bean> (MongoClient), connectionUriString (mongodb:// or mongodb+srv:// — SRV/TXT records resolved by the own UDP DNS client in cameleer_datastores::dns with TCP fallback, domain checks, TXT authSource/replicaSet, srvServiceName, srvMaxHosts, dnsServer) or hosts/username/password/authSource. Replica sets: replicaSet, hello topology discovery (follows primary, remembers hosts), re-discovery and retry after NotWritablePrimary, directConnection. Operations findById, findOneByQuery, findAll, findDistinct, count, insert, save, update, remove, bulkWrite (insertOne/updateOne/updateMany/replaceOne/deleteOne/deleteMany models, CamelMongoDbBulkOrdered, MongoBulkWriteException), aggregate, getDbStats, getColStats, command; headers CamelMongoDbCriteria, ...FieldsProjection, ...SortBy, ...Limit, ...NumToSkip, ...BatchSize, ...MultiUpdate, ...Upsert, ...RecordsAffected, ...RecordsMatched, ...ResultTotalSize, ...ResultPageSize, CamelMongoOid, dynamicity, writeResultAsHeader, createCollection. Consumers consumerType=tailable (in-memory tail tracking only) and changeStreams (streamFilter, fullDocument, resume after errors). mongodb-gridfs ✅: GridFS buckets (bucket, chunked files/chunks per the GridFS spec), operations create (CamelFileName, gridfs.chunksize, gridfs.metadata, Content-Type → gridfs.fileid), remove, findOne, listAll, count; polling consumer with queryStrategy TimeStamp / FileAttribute (fileAttributeName) / TimeStampAndFileAttribute and query. The embedded server implements SCRAM-SHA-1, X.509 and replica set roles. |
| elasticsearch, opensearch | ✅ | cameleer-datastores, REST/JSON over cameleer-http (HTTPS with enableSSL/sslContextParameters, user/password, apiKey, hostAddresses failover). Operations Index, Update, Bulk, GetById, MultiGet, Delete, DeleteIndex, Exists, Search, MultiSearch, Ping; headers operation, indexName, indexId, size, from, documentClass; enableDocumentOnlyMode. Scroll searches (useScroll, scrollKeepAliveMs: every page fetched with _search/scroll, context cleared, property CamelElasticsearchScrollQueryCount), sniffing (enableSniffing, sniffInterval, sniffAfterFailureDelay: hosts replaced by the GET /_nodes/http publish addresses), typed documentClass (an EsDocumentClass bean or inline field:type,... spec mapping _source documents to declared fields and types; Java map class names keep generic documents). The embedded server implements scroll contexts and node info. |
| cql | ✅ | cameleer-datastores, own CQL native protocol v4 client (PasswordAuthenticator, prepared statements with re-prepare, paging via fetchSize, consistency/serial consistency, TLS, multiple contact points, LZ4 / Snappy frame compression with own codecs (compression), token-aware routing (tokenAware, default on: Murmur3 tokens of the partition key bind values from the PREPARED pk indexes, ring from system.local + system.peers_v2/system.peers, per-node connections; tokenAware=false uses the contact points in order)). cql://host1,host2:port/keyspace?cql=... or cql:bean:<CqlSession>; body = bind values, header CamelCqlQuery; resultSetConversionStrategy ALL/ONE/LIMIT_n; polling consumer (one exchange per poll). Values map to text/numbers/bytes/arrays/objects (timestamps as ISO-8601 text, durations as Cassandra duration text with vint codec, UDTs as objects). The embedded server supports compression, CREATE TYPE / UDT columns and literals, CREATE INDEX (indexed equality without ALLOW FILTERING), duration columns and a configurable token ring (set_ring). loadBalancingPolicyClass/datacenter are accepted (no DC-aware policy). |
| couchdb | ✅ | cameleer-datastores, REST API over cameleer-http (couchdb:http(s)://host:port/db, createDatabase, username/password). Producer saves (POST/PUT, _rev updates; array bodies in one _bulk_docs request with per-document results), CouchDbMethod=GET/DELETE; headers CouchDbId, CouchDbRev; DocumentConflictException / NoDocumentException. Consumer follows the _changes longpoll feed from the current sequence (since, updates, deletes, heartbeat, style, maxMessagesPerPoll) with headers CouchDbDatabase, CouchDbSeq, CouchDbId, CouchDbRev, CouchDbMethod. couchbase ❌ (binary KV protocol out of scope). |
| cxf (SOAP web services) | ✅ | cameleer-soap. WSDL 1.1 parser (XSD types, messages, portTypes, SOAP 1.1 and 1.2 bindings, document/literal (wrapped and bare), rpc/literal and rpc/encoded basics (xsi:type accessors, href multi-refs), soap:header parts (bound in POJO mode: extra positional / named parameters, result object entries), services/ports, soapAction, WSDL/XSD imports), SOAP 1.1/1.2 envelopes and faults (faultcode/faultstring/faultactor/detail, Code/Subcode/Reason/Role/Detail). cxf://http(s)://host:port/path?wsdlURL=...&serviceName={ns}Svc&portName={ns}Port&dataFormat=POJO|PAYLOAD|RAW|CXF_MESSAGE&defaultOperationName=... (cxf:/path = platform port). Producer: headers operationName, operationNamespace, SOAPAction, CamelCxfSoapHeaders; POJO maps an array (positional) / object (named) / scalar to the wrapper per WSDL+XSD with typed values and back (return value, or an object for several out parts; without WSDL a JAX-WS style arg0..n wrapper); PAYLOAD = body element XML; RAW/CXF_MESSAGE = whole envelope. Faults → SoapFault error + CamelCxfFault{Code,String,Detail} headers. Consumer: on cameleer-http's server, SOAP 1.1 and 1.2, dispatch by SOAP action (header or 1.2 action parameter) or body element, operationName/operationNamespace headers, exceptions → faults (SoapFault::into_error keeps code/detail), one-way → 202, ?wsdl with rewritten address (publishedEndpointUrl), schemaValidationEnabled. WS-Security: UsernameToken text/digest (wsSecurityUsername/wsSecurityPassword/wsSecurityPasswordType, consumer wsSecurityUsers) with nonce replay and freshness checks, wsu:Timestamp, enveloped envelope signature (wsSecuritySignatureKey/...Certificate, consumer wsSecuritySignatureVerifyCertificate, cameleer-xml xmlsecurity). HTTP basic auth, sslContextParameters, timeouts. MTOM/XOP (mtomEnabled, mtomThreshold) and SwA attachments (CamelAttachments property) both ways; XML Encryption of the body (AES-128/256-CBC/GCM, RSA-OAEP key transport via cameleer-tls: wsSecurityEncryptionCertificate/Key, wsSecurityEncryptionAlgorithm, wsSecurityDecryptionKey); X.509 BinarySecurityToken signatures (wsSecuritySignatureKeyIdentifier, consumer wsSecuritySignatureTrustedCertificates); SAML 2.0 assertions (wsSecuritySamlSubject/Issuer/Attributes, consumer wsSecuritySamlRequired/TrustedIssuers, CamelCxfSaml* headers); WS-Addressing (wsAddressingEnabled/features=wsa, RelatesTo checks, decoupled ReplyTo) and WS-RM basics (wsrmEnabled: CreateSequence/TerminateSequence, acknowledgements, duplicate suppression); cxf:bean: (options from an object/map bean); code-first serviceClass=#ServiceDescriptor with WSDL generation. Not implemented: WS-Policy, WS-SecureConversation, signed SAML / holder-of-key, WS-RM persistence and resend. |
| cxfrs (JAX-RS) | ✅ | cameleer-soap: resource model from ResourceDescriptor beans (resourceClasses=#bean,...: class path, methods with HTTP method, path template, consumes/produces; Java class names ignored) or inline operations=name:METHOD:/path/{param};...; 415 for unsupported request media, 406 for unacceptable Accept; entity providers (providers=#bean, EntityProvider = MessageBodyReader/Writer for media types) on consumer and producer, JSON built in. Consumer sets operationName, CamelHttpMethod, CamelHttpPath (relative), CamelHttpUri, CamelHttpQuery, path/query parameters as headers; replies JSON/text/bytes or provider output, CamelHttpResponseCode; unmatched operation → 404. Producer (httpClientAPI style): CamelHttpMethod/CamelHttpPath/CamelHttpQuery, JSON or provider bodies, parseJson, throwExceptionOnFailure. Not implemented: JAX-RS proxy-client API, sub-resource locators. |
| spring-ws | ✅ | cameleer-soap. Consumers rootqname:, soapaction:, uri:, xpathresult: (expression), action:/to: (WS-Addressing), beanname: (a SpringWsMapping registry bean — predicate or root-QName/SOAP-action/WSA-action mapping — or a String bean holding another endpoint spec) sharing one dispatcher per address (default /ws on the platform port; unmatched → 404); payload XML body, CamelSpringWebserviceSoapAction/SoapHeader/AddressingAction headers, exceptions → faults, null reply → 202. Producer spring-ws:http://... with soapAction, wsAddressingAction, soapVersion, timeout, header overrides (CamelSpringWebserviceEndpointUri...), faults → SoapFaultClientException; WS-Security options as in cxf. Spring message factories/interceptors are accepted and ignored; no SOAP attachments. |
| fhir | ✅ | cameleer-soap. fhir://<api>/<method>?serverUrl=...&fhirVersion=R4&encoding=JSON|XML: create/resource, read/resourceById/resourceByUrl, update/resource, delete/resource/resourceById/resourceConditionalByUrl, search/searchByUrl, history/onInstance/onType/onServer, transaction/withBundle/withResources, capabilities/ofType, load-page/next/previous/byUrl, operation/onServer/onType/onInstance/onInstanceVersion (name, parameters as a Parameters resource or a name → value object, useHttpGet) and operation/processMessage, patch/withBody/withUrl (JSON Patch, XML Patch, FHIRPath Patch Parameters), meta/getFromServer/getFromType/getFromResource/add/delete, validate/resource (server $validate, or local validation against a profile StructureDefinition from a file / #bean / text; CamelFhirValidationSuccessful header); fhirVersion DSTU3/R4/R4B/R5 selects the type registry; parameters from options or CamelFhir.<name> headers, the body supplies the main one (inBody); resources as values or JSON/XML text; basic (username/password) and bearer (accessToken) auth; HTTP errors → HAPI exception kinds (ResourceNotFoundException, ResourceGoneException, AuthenticationException...). cameleer_soap::testing::FhirMock: in-memory R4 server (CRUD, versioning, vread, search with token/reference/prefix matching and paging, history, transaction/batch with urn:uuid rewriting, JSON+XML, auth, $meta/$meta-add/$meta-delete, $validate, Patient/$everything, $process-message, $echo, PATCH with JSON Patch and FHIRPath Patch). No HAPI typed client builders (Camel's API surface only). |
| Datastore servers for tests | ✅ | cameleer_datastores::testing: RedisServer (RESP2/3, auth, pub/sub, TLS), MongoServer (OP_MSG, SCRAM, TLS, query engine with $eq $gt $gte $lt $lte $ne $in $nin $and $or $nor $not $exists $regex $size $all $elemMatch $type, update operators, aggregation $match $group $sort $limit $skip $project $addFields $count $unwind, capped collections/tailable cursors, change streams), ElasticsearchServer (inverted index, match/term/bool/range/... queries, _bulk, auth, TLS), CassandraServer (CQL v4, CQL subset engine, auth, paging, TLS), CouchDbServer (revisions, _changes, auth). |
Cameleer