META-INF.mule.xsd Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of mule-module-spring-config
Show all versions of mule-module-spring-config
Mule Builder for use with Spring 2.X Namespace based XML configuration.
Allow any third-parties to annotate these elements with global attributes. All types for
top-level elements must extend this.
Allow any third-parties to annotate these elements with global attributes
Either the root element of a Mule configuration, or a "top-level" element in a Spring configuration that contains further Mule elements.
Holds any kind of documentation that accompanies this configuration file. It is intended to be "human readable" only and is not used by the system.
Allows the embedding of any Spring elements.
Allows Spring beans to be defined alongside Mule elements.
Allows Spring property placeholders to be configured directly in the Mule configuration file.
Allows to reference Spring beans alongside Mule elements.
A global property is a named string. It can be inserted in most attribute values using standard (ant-style) Spring placeholders.
Specifies defaults and general settings for the Mule instance.
Registers listeners for notifications and associates interfaces with particular events.
A placeholder for arbitrary extensions as children of the 'mule' element or 'mule-domain'. Other transports and modules can extend this if they need to add global elements to the configuration (but consider the more specific elements like abstract-connector first).
A placeholder for arbitrary extensions as children of the 'mule' element. Other transports and modules can extend this if they need to add global elements to the configuration (but consider the more specific elements like abstract-connector first).
A placeholder for arbitrary extensions as children of the 'mule' element. Other transports and modules can extend this if they need to add global elements with mixed content to the configuration (but consider the more specific elements like abstract-connector first).
A placeholder for connector elements. Connector elements allow properties to be configured across all message processors that use the same connector.
A placeholder for connector elements. Connector elements allow properties to be configured across all message processors that use the same connector.
Identifies the connector so that other elements can reference it.
@Deprecated since 4.0.
A placeholder for global endpoint elements. Global endpoints are named templates that allow you to define an endpoint once and refer to it in several places. The same template can be used for both inbound and outbound endpoints.
Identifies the endpoint so that other elements can reference it. This name can also be referenced in the MuleClient.
A placeholder for agent elements. Are used to run processes as part of the server instance.
Identifies the agent in the registry.
A placeholder for message processor elements.
A placeholder for message processor elements.
A placeholder for operator elements.
Adds an error mapping.
Determines that an error thrown by this operation should be mapped to another.
A placeholder for message processors that observe the message but do not mutate it used for exmaple for logging.
A message processor
A reference to a message processor defined elsewhere.
The name of the message processor to use.
Identifies the message processor in the registry.
The use of globally defined processor-chain element is deprecated since Mule 3.2. Use sub-flow instead.
A chain of message processors processed synchronously that can be referenced and reused.
This can hold any kind of documentation related to the sub-flow. It is intended to be
"human readable" only and is not used by the system.
Identifies the sub-flow in the registry.
This can hold any kind of documentation related to the processor chain. It is intended to be "human readable" only and
is not used by the system.
Identifies the message processor in the registry.
Invokes the method of a given object using method arguments expressed using mule expressions.
Reference to the object whose method will be invoked.
The name of the method to be invoked.
Comma-seperated list of mule expression that when evaluated are the arguments for the method invocation
Comma-seperated list of mule expression that when evaluated are the arguments for the method invocation
Identifies the message processor in the registry.
Enriches the current message, using expressins to define source and target,
with the result of processing a nested message processor. Use the target and optionally sourcre attributes
for 1-1 enrichment. If you require n-m enrichment than use the child 'enrich' elements instead.
An expression used to extract a value from the result of the
enrichment message processor. If an
expression is not specified then the payload of the
message is used.
The enricher expression used to enrich the current message with the result
the processing of the enrichement message processor specified.
An expression used to extract a value from the result of the
enrichment message processor. If an
expression is not specified then the payload of the
message is used.
The enricher expression used to enrich the current message with the result
the processing of the enrichement message processor specified.
Processes the nested list of message processors asynchronously using a thread pool
Optional name that will be used to name the threads used by this flow.
Provides support for the asynchronous request/reply pattern where a message is sent via a one-way message processor
and an asynchronous response is receivad via a separate message source. Message flow is blocked while
waiting for the reply message. Note: This does not currently support setting of replyTo property on the outbound message.
The message processor that will perform the asynchronous request.
The message source from which the asynchronous reply message will be received.
The time (ms) to wait for an asynchronous reply message to be received.
Defines the prefix of the object store names.
Performs logging using an expression that determines what should be logged. By default the current messages is
logged using the DEBUG level to the 'org.mule.runtime.core.api.processor.LoggerMessageProcessor' category but the level and
category can both be configured to suit your needs.
Message that will be logged. Embedded expressions can be used to extract value from the current message. If no message is
specified then the current message is used.
The logging level to be used. Default is DEBUG.
The log category to be used
Processes the nested list of message processors, within a transaction and with it's own error handler if required.
Transaction types supported. Availability will depend on the runtime version, though STANDARD is always available.
A placeholder for message source elements.
A message source
A placeholder for transformer elements. Transformers convert message payloads.
Identifies the transformer so that other elements can reference it. Required if the transformer is defined at the global level.
The class of the message generated by the transformer. This is used if transformers are auto-selected and to validate that the transformer returns the correct type. Note that if you need to specify an array type you need postfix the class name with '[]'. For example, if you want return a an Orange[], you set the return class to 'org.mule.tck.testmodels.fruit.Orange[]'.
Many transformers only accept certain classes. Such transformers are never called with inappropriate input (whatever the value of this attribute). If a transformer forms part of a chain and cannot accept the current message class, this flag controls whether the remaining part of the chain is evaluated. If true, the next transformer is called. If false the chain ends, keeping the result generated up to that point.
The mime type of the transformer's output
String encoding used for transformer output.
The name of the property. This is used inside Spring placeholders.
The value of the property. This replaces each occurence of a Spring placeholder.
A placeholder for filter elements, which control which messages are handled.
Identifies the filter so that other elements can reference it. Required if the filter is defined at the global level.
A placeholder for transaction manager elements, which are used to coordinate transactions.
A placeholder for transaction manager elements that can be defined as shared resource, which are used to coordinate transactions.
A placeholder for configuration elements.
The default reconnection strategy, used by connectors and sources. This can also be configured on connectors, in which case the connector configuration is used instead of this default.
Configuration of Mule Expression Language
Mule application configuration extensions. Extensions can be defined as child of the configuration elements and then accessed by each module that defines it.
The default period (ms) to wait for a synchronous response.
The default timeout (ms) for transactions. This can also be configured on transactions, in which case the transaction configuration is used instead of this default.
The default error handler for every flow. This must be a reference to a global error handler.
(As of Mule 2.2.2) The time in milliseconds to wait for any in-progress messages to finish processing before Mule shuts down. After this threshold has been reached, Mule starts interrupting threads, and messages can be lost. If you have a very large number of services in the same Mule instance, if you have components that take more than a couple seconds to process, or if you are using large payloads and/or slower transports, you should increase this value to allow more time for graceful shutdown. The value you specify is applied to services and separately to dispatchers, so the default value of 5000 milliseconds specifies that Mule has ten seconds to process and dispatch messages gracefully after shutdown is initiated.
The approximated maximum space in megabytes used by the transaction log files for transactional persistent queues. Take into account that this number applies both to the set of transaction log files for XA and for local transactions. If both type of transactions are used then the approximated maximum space used will be twice the configured value.
An optional reference to an ObjectSerializer to be used as the application's default
The default processing strategy to use in all flows which don't specify otherwise
A placeholder for arbitrary extensions as children of the 'configuration' element. Other transports and modules can extend this if they need to add elements to the configuration.
Associates an event with an interface. Listeners that implement the interface will receive instances of the event.
Blocks the association of an event with a particular interface. This filters events after the association with a particular interface (and so takes precedence).
Registers a bean as a listener with the notification system. Events are dispatched by reflection - the listener will receive all events associated with any interfaces it implements. The relationship between interfaces and events is configured by the notification and disable-notification elements.
The bean that will receive notifications.
An optional string that is compared with the event resource identifier. Only events with matching identifiers will be sent. If no value is given, all events are sent.
If the notification manager is dynamic, listeners can be registered dynamically at runtime via the MuleContext, and the configured notification can be changed. Otherwise, some parts of Mule will cache notification configuration for efficiency and will not generate events for newly enabled notifications or listeners. The default value is false.
The class associated with a notification event that will be delivered to the interface. This can be used instead of the 'event' attribute to specify a custom class.
The notification event to deliver.
The interface (class name) that will receive the notification event.
The interface that will receive the notification event.
The class associated with an event that will no longer be delivered to any interface. This can be used instead of the 'event' attribute to specify a custom class.
The event you no longer want to deliver.
The interface (class name) that will no longer receive the event.
The interface that will no longer receive the event.
@Deprecated since 4.0.
A placeholder for entry point resolver set elements. These combine a group of entry point resolvers, trying them in turn until one succeeds.
An extensible set of entry point resolvers (which determine how a message is passed to a component in Java) that already contains resolvers to implement the standard logic. This is already provided by default and is only needed explicitly if it will be extended with other entry point resolvers. This element can be set on the model or component; the model value provides a default that individual component values can override.
An extensible set of entry point resolvers. These determine how a message is passed to a component in Java. Each entry point resolver is tried in turn until one succeeds in delivering the message to the component. This element can be set on the model or component; the model value provides a default that individual component values can override.
A custom entry point resolver set. This allows user-supplied code to determine how a message is passed to a component in Java. This element can be set on the model or component; the model value provides a default that individual component values can override.
Spring-style property element for custom configuration.
An implementation of the EntryPointResolverSet interface.
A placeholder for an entry point resolver element. Entry point resolvers define how payloads are delivered to Java code by choosing the method to call.
An entry point resolver for components that implement the Callable interface. This passes a MuleEventContext to the component. This element can be set on the model or component; the model value provides a default that individual component values can override. This element can also be used directly or as part of a set of resolvers; the resolvers in a set are used in turn until one is successful.
A custom entry point resolver. This allows user-supplied code to determine how a message is passed to a component in Java. This element can be set on the model or component; the model value provides a default that individual component values can override. This element can also be used directly or as part of a set of resolvers; the resolvers in a set are used in turn until one is successful.
Spring-style property element for custom configuration.
An implementation of the EntryPointResolver interface.
Whether the resolver should call void methods. By default, void methods are not considered as possible candidates for message delivery.
Uses a message property to select the component method to be called. This element can be set on the model or component; the model value provides a default that individual component values can override. This element can also be used directly or as part of a set of resolvers; the resolvers in a set are used in turn until one is successful.
The name of the message property used to select a method on the component.
Delivers the message to a named method. This element can be set on the model or component; the model value provides a default that individual component values can override. This element can also be used directly or as part of a set of resolvers; the resolvers in a set are used in turn until one is successful.
Generates a list of candidate methods from the component via reflections. This element can be set on the model or component; the model value provides a default that individual component values can override. This element can also be used directly or as part of a set of resolvers; the resolvers in a set are used in turn until one is successful.
If specified, methods in the Java Object interface are not included in the list of possible methods that can receive the message.
Explicitly excludes a named method from receiving the message.
Delivers the message to a method that takes a single array as argument. This element can be set on the model or component; the model value provides a default that individual component values can override. This element can also be used directly or as part of a set of resolvers; the resolvers in a set are used in turn until one is successful.
Calls a method without arguments (the message is not passed to the component).
If no method names are configured, attempts to discover the method to invoke based on the inbound message type.
A possible method for delivery.
The name of the method.
A placeholder for an exception strategy element. Exception strategies define how Mule should react to errors.
A placeholder for an on-error element. These handlers define how Mule should react to errors.
Base type for every exception strategy.
Base type for every on error handler.
The full name of the error type to match against or a comma separated list of full names, to match against any of them.
The full name of the error type to match against or a comma separated list of full names, to match against any of them.
Used to match against any error type.
Occurs when there's a source that has a redelivery policy and the message has exceeded the maximum supported redelivery count.
Occurs when there's a transformation that fails.
Occurs when there's an error executing an expression.
Occurs when there's a security error.
Occurs when there's a security error related to security failures calling external endpoint.
Occurs when there's a security error related to security enforced within the mule runtime.
Occurs when there's an error executing a router.
Occurs when there's a connection error.
Specialization of CONNECTIVITY error, that occurs when all reconnection attempts have failed.
Determines whether ExceptionNotifications will be fired from this strategy when an exception occurs. Default is true.
Name of the exception strategy that will be used in ref attribute of 'exception-strategy' element
The expression that will be evaluated to determine if this exception strategy should be executed. This should always be a boolean expression.
Determines whether the handled exception will be logged to its standard logger in the ERROR level before being handled. Default is true.
These exceptions will be considered "delivered" after handling by the exception strategy. Any exception not
accepted by this filter will be redelivered/rolled back.
You can set a comma-separated list of wildcard patterns that will be matched against the fully qualified class name of the current exception.
These exceptions will be redelivered/rolled back after handling by the exception strategy.
You can set a comma-separated list of wildcard patterns that will be matched against the fully qualified class name of the current exception.
Destination to which an ExceptionMessage will be sent; this could be a router, or other message processor.
A comma-separated list of wildcard expressions that will be matched against the fully qualified classname of the current exception received by the ExceptionStrategy.
A placeholder for a reconnection strategy element. Reconnection strategies define how Mule should attempt to handle a connection failure.
If false, the reconnection strategy will run in a separate, non-blocking thread
A placeholder for a reconnection notifier element. The RetryNotifier interface is a callback that allows actions to be performed after each reconnection attempt, e.g., firing server notification events on success or failure.
A reconnection strategy that allows the user to configure how many times a reconnection should be attempted and how long to wait between attempts.
How often (in ms) to reconnect
How many reconnection attempts to make
A reconnection strategy that retries an infinite number of times at the specified frequency.
How often (in ms) to reconnect
A user-defined reconnection strategy.
Properties to be set on the created object.
A class that implements the RetryPolicyTemplate interface.
Fires a ConnectionNotification upon each reconnection attempt.
A user-defined reconnection notifier.
Properties to be set on the created object.
A class that implements the RetryNotifier interface.
A placeholder for a flow construct element.
The name used to identify this flow construct.
Determines if the flow construct is abstract (ie a parent that will be inherited in concrete constructs).
Determines if the flow construct inherits part of its configuration from a parent construct.
Base support for a flow construct.
This can hold any kind of documentation related to the flow construct. It is intended to be "human readable" only and is not used by the system.
The initial state of the flow. Usually a flow is started automatically ("started"), but this attribute can be used to disable initial startup ("stopped").
A pipeline of message processors processed using a given processingStrategy.
Called when a new message is received from a message source, a flow-ref, or programmatically.
The name of a globally configured processing strategy
This processing strategy uses the 'asynchronous' strategy where possible, but if an event is synchronous it processes it synchronously rather than failing.
Processes all message processors in the calling thread, waiting for any IO operations (e.g. http request) before continuing processing. This is also known as 'blocking'.
This can hold any kind of documentation related to the flow construct. It is intended to be "human readable" only and is not used by the system.
An outbound endpoint
The name used to identify this flow construct.
Strategy used to process the configured message processors when exchange pattern is 'one-way'.
This attribute accepts either one of the enumerated strategies with default configuration options or a reference to a globally defined strategy.
If not specified, it will be taken from the defaultProcessingStrategy attribute of the <configuration> element. If that one
is not defined either, then the mule.default.processing.strategy system property will be checked. If that's not setup
either, then the value 'default' will be used
The initial state of the flow. Usually a flow is started automatically ("started"), but this attribute can be used to disable initial startup ("stopped").
The processing strategy to be used for processing a pipeline of message processors (e.g. in a Flow)
The name used to identify the processing strategy.
Allows for the configuration of a custom processing strategy.
Custom processing strategy factory fully qualified class name. Custom processing strategy factories should implement 'org.mule.runtime.core.api.processor.strategy.ProcessingStrategyFactory'.
Allows a 'flow' to be referenced such that the message processing will continue in the referenced flow before returning.
Message processing in the referenced 'flow' will occur within the context of the referenced flow and will therefore use its exception strategy etc.
A placeholder for a component element. A component is invoked when inbound messages are received by the service.
Interceptors that can be used to intercept component invocation.
A simple POJO (Plain Old Java Object) component that will be invoked by Mule when a message is received. The class or object instance to be used can be specified using a child object factory element, or via the 'class' attribute. If the 'class' attribute is used, an object factory cannot be configured as well. Using the 'class' attribute is equivilant to using the propotype object factory ('prototype-object' child element).
Entry point resolvers that are used to determine how a message is passed to a component.
Object factory used to obtain the object instance that will be used for the component implementation. The object factory is responsible for object creation and may implement different patterns, such as singleton or prototype, or look up an instance from other object containers.
Specifies a component class. This is a shortcut that is equivalent to providing a 'prototype-object' element.
A pooled POJO (Plain Old Java Object) component that will be invoked by Mule when a message is received. The instance can be specified via a factory or a class.
Characteristics of the object pool.
Logs the message and returns the payload as the result.
Logs the message content (or content length if it is a large message).
Throws an exception if it receives a message.
A service that will return static data as a result. The data returned can be read from a file or can be embedded directly in the XML.
Defines the data to return from the service once it has been invoked. The return data can be located in a file, which you specify using the {{file}} attribute (specify a resource on the classpath or on disk), or the return data can be embedded directly in the XML.
The location of a file to load. The file can point to a resource on the classpath or on disk.
A placeholder for transaction elements. Transactions allow a series of operations to be grouped together.
A placeholder for XA transaction elements. XA transactions allow a series of operations to be grouped together spanning different transports, such as JMS and JDBC.
A placeholder for multi-transaction elements.
Multi-transactions allow a series of operations to be grouped together spanning different
transports, e.g. JMS and JDBC, but without the overhead of XA. The trade-off is that XA
reliability guarantees aren't available, and services must be ready to handle duplicates.
This is very similar to a 1.5 PC concept. EE-only feature.
The type of action the transaction should take, one of the following:
NONE - Never participate in a transaction.
ALWAYS_BEGIN - Always start a new transaction when receiving a message. An exception will be thrown if a transaction already exists.
BEGIN_OR_JOIN - If a transaction is already in progress when a message is received, join the transaction if possible. Otherwise, start a new transaction.
ALWAYS_JOIN - Always expects a transaction to be in progress when a message is received. If there is no transaction, an exception is thrown.
JOIN_IF_POSSIBLE - Join the current transaction if one is available. Otherwise, no transaction is created.
NOT_SUPPORTED - Execute outside any existent transaction
Timeout for the transaction (ms).
A user-defined or otherwise unsupported third-party transactions.
A class that implements the TransactionFactory interface that will be instantiated and used to generate a transaction. This attribute and the 'factory-ref' attribute are mutually exclusive; one of the two is required.
A bean that implements the TransactionFactory interface that will be used to generate a transaction. This attribute and the 'factory-class' attribute are mutually exclusive; one of the two is required.
An XA transaction.
If this is set to "true", Mule interacts with transactions begun outside of Mule. E.g. if an external transaction is active, then BEGIN_OR_JOIN wil join it, and ALWAYS_BEGIN will cause an exception to be thrown.
An optional name for the transaction manager. The default value is "transactionManager".
A user-implemented transaction manager.
The JNDI environment.
Spring-style property element for custom configuration.
The class to instantiate to create a transaction manager.
A placeholder for scheduling strategies
A placeholder for scheduling strategies
Polling frequency in milliseconds. Default frequency is 1000ms (1s).
The time unit for the frequency value
The delay time in time units that sheduler needs to wait before start
Source that schedules periodic execution of a flow. By default it will used a fixed frequency
scheduling of 1 second.
Cron scheduler expression
The ID of the time zone in which the expression will be based. Refer to java.util.TimeZone for the format and possible values of the timeZone ID.
A placeholder for security filter elements, which control access to the system.
Authenticates a message based on username and password expressions.
A Mule expression which extracts the username from the message. Defaults to #[mel:message.inboundProperties.username].
A Mule expression which extracts the password from the message. Defaults to #[mel:message.inboundProperties.password].
Allows developers to configure custom security filters
The name of the security filter to use.
A filter that is defined elsewhere (at the global level, or as a Spring bean).
The name of the filter to use.
Inverts the enclosed filter. For example, if the filter would normally return true for a specific message, it will now return false, and vice versa.
Returns true only if all the enclosed filters return true.
Returns true if any of the enclosed filters returns true.
A filter that matches string messages against wildcards. It performs matches with "*", for example, "jms.events.*" would catch "jms.events.customer" and "jms.events.receipts". This filter accepts a comma-separated list of patterns, so more than one filter pattern can be matched for a given argument: "jms.events.*, jms.actions.*" will match "jms.events.system" and "jms.actions" but not "jms.queue".
A filter that can evaluate a range of expressions. It supports some base expression types such as header, payload (payload type), regex, and wildcard.
The expression that will be evaluated. This should always be a boolean expression. The syntax of the expression will be determined by the expression language being used.
Whether the filter should return true if the specified expression returns null.
A filter that matches string messages against a regular expression. The Java regular expression engine (java.util.regex.Pattern) is used.
Comma-separated list of flags for compiling the pattern. Valid values are CASE_INSENSITIVE, MULTILINE, DOTALL, UNICODE_CASE and CANON_EQ.
The property name and optionally a value to use when matching. If the expression is just a property name, the filter will check that the property exists. Users can also use '=' and '!=' to determine a specific value for a property.
Value to validate.
A filter that matches properties on a message. This can be very useful, as the message properties represent all the meta information about the message from the underlying transport, so for a message received over HTTP, you can check for HTTP headers and so forth. The pattern should be expressed as a key/value pair, such as "propertyName=value". If you want to compare more than one property, you can use the logic filters for And, Or, and Not expressions. By default, the comparison is case sensitive, which you can override with the 'caseSensitive' property.
Property scope to lookup the value from (default: outbound)
If false, the comparison ignores case.
A filter that matches the type of an exception.
A filter that matches the type of the payload.
The expected class used in the comparison.
A user-implemented filter.
Spring-style property element for custom configuration.
An implementation of the Filter interface.
A placeholder for interceptor stack elements.
The name used to identify this interceptor stack.
A placeholder for an interceptor element.
A reference to a stack of intereceptors defined globally.
The name of the interceptor stack to use.
The timer interceptor (ported from 1.x).
The logging interceptor (ported from 1.x).
A user-implemented interceptor.
Spring-style property element for custom configuration.
An implementation of the Interceptor interface.
A filter that provides password-based encyption.
The name of the encryption strategy to use. This should be configured using the 'password-encryption-strategy' element, inside a 'security-manager' element at the top level.
A reference to a transformer defined elsewhere.
The name of the transformer to use.
A transformer that uses the transform discovery mechanism to convert the message payload. This transformer works much better when transforming custom object types rather than Java types, because there is less chance for ambiguity.
A user-implemented transformer.
Spring-style property element for custom configuration.
An implementation of the Transformer interface.
The mime type of the value assigned to the property
The encoding of the value assigned to the property
A processor that adds outbound message properties.
A processor that remove outbound message properties by name or regular expression.
A processor that copy properties from inbound to outbound scope by name or regular expression.
A processor that adds variables.
A processor that remove variables by name or regular expression.
A transformer that base64 encodes a string or byte array message.
A transformer that base64 decodes a message to give an array of bytes.
A transformer that encodes a string using XML entities.
A transformer that decodes a string containing XML entities.
A transformer that compresses a byte array using gzip.
A transformer that uncompresses a byte array using gzip.
A transformer that converts a byte array to a string of hexadecimal digits.
A transformer that converts a string of hexadecimal digits to a byte array.
A transformer that converts a byte array to an object (either deserializing or converting to a string).
A transformer that serializes all objects except strings (which are converted using getBytes()).
A transformer that gives a human-readable description of various types (useful for debugging).
A transformer that converts a byte array to an object (deserializing the object).
A transformer that converts an object to a byte array (serializing the object).
A transformer that converts a byte array to a string.
A transformer that converts a string to a byte array.
Creates and object of type @return-class and populates values of a {{java.util.Map}} as bean properties on the object.
The bean class name can also be passed in as a property on the Map (which gets removed once read). The {{MapToBean.CLASS_PROPERTY}} 'className' should be set as a fully qualified class name string.
Conversts a simple bean object to a Map. every property on the bean will become an entry in the result {{java.util.Map}}. Note that only exposed bean properties with getter and setter methods will be added to the map.
A transformer that appends a string to a string payload.
The string to append.
A transformer that parses a template in a given location
The location of the template. The order in which the transformer will attempt to load the file are: from the file system, from a URL or from the classpath.
A transformer that sets the paylaod with the provided value
The mime type of the value assigned to the payload
The encoding of the value assigned to the payload
The value to be set on the payload. Supports expressions.
A transformer that encrypts a message.
A transformer that decrypts a message.
The name of the encryption strategy to use. This should be configured using the password-encryption-strategy element, inside a security-manager element at the top level.
A transformer that uses expressions to configure a simple bean object. The user can specify a bean class or factory to create and one or more expressions that are used to configure properties on the bean.
The name of the bean property
If the expression evaluates to null, whether to continue to the next expression without error.
The bean class to create
A Bean factory to use when creating the bean object. The factory must implement {{org.mule.runtime.core.api.object.ObjectFactory}}.
A transformer that evaluates one or more expressions on the current message. Each expression equates to a parameter in the return message. The return message for two or more expressions will be an Object[].
If all expressions return null or NullPayload on this transformer, this flag will cause the source payload to be returned without modification.
If the expression evaluates to null, specifies whether to continue to the next expression without error.
If all expressions return null on this transformer, this flag will cause the source payload to be returned without modification.
The expression to evaluate.
The expression to evaluate.
A regular expression used to match against a source value. The regular expression should contain a capture group which value will be returned.
The enricher expression used to enrich the current message with the result the processing of the regular expression.
Determines if there should be an error in case the pattern is not matched by the source value.
The default value used to enrich the message when the source value does not match the pattern. Useful only when failIfNoMatch is false.
A security manager is a container for security providers. More than one security manager may be configured; each contains providers from a particular module and has that module type. This element is abstract - a security-related module or transport will provide a suitable implementation.
An empty holder that can be extended by modules that want to provide security managers. Typically it will contain elements called 'module:type-security-provider', which extend securityProviderType where "module" might be "spring-security" and "type" might de "delegate", for example. It can also contain encryption strategies, which should follow a similar scheme and extend encryptionStrategyType.
The default security manager.
The default security manager (type 'defaultSecurityManagerType') provides basic support for security functions. Other modules (PGP, Spring Security) provide more advanced functionality.
A custom implementation of SecurityProvider.
A custom implementation of EncryptionStrategy.
Provides secret key-based encryption using JCE.
Provides password-based encryption using JCE. Users must specify a password and optionally a salt and iteration count as well. The default algorithm is PBEWithMD5AndDES, but users can specify any valid algorithm supported by JCE.
A security provider is a source of specific security-related functionality.
An encryption strategy provides support for a specific encryption algorithm.
Spring-style property element for custom configuration.
The name of the security provider to use.
A reference to the encryption strategy (which may be a Spring bean that implements the EncryptionStrategy interface).
The password to use.
The salt to use (this helps prevent dictionary attacks).
The number of iterations to use.
The key to use. This and the 'keyFactory-ref' attribute are mutually exclusive.
The name of the key factory to use. This should implement the ObjectFactory interface and return a byte array. This and the 'key' attribute are mutually exclusive.
Error handler used to handle exceptions. It will commit any transaction as if the message was consumed successfully.
Allows the definition of internal selective handlers. It will route the error to the first handler that matches it. If there's no match, then a default error handler will be executed.
Error handler used to propagate errors. It will rollback any transaction and not consume messages.
Destination to which a MuleMessage with an ExceptionPayload will be sent; this could be any message processor.
Name of the exception strategy that will be used in ref attribute of 'exception-strategy' element
Destination to which the message will be sent; this could be a router, or message processor.
A user-defined exception strategy.
Spring-style property element for custom configuration.
A class that implements the ExceptionListener interface.
A placeholder for intercepting router elements.
A placeholder for intercepting router elements.
Identifies the processor so that other elements can reference it. Required if the processor is defined at the global level.
Events that are not accepted by the filter are sent to this (optional) named message processor.
Whether to throw an exception if a message is not accepted
A message processor that uses a filter to determine whether to process an event.
Used to filter events.
Ensures that only unique messages are received by a service by checking the unique ID of the incoming message. Note that the ID used can be generated from the message using an expression defined in the 'idExpression' attribute. Otherwise, a 'FILTERED' error is generated.
Defines one or more expressions to use when extracting the ID from the message. If this property is not set, '#[id]' will be used by default.
Defines one or more expressions to use when extracting the value from the message.
The object store where the IDs of the processed events are going to be stored.
Defines the prefix of the object store names. This will only be used for the internally built object store.
A placeholder for a redelivery policy. Redelivery policies determine what action to take when the same message
is redelivered repeatedly.
The maximum number of times a message can be redelivered and processed unsuccessfully before triggering
process-failed-message
Defines a policy for processing the redelivery of the same message
Whether to use a secure hash algorithm to identify a redelivered message
The secure hashing algorithm to use. If not set, the default is SHA-256.
Defines one or more expressions to use to determine when a message has been redelivered.
This property may only be set if useSecureHash is false..
The object store where the redelivery counter for each message is going to be stored.
Ensures that only unique messages are received by a service by calculating the hash of the message itself using a message digest algorithm. This provides a value with an infinitesimally small chance of a collision. This can be used to filter message duplicates. Keep in mind that the hash is calculated over the entire byte array representing the message, so any leading or trailing spaces or extraneous bytes (like padding) can produce different hash values for the same semantic message content. Care should be taken to ensure that messages do not contain extraneous bytes. This class is useful when the message does not support unique identifiers.
The secure hashing algorithm to use. If not set, the default is SHA-256.
The WireTap inbound router allows you to route certain messages to a different message processor as well as to the component.
Takes a payload which is a Collection of Collections and turns into a single List. For example, if the payload is a Collection
which contains a Collection with elements A and B and another Collection with elements C and D, this will turn them into
a single Collection with elements A, B, C and D.
This transformer will also work on MuleMessageCollections. In this case, it will take the individual Collection
payloads of each MuleMessage and merge them into a single Collection on a new MuleMessage.
Defines a timeout in Milliseconds to wait for events to be aggregated. By default the router will throw an exeception if the router is waiting for a correlation group and times out before all group enties are received.
When false, incomplete aggregation groups will be forwarded to a component on timeout as a java.util.List. When true (default), a CorrelationTimeoutException is thrown and RoutingNotification.CORRELATION_TIMEOUT is fired. The component doesn't receive any messages in this case.
The object store where the processed groups are going to be stored. It is recommended that this object store has a max capacity and an expiration interval.
The object store where the event groups are going to be stored.
Defines if the object stores used are persistent or not. This will only be used for the internally built object stores.
Defines the prefix of the object store names. This will only be used for the internally built object stores.
Holds back a group of messages and resequences them using each message's correlation sequence property.
Configures a Collection Response Router. This will return a MuleMessageCollection message type that will contain all messages received for a each correlation group.
Combines two or more messages into a single message by matching messages with a given Correlation ID. Correlation IDs are set on messages when they are dispatched by certain outbound routers, such as the Recipient List and Message Splitter routers. These messages can be aggregated back together again using this router.
Configures a custom message aggregator. Mule provides an abstract implementation that has a template method that performs the message aggregation. A common use of the aggregator router is to combine the results of multiple requests such as "ask this set of vendors for the best price of X".
Spring-style property element for custom configuration.
Fully qualified class name of the custom correlation aggregator router to be used.
The splitter splits incoming message into parts using the configured expression passing on each part in turn to the next message processor. The expression
may return a collection, or map, or a
The collection splitter accepts a collection of objects and splits the collection invoking the next message processor with each item in the collection in sequence.
The message chunk size (in bytes) that the current message will be split into. Note that this is mutually exclusive to the 'numberOfMessages' property.
Configures a custom message splitter. Mule provides an abstract implementation that has a template method that performs the message aggregation.
Spring-style property element for custom configuration.
Fully qualified class name of the custom correlation aggregator router to be used.
The expression to evaluate.
An expression to that returns a java collection, object array, map or DOM nodes.
Partitions the collection in subcollections of the specified size.
Property name where the parent message is stored.
Property name used to store the number of message being iterated.
A placeholder for intercepting router elements.
Sends the message to the first message processor whose condition has been satisfied. If no conditions were satisfied, sends to the configured default message processor if configured, or throws an exception if not configured.
Sends the same message to multiple message processors.
@Deprecated since 3.5.0. Use scatter-gather instead
Sends a message to a list of message processors until one processes it
successfully
Specifies an expression that when evaluated as determines if the processing of one a route was a failure or not.
Attempts to route a message to the message processor it contains in an asynchronous manner.
Routing is considered successful if no exception has been raised and, optionally, if the response matches an expression
Reference to the org.mule.runtime.core.api.store.ListableObjectStore that will be used to store events pending (re)processing.
Specifies the maximum number of processing retries that will be performed.
Specifies the minimum time interval between two process retries in milliseconds.
The actual time interval depends on the previous execution but should not exceed twice this number.
Default value is 60000 (one minute)
Specifies the minimum time interval between two process retries in seconds.
The actual time interval depends on the previous execution but should not exceed twice this number.
THIS ATTRIBUTE IS DEPRECATED. Please use millisBetweenRetries instead
Specifies an expression that when evaluated determines if the processing of one a route was a failure or not.
If no expression is specified, only exceptions will be considered as processing failures.
Specifies an expression that when evaluated determines the synchronous response of until-successful.
Defines if the route inside until-successful should be executed asynchronously or synchronously within the caller thread.
Sends the same message to multiple message processors in parallel.
Allows customizing the logic used for aggregation the events back together.
Whether the configured routes will run in parallel (default is true).
Sets a timeout in milliseconds for each route. Values lower or equals than zero means no timeout.
The canonical name of a class that implements org.mule.runtime.core.routing.AggregationStrategy.
Such a class is required to have a default constructor.
This property cannot be set at the same time as 'ref'
A reference to a registered bean that implements org.mule.runtime.core.routing.AggregationStrategy.
This property cannot be set at the same time as 'class'
Send each message received to the next message processor in the circular list of targets
A placeholder for route resolver elements, which return a set of routes.
A placeholder for a bytes streaming strategy element. This element allows to configure repeatable streams behaviour
This strategy uses an in-memory buffer to provide repeatable access to any input stream.
It uses a buffer with an initial buffer size, which can be expanded up to a configurable threshold.
This is the most performant way of providing repeatable access, as long as the size of all the concurrent
stream contents fits into memory
This is the amount of memory that will be allocated in order to consume the stream and provide random
access to it. If the stream contains more data than can be fit into this buffer, then it will be expanded
by according to the bufferSizeIncrement attribute, with an upper limit of maxInMemorySize.
This is by how much will be buffer size by expanded if it exceeds its initial size. Setting a value of zero or
lower will mean that the buffer should not expand, meaning that a STREAM_MAXIMUM_SIZE_EXCEEDED error will be raised
when the buffer gets full.
This is the maximum amount of memory that will be used. If more than that is used then a STREAM_MAXIMUM_SIZE_EXCEEDED error will be raised.
A value lower or equal to zero means no limit.
The unit in which all these attributes are expressed
This strategy only allows the input stream to be read. It will not allow to seek randomly
which will limit the transformations that DW can perform on this stream.
Use this option for use cases which just require moving data around from one system to another to get optimum performance.
A placeholder for an object streaming strategy element. This element allows to configure repeatable streams behaviour
This strategy uses an in-memory buffer to provide repeatable access to the object stream. It uses a buffer
with an initial buffer size, which can be expanded up to a configurable threshold. This is the most performant way
of providing repeatable access, as long as the size of all the concurrent stream contents fits into memory.
This is the amount of instances that will be initially be allowed to be kept in memory in order to
consume the stream and provide random access to it. If the stream contains more data than can fit
into this buffer, then it will be expanded according to the bufferSizeIncrement attribute, with an upper
limit of maxInMemorySize. Default value is 100 instances.
This is by how much will the buffer size by expanded if it exceeds its initial size. Setting a value of zero or
lower will mean that the buffer should not expand, meaning that a STREAM_MAXIMUM_SIZE_EXCEEDED error will be raised
when the buffer gets full. Default value is 100 instances.
This is the maximum amount of instances that will be kept in memory. If more than that are required,
then a STREAM_MAXIMUM_SIZE_EXCEEDED error will be raised. A value lower or equal to zero means no limit.
Default value is 500 instances.
This strategy only allows the stream to be read once. It will not allow to seek randomly
which will limit the transformations that DW can perform on this stream.
Use this option for use cases which just require moving data around from one system to another to get optimum performance.
Allows a lifecycle adaptor factory to be implemented, which allows an alternative custom lifecycle adaptor to be used if required instead of the default implementation that propagates the Mule lifecycle to component implementations.
Spring-style property element for custom configuration.
An implementation of the LifecycleAdapter interface.
An object factory is used to obtain object instances. The object factory is responsible for object creation and can implement different patterns, such a singleton or prototype, or lookup an instance from other object containers.
Properties to be set on the created object.
Object factory used to obtain Spring bean instances. This object factory does not create any instances but rather looks them up from Spring.
Name of Spring bean to look up.
Object factory that creates and always returns a singleton object instance.
Class name
Object factory that creates and returns a new 'prototype' object instance every time it is called.
Class name
A pooling profile is used to configure the pooling behaviour of Mule components. Each component can have its own pooling profile.
Controls the maximum number of Mule components that can be borrowed from a session at one time. When set to a negative value, there is no limit to the number of components that may be active at one time. When maxActive is exceeded, the pool is said to be exhausted.
Controls the maximum number of Mule components that can sit idle in the pool at any time. When set to a negative value, there is no limit to the number of Mule components that may be idle at one time.
Determines how components in a pool should be initialized. The possible values are: INITIALISE_NONE (will not load any components into the pool on startup), INITIALISE_ONE (will load one initial component into the pool on startup), or INITIALISE_ALL (will load all components in the pool on startup)
Specifies the behavior of the Mule component pool when the pool is exhausted. Possible values are: "WHEN_EXHAUSTED_FAIL", which will throw a NoSuchElementException, "WHEN_EXHAUSTED_WAIT", which will block by invoking Object.wait(long) until a new or idle object is available, or WHEN_EXHAUSTED_GROW, which will create a new Mule instance and return it, essentially making maxActive meaningless. If a positive maxWait value is supplied, it will block for at most that many milliseconds, after which a NoSuchElementException will be thrown. If maxThreadWait is a negative value, it will block indefinitely.
Specifies the number of milliseconds to wait for a pooled component to become available when the pool is exhausted and the exhaustedAction is set to WHEN_EXHAUSTED_WAIT.
Specifies the number of milliseconds between runs of the object evictor. When non-positive, no object evictor is executed.
Determines the minimum amount of time an object may sit idle in the pool before it is eligible for eviction. When non-positive, no objects will be evicted from the pool due to idle time alone.
Whether pooling should be disabled
A type that defines a Java keystore.
The default Java KeyStore. If no keystore type is specified, "jks" will be used.
Used by the Java Cryptography Extension
A format commonly used to store private keys.
Any other keystore type.
A type that defines a Mule-style property placeholder.
A custom xsd:NMTOKEN-like type that also allows for Ant-style property placeholders and a leading "[".
A custom xsd:string-like type that cannot be empty.
A custom xsd:NMTOKEN type that also allows for Ant-style property placeholders.
A custom xsd:string type that also allows for Ant-style property placeholders.
A custom xsd:int type that also allows for Ant-style property placeholders and restricts the int value to a valid port number.
A custom xsd:int type that also allows for Ant-style property placeholders.
A custom xsd:decimal type that also allows for Ant-style property placeholders.
A custom xsd:dateTime type that also allows for Ant-style property placeholders.
A custom xsd:long type that also allows for Ant-style property placeholders.
A custom xsd:boolean type that also allows for Ant-style property placeholders.
A custom xsd:string-like type that represents a MEL expression.
Attributes should use this type to declare that they support expressions.
It allows property placeholders and requires the value to not be blank.
An embeddable expression that outputs a String
A non-embeddable expression that outputs a Boolean
A non-embeddable expression that outputs an Integer
A non-embeddable expression that outputs a Long
A non-embeddable expression that outputs a Double
A non-embeddable expression that outputs a Decimal
A non-embeddable expression that outputs a generic object
A non-embeddable expression that outputs a Collection type
A non-embeddable expression that outputs a Map
A non-embeddable expression that outputs a Date
Supported time units enumeration
Data units enumeration
A map of Mule properties.
Sets a Mule property. This is a name/value pair that can be set on components, services, etc., and which provide a generic way of configuring the system. Typically, you shouldn't need to use a generic property like this, since almost all functionality is exposed via dedicated elements.
The mime type for the property
String encoding for the property.
The mime type, e.g. text/plain or application/json
A placeholder for caching strategies elements.
The name of the caching strategy.
© 2015 - 2025 Weber Informatics LLC | Privacy Policy