schema stringclasses 471
values | key stringlengths 0 203 | description stringlengths 0 4.37k | object stringlengths 2 322k |
|---|---|---|---|
camel-yaml-dsl.json | idempotent-repository | Sets the reference name of the message id repository | {"type": "string"} |
camel-yaml-dsl.json | remove-on-failure | Sets whether to remove or keep the key on failure. The default behavior is to remove the key on failure. | {"type": "boolean"} |
camel-yaml-dsl.json | skip-duplicate | Sets whether to skip duplicates or not. The default behavior is to skip duplicates. A duplicate message would have the Exchange property org.apache.camel.Exchange#DUPLICATE_MESSAGE set to a Boolean#TRUE value. A none duplicate message will not have this property set. | {"type": "boolean"} |
camel-yaml-dsl.json | org.apache.camel.model.InputTypeDefinition | Set the expected data type of the input message. If the actual message type is different at runtime, camel look for a required Transformer and apply if exists. If validate attribute is true then camel applies Validator as well. Type name consists of two parts, 'scheme' and 'name' connected with ':'. For Java type 'name' is a fully qualified class name. For example {code java:java.lang.String} , {code json:ABCOrder} . It's also possible to specify only scheme part, so that it works like a wildcard. If only 'xml' is specified, all the XML message matches. It's handy to add only one transformer/validator for all the transformation from/to XML. | {"type": "object", "properties": {"id": {"type": "string"}, "urn": {"type": "string"}, "validate": {"type": "boolean"}}, "required": ["urn"]} |
camel-yaml-dsl.json | description | Sets the id of this node | {"type": "string"} |
camel-yaml-dsl.json | id | Sets the id of this node | {"type": "string"} |
camel-yaml-dsl.json | urn | The input type URN. | {"type": "string"} |
camel-yaml-dsl.json | validate | Whether if validation is required for this input type. | {"type": "boolean"} |
camel-yaml-dsl.json | org.apache.camel.model.InterceptDefinition | Intercepts a message at each step in the route | {"type": "object", "properties": {"disabled": {"type": "boolean"}, "id": {"type": "string"}, "inherit-error-handler": {"type": "boolean"}, "steps": {"type": "array", "items": {}}}} |
camel-yaml-dsl.json | description | Sets the id of this node | {"type": "string"} |
camel-yaml-dsl.json | disabled | Whether to disable this EIP from the route during build time. Once an EIP has been disabled then it cannot be enabled later at runtime. | {"type": "boolean"} |
camel-yaml-dsl.json | id | Sets the id of this node | {"type": "string"} |
camel-yaml-dsl.json | org.apache.camel.model.InterceptFromDefinition | Intercepts incoming messages | {"oneOf": [{"type": "string"}, {"type": "object", "properties": {"disabled": {"type": "boolean"}, "id": {"type": "string"}, "inherit-error-handler": {"type": "boolean"}, "steps": {"type": "array", "items": {}}, "uri": {"type": "string"}}}]} |
camel-yaml-dsl.json | description | Sets the id of this node | {"type": "string"} |
camel-yaml-dsl.json | disabled | Whether to disable this EIP from the route during build time. Once an EIP has been disabled then it cannot be enabled later at runtime. | {"type": "boolean"} |
camel-yaml-dsl.json | id | Sets the id of this node | {"type": "string"} |
camel-yaml-dsl.json | uri | Intercept incoming messages from the uri or uri pattern. If this option is not configured, then all incoming messages is intercepted. | {"type": "string"} |
camel-yaml-dsl.json | org.apache.camel.model.InterceptSendToEndpointDefinition | Intercepts messages being sent to an endpoint | {"oneOf": [{"type": "string"}, {"type": "object", "properties": {"after-uri": {"type": "string"}, "disabled": {"type": "boolean"}, "id": {"type": "string"}, "inherit-error-handler": {"type": "boolean"}, "skip-send-to-original-endpoint": {"type": "string"}, "steps": {"type": "array", "items": {}}, "uri": {"type": "string"}}}], "required": ["uri"]} |
camel-yaml-dsl.json | after-uri | After sending to the endpoint then send the message to this uri which allows to process its result. | {"type": "string"} |
camel-yaml-dsl.json | description | Sets the id of this node | {"type": "string"} |
camel-yaml-dsl.json | disabled | Whether to disable this EIP from the route during build time. Once an EIP has been disabled then it cannot be enabled later at runtime. | {"type": "boolean"} |
camel-yaml-dsl.json | id | Sets the id of this node | {"type": "string"} |
camel-yaml-dsl.json | skip-send-to-original-endpoint | If set to true then the message is not sent to the original endpoint. By default (false) the message is both intercepted and then sent to the original endpoint. | {"type": "string"} |
camel-yaml-dsl.json | uri | Intercept sending to the uri or uri pattern. | {"type": "string"} |
camel-yaml-dsl.json | org.apache.camel.model.LoadBalanceDefinition | Balances message processing among a number of nodes | {"type": "object", "properties": {"custom-load-balancer": {}, "disabled": {"type": "boolean"}, "failover": {}, "id": {"type": "string"}, "inherit-error-handler": {"type": "boolean"}, "random": {}, "round-robin": {}, "steps": {"type": "array", "items": {}}, "sticky": {}, "topic": {}, "weighted": {}}} |
camel-yaml-dsl.json | description | Sets the id of this node | {"type": "string"} |
camel-yaml-dsl.json | disabled | Whether to disable this EIP from the route during build time. Once an EIP has been disabled then it cannot be enabled later at runtime. | {"type": "boolean"} |
camel-yaml-dsl.json | id | Sets the id of this node | {"type": "string"} |
camel-yaml-dsl.json | inherit-error-handler | Sets whether or not to inherit the configured error handler. The default value is true. You can use this to disable using the inherited error handler for a given DSL such as a load balancer where you want to use a custom error handler strategy. | {"type": "boolean"} |
camel-yaml-dsl.json | org.apache.camel.model.LogDefinition | Logs the defined message to the logger | {"oneOf": [{"type": "string"}, {"type": "object", "properties": {"disabled": {"type": "boolean"}, "id": {"type": "string"}, "inherit-error-handler": {"type": "boolean"}, "log-name": {"type": "string"}, "logger": {"type": "string"}, "logging-level": {"type": "string", "default": "INFO", "enum": ["TRACE", "DEBUG", "INFO", "WARN", "ERROR", "OFF"]}, "marker": {"type": "string"}, "message": {"type": "string"}}}], "required": ["message"]} |
camel-yaml-dsl.json | description | Sets the id of this node | {"type": "string"} |
camel-yaml-dsl.json | disabled | Whether to disable this EIP from the route during build time. Once an EIP has been disabled then it cannot be enabled later at runtime. | {"type": "boolean"} |
camel-yaml-dsl.json | id | Sets the id of this node | {"type": "string"} |
camel-yaml-dsl.json | log-name | Sets the name of the logger | {"type": "string"} |
camel-yaml-dsl.json | logger | To refer to a custom logger instance to lookup from the registry. | {"type": "string"} |
camel-yaml-dsl.json | logging-level | Sets the logging level. The default value is INFO | {"type": "string", "default": "INFO", "enum": ["TRACE", "DEBUG", "INFO", "WARN", "ERROR", "OFF"]} |
camel-yaml-dsl.json | marker | To use slf4j marker | {"type": "string"} |
camel-yaml-dsl.json | message | Sets the log message (uses simple language) | {"type": "string"} |
camel-yaml-dsl.json | org.apache.camel.model.LoopDefinition | Processes a message multiple times | {"type": "object", "anyOf": [{}], "properties": {"break-on-shutdown": {"type": "boolean"}, "copy": {"type": "boolean"}, "disabled": {"type": "boolean"}, "do-while": {"type": "boolean"}, "expression": {}, "id": {"type": "string"}, "inherit-error-handler": {"type": "boolean"}, "steps": {"type": "array", "items": {}}}} |
camel-yaml-dsl.json | break-on-shutdown | If the breakOnShutdown attribute is true, then the loop will not iterate until it reaches the end when Camel is shut down. | {"type": "boolean"} |
camel-yaml-dsl.json | copy | If the copy attribute is true, a copy of the input Exchange is used for each iteration. That means each iteration will start from a copy of the same message. By default loop will loop the same exchange all over, so each iteration may have different message content. | {"type": "boolean"} |
camel-yaml-dsl.json | description | Sets the id of this node | {"type": "string"} |
camel-yaml-dsl.json | disabled | Whether to disable this EIP from the route during build time. Once an EIP has been disabled then it cannot be enabled later at runtime. | {"type": "boolean"} |
camel-yaml-dsl.json | do-while | Enables the while loop that loops until the predicate evaluates to false or null. | {"type": "boolean"} |
camel-yaml-dsl.json | expression | Expression to define how many times we should loop. Notice the expression is only evaluated once, and should return a number as how many times to loop. A value of zero or negative means no looping. The loop is like a for-loop fashion, if you want a while loop, then the dynamic router may be a better choice. | {} |
camel-yaml-dsl.json | id | Sets the id of this node | {"type": "string"} |
camel-yaml-dsl.json | org.apache.camel.model.MarshalDefinition | Marshals data into a specified format for transmission over a transport or component | {"type": "object", "properties": {"asn1": {}, "avro": {}, "barcode": {}, "base64": {}, "bindy": {}, "cbor": {}, "crypto": {}, "csv": {}, "custom": {}, "disabled": {"type": "boolean"}, "fhir-json": {}, "fhir-xml": {}, "flatpack": {}, "grok": {}, "gzip-deflater": {}, "hl7": {}, "ical": {}, "id": {"type": "string"}, "inherit-error-handler": {"type": "boolean"}, "jackson-xml": {}, "jaxb": {}, "json": {}, "json-api": {}, "lzf": {}, "mime-multipart": {}, "parquet-avro": {}, "pgp": {}, "protobuf": {}, "rss": {}, "soap": {}, "swift-mt": {}, "swift-mx": {}, "syslog": {}, "tar-file": {}, "thrift": {}, "tidy-markup": {}, "univocity-csv": {}, "univocity-fixed": {}, "univocity-tsv": {}, "xml-security": {}, "yaml": {}, "zip-deflater": {}, "zip-file": {}}} |
camel-yaml-dsl.json | description | Sets the id of this node | {"type": "string"} |
camel-yaml-dsl.json | disabled | Whether to disable this EIP from the route during build time. Once an EIP has been disabled then it cannot be enabled later at runtime. | {"type": "boolean"} |
camel-yaml-dsl.json | id | Sets the id of this node | {"type": "string"} |
camel-yaml-dsl.json | org.apache.camel.model.MulticastDefinition | Routes the same message to multiple paths either sequentially or in parallel. | {"type": "object", "properties": {"aggregation-strategy": {"type": "string"}, "aggregation-strategy-method-allow-null": {"type": "boolean"}, "aggregation-strategy-method-name": {"type": "string"}, "disabled": {"type": "boolean"}, "executor-service": {"type": "string"}, "id": {"type": "string"}, "inherit-error-handler": {"type": "boolean"}, "on-prepare": {"type": "string"}, "parallel-aggregate": {"type": "boolean"}, "parallel-processing": {"type": "boolean"}, "share-unit-of-work": {"type": "boolean"}, "steps": {"type": "array", "items": {}}, "stop-on-exception": {"type": "boolean"}, "streaming": {"type": "boolean"}, "synchronous": {"type": "boolean"}, "timeout": {"type": "string", "default": "0"}}} |
camel-yaml-dsl.json | aggregation-strategy | Refers to an AggregationStrategy to be used to assemble the replies from the multicasts, into a single outgoing message from the Multicast. By default Camel will use the last reply as the outgoing message. You can also use a POJO as the AggregationStrategy | {"type": "string"} |
camel-yaml-dsl.json | aggregation-strategy-method-allow-null | If this option is false then the aggregate method is not used if there was no data to enrich. If this option is true then null values is used as the oldExchange (when no data to enrich), when using POJOs as the AggregationStrategy | {"type": "boolean"} |
camel-yaml-dsl.json | aggregation-strategy-method-name | This option can be used to explicit declare the method name to use, when using POJOs as the AggregationStrategy. | {"type": "string"} |
camel-yaml-dsl.json | description | Sets the id of this node | {"type": "string"} |
camel-yaml-dsl.json | disabled | Whether to disable this EIP from the route during build time. Once an EIP has been disabled then it cannot be enabled later at runtime. | {"type": "boolean"} |
camel-yaml-dsl.json | executor-service | Refers to a custom Thread Pool to be used for parallel processing. Notice if you set this option, then parallel processing is automatic implied, and you do not have to enable that option as well. | {"type": "string"} |
camel-yaml-dsl.json | id | Sets the id of this node | {"type": "string"} |
camel-yaml-dsl.json | on-prepare | Uses the Processor when preparing the org.apache.camel.Exchange to be send. This can be used to deep-clone messages that should be send, or any custom logic needed before the exchange is send. | {"type": "string"} |
camel-yaml-dsl.json | parallel-aggregate | If enabled then the aggregate method on AggregationStrategy can be called concurrently. Notice that this would require the implementation of AggregationStrategy to be implemented as thread-safe. By default this is false meaning that Camel synchronizes the call to the aggregate method. Though in some use-cases this can be used to archive higher performance when the AggregationStrategy is implemented as thread-safe. | {"type": "boolean"} |
camel-yaml-dsl.json | parallel-processing | If enabled then sending messages to the multicasts occurs concurrently. Note the caller thread will still wait until all messages has been fully processed, before it continues. Its only the sending and processing the replies from the multicasts which happens concurrently. When parallel processing is enabled, then the Camel routing engin will continue processing using last used thread from the parallel thread pool. However, if you want to use the original thread that called the multicast, then make sure to enable the synchronous option as well. | {"type": "boolean"} |
camel-yaml-dsl.json | share-unit-of-work | Shares the org.apache.camel.spi.UnitOfWork with the parent and each of the sub messages. Multicast will by default not share unit of work between the parent exchange and each multicasted exchange. This means each sub exchange has its own individual unit of work. | {"type": "boolean"} |
camel-yaml-dsl.json | stop-on-exception | Will now stop further processing if an exception or failure occurred during processing of an org.apache.camel.Exchange and the caused exception will be thrown. Will also stop if processing the exchange failed (has a fault message) or an exception was thrown and handled by the error handler (such as using onException). In all situations the multicast will stop further processing. This is the same behavior as in pipeline, which is used by the routing engine. The default behavior is to not stop but continue processing till the end | {"type": "boolean"} |
camel-yaml-dsl.json | streaming | If enabled then Camel will process replies out-of-order, eg in the order they come back. If disabled, Camel will process replies in the same order as defined by the multicast. | {"type": "boolean"} |
camel-yaml-dsl.json | synchronous | Sets whether synchronous processing should be strictly used. When enabled then the same thread is used to continue routing after the multicast is complete, even if parallel processing is enabled. | {"type": "boolean"} |
camel-yaml-dsl.json | timeout | Sets a total timeout specified in millis, when using parallel processing. If the Multicast hasn't been able to send and process all replies within the given timeframe, then the timeout triggers and the Multicast breaks out and continues. Notice if you provide a TimeoutAwareAggregationStrategy then the timeout method is invoked before breaking out. If the timeout is reached with running tasks still remaining, certain tasks for which it is difficult for Camel to shut down in a graceful manner may continue to run. So use this option with a bit of care. | {"type": "string", "default": "0"} |
camel-yaml-dsl.json | org.apache.camel.model.OnCompletionDefinition | Route to be executed when normal route processing completes | {"type": "object", "properties": {"disabled": {"type": "boolean"}, "executor-service": {"type": "string"}, "id": {"type": "string"}, "inherit-error-handler": {"type": "boolean"}, "mode": {"type": "string", "default": "AfterConsumer", "enum": ["AfterConsumer", "BeforeConsumer"]}, "on-complete-only": {"type": "boolean"}, "on-failure-only": {"type": "boolean"}, "on-when": {}, "parallel-processing": {"type": "boolean"}, "steps": {"type": "array", "items": {}}, "use-original-message": {"type": "boolean"}}} |
camel-yaml-dsl.json | description | Sets the id of this node | {"type": "string"} |
camel-yaml-dsl.json | disabled | Whether to disable this EIP from the route during build time. Once an EIP has been disabled then it cannot be enabled later at runtime. | {"type": "boolean"} |
camel-yaml-dsl.json | executor-service | To use a custom Thread Pool to be used for parallel processing. Notice if you set this option, then parallel processing is automatic implied, and you do not have to enable that option as well. | {"type": "string"} |
camel-yaml-dsl.json | id | Sets the id of this node | {"type": "string"} |
camel-yaml-dsl.json | mode | Sets the on completion mode. The default value is AfterConsumer | {"type": "string", "default": "AfterConsumer", "enum": ["AfterConsumer", "BeforeConsumer"]} |
camel-yaml-dsl.json | on-complete-only | Will only synchronize when the org.apache.camel.Exchange completed successfully (no errors). | {"type": "boolean"} |
camel-yaml-dsl.json | on-failure-only | Will only synchronize when the org.apache.camel.Exchange ended with failure (exception or FAULT message). | {"type": "boolean"} |
camel-yaml-dsl.json | on-when | Sets an additional predicate that should be true before the onCompletion is triggered. To be used for fine grained controlling whether a completion callback should be invoked or not | {} |
camel-yaml-dsl.json | parallel-processing | If enabled then the on completion process will run asynchronously by a separate thread from a thread pool. By default this is false, meaning the on completion process will run synchronously using the same caller thread as from the route. | {"type": "boolean"} |
camel-yaml-dsl.json | use-original-message | Will use the original input message body when an org.apache.camel.Exchange for this on completion. The original input message is defensively copied, and the copied message body is converted to org.apache.camel.StreamCache if possible (stream caching is enabled, can be disabled globally or on the original route), to ensure the body can be read when the original message is being used later. If the body is converted to org.apache.camel.StreamCache then the message body on the current org.apache.camel.Exchange is replaced with the org.apache.camel.StreamCache body. If the body is not converted to org.apache.camel.StreamCache then the body will not be able to re-read when accessed later. Important: The original input means the input message that are bounded by the current org.apache.camel.spi.UnitOfWork . An unit of work typically spans one route, or multiple routes if they are connected using internal endpoints such as direct or seda. When messages is passed via external endpoints such as JMS or HTTP then the consumer will create a new unit of work, with the message it received as input as the original input. Also some EIP patterns such as splitter, multicast, will create a new unit of work boundary for the messages in their sub-route (eg the split message); however these EIPs have an option named shareUnitOfWork which allows to combine with the parent unit of work in regard to error handling and therefore use the parent original message. By default this feature is off. | {"type": "boolean"} |
camel-yaml-dsl.json | org.apache.camel.model.OnExceptionDefinition | Route to be executed when an exception is thrown | {"type": "object", "properties": {"continued": {}, "disabled": {"type": "boolean"}, "exception": {"type": "array", "items": {"type": "string"}}, "handled": {}, "id": {"type": "string"}, "inherit-error-handler": {"type": "boolean"}, "on-exception-occurred-ref": {"type": "string"}, "on-redelivery-ref": {"type": "string"}, "on-when": {}, "redelivery-policy": {}, "redelivery-policy-ref": {"type": "string"}, "retry-while": {}, "steps": {"type": "array", "items": {}}, "use-original-body": {"type": "boolean"}, "use-original-message": {"type": "boolean"}}} |
camel-yaml-dsl.json | continued | Sets whether the exchange should handle and continue routing from the point of failure. If this option is enabled then its considered handled as well. | {} |
camel-yaml-dsl.json | description | Sets the id of this node | {"type": "string"} |
camel-yaml-dsl.json | disabled | Whether to disable this EIP from the route during build time. Once an EIP has been disabled then it cannot be enabled later at runtime. | {"type": "boolean"} |
camel-yaml-dsl.json | exception | A set of exceptions to react upon. | {"type": "array", "items": {"type": "string"}} |
camel-yaml-dsl.json | handled | Sets whether the exchange should be marked as handled or not. | {} |
camel-yaml-dsl.json | id | Sets the id of this node | {"type": "string"} |
camel-yaml-dsl.json | on-exception-occurred-ref | Sets a reference to a processor that should be processed just after an exception occurred. Can be used to perform custom logging about the occurred exception at the exact time it happened. Important: Any exception thrown from this processor will be ignored. | {"type": "string"} |
camel-yaml-dsl.json | on-redelivery-ref | Sets a reference to a processor that should be processed before a redelivery attempt. Can be used to change the org.apache.camel.Exchange before its being redelivered. | {"type": "string"} |
camel-yaml-dsl.json | on-when | Sets an additional predicate that should be true before the onException is triggered. To be used for fine grained controlling whether a thrown exception should be intercepted by this exception type or not. | {} |
camel-yaml-dsl.json | redelivery-policy | Used for configuring redelivery options | {} |
camel-yaml-dsl.json | redelivery-policy-ref | Sets a reference to a redelivery policy to lookup in the org.apache.camel.spi.Registry to be used. | {"type": "string"} |
camel-yaml-dsl.json | retry-while | Sets the retry while predicate. Will continue retrying until predicate returns false. | {} |
camel-yaml-dsl.json | use-original-body | Will use the original input org.apache.camel.Message body (original body only) when an org.apache.camel.Exchange is moved to the dead letter queue. Notice: this only applies when all redeliveries attempt have failed and the org.apache.camel.Exchange is doomed for failure. Instead of using the current inprogress org.apache.camel.Exchange IN message we use the original IN message instead. This allows you to store the original input in the dead letter queue instead of the inprogress snapshot of the IN message. For instance if you route transform the IN body during routing and then failed. With the original exchange store in the dead letter queue it might be easier to manually re submit the org.apache.camel.Exchange again as the IN message is the same as when Camel received it. So you should be able to send the org.apache.camel.Exchange to the same input. The difference between useOriginalMessage and useOriginalBody is that the former includes both the original body and headers, where as the latter only includes the original body. You can use the latter to enrich the message with custom headers and include the original message body. The former wont let you do this, as its using the original message body and headers as they are. You cannot enable both useOriginalMessage and useOriginalBody. The original input message is defensively copied, and the copied message body is converted to org.apache.camel.StreamCache if possible (stream caching is enabled, can be disabled globally or on the original route), to ensure the body can be read when the original message is being used later. If the body is converted to org.apache.camel.StreamCache then the message body on the current org.apache.camel.Exchange is replaced with the org.apache.camel.StreamCache body. If the body is not converted to org.apache.camel.StreamCache then the body will not be able to re-read when accessed later. Important: The original input means the input message that are bounded by the current org.apache.camel.spi.UnitOfWork . An unit of work typically spans one route, or multiple routes if they are connected using internal endpoints such as direct or seda. When messages is passed via external endpoints such as JMS or HTTP then the consumer will create a new unit of work, with the message it received as input as the original input. Also some EIP patterns such as splitter, multicast, will create a new unit of work boundary for the messages in their sub-route (eg the split message); however these EIPs have an option named shareUnitOfWork which allows to combine with the parent unit of work in regard to error handling and therefore use the parent original message. By default this feature is off. | {"type": "boolean"} |
camel-yaml-dsl.json | use-original-message | Will use the original input org.apache.camel.Message (original body and headers) when an org.apache.camel.Exchange is moved to the dead letter queue. Notice: this only applies when all redeliveries attempt have failed and the org.apache.camel.Exchange is doomed for failure. Instead of using the current inprogress org.apache.camel.Exchange IN message we use the original IN message instead. This allows you to store the original input in the dead letter queue instead of the inprogress snapshot of the IN message. For instance if you route transform the IN body during routing and then failed. With the original exchange store in the dead letter queue it might be easier to manually re submit the org.apache.camel.Exchange again as the IN message is the same as when Camel received it. So you should be able to send the org.apache.camel.Exchange to the same input. The difference between useOriginalMessage and useOriginalBody is that the former includes both the original body and headers, where as the latter only includes the original body. You can use the latter to enrich the message with custom headers and include the original message body. The former wont let you do this, as its using the original message body and headers as they are. You cannot enable both useOriginalMessage and useOriginalBody. The original input message is defensively copied, and the copied message body is converted to org.apache.camel.StreamCache if possible (stream caching is enabled, can be disabled globally or on the original route), to ensure the body can be read when the original message is being used later. If the body is converted to org.apache.camel.StreamCache then the message body on the current org.apache.camel.Exchange is replaced with the org.apache.camel.StreamCache body. If the body is not converted to org.apache.camel.StreamCache then the body will not be able to re-read when accessed later. Important: The original input means the input message that are bounded by the current org.apache.camel.spi.UnitOfWork . An unit of work typically spans one route, or multiple routes if they are connected using internal endpoints such as direct or seda. When messages is passed via external endpoints such as JMS or HTTP then the consumer will create a new unit of work, with the message it received as input as the original input. Also some EIP patterns such as splitter, multicast, will create a new unit of work boundary for the messages in their sub-route (eg the split message); however these EIPs have an option named shareUnitOfWork which allows to combine with the parent unit of work in regard to error handling and therefore use the parent original message. By default this feature is off. | {"type": "boolean"} |
camel-yaml-dsl.json | org.apache.camel.model.OnFallbackDefinition | Route to be executed when Circuit Breaker EIP executes fallback | {"type": "object", "properties": {"disabled": {"type": "boolean"}, "fallback-via-network": {"type": "boolean"}, "id": {"type": "string"}, "inherit-error-handler": {"type": "boolean"}, "steps": {"type": "array", "items": {}}}} |
camel-yaml-dsl.json | description | Sets the id of this node | {"type": "string"} |
camel-yaml-dsl.json | disabled | Whether to disable this EIP from the route during build time. Once an EIP has been disabled then it cannot be enabled later at runtime. | {"type": "boolean"} |
camel-yaml-dsl.json | fallback-via-network | Whether the fallback goes over the network. If the fallback will go over the network it is another possible point of failure. It is important to execute the fallback command on a separate thread-pool, otherwise if the main command were to become latent and fill the thread-pool this would prevent the fallback from running if the two commands share the same pool. | {"type": "boolean"} |
camel-yaml-dsl.json | id | Sets the id of this node | {"type": "string"} |
camel-yaml-dsl.json | org.apache.camel.model.OptimisticLockRetryPolicyDefinition | To configure optimistic locking | {"type": "object", "properties": {"exponential-back-off": {"type": "boolean"}, "maximum-retries": {"type": "number"}, "maximum-retry-delay": {"type": "string", "default": "1000"}, "random-back-off": {"type": "boolean"}, "retry-delay": {"type": "string", "default": "50"}}} |
camel-yaml-dsl.json | exponential-back-off | Enable exponential backoff | {"type": "boolean"} |
camel-yaml-dsl.json | maximum-retries | Sets the maximum number of retries | {"type": "number"} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.