# Cameleer feature matrix

This page compares Cameleer with [Apache Camel 4](https://camel.apache.org/). It was written
by reading the code and the conformance test suite (`crates/cameleer-core/tests/conformance_*.rs`,
`crates/cameleer-http/tests/conformance_http.rs`), not from the wishlist.

Legend: ✅ implemented, ⚠️ partial (see notes), ❌ not implemented.

Cameleer uses only the Rust standard library, so anything that needs a database driver,
a broker client or a JVM library is out of scope unless it can be written from scratch. TLS is
provided by the from-scratch `cameleer-tls` crate and is wired into every network component
(see "TLS / SSL context parameters" below).

## Interop verified against real servers

Besides the embedded test servers, these components are verified end-to-end against real,
independent server software by the opt-in live suite (`CAMEL_LIVE_INTEROP=1`, servers set up by
`scripts/live-interop.sh`); details, broker limitations and the bugs it found are in
[INTEROP.md](INTEROP.md). The emulator-only areas (embedded Kafka broker and datastores, the
AWS / Azure / GCP mocks, the Azure flavour of the AMQP 1.0 broker) and the TLS, HTTP/2 and gRPC
stacks are additionally driven by officially published clients (librdkafka, pymongo, the
DataStax driver, elasticsearch-py, redis-py, boto3, the Azure SDK for Python, gcloud / gsutil /
bq, grpcio, Go's crypto/tls and net/http) in the opt-in `CAMEL_OFFICIAL_CLIENTS=1` suite
(`scripts/official-clients.sh`); see "Official clients" in [INTEROP.md](INTEROP.md).

| Components | Interop verified against |
|---|---|
| `sql`, `jdbc`, `sql-stored`, JDBC idempotent / aggregation repositories, transactions | PostgreSQL 16.15 (SCRAM-SHA-256, `sslmode=verify-full`, PL/pgSQL) |
| `spring-redis` (producer, pub/sub consumer), Redis idempotent / aggregation repositories | Redis 7.0.15 (AUTH, RESP3, TLS) |
| `paho`, `paho-mqtt5` | Eclipse Mosquitto 2.0.18 (QoS 0/1/2, retained, wildcards, credentials, TLS, persistent sessions); RabbitMQ 3.12 MQTT plugin |
| `spring-rabbitmq`, `rabbitmq` | RabbitMQ 3.12.1 (exchanges, ack/reject, DLX, request/reply, confirms, AMQPS) |
| `stomp`, `jms`, `activemq` | RabbitMQ 3.12.1 STOMP plugin (queues, topics, temp-queue request/reply, transactions, durable subscriptions, TLS) |
| `amqp` (AMQP 1.0) | RabbitMQ 3.12.1 AMQP 1.0 plugin (queues, topics, request/reply, client ack, AMQPS) |
| `ftp`, `ftps` | vsftpd 3.0.5 (passive/active, explicit/implicit FTPS, `require_ssl_reuse=YES`) |
| `smtp`/`smtps`, `imap`/`imaps`, `pop3`/`pop3s` | Postfix 3.8.6 + Dovecot 2.3.21 (STARTTLS/STLS, implicit TLS, SASL, attachments) |
| `http`/`https` producer | nginx 1.24.0 (HTTP/1.1, gzip, keep-alive, HTTPS, HTTP/2 via ALPN, h2c); OpenJDK 21 JSSE `HttpsServer` (TLS 1.3 / 1.2) |
| `jetty:https` consumer | OpenJDK 21 `java.net.http.HttpClient` |
| `stomp`, `jms`, `activemq` | Apache ActiveMQ 5.17.6 STOMP (JMS selectors, temp-queue request/reply, durable subscriptions, transactions with redelivery and DLQ, priority / TTL, persistent / non-persistent, map / object messages, virtual topics, authentication, STOMP+SSL) |
| `paho` | Apache ActiveMQ 5.17.6 MQTT (QoS 0/1/2, retained, wildcards, persistent sessions, authentication, TLS, MQTT ↔ STOMP bridging) |
| `amqp` (AMQP 1.0) | Apache ActiveMQ 5.17.6 AMQP transport (`queue://` / `topic://` prefixed addressing, topic fan-out, JMS selectors, AMQP transactions with redelivery, dynamic reply queues, durable subscriptions, JMS mapping through the JMS transformer, multi-frame messages, SASL PLAIN, AMQPS; shared subscriptions refused) |

### Third-party simulators

Cloud services, Kafka and MongoDB are additionally verified against independent simulators run
locally by the opt-in `CAMEL_SIMULATORS=1` suite (`scripts/simulators.sh`); see "Third-party
simulators" in [INTEROP.md](INTEROP.md) for what passed, the bugs it found and what could not run
(Elasticsearch / OpenSearch, Cassandra, real Kafka, LocalStack, Cosmos DB / Service Bus and the
gcloud emulators).

| Components | Verified against |
|---|---|
| AWS: `aws2-s3`, `aws2-sqs`, `aws2-sns`, `aws2-ddb`, `aws2-ddbstream`, `aws2-kinesis`, `aws2-kinesis-firehose`, `aws2-eventbridge`, `aws-secrets-manager`, `aws2-kms`, `aws2-sts`, `aws2-iam`, `aws2-ec2`, `aws2-cw`, `aws2-ses`, `aws2-step-functions`, `aws2-lambda` (management), `aws2-athena` | moto 5.2.5 (incl. IAM-enforced SigV4, HTTPS) |
| `azure-storage-blob`, `azure-storage-queue` | Azurite 3.37.0 (Shared Key, account / service SAS, HTTPS) |
| `google-storage` | fake-gcs-server 1.53.1 (HTTP, HTTPS) |
| `google-pubsub` streaming-pull consumer | pstest (cloud.google.com/go/pubsub 1.50.1) |
| `mongodb`, `mongodb-gridfs` | FerretDB 1.24.2 on PostgreSQL 16 (SCRAM, TLS) |
| `kafka` | franz-go kfake, 3 brokers (groups, SASL PLAIN / SCRAM, TLS) |

## Core concepts

| Feature | Status | Notes |
|---|---|---|
| CamelContext lifecycle (start/stop/restart) | ✅ | Routes start by `startupOrder` and stop in reverse order. Default shutdown timeout is 45 s (`set_shutdown_timeout`). |
| Graceful shutdown | ✅ | Waits for in-flight exchanges. Exchanges still queued on a seda consumer are completed first unless `purgeWhenStopping=true`. |
| Adding/removing routes at runtime | ✅ | Routes added after start begin at once. `remove_route` returns `false` until the route is stopped, as in Camel. |
| Route ids, auto-generated ids (`route1`...) | ✅ | |
| `autoStartup`, `startupOrder`, route groups/descriptions | ✅ | |
| Suspend/resume | ✅ | `SuspendableService` (`Service::as_suspendable`): the seda, timer, scheduler, file, cron/quartz and platform-http consumers are suspended in place — seda leaves messages queued, timer/scheduler/cron skip fires, the file consumer skips polls, HTTP answers `503 Service Unavailable` — and in-flight exchanges complete; other consumers are stopped (as Camel does for non-suspendable consumers). `suspend_route`/`resume_route` (`start_route` resumes a suspended route), context-level `suspend()`/`resume()`, `RouteSuspended`/`RouteResumed`/`ContextSuspended`/`ContextResumed` events, `is_route_suspended_in_place`. |
| Exchange / Message / headers | ✅ | Headers are case-insensitive and keep the original key spelling. |
| Exchange patterns InOnly/InOut, `inOnly()`/`inOut()`/`setExchangePattern` | ✅ | |
| Exchange properties, variables (`setVariable`, `${variable.x}`) | ✅ | Variables are stored as exchange properties (`CamelVariable.<name>`), not in a separate variable repository. |
| `Exchange.correlated_copy` (`CamelCorrelationId`) | ✅ | |
| Type conversion (`convertBodyTo`, `bodyAs`) | ✅ | `cameleer_core::typeconverter`: a per-context `TypeConverterRegistry` (`ctx.type_converter()`) used by `convertBodyTo`/`convertHeaderTo`, Simple `bodyAs`/`headerAs`/`mandatoryBodyAs` and languages' `resultType`. Custom converters per (from, to) type (`add_converter`, `Object` = any source), fallback converters, `TypeConverterExists` policy (Override/Ignore/Fail), statistics (attempts/hits/misses/failures). Built-in conversions modelled on Camel's core converters: String (charset from `CamelCharsetName`), Character, Integer/Short/Byte (range checked), Long/BigInteger, Double/Float/BigDecimal/Number, Boolean, byte[]/InputStream/ByteBuffer, Map (JSON, `Properties` text), List/Collection/Iterator/Set/Object[]/String[], Date/Timestamp/Calendar (epoch millis), Instant/OffsetDateTime/ZonedDateTime/LocalDate/LocalDateTime/LocalTime, Duration (ISO-8601 or `1m30s`), UUID, URI/URL/File/Path, Reader/XML Document/Source (text), JsonNode. Values stay dynamic `Value`s, so a "type" is a name (`com.acme.Order` keys custom converters). |
| Unit of work, on-completion synchronizations | ✅ | `useOriginalMessage` follows Camel's unit-of-work scope: it spans direct/seda routes, and split/multicast/recipientList start a child unit of work unless `shareUnitOfWork`. |
| Property placeholders `{{key}}`, `{{key:default}}`, `{{env:X}}` | ✅ | Resolved in uris, endpoint options and Simple expressions when the route is created. |
| Registry / beans | ✅ | A typed registry (`bind`, `lookup`, processors, aggregation strategies, bean methods). |
| Event notifiers | ✅ | Context, route and exchange events. |
| Endpoint uri normalization | ✅ | Like Camel's `URISupport.normalizeUri`: `Endpoint::uri()`, route endpoints, `CamelToEndpoint`, `CamelRecipientListEndpoint`, `CamelSlipEndpoint`, `CamelFailureEndpoint`, `CamelInterceptedEndpoint` and endpoint errors use `scheme://path?sorted-params` (`mock://result`, `seda://foo?blockWhenFull=true&size=10`, values encoded like `URLEncoder`). Lookups and `interceptSendToEndpoint` patterns work with either form. `RAW(...)` values are shown encoded rather than as `RAW(...)`. |
| Value predicate truthiness | ✅ | `ObjectHelper.evaluateValuePredicate` (`Value::is_predicate_true`): a boolean is its value, a string is false only for `"false"` (trimmed, any case), an array is true when not empty, null is false and anything else (`0`, `""`, maps, bytes) is true. Used by Simple, `header`/`constant`/... languages used as predicates and JSONPath. |
| SSL context parameters (`SSLContextParameters`) | ✅ | `cameleer_tls::SslContextParameters`: key and trust stores as PEM (combined or separate certificate/key files, `ENCRYPTED PRIVATE KEY` with PBES2 or PKCS#12 PBE), PKCS#12 (`.p12`/`.pfx`: PBES2/PBKDF2-HMAC-SHA1/256 + AES-128/256-CBC, legacy 3DES and RC2-40, HMAC-SHA1/256 MAC), Java JKS and JCEKS (format detected or `keyStoreType`/`trustStoreType`; `keystorePassword`, `keyPassword`, `certAlias`, `trustStorePassword`), optional system trust store, `insecure_skip_verify`, host name verification switch, ALPN, min/max TLS version, SNI override, client authentication (`clientAuthentication=NONE\|WANT\|REQUIRE`, also `serverParameters.clientAuthentication`; the client presents its key store when asked), CRL files (`crlFile`), session resumption (`sessionResumption`, `sessionTimeout`). Bind as a bean and reference with `sslContextParameters=#name` (also `camel.component.<scheme>.sslContextParameters`), or configure the global parameters with `camel.ssl.*` properties (`camel.ssl.enabled=true`, `keyStore`/`certFile`+`keyFile`, `keystorePassword`, `keyPassword`, `keyStoreType`, `certAlias`, `trustStore`, `trustStorePassword`, `trustStoreType`, `trustAllCertificates`, `hostnameVerification`, `secureSocketProtocol(s)`, `clientAuthentication`, `crlFile`, `sessionTimeout`) or the bean `CamelGlobalSSLContextParameters`, used with `useGlobalSslContextParameters=true` and as the default trust for TLS endpoints when `camel.ssl.enabled=true`. Embedded HTTP server: `camel.server.ssl.*` / `camel.server.sslEnabled` / `camel.server.useGlobalSslContextParameters`. TLS failures are `SSLHandshakeException`/`SSLPeerUnverifiedException` (subclasses of `IOException`). Not supported: OCSP, JCEKS secret-key entries, PKCS#12 public-key integrity/privacy modes, key managers selecting among several key entries by SNI. |

## Enterprise Integration Patterns

| EIP | Status | Notes |
|---|---|---|
| Pipeline, `to`, `toD` (Simple uri), `step` | ✅ | |
| Message Filter (+ `CamelFilterMatched`) | ✅ | |
| Content-Based Router (`choice/when/otherwise`, `endChoice`, nested) | ✅ | A choice with no `otherwise` continues after the choice. |
| Splitter (tokenize, arrays, delimiter, streaming, parallel, timeout, stopOnException, shareUnitOfWork, aggregation strategy) | ✅ | Without a strategy the original message continues. `stop()` in a split part stops only that part. Sequential `streaming` is lazy: a string body is split one part at a time and sub-exchanges are created on demand; `CamelSplitSize` is set on the last part only, as in Camel. The tokenize language itself still returns all tokens at once. |
| Aggregator (completionSize/Timeout/Interval/Predicate/FromBatchConsumer/OnNewCorrelationGroup, eager check, forceCompletionOnStop, discardOnCompletionTimeout, closeCorrelationKeyOnCompletion, custom repository) | ✅ | `completionTimeout` is an inactivity timeout. `CamelAggregatedCompletedBy` takes the values `size`, `timeout`, `predicate`, `interval`, `force`... Repositories are in memory only (no JDBC/LevelDB). |
| Multicast (parallel, strategy, stopOnException, timeout) | ✅ | Without a strategy the last reply wins, as in Camel. |
| Recipient List (delimiter, ignoreInvalidEndpoints, parallel, strategy) | ✅ | |
| Routing Slip, Dynamic Router | ✅ | |
| Wire Tap (copy, `newExchangeBody/Header`, `onPrepare`) | ✅ | Asynchronous, on a separate exchange. |
| Content Enricher `enrich` / `pollEnrich` (strategy, timeout, aggregateOnException, dynamic uri) | ✅ | |
| Loop (count, `doWhile`, `copy`) | ✅ | |
| Idempotent Consumer (eager, skipDuplicate, removeOnFailure, completionEager) | ✅ | Memory LRU repository only. Duplicates skip only the idempotent block, as in Camel. |
| Load Balancer (round robin, random, sticky, weighted, topic, failover, custom) | ✅ | |
| Resequencer (batch, stream) | ✅ | |
| Sort, Claim Check, Sampling, Delay, Throttle (incl. correlated) | ✅ | `asyncDelayed` (default true for delay, false for throttle, as in Camel; `sync_delayed()`) releases the consumer thread of asynchronous consumers (seda, timer) while the exchange waits, see `cameleer_core::async_delay`. Synchronous callers (direct, `ProducerTemplate`) still wait. |
| Validate | ✅ | Throws `PredicateValidationException`. |
| Circuit Breaker (`onFallback`) | ✅ | A resilience4j-style state machine built in. No Resilience4j/MicroProfile integrations. |
| Stop, Rollback, markRollbackOnly(Last), throwException | ✅ | `throwException` messages are Simple expressions. |
| Threads, Policy, Transacted | ✅ | **Threads**: `threads(n)`/`threads_with(ThreadsOptions)`/YAML `threads` with `poolSize`, `maxPoolSize`, `keepAliveTime` (+`timeUnit`), `maxQueueSize` (0 = hand-off, -1 = unbounded), `allowCoreThreadTimeOut`, `rejectedPolicy` (Abort, CallerRuns, Discard, DiscardOldest), `callerRunsWhenRejected`, `threadName`, `executorService` (shared `BoundedThreadPool` or `ThreadPoolProfile` bean) on `executor::BoundedThreadPool` (ThreadPoolExecutor semantics, Camel's default profile). **Policy**: `policy(Arc<dyn Policy>)`/`policy_ref` (also resolves `TransactionPolicy` beans). **Transacted**: `cameleer_core::transaction` — `TransactionManager` SPI (begin/commit/rollback, savepoints, suspend/resume; `FnTransactionManager`), `TransactionPolicy` with propagation REQUIRED, REQUIRES_NEW, MANDATORY, SUPPORTS, NOT_SUPPORTED, NEVER, NESTED, isolation/timeout/read-only, `TransactionSynchronization` callbacks, `TransactionPolicy::execute` (TransactionTemplate). `transacted()`/`transacted_ref(name)`/YAML `transacted` wrap the rest of the route and resolve the policy as Camel does (bean named `PROPAGATION_REQUIRED`, single policy, `PROPAGATION_*` names, `transactionManager` bean); exceptions and `markRollbackOnly` roll back, participating scopes mark the shared transaction rollback-only, `markRollbackOnlyLast` rolls back only the innermost one. Transactions are thread-bound like Spring's (synchronous `direct:` calls join). |
| Route Policy | ✅ | |
| Intercept, interceptFrom, interceptSendToEndpoint (skip, afterUri, onWhen) | ✅ | |
| Process / bean / method | ✅ | Processors are closures or registry beans. There is no reflection-based bean binding. |
| Kamelets, Pipes / KameletBindings | ✅ | `cameleer-yaml::kamelet`: YAML Kamelets (`spec.definition.properties`, `required`, defaults, `spec.template`/`spec.flow`, `spec.dataTypes`), `kamelet:name?prop=x` as source (`from`) and sink/action (`to`), `{{prop}}`/`{{?prop}}` from uri parameters, `camel.kamelet.<name>[.<routeId>].<prop>` properties and defaults, `add_kamelet`, `load_kamelets_from_dir`, built-in `timer-source`, `log-sink`, `log-action`, `insert-header-action`, `set-body-action`. Template local beans (`spec.template.beans`, created per Kamelet route with the registered bean factories, `{{beanName}}` resolves to the route's bean). Pipes/KameletBindings become routes: Kamelet refs, uris and non-Kamelet refs (Strimzi `KafkaTopic` → `kafka:`, Knative `Channel`/`Broker` → in-process `vm:` channels, Kubernetes `Service` → `http://`, `Endpoint`, custom kinds via `register_pipe_ref_resolver`); endpoint `dataTypes` (`in`/`out` `format`, validated against the Kamelet's declared types, applied with `transformDataType` + `Content-Type`); `spec.errorHandler` `sink` (dead letter channel with redelivery parameters), `log`, `none`. cameleer-main loads Kamelets from `camel.main.kamelet-locations` (default `classpath:kamelets` = `./kamelets`; remote `github:` locations are skipped since there is no network access). |
| Saga (`saga()`: propagation REQUIRED/REQUIRES_NEW/MANDATORY/SUPPORTS/NOT_SUPPORTED/NEVER, completionMode AUTO/MANUAL, timeout, compensation/completion endpoints, options, `saga:complete`/`saga:compensate`) | ✅ | `processor::saga`. `CamelSagaService` trait; `InMemorySagaService` (default; compensation/completion endpoints called in reverse step order with the options and `Long-Running-Action` as headers, retried `maxRetryAttempts` times; timeout compensates a still running saga) and `LraSagaService` (Narayana-LRA compatible REST client: `start`, join with `Link`, `close`/`cancel`, embedded participant HTTP server; `lra::testing::MockLraCoordinator`). Plain `http://` coordinators only (no TLS), not durable. Rust DSL `saga().propagation(..).completion_mode(..).saga_timeout(..).compensation(uri).completion(uri).option(k, e)`; YAML `saga`. |
| Transformer / Validator (data types), `transformDataType` | ✅ | `processor::transformer`: `ctx.add_transformer(from, to, t)` (`json:Order`, `xml:Order`, `java:...` urns; `from = None` = any), `add_scheme_transformer`, `add_named_transformer`, `add_validator`; `data_format_transformer`, `endpoint_transformer`, `processor_transformer`, `predicate_validator`, `endpoint_validator`. Route `input_type(urn, validate)`/`output_type(urn, validate)` (YAML `inputType`/`outputType` `{urn, validate}`): the message data type (property `CamelMessageDataType`) is transformed automatically when it reaches a route declaring another type (e.g. `to("direct:x")`), with one-hop transformer chains; `ValidationException` on validation failure or missing validator, `IllegalArgumentException` when no transformer exists. Built-in data type transformers `text-plain`, `application-json`, `application-octet-stream`, `application-x-struct`. No Pipe/Kamelet data types, no transformers declared in YAML. |
| Service Call | ✅ | `service_call("name[/path]")` with static (`[name@]host:port,...`), custom or registry service discovery, healthy/blacklist/pass-through/custom filters, round-robin or random load balancer, `uri` template (`{host}`, `{port}`, `{name}`, `{path}`, or the service name replaced by `host:port`), `expression`, default `http://host:port/path`; `CamelServiceCall*` headers. YAML `serviceCall`. No DNS-SRV/Consul/Kubernetes discovery. |
| Script | ✅ | Rust DSL `.script(expr)` and YAML `script`: any registered language (simple, constant, jq, jsonpath, xpath, ...); the result is discarded. With `cameleer-script`, the YAML `script` step also runs `groovy`, `js`, `python`, `java`/`joor`, `mvel`... scripts as processors whose changes to the message, headers, properties and variables are kept. |
| Poll (Camel 4), Kamelet EIP, `removeVariables` | ✅ | `.poll(uri, timeout_ms)` / YAML `poll` (default timeout 20s, dynamic uri with `${..}`); `.kamelet("name?p=v")` / YAML `kamelet` (sends to `kamelet:`, component from `cameleer-yaml`); Rust DSL `.remove_variables(pattern)`. |
| Route templates | ✅ | Rust DSL (`add_route_template`, `TemplatedRouteBuilder`) and YAML/XML (`routeTemplate`, `templatedRoute`, `{{param:default}}`, `prefixId`, template beans via registered bean factories). Kamelets: see above. |
| Message history, tracer, route supervising | ✅ | `set_message_history` (also printed in the exhausted-failure log), `set_tracing` + backlog tracer, supervising route controller with back-off. |

## Error handling

| Feature | Status | Notes |
|---|---|---|
| DefaultErrorHandler, DeadLetterChannel, NoErrorHandler | ✅ | Redelivery headers `CamelRedelivered`, `CamelRedeliveryCounter` and `CamelRedeliveryMaxCounter`. Redelivery happens at the point of failure. |
| Redelivery policy (delay, back-off, collision avoidance, delayPattern, max delay, retryWhile, onRedelivery, onExceptionOccurred, onPrepareFailure, log levels, asyncDelayedRedelivery) | ✅ | With `asyncDelayedRedelivery` (Rust DSL and YAML `redeliveryPolicy`) the consumer thread of asynchronous consumers (seda, timer) is released during the delay: a replacement consumer thread takes over and the waiting exchange finishes on the released thread (Cameleer processors are synchronous, so this is a thread hand-off rather than a scheduler continuation). Otherwise, and for synchronous callers, the delay blocks the calling thread. |
| `onException` (hierarchy matching, cause chain, onWhen, handled, continued, useOriginalMessage/Body, route, builder and route configuration scope) | ✅ | Exception "classes" are string kinds with a registered parent hierarchy (`register_kind_parent`). Route configurations for Rust DSL routes: `ctx.add_route_configuration(Some("id") / None, \|c\| ...)` with `on_exception`, `on_completion`, `intercept*` and `error_handler`, selected with `route_configuration_id("a,b*")`; a configuration without id applies to every route that names none (context-wide `onException`). |
| Error handler scope across direct sub-routes | ✅ | The failing route's error handler applies. A handled exchange stops the caller too (`CamelErrorHandlerHandled`). An exhausted exchange is not redelivered again by the caller. |
| deadLetterHandleNewException | ✅ | |
| doTry / doCatch (onWhen) / doFinally | ✅ | No error-handler redelivery inside doTry. |
| onCompletion (onCompleteOnly, onFailureOnly, onWhen, mode before/after consumer, route/global scope) | ✅ | |
| ProducerTemplate failures | ✅ | Returned as `CamelExecutionException` with the original exception as the cause. |

## Languages

| Language | Status | Notes |
|---|---|---|
| Simple | ✅ | Operators (`==`, `=~`, `!=`, `>`..., `contains`, `~~`, `regex`, `in`, `range`, `is`, `startsWith`, `endsWith`, `&&`, `||`), ternary, elvis, OGNL navigation and method calls, `bodyAs`/`headerAs`, `date`/`date-with-timezone`, `properties`, `env`/`sys`, `file:*` functions, string/math/collection functions, `jsonpath`/`jq`/`xpath` inline, `bean`, `ref`. `${bodyType}` returns the Java class name Camel would report (`java.lang.String`, `java.lang.Integer`/`Long`, `java.lang.Double`, `java.lang.Boolean`, `byte[]`, `java.util.ArrayList`, `java.util.LinkedHashMap`). `${type:org.apache.camel.Exchange.FILE_NAME}` gives the `Exchange` constants (and `java.lang.Integer/Long.MIN_VALUE/MAX_VALUE`, `Boolean.TRUE/FALSE`). `${messageHistory}` / `${messageHistory(false)}`. `date-with-timezone` accepts region ids (`Europe/Paris`); `${date:...}` uses the default time zone (`TZ`). |
| Constant, Header, ExchangeProperty, Variable, Ref, Bean/Method | ✅ | |
| Tokenize (token, regex, pair, xml) | ✅ | |
| JSONPath | ✅ | A built-in implementation (Jayway-style syntax). |
| XPath | ✅ | `cameleer-xml` (registered by `cameleer-main`; cameleer-core alone keeps a small subset): complete, namespace-aware XPath 1.0 — all 13 axes, node tests, positional predicates, unions, variables and the 27 core functions — over a full XML 1.0 parser (namespaces, DTD internal subset entities and attribute defaults, CDATA, PIs, comments, UTF-8 / ISO-8859-1 / UTF-16, XXE and entity-expansion protection). `resultType` `String` (trimmed unless `trim=false`) / `nodeset` / `node` / `number` / `Integer` / `boolean`, `namespace` prefix bindings (`p=uri,...`, JSON, YAML `[{key, value}]`, Rust DSL `cameleer_xml::xpath_ns`), `headerName`/`source`, `saxon=false` (`saxon=true` fails: no XPath 2.0). Camel functions `in:body()`, `in:header()`, `out:*`, `function:properties()`, `function:simple()` and variables `$header` (header, property, variable), `$env:X`, `$system:X`. Unprefixed names match no-namespace nodes only, as in JAXP. |
| XQuery | ✅ | `cameleer-xml` (`xquery` module): XQuery 1.0 main modules without schema support, plus common 3.x conveniences. Prolog (`declare namespace`, default element/function namespace, `declare variable ... [external [:= default]]`, recursive `declare function local:f($a as T) as T`, boundary-space, default order), FLWOR (`for ... at`, `let`, `where`, `[stable] order by ... descending empty greatest`, 3.0 `group by` / `count`), `some`/`every`, `if`, `typeswitch`, 3.0 `try`/`catch`, the XPath 2.0 expression language on the cameleer-xml DOM (sequences, `to`, general/value/node comparisons, integer/decimal/double arithmetic with `div`/`idiv`/`mod`, `union`/`intersect`/`except`, `instance of`/`treat as`/`castable as`/`cast as` for `xs:string`, `integer` (+ subtypes), `decimal`, `double`, `float`, `boolean`, `date`, `dateTime`, `time`, `anyURI`, `untypedAtomic`; all 13 axes, wildcards and kind tests, predicates), 3.x `||` and `!`, direct and computed element/attribute/text/comment/PI/document constructors, ~90 F&O functions (strings, regex `matches`/`replace`/`tokenize` via the built-in engine, aggregates, sequences, `doc()` for local files, `current-dateTime`, date accessors, `deep-equal`, `serialize`, `parse-xml`, `math:*`...). `xquery` language (`resultType` DOM (default, serialized XML) / String / List / Node / Bytes / Integer / Double / Boolean, `namespace(s)`, `headerName`/`source`, `stripsAllWhiteSpace`) and `xquery:` component (`xquery:file:q.xq?resultsFormat=DOM|String|Bytes|List`, `classpath:`/`ref:`, `contentCache`, `namespacePrefixes`; Saxon `configuration*`/`staticQueryContext`/`moduleURIResolver`/`parameters`/`properties` accepted and ignored). External variables as in camel-saxon: `$in.body`, `$in.headers.NAME`, `$NAME` (exchange property, then header, then variable); declared atomic types cast string values, declared node types parse XML. XQuery 3.1 maps (`map{}`, `map:*`), arrays (`[]`, `array{}`, `array:*`), lookups (`?key`, `?*`), inline functions, named function references (`f#1`), dynamic calls, partial application, `=>`, `for-each`/`filter`/`fold-left`/`fold-right`/`for-each-pair`/`sort`/`apply`/`function-lookup`; library modules (`module namespace`, `import module ... at` relative to the query file, or `register_module`); arbitrary-precision `xs:decimal`; date/time/duration arithmetic (`dateTime - dateTime`, `date + yearMonthDuration`, `duration * n`, `duration div duration`), duration accessors, `adjust-*-to-timezone`, `dateTime()`; Update Facility basics (`insert`/`delete`/`replace [value of]`/`rename node`, `copy ... modify ... return`; an updating query returns the updated document). Not implemented: schema import/validation and user-defined types, full-text, XQuery consumer. |
| jq | ✅ | `language::jq`: the jq 1.7 language — full grammar (paths, slices, optional `?`, pipes, comma, alternative `//`, arithmetic, comparisons, all assignment operators, object/array construction, string interpolation and `@format` strings, `if/elif/else`, `try/catch`, `reduce`, `foreach`, `label/break`, variables and destructuring with `?//`, function definitions with filter/`$` parameters and recursion, `$__loc__`, `$ENV`) and the builtins of the jq 1.7 manual (paths, `getpath/setpath/delpaths/pick`, `to_entries/with_entries`, math, `sort_by/group_by/unique_by/min_by/max_by`, strings, regex `test/match/capture/scan/splits/sub/gsub` with jq flags, `@base32d` and the other formats, dates `strftime/strptime/mktime/gmtime/todate/fromdate`, streaming `tostream/fromstream/truncate_stream`, `limit/first/last/nth/until/while/repeat/combinations/walk`, `ltrimstr/rtrimstr/trim`, `abs`, `toarray` ...) plus camel-jq's `header()`, `property()`, `variable()`. Modules (`import`/`include`) and `input`/`inputs` streams are not applicable to one exchange. |
| File language | ✅ | Available in file component options and as Simple `${file:...}` functions. |
| JavaScript (`js`, `javascript`) | ✅ | `cameleer-script`: built-in tree-walking interpreter (no GraalJS), evaluated on the caller's thread (deep recursion continues on an extra stack segment; call depth limit 900, `RangeError` beyond). ES5.1 plus ES2015-2023 as used in route scripts: `var`/`let`/`const`, functions, closures, arrow functions, default/rest parameters, spread, destructuring, template literals and tagged templates (`strings.raw`, `String.raw`), classes (`extends`/`super`, static members, getters/setters, private `#fields`, computed and `[Symbol.iterator]` members), object-literal and `Object.defineProperty` accessors, prototypes, `this`/`call`/`apply`/`bind`, optional chaining, `??`, optional catch binding, labels, `switch`, `try`/`catch`/`finally`, generators (`function*`, `yield`, `yield*`, `next`/`return`/`throw`), iterators and `for...of` over any iterable, `Promise` (`then`/`catch`/`finally`, `all`/`allSettled`/`race`/`any`), `async`/`await` with a microtask queue and virtual-time `setTimeout`/`setInterval`/`queueMicrotask` (all drained before the result is returned), async generators whose `await`s suspend through the microtask queue (`next()` returns promises, requests are queued) and `for await` (async iterables, `Symbol.asyncIterator`, sync iterables of promises), `Map`/`Set`/`WeakMap`/`WeakSet`, `Symbol` (`Symbol.for`, `description`, well-known symbols), `Proxy` (`get`/`set`/`has`/`deleteProperty`/`ownKeys`/`apply`/`construct` traps, `Proxy.revocable`) and `Reflect` (`get`/`set`/`has`/`ownKeys`/`apply`/`construct`/`defineProperty`/`deleteProperty`/`getPrototypeOf`...), `BigInt` (literals `10n`/`0xffn`, arithmetic, comparisons, bitwise ops, `BigInt.asIntN`/`asUintN`, mixing errors), `ArrayBuffer`, typed arrays (`Int8`...`Float64Array`, `BigInt64Array`/`BigUint64Array`, `Uint8ClampedArray`; shared buffers, `subarray`/`slice`/`set`/`fill`/`sort`/`map`/`filter`/`from`/`of` and the read-only array methods; `Uint8Array` results become byte bodies) and `DataView` (all getters/setters, endianness), `TextEncoder`/`TextDecoder`, `Intl` for en-US, en-GB, de-DE and fr-FR (`NumberFormat` decimal/currency/percent/unit/compact, fraction and significant digits, grouping, `formatToParts`; `DateTimeFormat` dateStyle/timeStyle and component options, `timeZone` via `cameleer_core::tz`; `toLocaleString`/`toLocaleDateString`/`toLocaleTimeString`; `PluralRules`, `Collator` (accents, `numeric`), `ListFormat`, `RelativeTimeFormat`), `globalThis`, `structuredClone` (cycles, `Map`/`Set`/`Date`/typed arrays, `DataCloneError` for functions), regular expressions via the built-in engine (named groups `(?<name>)` with `match.groups`, `$<name>` replacements and replacer `groups` argument, lookbehind, `index`/`input` on matches, `matchAll`, global `exec` with `lastIndex`), ES modules (`import`/`export` incl. default, namespace, renamed, `export * from`, JSON modules, dynamic `import()`; paths relative to the importing module, the script (`scriptDir` option), the working directory or `classpath:`; modules are evaluated once per evaluation). Builtins: `Math`, `JSON`, `Object` (incl. `fromEntries`), `Array`, `String`, `Number`, `Date` (UTC), `parseInt`/`parseFloat`/`isNaN`, URI functions, `console`, `Java.type` for safe JDK classes (`java.lang.Integer`/`Long`/`Double`/`Boolean`/`String`/`Math`, `java.util.ArrayList`/`HashMap`/`LinkedHashMap`/`HashSet`/...; others are refused). Bindings: `exchange` (Java-like accessors `getIn()`, `getMessage()`, `getBody()`, `getHeader()`, `setHeader()`, `getProperty()`, `setProperty()`, `getVariable()`...), `request`/`message`, `body`, `headers`, `properties`/`exchangeProperties`, `variables`, `camelContext`, `log`. Out of scope by design: Node/browser host APIs (`fs`, `require`, `fetch`, DOM), `SharedArrayBuffer`/`Atomics`, WebAssembly, `Temporal`, `Intl` locales other than the four listed (they fall back to en-US formatting), and JVM interop beyond the `Java.type` classes listed. |
| Groovy | ✅ | `cameleer-script` interpreter for Groovy as used in route scripts: `def`/typed declarations, methods, closures (`it`, trailing closures, `delegate` in `with`), GStrings, `?.`, `?:`, `*.`, GPath (`list.name`), list/map literals, spread map entries / named arguments `[*:m, k: v]` / `f(*:m)`, safe index `list?[i]` / `map?['k']`, ranges and range indexing, `as` conversions, `=~`/`==~`/`~/re/`, `<<`, `in`, `<=>`, `switch` statements and Groovy 4 switch expressions (`case 1..3 ->`, `case String ->`, `case { it > 3 } ->`, regexes, lists, enum constants, `yield`) with `isCase`, command expressions (`println x`), varargs (`int... xs`), methods and constructors overloaded by parameter type (runtime multi-dispatch picking the most specific candidate: exact types, subclasses, interfaces, boxing/widening, `null`, varargs; `MissingMethodException` when none applies), classes (fields and properties with generated getters/setters, `this.@field`, constructors incl. named-argument ones, instance and static methods/fields, `static {}` blocks, inheritance with `super`, abstract classes, interfaces with default methods, traits, nested classes, operator overloading `plus`/`minus`/`leftShift`/`compareTo`..., `equals`/`toString`/`hashCode`, `getClass()`, `properties`, `hasProperty`, `propertyMissing`/`methodMissing`), metaprogramming (`Type.metaClass.m = {..}`, `Type.metaClass.static.m`, per-instance `obj.metaClass.m`, `Expando`, categories with `use(Category) {..}`), enums (constants with constructor arguments, fields, methods, `values()`/`valueOf()`/`name()`/`ordinal()`), AST transforms `@ToString`, `@EqualsAndHashCode`, `@TupleConstructor`, `@Canonical`, `@Immutable` (read-only instances, `ReadOnlyPropertyException`), `@Builder` (`Type.builder().x(..).build()`), `@Singleton` (`Type.instance`), `@Sortable`, `@AutoClone`, `@Slf4j`/`@Log`/`@Log4j`/`@CommonsLog` (`log`), `@Field`; `@CompileStatic`/`@TypeChecked` are accepted; `JsonSlurper`/`JsonOutput`, `StringBuilder`, GDK methods (`each`, `collect`, `findAll`, `find`, `inject`, `sum`, `groupBy`, `collectEntries`, `times`, `upto`...). Same bindings as JavaScript; `request.headers.foo = 'x'` / `exchange.in.body = ..` mutate the exchange in `script`. `@Grab`/`@Grapes` fail with a clear error (no JVM, dependencies cannot be loaded). Out of scope by design: static type checking (`@CompileStatic`/`@TypeChecked` and generics are not checked — the dynamic semantics apply), compile-time AST transforms beyond the listed ones, and JVM/third-party classes beyond the bundled GDK subset. |
| Python | ✅ | `cameleer-script` interpreter for Python 3 as used in route scripts: indentation-based blocks, `if`/`elif`/`else`, `for`/`while` (+`else`), `def` (defaults, `*args`, keyword-only parameters, `**kwargs`, positional-only `/`), `lambda`, closures, `global`/`nonlocal`, decorators (functions and classes), tuple unpacking, list/dict/set comprehensions and generator arguments, slicing, f-strings with format specs and the self-documenting `{x=}`, `%` and `str.format`, assignment expressions (`:=`), `try`/`except`/`else`/`finally`, `raise` (also bare `raise`), chained comparisons, structural pattern matching (`match`/`case` with literal, capture, wildcard, value, sequence (`*rest`), mapping (`**rest`), class (positional via `__match_args__`, keyword), or-, as- patterns and guards), classes (`__init__`, methods, class attributes, inheritance incl. several bases, `super()`, `@staticmethod`, `@classmethod`, `@property` + `@x.setter`, special methods `__str__`/`__repr__`/`__eq__`/`__lt__`/`__add__`.../`__len__`/`__getitem__`/`__setitem__`/`__contains__`/`__iter__`/`__call__`, user exception classes), metaclasses (`metaclass=` with `__new__`/`__init__`/`__call__`, inherited metaclasses, metaclass methods on the class, `type(name, bases, ns)`), generators (`yield`, `yield from`, `send`, `next(it, default)`, `StopIteration`), `with` (context managers, exception suppression, several items), `async def`/`await` coroutines with an event loop (`asyncio.run`, `gather`, `sleep` (virtual time), `create_task`, `wait_for`), async generators with `async for`, `async with`; imports of user modules (`import a.b [as c]`, `from m import x [as y]`, `from m import *`, relative `from .m import x`, packages with `__init__.py`; resolved relative to the importing module, the script (`scriptDir` option), the working directory, `src/main/resources`, `PYTHONPATH` or `classpath:`) and of the bundled modules `json`, `math`, `re`, `collections` (`Counter`, `defaultdict`, `OrderedDict`, `namedtuple`, `deque`, `ChainMap`), `functools` (`reduce`, `partial`, `lru_cache`/`cache`, `wraps`, `cmp_to_key`, `singledispatch`), `itertools` (`count`, `cycle`, `repeat`, `islice`, `chain`, `accumulate`, `takewhile`/`dropwhile`, `product`, `permutations`, `combinations`, `groupby`, `zip_longest`, `starmap`, `pairwise`, `batched`...), `contextlib` (`contextmanager`, `asynccontextmanager`, `suppress`, `closing`, `nullcontext`, `ExitStack`), `dataclasses` (`@dataclass(frozen, order, eq, repr, init)`, `field(default, default_factory, init, repr, compare)`, `__post_init__`, `asdict`, `astuple`, `replace`, `fields`, `FrozenInstanceError`), `asyncio`, `typing`, `abc`, `operator`, `copy`, `sys`, `string`, `time`, `random`; common builtins (`len`, `str`, `int`, `float`, `range`, `sum`, `min`, `max`, `sorted`, `enumerate`, `zip`, `map`, `filter`, `isinstance`, `getattr`/`hasattr`, `iter`/`next`...). Out of scope by design: C extensions and third-party packages (no pip), OS / process / network / threading modules (`os`, `subprocess`, `socket`, `threading`), dict keys are strings (non-string keys are converted), call depth beyond 900. |
| OGNL | ✅ | `cameleer-script`: Camel root object (`request`, `response`, `exchange`, `properties`, `property(name)`, `headers`, `body`, `context`), property/index navigation, method calls, static member access `@java.lang.Math@max(1, 2)` / `@Integer@MAX_VALUE` (JDK classes known to the interpreter), `#var`/`#this`/`#root`, `{a, b}` lists, `#{k: v}` maps, projection `.{expr}`, selection `.{? expr}`/`.{^ }`/`.{$ }`, `in`/`not in`, `eq`/`gt`/`and`/`bor`/`band`/`xor`/... word operators, ternary, `,` sequences. Arbitrary Java classes are not available (no JVM). |
| MVEL | ✅ | `cameleer-script`: Camel root object, property navigation, method calls, inline lists/maps/arrays, `contains`, `is`, `empty`, `nil`, projections `(name in list)`, `;`-separated statements, assignments, typed declarations (`int x = 5`, `java.util.List l = ...`), `with (obj) { a = 1, b += 2 }` blocks, `if`/`else`, `foreach`/`for (x : list)`, `while`, `def` functions; interceptors (`@Name statement`: `cameleer_script::mvel::MvelInterceptor` with `before` (reads/changes the script variables) and `after` (sees / replaces the statement value) hooks, bound in the Camel registry under the name or registered process-wide with `register_interceptor`); MVEL 2 templates (`render_template`): `@{expr}`, `@if{}`/`@elseif{}`/`@else{}`/`@end{}`, `@foreach{x : list, y : list2}..@end{sep}`, `@code{}`, `@comment{}`, `@include{'file'}` (relative to the template), `@declare{'name'}` + `@includeNamed{'name'}`, `@@` escapes — also as the `mvel:` component (see below). |
| SpEL | ✅ | `cameleer-script`: `#{...}` templates (a lone `#{expr}` returns the typed value) or plain expressions; Camel root object (`request`, `response`, `exchange`, `message`, `body`, `headers`, `properties`), `#root`/`#this`/`#var`, `@bean` references resolved from the Camel registry (plain values, and bean methods bound as `name.method` via `bind_bean_method`: `@calc.twice(21)`), `T(Type)` static calls, `new` for JDK collection types, `?.`, `?:`, ternary, `{1, 2}` lists, `{k: v}` maps, selection `.?[]`/`.^[]`/`.$[]`, projection `.![]`, `matches`, `between`, `instanceof`, word operators (`eq`, `div`, `mod`...). Arbitrary Java classes/constructors are not available (no JVM). |
| DataSonnet | ✅ | `cameleer-script`: a Jsonnet interpreter (objects with late binding: `self`, `super`, `$`, hidden `::` and forced-visible `:::` fields, `+:` merges, object inheritance with `+`, method fields, object `local`s and `assert`s, lazy fields that resolve after a later `+`; arrays, `local`, functions with defaults/named arguments, `if`/`then`/`else`, array/object comprehensions, slices, `%` formatting, `error`, `assert`, text blocks, local `import`/`importstr`/`importbin` (absolute, working-directory relative or `classpath:` paths)) with `payload`, `cml.header()`, `cml.exchangeProperty()`, `cml.variable()`, `cml.properties()`, `std.extVar(name)` (script option `extVar.<name>` (JSON or text), else the exchange variable / header / property of that name) and top-level arguments (a program evaluating to a function is called with `tla.<name>` options, exchange variables / headers, `payload` or the parameter defaults), the complete `ds` library: the top-level functions (`map`/`filter`/`flatMap`/`foldLeft`/`reduce`/`groupBy`/`orderBy`/`distinctBy`/`mapObject`/`mapEntries`/`filterObject`/`entriesOf`/`combine`/`contains`/`find`/`match`/`matches`/`scan`/`replace`/`splitBy`/`joinBy`/`select`/`remove`/`removeMatch`/`read`/`write`/`readUrl`/`zip`/`unzip`/`range`/`parse*`/`uuid`/`is*`/`max(By)`/`min(By)`/`sizeOf`/`typeOf`...), `ds.arrays`, `ds.binaries`, `ds.crypto` (`hash` MD5/SHA-1/SHA-256/384/512, `hmac`, AES `encrypt`/`decrypt` (CBC with a random IV prefix, or ECB) via cameleer-tls), `ds.datetime` (`now`, `today`, `format`, `parse` with Java patterns or `unix`, `changeTimeZone` with zoneinfo region ids or offsets via `cameleer_core::tz`, `plus`/`minus` ISO periods, `compare`, `daysBetween`, `toLocalDate`/`toLocalTime`/`toLocalDateTime`, `atBeginningOf*`, `isLeapYear`), `ds.jsonpath.select`, `ds.math`, `ds.numbers`, `ds.objects`, `ds.period`, `ds.strings`, `ds.url`, `ds.xml.flattenContents`; and the common `std` functions (`map`, `filter`, `foldl`, `length`, `join`, `split`, `objectFields(All)`, `objectHas(All)`, `toString`, `parseJson`, `manifestJsonEx`, `format`, `sort`, `uniq`, `mergePatch`...). Media types (`bodyMediaType` / `outputMediaType`, with parameters such as `application/csv; separator=;`): `application/json` (default; output with sorted keys, sjsonnet's default), `text/plain`, `application/xml` (BadgerFish-style `@attr` / `$` text with the DataSonnet XML plugin options `TextValueKey`, `AttributeCharacterKey`, `CDataValueKey` (output), `NamespaceSeparator`, `NamespaceDeclarations.<prefix>` (read: namespace URIs mapped to the declared prefixes, `@xmlns` declarations; write: declared on the root), `RootElement`, `OmitXmlDeclaration`, `XmlVersion`, `Encoding`, `AutoEmptyElements`, `NullAsEmptyElement`, `indent`), `application/csv` (header row or `header=false`), `application/x-www-form-urlencoded`, `application/x-java-object` (returns the value); `resultType` converts. Out of scope by design: CDATA sections and mixed-content ordering keys when reading XML (text is merged into the text key), Java classes/libraries plugged into DataSonnet. |
| CSimple | ✅ | `csimple` is an alias of the Simple language (Simple is already evaluated natively). |
| jOOR / Java (`joor`, `java`) | ✅ | `cameleer-script`: Java snippets are interpreted (no JDK compiler): bindings `exchange`, `message`, `body`, `optionalBody`, `bodyAs(Type.class)`, `optionalBodyAs`, `header`/`headerAs(name[, default], Type.class)`, `exchangeProperty(As)`, `variable(As)`; class / record / enum / interface declarations and methods in the snippet (fields, constructors overloaded by parameter types, static members and static methods, inheritance, abstract classes, interfaces with default methods, generic classes and methods (erased: type arguments are not checked), records with canonical / compact constructors, accessors, `toString`/`equals`/`hashCode`, enums with fields, constructors and methods, `switch` on enum constants), typed locals and `var`, `final`, `if`/`for`/enhanced `for`/`while`/`do`, labeled `break`/`continue`, `switch` statements (colon and arrow forms) and switch expressions (`case A, B ->`, `yield`, type patterns `case String s ->`), ternary, string concatenation, Java integer division and `ArithmeticException`, `char` as a numeric type (char literals, `c + 1`, `c - '0'`, `c++`, `(char)`/`(int)` casts, char arithmetic into arrays), casts, `instanceof` with pattern binding, overload resolution by static type where the snippet declares it (`List.remove(Integer)`/`remove((Object) x)` remove the element, `remove(int)` the index), lambdas and method references, `new ArrayList<>()`/`HashMap`/`LinkedHashMap`/`HashSet`/`StringBuilder`, sorted `TreeMap`/`TreeSet` (ordered on every change, natural order or a `Comparator`, `firstKey`/`floorKey`/`ceilingKey`/`headMap`/`tailMap`/`subMap`/`pollFirst`/`descendingMap`...), arrays (`new int[3]`, `new int[]{..}`, `{..}` initializers, multi-dimensional literals), text blocks, `return`, `throw`/`try`/`catch` (multi-catch)/`finally`, and the common JDK API (`String`, `String.format`, `String.join`, `Integer`/`Long`/`Double`/`Boolean`/`Character`, `Math`, `List`/`Map`/`Set`/`Arrays`/`Collections`/`Objects`/`Optional`, streams (`stream().filter().map().collect(Collectors.toList()/joining/groupingBy/...)`, `IntStream`), `Comparator`, functional interfaces, `java.time` (`LocalDate`, `LocalDateTime`, `LocalTime`, `Duration`, `Period`, `ChronoUnit`, `DayOfWeek`, `Month`, `DateTimeFormatter.ofPattern` / ISO formatters, parsing and formatting)). Out of scope by design: compile-time checks (generics, checked exceptions, missing returns), reflection, threads, and JDK / third-party classes beyond the listed API (no JVM interop). |

## Data formats

| Data format | Status | Notes |
|---|---|---|
| JSON (`json`, aliases `jackson`, `gson`...) | ✅ | Pretty print. No POJO binding: values map to `Value`. |
| CSV | ✅ | RFC 4180. |
| Base64, Hex, String (charset) | ✅ | |
| GZip, Zip/Deflate, ZipFile | ✅ | Built-in deflate implementation. |
| XML (`jacksonXml`, aliases `xml`, `jaxb`) | ✅ | A generic Jackson `XmlMapper`-style value ⇄ XML mapping (no schema binding): keys → elements, arrays repeat, `rootName`, `prettyPrint`, `xmlDeclaration`, `contentTypeHeader`. Annotation equivalents as options: `attributes=a,b` / `@`-prefixed keys (`attributePrefix`, also applied on unmarshal when set) → attributes (`@JacksonXmlProperty(isAttribute=true)`), `textProperty` (`@JacksonXmlText`), `properties=key:xmlName` with `p:local` / `{uri}local` names (`localName`/`namespace`), `namespace` (default) + `namespaces=p=uri` declared on the root, generated prefixes for other `{uri}` names, `wrappers=key:item` (`@JacksonXmlElementWrapper`, unwrapped on unmarshal). With `cameleer-soap` registered (as in `cameleer_main::new_main`), `jaxb` is the schema-typed binding below. |
| URL-encoded form | ✅ | |
| Custom data formats (registry) | ✅ | |
| Protobuf (`protobuf`) | ✅ | `cameleer-grpc`. Runtime `.proto` parsing (proto3 + basic proto2, imports from the same directory, nested types, enums, `repeated`/packed, `map`, `oneof`, well-known types Empty/Timestamp/Duration/Struct/Value/ListValue/wrappers/Any) instead of generated classes: `instanceClass` names the message type, `protoFile` the schema. Bodies are `Value` objects keyed by field name; `contentTypeFormat=native` (wire bytes) or `json` (proto3 JSON mapping, lowerCamelCase names). Rust DSL: `cameleer_grpc::protobuf(file, type)`; name-based references with options (YAML `marshal: {protobuf: {instanceClass, protoFile}}`, `dataformat:protobuf:marshal?...`) are resolved through the core data format factory; without options it reads `CamelProtobuf*` headers or `camel.dataformat.protobuf.*` properties. No extensions, no proto2 groups. |
| Custom data format factories | ✅ | `cameleer_core::dataformat::register_data_format_factory`: crates contribute formats by name so options on name references work (Rust DSL `DataFormatDefinition::new(name).option(..)`, YAML `marshal: {name: {...}}`, `dataformat:name:marshal?...`). |
| Avro (`avro`, `avroJackson`) | ✅ | `cameleer-dataformats`. JSON schema parser (records/errors, enums, arrays, maps, unions, fixed, namespaces, aliases, defaults; logical types date, time/timestamp millis/micros, local-timestamp, decimal (bytes/fixed), uuid, duration), binary encoding (a bare datum like Camel), Avro JSON encoding (`encoding=json`) and Object Container Files (`encoding=container`, `codec=null`/`deflate`, `syncInterval`; unmarshal reads the writer schema). Options `schema`, `schemaFile`, `instanceClassName` (selects a named type, or a registry schema), `contentTypeHeader`, `logicalTypeConversions` (ISO-8601 dates / decimal strings, default true). `avroJackson` marshals JSON text, `jsonView=true` unmarshals to JSON text. No snappy/zstd codecs, no reader/writer schema resolution. |
| Bindy (`bindyCsv`/`bindy`, `bindyFixed`, `bindyKvp`) | ✅ | `cameleer-dataformats`. Record layouts are descriptors instead of annotations: YAML/JSON (`descriptor`, `descriptorFile`, or `classType` naming a registry bean / descriptor file) or the `BindyDescriptor`/`BindyField` builder (`bindy::bind_descriptor`). CSV `separator`, `skipFirstLine`, `generateHeaderColumns`, `quote`/`quoting`/`removeQuotes`, `crlf`; fixed `length`, `paddingChar`, `align`, `delimited` fields, `clip`, `ignoreTrailingChars`/`ignoreMissingChars`, `skipHeader`/`skipFooter`; kvp `keyValuePairSeparator`, `pairSeparator`, `tag`; fields `pos`, `type` (int, decimal, date with `pattern`, boolean...), `precision`, `trim`, `defaultValue`, `required`, `columnName`. Unmarshal gives objects (`unwrapSingleInstance`). No `@Link`/`@OneToMany` sections, header/footer records. |
| YAML (`yaml`, `snakeYaml`) | ✅ | `cameleer-dataformats`, cameleer-yaml's parser. SnakeYAML-like output (`defaultFlowStyle` AUTO/BLOCK/FLOW, `prettyFlow`), safe constructor (application tags rejected unless `allowAnyType` or `typeFilter`; tags never construct types), `maxAliasesForCollections`. |
| Tar (`tarFile`), ZipFile multi-entry | ✅ | `cameleer-dataformats`. ustar + pax (long names, GNU long names on read), `usingIterator` (body = array of entry contents, names in `CamelTarFileEntryNames`/`CamelZipFileEntryNames`), `allowEmptyDirectory`, `preservePathElements`, `CamelFileName`; an object body marshals one entry per key. Replaces core's single-entry `zipFile`. No aggregation strategies. |
| Crypto (`crypto`) | ✅ | `cameleer-dataformats`. AES/DES/DESede with ECB, CBC, CTR, CFB, OFB, GCM and PKCS5/No padding, `keyRef`/`key`/`CamelCryptoKey`, `initVectorRef`/`initVector`, `inline` IV (Camel's length-prefixed layout), `shouldAppendHMAC` with `macAlgorithm` HmacSHA1/256/384/512. |
| PGP (`pgp`) | ✅ | `cameleer-dataformats`. OpenPGP v4: RSA, Ed25519 (EdDSA), ECDSA/ECDH (Curve25519, P-256, P-384) keys from armored/binary keyrings (`keyFileName`, `encryptionKeyRing`, `#bean`); S2K-protected secret keys (AES/3DES); PKESK + SEIPD v1 with MDC (`integrity`), legacy SED, decryption of GnuPG's OCB packets; ZIP/ZLIB; one-pass signatures and verification (`signatureKeyFileName`, `signatureKeyUserid(s)`, `signaturePassword`, `signatureVerificationOption`), `keyUserid(s)`, `password`, `armored`, `algorithm`, `hashAlgorithm`, `compressionAlgorithm`, `CamelPGPDataFormat*` headers. Verified against GnuPG 2.4 both ways. No CAST5/IDEA, BZip2, v6 keys, SEIPD v2, password (SKESK) messages, cleartext signatures. |
| CBOR (`cbor`) | ✅ | `cameleer-dataformats`. RFC 8949 (preferred serialization, indefinite lengths, bignums, tags dropped). |
| Thrift (`thrift`) | ✅ | `cameleer-dataformats`. Runtime IDL (`schema`/`idlFile` + `instanceClass`) instead of generated classes: structs, unions, exceptions, enums, typedefs, `const` (evaluated: numbers, strings, lists, sets, maps, struct literals, constant / `Enum.VALUE` references), field defaults (applied on marshal and unmarshal), `service` definitions (methods, `throws`, `oneway`, `extends`); `contentTypeFormat` binary (TBinaryProtocol), compact (TCompactProtocol), json (TJSONProtocol) or sjson (TSimpleJSONProtocol-style plain JSON). |
| ASN.1 (`asn1`) | ✅ | `cameleer-dataformats`. `usingIterator` splits BER record streams; generic BER/DER ⇄ `Value` tree; typed mode with a runtime ASN.1 module compiler instead of jASN1/ASN1bean classes (`schema` / `moduleFile` + `clazzName`): X.680 modules with EXPLICIT/IMPLICIT/AUTOMATIC tag defaults, type and value assignments (INTEGER, OID with named components), BOOLEAN, INTEGER (named numbers), ENUMERATED, REAL (X.690 binary/decimal/special), NULL, OCTET/BIT STRING (named bits), OBJECT IDENTIFIER, RELATIVE-OID, all character string and time types, SEQUENCE/SET (OPTIONAL, DEFAULT omitted in DER and filled on decode, COMPONENTS OF, extension markers, version groups, DER SET ordering), SEQUENCE OF / SET OF, CHOICE, ANY, tagged types and references; BER input (indefinite lengths, constructed strings). Verified against the X.690 Annex A PersonnelRecord encoding. Constraints are parsed but not checked; information object classes / parameterized types are skipped. |
| iCal (`iCal`) | ✅ | `cameleer-dataformats`. RFC 5545 parse/emit (folding, parameters, TEXT escaping), `validating`. |
| MIME multipart (`mimeMultipart`) | ✅ | `cameleer-dataformats`. Attachments in the `CamelAttachments` property; `multipartSubType`, `multipartWithoutAttachment`, `headersInline`, `includeHeaders`, `binaryContent`. |
| uniVocity (`univocityCsv`, `univocityTsv`, `univocityFixed`) | ✅ | `cameleer-dataformats`. CSV aliases core `csv` with translated options (`delimiter`, `quote`, `quoteEscape`, `quoteAllFields`, `lineSeparator`/`normalizedLineSeparator`, `nullValue`, `comment`, `skipEmptyLines`, whitespace trimming) plus `numberOfRecordsToRead` and `emptyValue`; TSV (`escapeChar`) and fixed width (`fieldLengths`, `padding`, character-stream records with `skipTrailingCharsUntilNewline` and `recordEndsOnNewline`); all with `headers`, `headersDisabled`, `headerExtractionEnabled`, `asMap`, `numberOfRecordsToRead`, `emptyValue`, `lazyLoad` (rows are returned as a list). |
| Fory (`fory`) | ✅ | `cameleer-dataformats`. Apache Fory **xlang** protocol for dynamic values: header bitmap + language, reference flags (`refTracking`, back references), xlang type ids (bool, int8..64, var/zigzag/SLI int64, float16/32/64, string with Latin-1/UTF-16/UTF-8 coders, enum, list/set with element headers, chunked maps, named/numeric structs, binary, local date, timestamp, duration, primitive arrays), meta strings (LOWER_SPECIAL / LOWER_UPPER_DIGIT_SPECIAL / FIRST_TO_LOWER / ALL_TO_LOWER / UTF-8, murmur3 hash header, back references). Objects with a `@type` key are `NAMED_STRUCT`s; field names for reading come from `structTypes` (`ns.Type=f1,f2;...`). `requireClassRegistration` (default false), `threadSafe`/`allowAutoWiredFory`/`unmarshalType` accepted. Compatible mode (`compatible=true` / `compatibleMode=COMPATIBLE`): `NAMED_COMPATIBLE_STRUCT` with shared TypeDef meta (meta-share index markers, 8-byte global header with size + murmur3 hash, field infos with name encodings / nullable flags / field types), readers match fields by name without `structTypes`. `DECIMAL` (`{"@decimal": "1.25"}`, small and big unscaled encodings; read as decimal text). Extension types (`NAMED_EXT`) via registered `ExtSerializer`s (`{"@ext": "ns.Name", ...}`). Protocol edition `xlangSpec`: `CURRENT` (default) writes the current xlang specification — one-byte header (xlang / out-of-band bits), the renumbered internal type-id table (incl. reading `UINT8`..`TAGGED_UINT64`, `BFLOAT16`, `NONE`, unsigned / bfloat16 arrays) and numeric user type ids as a separate varuint after the internal id, also inside TypeDefs; `LEGACY` writes the Fory 0.10/0.11 layout (bitmap + language byte, `(user_id << 8) | internal_id`). Readers detect the edition from the header. Remaining gaps: Java native mode and out-of-band buffers are not applicable to dynamic values (rejected); `FLOAT8` and the union types of the current spec are rejected. |
| Barcode (`barcode`) | ✅ | `cameleer-dataformats`, own codecs instead of ZXing, covering every `barcodeFormat` value (ZXing's `BarcodeFormat`). **Encode** (the formats ZXing writes): QR Code (versions 1-40, `errorCorrectionLevel` L/M/Q/H, numeric/alphanumeric/Kanji (JIS X 0208 via the Shift_JIS mapping)/byte modes with UTF-8 ECI, Reed-Solomon, mask selection by the four penalty rules), Data Matrix ECC 200 (square 10x10..144x144 and rectangular 8x18..16x48, `dataMatrixShape` NONE/SQUARE/RECTANGLE with ZXing's size order) through a port of ZXing's `HighLevelEncoder` (ASCII with digit pairs and upper shift, C40, Text, ANSI X12, EDIFACT and Base 256 with the ISO/IEC 16022 Annex P look-ahead, ZXing's capacity-dependent end-of-data handling, macro 05/06 headers, 253-state padding), Aztec (compact and full-range up to 32 layers, ZXing-style 33% EC, ZXing's optimal high-level encoder: all non-dominated states per character with latches, shifts, the four punctuation pairs and binary shift, ties broken in ZXing's order, ECI 26), PDF417 (`PDF_417`: ZXing's AUTO/TEXT/BYTE/NUMERIC compaction (`pdf417Compaction`) including its sub-mode rules, UTF-8 via ECI 927/26, error correction levels 0-8 (`errorCorrectionLevel`, default 2) with Reed-Solomon over GF(929), ZXing dimension choice (2-30 columns, rows up to 90), row indicators, start/stop patterns and the three cluster tables, ZXing rendering incl. 90° rotation for portrait requests), Code 128 (sets A/B/C), Code 39, Code 93 (full ASCII via the shift characters, two check characters, termination bar), Codabar (start/stop A-D or T/N/*/E, default A), ITF, EAN-13, EAN-8, UPC-A, UPC-E (number system 0/1, check digit via the UPC-A expansion); ZXing-style rendering (`width`/`height`, integer scaling, quiet zones) to PNG (own encoder over cameleer-core zlib + CRC-32), GIF (own LZW encoder, gray palette) or JPG (own baseline JPEG encoder), `imageType`. MAXICODE, RSS_14, RSS_EXPANDED and UPC_EAN_EXTENSION are decode-only, as in ZXing (marshalling them fails like ZXing's `MultiFormatWriter`). **Decode** (unmarshal, header `BarcodeFormat`, `ERROR_CORRECTION_LEVEL` for QR, `UPC_EAN_EXTENSION` + `SUGGESTED_PRICE`/`ISSUE_NUMBER` for add-ons) from PNG (all color types / bit depths / filters, Adam7), GIF (87a/89a, interlace, transparency) and baseline JPEG (SOF0/SOF1, subsampled YCbCr, restart intervals); `multiple=true` decodes every symbol of an image (the image, then overlapping halves of it recursively, like ZXing's `GenericMultipleBarcodeReader` searches beside each result; distinct results as a list of `{text, BarcodeFormat, ...}` maps, headers `BarcodeFormat` (list) and `BarcodeCount`). Camera-like images (photographs): luminance from gray/RGB/palette, noise-adaptive smoothing, ZXing's `HybridBinarizer` (8x8 block black points, 5x5 neighbourhood averaging, global-histogram fallback for small images), a copy deskewed by the dominant edge orientation for linear/stacked symbols; QR via ZXing's `FinderPatternFinder` (1:1:3:1:1 runs cross-checked vertically, horizontally and diagonally, best-triangle selection), alignment-pattern search for version >= 2 and a perspective transform for grid sampling, mirrored symbols, version information, Shift_JIS guessing for byte segments without ECI; Data Matrix via `WhiteRectangleDetector`, sides fitted as lines through the outermost dark edge points, size and orientation chosen by scoring the L finder/timing pattern under perspective (square and rectangular), every encodation (incl. EDIFACT unlatch alignment and implicit end) and macro 05/06; Aztec via the bull's-eye (ring runs, blob-checked centre, ring rotation from a polar profile, least-squares perspective fit refined at the predicted ring corners, the fitted outer sides and the reference grid) in all eight orientations; MaxiCode with ZXing's pure-image reader (`extractPureBits` over the dark bounding box, ZXing's bit-number table, GF(64) Reed-Solomon of the primary and even/odd secondary blocks, modes 2-5 with the structured carrier message, code sets A-E with shifts/latches/lock/NS) plus, beyond ZXing, a photograph detector (bull's-eye confirmed on eight rays, orientation-module and module-fit search with a refined projective map); linear symbols (Code 128, Code 39, Code 93, Codabar, ITF, EAN-13/UPC-A, EAN-8, UPC-E with 2/5-digit add-ons, RSS-14 incl. stacked via pairs collected over rows, RSS Expanded with ZXing's finder sequences, checksum and AI decoders/`FieldParser`) on band-averaged, locally thresholded scan lines (rows and columns, both directions) with ZXing's variance limits and quiet zones; PDF417 rows with chained codeword slots following perspective foreshortening and per-codeword row tracking by cluster, per-row voting, RS errors + erasures, text/byte/numeric/ECI decoding, Macro PDF417 blocks skipped. **Tested** with synthetic photographs (perspective warp, arbitrary rotations incl. a 14-angle sweep, scaling, Gaussian and box blur, lighting gradients, additive noise up to sigma 18, our JPEG encoder at quality 60, and all combined) for QR (incl. version 10), Data Matrix (incl. 4 regions), Aztec (compact and full-range), PDF417, Code 128, Code 93, Codabar, ITF, EAN-13, EAN-8, UPC-E, EAN-13 with a 5-digit add-on, RSS-14 and RSS Expanded (every combination decodes) and MaxiCode (all but the strong-keystone cases, which ZXing cannot read from photographs at all); multiple-symbol images (a 2x2 grid of QR/Data Matrix/Code 128/EAN-13, a photographed row of three); images from ZXing's blackbox suite (embedded as fixtures with attribution: qrcode-1/2/3, datamatrix-1/2, aztec-2, pdf417-2/3, code128-1, ean13-1, codabar-1, code93-1, ean8-1, itf-1, upce-1, upcean-extension-1 (incl. a phone photograph), maxicode-1 (modes 2, 3, 4, mixed code sets), rss14-1 (incl. stacked), rssexpanded-1 — all decode). Verified against ZXing's writer test vectors for Code 93 (incl. full ASCII), Codabar, ITF, EAN-8 and UPC-E (module strings), ZXing's Data Matrix `HighLevelEncodeTestCase` (48 codeword vectors for every encodation, incl. Base 256 lengths up to 277), ZXing's Aztec `EncoderTest` (high-level bit strings, binary-shift length rules and the complete compact 3-layer Wikipedia symbol, module-exact), full QR symbols from ZXing's encoder tests (module-exact), the ZXing Aztec reference symbols, the PDF417 cluster tables and ZXing's PDF417 high-level vectors, ISO/IEC 18004 Annex I, ISO/IEC 16022 codewords, ZXing's six rectangular Data Matrix blackbox symbols (module-exact) and `SymbolInfo` vectors, ZXing's RSS width tables (every character value round-trips through the ISO/IEC 24724 width routines), Pillow-written PNG/GIF/JPEG files. Differences from ZXing: the PDF417 text encoder resets to Alpha after a final pad in Punctuation sub-mode (ZXing keeps Punctuation, which misencodes text after a following byte shift); the multiple-symbol search splits the image into overlapping halves instead of using result points; Data Matrix's optional `MinimalEncoder` (ZXing's `DATA_MATRIX_COMPACT` hint, not a Camel option) is not ported. |
| JAXB binding (`jaxb`) | ✅ | `cameleer-soap`. No generated classes: XML ⇄ `Value` typed by an XML Schema (`contextPath` = XSD location(s) or a `.properties` descriptor with `schema=` / `prefix.<p>=<ns>`; ints/longs → `Int`, decimal/float/double → `Float`, boolean → `Bool`, base64/hex → `Bytes`, dates as lexical strings, `maxOccurs>1` → arrays, `xs:list` → arrays, simple content + attributes → `{value, @attr}`, `xsi:nil` → null, extensions/groups/attribute groups resolved), `schema` validation on unmarshal and marshal (`UnmarshalException`/`MarshalException` with Xerces-style messages), `prettyPrint` (default true), `fragment`, `encoding`, `namespacePrefix` (`uri=prefix,...`), `partClass`/`partNamespace` (root element), `ignoreJAXBElement`, `attributePrefix` (`@`) or `plainAttributes`, `filterNonXmlChars`. Without a schema: structural mapping (text-only elements → strings, repeated siblings → arrays). Overrides core's `jaxb` alias of `jacksonXml`. Polymorphism: `xsi:type` selects the derived type on unmarshal (recorded as `@xsi:type`) and marshal (writes `xsi:type`), substitution group members (transitive, typeless members inherit the head's type) bind where the head is declared. `typedDates=true` maps `date`/`dateTime`/`time` to `XMLGregorianCalendar`-like objects (`year`...`millisecond`, `timezone` minutes) and `duration` to an object; marshal also takes epoch millis. Schemas from registry beans: `contextPath`/`schema` = `#bean` / `ref:` / `bean:` naming a `String`/`Value::String` XSD, a `cameleer_soap::xsdmodel::SchemaSet` or a compiled `cameleer_xml::xsd::Schema` (the factory holds a weak context reference). No generated classes, so `ObjectFactory`/`@XmlRootElement` map to the schema's global elements. |
| FHIR (`fhirJson`, `fhirXml`) | ✅ | `cameleer-soap`. FHIR R4 serialization rules without HAPI: `resourceType` ⇄ root element, primitives `<x value=""/>` with `_x` id/extensions (aligned arrays for repeating primitives), repeating elements → arrays, boolean/integer/decimal JSON types, `Element.id`/`Extension.url` attributes, nested resources (`contained`, `Bundle.entry.resource`...) wrapped, narrative `div` XHTML passthrough. An embedded type registry (names, types, cardinality, spec order) covers the common data types (incl. Dosage, ElementDefinition) and Patient, Practitioner, Organization, Observation, Encounter, Condition, Procedure, Medication, MedicationRequest, AllergyIntolerance, DiagnosticReport, Immunization, Location, Device, ServiceRequest, Appointment, Binary, Basic, StructureDefinition, Bundle, OperationOutcome, CapabilityStatement, Parameters (other resources: heuristics); `fhirVersion=DSTU3` / `R5` switch to per-release definitions of the resources that changed shape (Observation, Encounter, Condition, AllergyIntolerance, MedicationRequest, Patient, Dosage; R5 `CodeableReference`), R4B = R4. XML output is written in the specification's element order (unknown elements last). Decimals keep their lexeme: exact `f64`s unmarshal to `Float`, others (`185.00`) to `String` and are written back as numbers; hand-built values are retyped by the registry (numeric/boolean strings → JSON numbers/booleans). Unmarshal → resource `Value`; marshal accepts a value or FHIR JSON/XML text (so the pair converts between encodings). Options `fhirVersion`, `prettyPrint`, `suppressNarratives`, `omitResourceId`, `encodeElements`, `dontEncodeElements`, `stripVersionsFromReferences`. Profile validation (`cameleer_soap::fhir::validation`, also the fhir component's `validate/resource?profile=`): registry checks (unknown elements, single vs repeating, primitive JSON types and lexical forms) plus `StructureDefinition` snapshot/differential `min`/`max`, `type` (choice suffixes, primitive kinds, `Reference.targetProfile`), `fixed[x]`, `pattern[x]`, `maxLength`, profile `type`; slices and FHIRPath invariants are not evaluated. |

## Components

| Component | Status | Key options / notes |
|---|---|---|
| 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:*`, `.`, `|`; keyrefs resolved against the referenced key on an ancestor-or-self or descendant scope; `cvc-identity-constraint.*` messages), substitution groups (transitive, `abstract` elements, typeless members take the head's type), `xsi:type` (QName in the instance's namespace context, derivation from the declared type checked — `cvc-elt.4.*`, abstract complex types require it — `cvc-type.2`), `redefine` (types, groups and attribute groups replaced, self references bound to the original). `SchemaValidationException` lists every error with Xerces codes and line/column (`cvc-complex-type.2.4.a: Invalid content was found starting with element 'x'. One of '{a, b}' is expected.`), also in the `CamelValidationErrors` property. Not checked: `block`/`final`, ID/IDREF uniqueness. |
| 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`, `||`, regex/string/sequence/date functions, `format-date`, `xs:*` constructors) and get the XSLT 2.0 core: `for-each-group` (`group-by`/`group-adjacent`/`group-starting-with`/`group-ending-with`, sorting, `current-group()`/`current-grouping-key()`), `xsl:function`, `xsl:sequence`, sequence-typed variables (`as`), `analyze-string` + `regex-group()`, tunnel parameters, `result-document` (files + `TransformResult::secondary`), `next-match`, `namespace`, `perform-sort`, `value-of separator`, `unparsed-text()`. Endpoint: `xslt:file:a.xsl` (also `classpath:`, `ref:`), `output=string\|bytes\|DOM\|file` (`CamelXsltFileName`, `deleteOutputFile`), `contentCache`, `failOnNullBody`, `allowTemplateFromHeader` (`CamelXsltStylesheet`/`CamelXsltResourceUri`); exchange properties and headers are passed as `xsl:param`s; transformer-factory options are ignored. Not implemented: schema-aware XSLT, XSLT 3.0 (`iterate`, `try`, maps, streaming — rejected with a `TransformerConfigurationException` unless an `xsl:fallback` is present). |
| 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|WANT|REQUIRE` (or `clientAuthentication` in the parameters); the verified client certificate is exposed as headers `CamelHttpSslClientCert` (leaf PEM), `CamelHttpSslClientCertSubjectName`, `CamelHttpSslClientCertIssuerName`, `CamelHttpSslClientCertSerialNo`, `CamelHttpSslClientCertNotBefore`, `CamelHttpSslClientCertNotAfter`. |
| 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|require|verify-ca|verify-full`, `ssl=true`, `sslrootcert`, client certificates with `sslcert`/`sslkey` (PEM or DER PKCS#8, encrypted with `sslpassword`) or a PKCS#12 `sslkey`); no COPY or binary format. `camel.datasource[.<name>].url` properties in cameleer-main. Transactions: `JdbcTransactionPolicy` via `.policy(...)` (the core `transacted()` uses `cameleer_core::transaction` managers; cameleer-sql does not register one). |
| 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](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](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|deflate` for requests (producer) and responses (consumer, when accepted by the client). Authentication (`authenticationType`): `JWT` (producer sends an HMAC256/384/512-signed bearer JWT from `jwtSecret` / `jwtIssuer` / `jwtSubject`; the consumer verifies signature, algorithm, expiry and issuer/subject, else UNAUTHENTICATED) and `GOOGLE` (service-account JWT access tokens: RS256 self-signed JWT with audience `https://<host>/<service>` from the `serviceAccountResource` JSON key, cached until 5 minutes before expiry). `routeControlledStreamObserver=true`: routes answer through a `ResponseObserver` (`cameleer_grpc::component::response_observer(&exchange)`, property `CamelGrpcResponseObserver`) with `on_next` / `on_completed` / `on_error`. HTTP/1.1 `Upgrade: h2c` (RFC 7540 3.2): consumers accept upgrade requests (101, `HTTP2-Settings` applied, the request served as stream 1) besides prior knowledge; producers with `negotiationType=PLAINTEXT_UPGRADE` upgrade (`H2Connection::connect_upgrade`). Remaining gaps: Google auth uses self-signed JWT access tokens only (no OAuth2 token exchange / scopes); no JWT verification for `GOOGLE` on the consumer side. The HTTP/2 client/server (`cameleer_grpc::h2`) are public for reuse. |
| 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`), `TApplicationException`s, `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_FAILURE`s 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|extract`): jobs.insert + jobs.get polling (`jobPollInterval`, `jobTimeout`), `sourceUris` / `CamelGoogleBigQuerySourceUris` (or a list body), `sourceFormat` (CSV, NEWLINE_DELIMITED_JSON...), `skipLeadingRows`, `fieldDelimiter`, `writeDisposition`, `createDisposition`, `autodetect`; `destinationUris`, `destinationFormat`, `printHeader`, `compression`; job errors raise `BigQueryException`. Tables and datasets (Cameleer operations): createTable (`tableSchema` / `CamelGoogleBigQueryTableSchema` list / JSON / `name:TYPE`, `timePartitioningField` / `timePartitioningType`, `clusteringFields`, `tableDescription`, `expirationMs`), getTable, listTables, deleteTable, createDataset (`datasetLocation`), listDatasets, deleteDataset (`deleteContents`); `createTableIfNotExists` on streaming inserts. |
| 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). |

## DSLs

| DSL | Status | Notes |
|---|---|---|
| Rust fluent DSL (equivalent of the Java DSL) | ✅ | `end()` with no open block is tolerated, as in the Java DSL. Route configurations: `ctx.add_route_configuration(...)` + `route_configuration_id(...)`. |
| YAML DSL | ✅ | All EIPs of the Rust DSL incl. marshal/unmarshal, `routeConfiguration` (onException, onCompletion, intercepts, errorHandler), top-level `errorHandler`, beans via registered factories, line/column error messages. Throttle needs a constant maximum; Kamelet, Pipe and KameletBinding resources (and `kamelet:` uris) are supported; options the core does not model (e.g. `executorService`) are ignored. |
| XML DSL | ✅ | `cameleer-yaml/src/xml.rs` converts XML to the YAML model and reuses the YAML step handlers, so coverage follows the YAML DSL. |
| REST DSL (Rust) | ✅ | See the rest component. |
| REST DSL in YAML | ✅ | `rest`/`restConfiguration` in YAML and XML (registered by `cameleer-main`), OpenAPI document. `rest` elements loaded before the context starts become routes at startup, so a `restConfiguration` from any file (earlier or later) applies. |

## Management and tooling

| Feature | Status | Notes |
|---|---|---|
| Route statistics, in-flight repository | ✅ | `RouteStats`, `inflight_count`, controlbus `stats`. |
| JMX-style management, health checks, dev console | ✅ | `managed_context()` (route/processor statistics, operations, JSON + Prometheus export), health check registry (context/routes/consumers, readiness/liveness), dev console `/q/health`, `/q/metrics`, `/q/dev/*` with route start/stop/suspend/resume. No JMX (not applicable). |
| `cameleer-main` runner (`application.properties`, route discovery, `duration-max-*`) | ✅ | |
| CLI `cameleer` (Camel JBang equivalent) | ✅ | `cameleer_main::cli` / `cameleer` binary: `init` (route `.yaml`/`.xml`, `.kamelet.yaml`, `.pipe.yaml`, `.integration.yaml`, `.properties` templates), `run` (files or the current directory, `application.properties/yaml`, `--profile`, `--dev` hot reload of changed route files, `--background`, `--name`, `--prop`, `--console`, `--port`, `--trace`, `--max-*`), `export` (standalone Cargo project embedding the routes and configuration with `include_str!`, depending on cameleer-main by path — crates.io is not reachable), `bind` (Pipe from Kamelets/uris with steps, `--property source.k=v`, `--error-handler`), `ps`, `stop` (`--all`), `get routes/context/health/endpoints`, `cmd start-route/stop-route/suspend-route/resume-route/reset-stats/reload`, `log` (`--follow`, `--tail`), `trace`, `catalog components/languages/kamelets`, `version`. Like JBang, running integrations publish `$CAMEL_HOME/<pid>.json` status files, log to `<pid>.log` and take commands from `<pid>-action.json` (`cameleer_main::local`); `get --url` queries a management server instead. No Maven/Gradle export, `jbang` plugins or Kubernetes deployment. |
| Spring Boot / Quarkus integration, Camel K | ✅ | There is no JVM, so the frameworks themselves do not apply; cameleer-main provides what they provide to Camel. **Spring Boot / Quarkus**: `application.properties` and `application.yaml` (nested keys flattened, multi-document), profiles (`camel.main.profile`, `spring.profiles.active`, `quarkus.profile`, env `SPRING_PROFILES_ACTIVE`/`QUARKUS_PROFILE`/`CAMEL_MAIN_PROFILE`; `application-<profile>.*`, `%profile.key`, YAML `spring.config.activate.on-profile`), `camel.springboot.*`/`quarkus.camel.*` aliases of `camel.main.*`, `server.port`/`quarkus.http.port`, relaxed binding (case, dashes, underscores) including `CAMEL_*` environment variables (`CAMEL_COMPONENT_SEDA_QUEUE_SIZE`), generic `camel.component.<scheme>.<option>` component options (core: defaults for the endpoint options of that scheme, `ctx.set_component_option`), `camel.beans.<name>=#class:<type>` beans via registered bean factories (the auto-configured beans/DI of Spring), health/metrics/dev consoles (`camel.server.*`, the Actuator/Quarkus `/q/*` endpoints). **Camel K**: `kind: Integration` resources run in-process by cameleer-main (`spec.flows`, inline `spec.sources` yaml/xml, `spec.configuration` properties, `traits.camel.properties`, `traits.environment.vars`, `metadata.name` as the name; Kubernetes-only traits are ignored with a log line; `dependencies` are informational since every component is built in); Pipes/Kamelets as above; `cameleer run`/`cameleer ps`/`cameleer log` replace `kamel run/get/logs`. No operator, Kubernetes deployment or image build. |

## Known deviations found by the conformance suite

These differences are kept on purpose (documented, not fixed):

1. In Simple text, `$${` is an escape that produces a literal `${`.
2. TLS comes from the in-house `cameleer-tls` crate (unaudited; see its limitations), not a mature library.
3. Asynchronous delays (`asyncDelayed`, `asyncDelayedRedelivery`) hand the waiting exchange to its (released) thread and start a replacement consumer thread, instead of scheduling a continuation on a scheduler pool.

## Found a problem?

If something on this page doesn't match what Cameleer does, or you hit a bug while building
with it, please help fix it, whether you are a person or a coding agent:
[open an issue](https://github.com/pmsudhi/cameleer/issues/new) that describes what you saw,
then fork the repository, fix it, add or update a test, run `cargo test --workspace`, and open
a pull request. [CONTRIBUTING.md](https://github.com/pmsudhi/cameleer/blob/main/CONTRIBUTING.md)
explains the ground rules.