|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
ForwardingCatchAllStrategy acts as a catch and forward router for any
events not caught by the router this strategy is associated with.Component to be used by all Component implementations.AbstractCompressionTransformer is a base class for all transformers
that can compress or uncompress data when they performa message transformation.ConfigurationBuilder implementations
that handles the logic of creating config arrays and Properties
argumentsAbstractConnector provides base functionality for all connectors
provided with Mule.EncryptionTransformer will transform an array of bytes or string
into an encrypted array of bytesImmutableMuleEndpoint describes a Provider in the Mule Server.AbstractEndpointSecurityFilter provides basic initialisation for
all security filters, namely configuring the SecurityManager for this instanceUrlEndpointURIBuilder is the default endpointUri strategy suitable for
most connectorsEntryPointResolver.AbstractEventAggregator will aggregate a set of messages into a
single message.AbstractEventResequencer is used to receive a set of events,
resequence them and forward them on to their destinationAbstractExceptionListener is a base implementation that custom
Exception Listeners can override.EntryPointResolverSet, NestedRouterCollection and
ObjectFactory.AbstractMessageAdapter provides a base implementation for simple
message types that maybe don't normally allow for meta information, such as a File
or TCP.AbstractMessageAwareTransformer is a transformer that has a reference
to the current message.AbstractMessageDispatcherFactory is a base implementation of the
MessageDispatcherFactory interface for managing the lifecycle of
message dispatchers.AbstractMessageReceiver provides common methods for all Message
Receivers provided with Mule.MessageRequesterFactory interface for managing the
lifecycle of message requesters.AbstractMessageSplitter is an outbound Message Splitter used to split
the contents of a received message into sub parts that can be processed by other
components.MuleModel is the default implementation of the Model.AbstractNotificationLoggerAgent Receives Mule server notifications
and logs them and can optionally route them to an endpointAbstractOutboundRouter is a base router class that tracks
statistics about message processing through the router.AbstractPollingMessageReceiver implements a base class for polling
message receivers.MessageReceiver implementations.AbstractRecipientList is used to dispatch a single event to
multiple recipients over the same transport.ConfigurationBuilder implementation used for
ConfigurationBuider's that use one of more configuration resources of the same
type that are defined using strings or ConfigResource objects.AbstractResponseAggregator provides a base class for implementing
response aggregator routers.AbstractResponseRouter is a base class for all Response RoutersAbstractRouterCollection provides common method implementations of
router collections for in and outbound routers.HtmlTablePrinter prints event processing stats as a HTML tableAbstractTransformer is a base class for all transformers.MessageDispatching methods are invoked.
MessageDispatcherFactory.create(OutboundEndpoint).
MessageDispatching methods are invoked.
MessageRequesterFactory.create(org.mule.api.endpoint.InboundEndpoint).
Agent is a server plugin that can be initialised, started and
destroyed along with the UMOManager itself.SingleResponseRouter will always return the first event of
an event group.
AllStatistics TODOAlreadyInitialisedException is thrown when a service or connector
has already been initialised.AndFilter accepts only if the leftFilter and rightFilter filter
accept.UMOAuthentication represents an authentication request and contains
authentication information if the request was successfulSecurityProviderInfo.Base64.InputStream will read data from another InputStream,
given in the constructor, and encode/decode to/from Base64 notation on the
fly.Base64.InputStream in DECODE mode.
Base64.InputStream in either ENCODE or DECODE mode.
Base64.OutputStream will write data to another OutputStream,
given in the constructor, and encode/decode to/from Base64 notation on the
fly.Base64.OutputStream in ENCODE mode.
Base64.OutputStream in either ENCODE or DECODE mode.
Base64Encoder transforms Base64 encoded data into strings or byte
arrays.Base64Encoder transforms strings or byte arrays into Base64 encoded
string.BaseMessage A default message implementation used for messages sent
over the wire.Transformer can be chained together to covert message payloads from one
object type to another.BatchConstraint is a filter that counts on every execution and
returns true when the batch size value equals the execution count.BeanUtils provides functions for altering the way commons BeanUtils
worksBlockingServerEvent is a marker interface that tells the server
event manager to publish this event in the current thread, thus blocking the
current thread of execution until all listeners have been processedMuleContext instance using configured builder instance.
MuleContext instance using configured builder instance.
ByteArrayToObject works in the same way as
ByteArrayToSerializable but checks if the byte array is a
serialised object and if not will return a String created from the bytes as the
returnType on the transformer.ByteArrayToSerializable converts a serialized object to its object
representationCallable is used to provide UMOs with an interface that supports
event calls.ChainedReader allows Reader objects to be chained together.ThreadingProfile.DEFAULT_THREADING_PROFILE
ChainingRouter is used to pass a Mule event through multiple
endpoints using the result of the first as the input for the second.AbstractMessageSplitter.getMessagePart(MuleMessage, OutboundEndpoint)
returned null.
CommonsPoolProxyPool is an implementation of ObjectPool
that internally uses the commons-pool GenericObjectPool and uses a
ObjectFactory for creating new pooled instances.Component is a invoked by a Service for each incoming
MuleEvent routed on by the InboundRouterCollection.CompressionStrategy implementation class to use, if no other
can be found.
CompressionException TODO documentCompressionHelper a static class that provides facilities for
compressing and uncompressing byte arraysCompressionStrategy is a base interface for Different compression
strategiesConfigurationBuilder is used to configure a Mule instance,
represented by a MuleContext instance.ConnectionNotificationListener is an observer interface that
objects can implement and then register themselves with the Mule manager to be
notified when a Connection event occurs.Connector is the mechanism used to connect to external systems
and protocols in order to send and receive data.ConnectorException Is thrown in the context of a Connector,
usually some sort of transport level error where the connection has failed.CorrelationAggregator uses the CorrelationID and
CorrelationGroupSize properties of the MuleMessage to manage
message groups.CorrelationEventResequencer is used to resequence events according
to their dispatch sequence in the correlation group.CorrelationPropertiesExpressionEvaluator is a default implementation used for
getting the Correlation information from a message.CorrelationSequenceComparator is a Comparator for
MuleEvents using their respective correlation sequences.CouldNotRouteInboundEventException thrown if the current service
cannot accept the inbound event.CouldNotRouteOutboundMessageException thrown if Mule fails to route
the current outbound event.MessageAdapter.getCorrelationGroupSize().
InitialisationException is thrown by the initialise method defined
in the org.mule.api.lifecycle.Initialisable interface.Message instance that is filled with the formatted
message with id code from the resource bundle bundlePath.
Message instance that is filled with the formatted
message with id code from the resource bundle bundlePath.
Message instance that is filled with the formatted
message with id code from the resource bundle bundlePath.
Message instance that is filled with the formatted
message with id code from the resource bundle bundlePath.
Message instance that is filled with the formatted
message with id code from the resource bundle bundlePath.
MuleContext is one exists, otherwise a
new MuleContext instance is created with defaults.
MuleContextBuilder provided.
MuleContextBuilder provided and
configures it with the list of configuration builder and c onfigures it with
configurationBuilder
MuleContextBuilder provided and
configures it with the list of configuration builders.
MuleContext instance from the resource provided.
MuleContext instance from the resource provided.
Message instance that is not read from a resource bundle.
Credentials holds credentials information for a user.CredentialsAccessor is a template for obtaining user credentials
from the current message and writing the user credentials to an outbound messageCredentialsNotSetException is thrown when user credentials cannot
be obtained from the current messageCryptoFailureException is a generic exception thrown by an
CryptoStrategy if encryption or decryption fails.CSVPrinter prints service stats in CSV formatCustomNotification Custom notifications can be used by components
and other objects such as routers, transformers, agents, etc to communicate a
change of state to each other.CustomNotificationListener is an observer interface that can be
used to listen for Custom notifications using
UMOManager.fireCustomEvent(..).DateUtils contains some useful methods dealing date/time
conversion, formatting etc.EncryptionTransformer will transform an encrypted array of bytes or
string into an decrypted array of bytesEntryPointResolverSet
It resolves a method to call on the given service when an event is received.DefaultExceptionPayload TODODefaultExceptionStrategy provides a default exception handling
strategy.DefaultInboundRouterCollection is a collection of routers that will be
invoked when an event is received.JavaComponent.DefaultLifecycleAdapter provides lifecycle methods for all Mule
managed components.DefaultLifecycleAdapterFactory creates a DefaultLifeCycleAdapter.LifecycleAdapter
instances for implementations of JavaComponent that require
LifecycleAdapter pooling such as PooledJavaComponent.Initialisable.initialise(), Startable.start(),
Stoppable.stop() and Disposable.dispose().DefaultMessageAdapter can be used to wrap an arbitary object where
no special 'apapting' is needed.MuleMessage type that manages a collection of MuleMessage Objects.MuleContextBuilder that uses DefaultMuleContext
as the default MuleContext implementation and builds it with defaults
values for MuleConfiguration, LifecycleManager, WorkManager,
WorkListener and ServerNotificationManager.MuleServer static and
uses DefaultMuleContextBuilder to build new MuleContext instances.DefaultMuleEvent represents any data event occuring in the Mule
environment.DefaultMuleEventContext is the context object for the current request.MuleException Is the base exception type for the Mule application
any other exceptions thrown by Mule code will be based on this exception.DefaultMuleMessage is a wrapper that contains a payload and properties
associated with the payload.DefaultMuleSession manages the interaction and distribution of events for
Mule UMOs.DefaultOutboundRouterCollection is a container of routers.DefaultReplyToHandler is responsible for processing a message
replyTo header.DefaultResponseRouterCollection is a router that can be used to control how
the response in a request/response message flow is created.DefaultServiceExceptionStrategy is the default exception handler
for components.false for
MessageDispatcherFactory.validate(OutboundEndpoint, MessageDispatcher).
false for
MessageRequesterFactory.validate(org.mule.api.endpoint.InboundEndpoint, org.mule.api.transport.MessageRequester).
DispatchException is thrown when an endpoint dispatcher fails to
send, dispatch or receive a message.Disposable is a lifecycle interface that gets called at the dispose
lifecycle stage of the implementing service as the service is being destroyed.Disposable interface.
DisposeException TODO (document class)EchoComponent will log the message and return the payload back as
the result.EncryptionNotSupportedException is thrown if an algorithm is set in
the MULE_USER header but it doesn't match the algorithm set on the security filterEncryptionStrategy can be used to provide different types of
Encryption strategy objects.EncryptionStrategyNotFoundException is thrown by the
SecurityManager when an encryption scheme is set in a property or header that
has not been registered witrh the managerEncryptionTransformer will transform an array of bytes or string
into an encrypted array of bytesEndpointException is an abstract exception extended by endpoint
specific exceptions.ImmutableEndpoint.EndpointNotFoundException is thrown when an endpoint name or
protocol is specified but a matching endpoint is not registered with the Mule
serverEndpointAbstractEventLoggerAgent will forward server notifications
to a configurered endpoint uri.EndpointSecurityFilter is a base filter for secure filtering of
inbound and outbout event flowEndpointSelector selects the outgoing endpoint based on a
message property ("endpoint" by default).EndpointURI is used to determine how a message is sent or
received.EndpointBuilder determines how a uri is translated to a
MuleEndpointURI Connectors can override the default behaviour to suit their needsEntryPoint defines the current entry method on a service.DefaultEntryPointResolverSet if after trying
all entrypointResolvers it cannot fin the entrypoint on the service serviceEntryPointResolver resolves a method to call on the given
UMODescriptor when an event is received for the serviceEntryPointResolver resolves a method to call on the given
service object when an event is received.EqualsFilter is a filter for comparing two objects using the
equals() method.EventGroup is a holder over events grouped by a common group Id.EventListener is a marker interface that is implemented by
objects wishing to receive UMO events in managed environments, succh as an EJB
container.EventTimerTask is a task that causes TimeEvent to be fired to
listening objects when a specific number of milliseconds have passed.ExceptionBasedRouter Will send the current event to the first
endpoint that doesn't throw an exception.ExceptionHelper provides a number of helper functions that can be
useful for dealing with Mule exceptions.ExceptionMessage is used by the DefaultServiceExceptionStrategy
for wrapping an exception with a message to send via an endpointUri.ExceptionNotificationListener is an observer interface that
objects can implement and then register themselves with the Mule manager to be
notified when a Exception event occurs.ExceptionPayload is a message payload that contains exception
information that occurred during message processing.Expirable implementing classes can be notified when they expireExpiryMonitor can monitor objects beased on an expiry time and can
invoke a callback method once the object time has expired.ExpressionEvaluator extracts a property from the message in a generic
way.ExpressionEvaluatorManager so that they will
be resolved at run-time.ExpressionEvaluatorManager if an expression returns null
and failIfNull was set when ExpressionEvaluatorManager.evaluate(String, Object, boolean)
was called.FailedToQueueEventException is thrown when an event cannot be put
on an internal service queue.FatalException can be thrown during initialisation or during
execution to indicate that something fatal has occurred and the MuleManager must
shutdown.FileUtils contains useful methods for dealing with files &
directories.Filter interface allows MuleMessage filtering.FilteringListMessageSplitter accepts a List as a message payload
then routes list elements as messages over an endpoint where the endpoint's filter
accepts the payload.FilteringRouter is a router that accepts events based on a filter
set.org.mule.api.context.notification.listener.ExceptionNotificationListener
eventManager.
org.mule.api.context.notification.listener.CustomNotificationListener notificationManager.
org.mule.api.context.notification.listener.TransactionNotificationListeners.
ForwardingCatchAllStrategy acts as a catch and forward router for
any events not caught by the router this strategy is associated with.ForwardingConsumer is used to forward an incoming event over
another transport without invoking a service.FutureMessageResult is an MuleMessage result of a remote invocation
on a Mule Server.META-INF/services/org/mule/i18n/<bundleName>-messages.properties) from
bundleName.
Service for each incoming
MuleEvent routed on by the InboundRouterCollection.
JavaComponent can have a custom entry-point resolver for its own
object.
RegExFilter.getPattern() This method name was changed to be consistent with other filters
ReflectionEntryPointResolver.addIgnoredMethod(String)
MessageAdapter from the connector for the given message
(data)
MessageAdapter for the endpoint for the given message
(data)
InvocationResult.STATE_INVOKED_SUCESSFUL
AbstractConnector.isCreateMultipleTransactedReceivers() returns true.
DefaultMessageCollection.getPayload(Class) call to every message in the collection and returns a
List of results.
TransportServiceDescriptor for this connector.
code from the resource bundle.
code from the resource bundle.
code from the resource bundle.
GZipCompression is a CompressionStrategy implementation using the
GZip library included in the JDK java.util.zip.GZipCompressTransformer is a transformer compressing objects into
byte arrays.GZipCompressTransformer TODORoutingException holds a reference to the current
message and te endpoint being routing to or from when the error occurred.
EventGroup.getGroupId().
HtmlTablePrinter prints event processing stats as a HTML tableIdempotentInMemoryMessageIdStore implements an optionally bounded
in-memory store for message IDs with periodic expiry of old entries.IdempotentMessageIdStore is the main interface used by
IdempotentReceiver for storing received message IDs.IdempotentReceiver ensures that only unique messages are received by a
service.IdempotentSecureHashReceiver ensures that only unique messages are
received by a service.ObjectUtils.identityToString(Object) but without the object's full package
name.
IllegalTransactionStateException TODO (document class)ImmutableEndpoint describes a Message endpoint where data is
sent or received.InboundPassThroughRouter allows inbound routing over all
registered endpoints without any filtering.InboundRouter defines an interface for an inbound Message
router.DefaultInboundRouterCollection manages a collection of inbound routers.TransportServiceDescriptor This
will be called before the AbstractConnector.doInitialise() method is called.
Initialisable is a lifecycle interface that gets called at the
initialise lifecycle stage of the implementing service.InitialisationCallback is used to provide customised initialiation
for more complex components.InitialisationException is thrown by the initialise method defined
in the org.mule.api.lifecycle.Initialisable interface.Initialisable interface.
AbstractMessageSplitter.getMessagePart(MuleMessage, OutboundEndpoint) method is called.
TransportFactory the endpoint used to
determine the connector type is passed to this method so that any properties
set on the endpoint that can be used to initialise the connector are made
available.
MessageDispatcherFactory.isCreateDispatcherPerRequest() returns
false, which means that dispatchers are pooled according to
their lifecycle as described in MessageDispatcher.
AbstractConnector.getNumberOfConcurrentTransactedReceivers().
MessageDispatcherFactory.isCreateDispatcherPerRequest() returns
false, which means that dispatchers are pooled according to
their lifecycle as described in MessageRequester.
TODO can be used as a source of trust information.
TlsConfiguration) then this flag will
control whether client authenticatin is required.
JavaComponent is a Java Component implementation used to
invoke Java component implementations.KeyedPoolMessageDispatcherFactoryAdapter adapts a
MessageDispatcherFactory with methods from commons-pool
KeyedPoolableObjectFactory.KeyedPoolMessageRequesterFactoryAdapter adapts a
MessageRequesterFactory with methods from commons-pool
KeyedPoolableObjectFactory.EntryPointResolverSet that mimics the behaviour of the Mule 1.x
DynamicEntryPointResolver.DefaultLifecyclePhase adds lifecycle methods start,
stop and dispose.LifecycleAdapter is a wrapper around a pojo service that adds Lifecycle methods to the pojo.LifecycleAdapterFactory TODO (document class)LifecycleException TODOLocaleMessageHandler is essentially a merging of the Message
and Messages classes, since there is no good reason to have them separate.AbstractNotificationLoggerAgent Receives Mule server notifications
and logs them and can optionally route them to an endpointLogComponent simply logs the content (or content length if it is a
large message)LoggingCatchAllStrategy is a simple strategy that only logs any
events not caught by the router associated with this strategy.Registry API as it should only be used
internally and may confuse users.
Transformer objects that accept the given
input and return the given output type of object
Transformer objects that accept the given
input and return the given output type of object
MalformedEndpointException is thrown by the MuleEndpointURI class
if it fails to parse a UrlManagementNotification is fired when monitored resources such as
internal queues reach capacityManagementNotificationListener is an observer interface that
objects can use to receive notifications about the state of the Mule instance and
its resourcesManualConstraint always returns false, meaning that the transaction
should be committed manually.MapLookup looks up and returns an object from a Map based on a key.PropertiesUtils.registerMaskedPropertyName(String).
MessageAdapter provides a common abstraction of different
message implementations provided by different underlying technologies.MessageDispatching with
various lifecycle methods for the actual instances doing message sending.MessageDispatcherFactory is a factory interface for managing the
lifecycles of a transport's message dispatchers.MessageNotificationListener is an observer interface that objects
can use to receive notifications about messages being sent and received from a
Mule ServerMessagePropertyFilter can be used to filter against properties on
an event.MessageReceiver is used to receive data from an external system.MessageRequesting with
various lifecycle methods for the actual instances doing message sending.MessageTypeNotSupportedException is thrown when a message payload
is set on a Message implementation of MessageAdapter which is not of supported
type for that message or adapter.MessagingException is a general message exception thrown when
errors specific to Message processing occur..Model encapsulates and manages the runtime behaviour of a
Mule Server instance.ModelNotification is fired when an event such as the model starting
occurs.ModelNotificationListener is an observer interface that objects can
implement and then register themselves with the Mule manager to be notified when a
Model event occurs.ModelServiceDescriptor describes the necessery information for
creating a model from a service descriptor.MuleContext.MuleContextException is thrown when an exception occurs with Manager
objectsCopyOfMuleContextFactory is used to create instances of
MuleContext.ContainerManagedLifecyclePhaseMuleContextNotification is fired when an event such as the mule
context starting occurs.MuleContextNotificationListener is an observer interface that objects
can implement and then register themselves with the Mule manager to be notified
when a Manager event occurs.MuleCredentials can be used to read and set Mule user information
that can be stored in a message header.MuleEncryptionEndpointSecurityFilter provides password-based
encryptionMuleEndpointURI is used to determine how a message is sent of
received.MuleEvent represents any data event occuring in the Mule
environment.MuleEventContext is the context object for the current request.MuleException is the base exception type for the Mule server any
other exceptions thrown by Mule code will be based on this exception,MuleHeaderCredentialsAccessor obtains and sets the user credentials
as Mule property headers.Log wrapper that supports boilerplate logging for high impact messagesMuleMessage represents a message payload.MessageInfoMapping that simply
grabs the message information from the MuleMessage untouched.MuleProperties is a set of constants pertaining to Mule properties.MuleRuntimeException Is the base runtime exception type for the
Mule Server any other runtimes exceptions thrown by Mule code will use or be based
on this exception.MuleSecurityManager is a default implementation security manager
for a Mule instance.MuleServer is a simple application that represents a local Mule
Server daemon.MuleSession is the context in which a request is executed.MuleTransactionConfig defines transaction configuration for a
transactional endpoint.MuleWorkManager is a JCA Work manager implementation used to manage
thread allocation for Mule components and connectors.Multicaster is a utility that can call a given method on a
collection of objects that implement one or more common interfaces.MulticastingRouter will broadcast the current message to every endpoint
registed with the router.MessageAdapter that can have its payload re-assigned after it
has been created.NamedObject.getName() and NamedObject.setName(java.lang.String) methods to an objectNestedRouterCollection manages a collection of nested routers.NoActionTransformer doesn't do any transformation on the source
object and returns the source as the result.NoReceiverForEndpointException is thrown when an enpoint is
specified for a receiver but no such receiver exists.NoSatisfiableMethodsException is thrown by EntryPointResolvers when
the service passed has no methods that meet the criteria of the configured
EntryPointResolver.NotFilter accepts if the filter does not accept.NullComponent is a service that is used as a placeholder.NullPayload represents a null event payloadNumberUtils contains useful methods for manipulating numbers.ObjectArrayToString transformer is the opposite of
StringToObjectArray - it simply converts Object[] to a String in which each
element is separated by a configurable delimiter (default is a space).ObjectFactory is a generic Factory interface.ObjectPool is a simple pooling interface for objectsObjectToByteArray converts serilaizable object to a byte array but
treats java.lang.String differently by converting to bytes using
the String.getBytrs() method.ObjectToInputStream converts serilaizable object to a input stream but
treats java.lang.String differently by converting to bytes using
the String.getBytrs() method.ObjectToOutputHandler converts a byte array into a String.ObjectToString transformer is useful for debugging.OrFilter accepts if any of the filters accept the messageOutboundPassThroughRouter allows outbound routing over a single
endpoint without any filtering.OutboundRouter is used to control outbound routing behaviour for
an event.OutboundRouterCollection is responsible for holding all outbound routers for a service service.-Dkey=value
format.
PassThroughComponent will simply return the payload back as the result.PayloadTypeFilter filters based on the type of the object received.PooledJavaComponent implements pooling.LifeCycleAdaptorFactory wraps the Component' s
ObjectFactory.PoolingProfile is a configuration object used to define the object
pooling parameters for the service it is associated with.AbstractReceiverWorker.handleResults(java.util.List))
MapUtils.toString(Map, boolean) instead
PropertiesHelper is a utility class for manipulating and filtering
property Maps.PropertyFactory is used to create objects from the property file.PropertyScope instances in a map.Queue TODOQueuePersistenceStrategy defines the The api to a persistent queue
store.QueueProfile determines how an internal queue for a service will
behaveBase64.InputStream.read() repeatedly until the end of stream is reached or
len bytes are read.
ReceiveException is specifically thrown by the Provider receive
method if something fails in the underlying transportRecoverableException can be thrown during initialisation to
indicate that the error occurred is not fatal and a reactive action can be
performed to try and remedy the error.ReflectEntryPointResolver is used to determine the entry point on a service
after an event has been received for it.RegExFilter is used to match a String argument against a regular
pattern.MessageReceiver associated with this endpoint
and registers it with the connector
RegistyNotification is fired when an event such as an object being
registered in the Registry starting occurs.RegistryNotificationListener is an observer interface that objects
can implement and then register themselves with the MuleContext to be notified
when a Registry event occurs.StringUtils.repeat(String, int) but with a single character as argument.
ReplyToHandler is used to handle routing where a replyTo endpointUri is
set on the messageRequestContext is a thread context where components can get the
current event or set response properties that will be sent on the outgoing
message.ResourceNameEndpointBuilder extracts a resource name from a uri
endpointUriResponseCorrelationAggregator Correlates one or more events on a
response flow using the Correlation Id to group events.ResponseOutputStream is an output stream associated with the
currently received event.ResponseRouter is a router that handles response flow.ResponseRouterCollection is a router that can be used to control
how the response in a request/response message flow is created.ResponseTimeoutException is thrown when a response is not received
in a given timeout in the Response Router.AbstractTransformer.transform(java.lang.Object) method is
called
RoutePathNotFoundException is thrown if a routing path for an event
cannot be found.Router is a base interface for all routers.RouterCatchAllStrategy TODORouterCollection defines the interface for a MessageRouter that
manages more than one router.RouterStatistics TODORoutingException is a base class for all routing exceptions.RoutingNotificationListener is an observer interface that objects
can use to receive notifications about routing events such as async-reply misses.AbstractReceiverWorker.release() once AbstractReceiverWorker.doRun() completes.
SecretKeyEncryptionStrategy.SecurityContext holds security information and is associated
with the MuleSession.SecurityContextFactory is responsible for creating a
SecurityContext instance.SecurityException is a generic security exceptionSecurityManager is responsible for managing one or more
security providers.SecurityNotification is fired when a request for authorisation
occurs.MuleContextNotificationListener is an observer interface that objects
can implement to receive notifications about secure access requests.SecurityProvider is a target security provider thsat actually
does the work of authenticating credentials and populating the Authentication
object.SecurityProviderNotFoundException is thrown by the
SecurityManager when an authentication request is made but no suitable security
provider can be found to process the authenticationSelectiveConsumer is an inbound router used to filter out unwanted
events.SerializableToByteArray converts a serializable object or a String
to a byte array.ServerNotification is an event triggered by something happening
in the Server itself such as the server starting or a service being registered.ServerNotificationListener is an observer interface that ojects
can implement and register themselves with the Mule Server to receive
notifications when the server, model and components stop, start, initialise, etc.Service is the interal repesentation of a Mule Managed service.ServiceAware is an injector interface that will supply a
Service to the object.ServiceCatchAllStrategy is used to catch any events and forward the
events to the service as is.ServiceException should be thrown when some action on a service
fails, such as starting or stoppingServiceFinder can be used as a hook into the service lookup process to
return the correct Service Descriptor for a given service name.ServiceNotification is fired when an event such as the service
starting occurs.ServiceNotificationListener is an observer interface that objects
can implement and then register themselves with the Mule manager to be notified
when a Service event occurs.ServiceRoutingException is thrown due to a routing exception
between the endpoint the event was received on and the service receiving the
event.SessionException is thrown when errors occur in the DefaultMuleSession or
Seession ManagerService for each incoming
MuleEvent routed on by the InboundRouterCollection.
JavaComponent can have a custom entry-point resolver for its own
object.
InvocationResult.STATE_INVOKED_SUCESSFUL
TODO can be used as a source of trust information.
RegExFilter.getPattern() This method name was changed to be consistent with other filters
TlsConfiguration) then this flag will
control whether client authenticatin is required.
SingleResponseRouter will return true if the event group
size is 1.
JavaComponent implementation to be used when
LifecycleAdapter is not required because i) the object instance implements
Callable and so entry-point resolution is required and ii) nested-routers
are not used.ObjectFactory can be set but must return object
instances that implement Callable.Callable
SimplePrinter Default stats printerregistry-bootstrap.properties into the local registry.SocketEndpointBuilder builds an endpointUri based on host and port
onlyStringUtils.split(String, String), but
additionally trims whitespace from the result tokens.
Startable interface.
Startable provides an object with a Startable.start() method
which gets called when the Mule instance gets started.DisposeException TODO (document class)StaticRecipientList is used to dispatch a single event to multiple
recipients over the same transport.Statistics TODOStoppable interface.
MuleManager which stops all sessions and
connectors
DisposeException TODO (document class)Stoppable TODO (document class)StringToObjectArray converts a String into an object array.StringUtils contains useful methods for manipulating Strings.TemplateParser is a simple string parser that will substitute
tokens in a string with values supplied in a Map.TimeEvent TODO is an event that occurs at a specified number of
milliseconds.TimeEventListener provides a method to pass timer events to
implementing objects.TlsConfiguration to and from Properties (typically System Properties).TlsConfiguration
that has been stored via TlsPropertiesMapper.Class as
element type.
Class as element type.
IOUtils' toByteArray(InputStream)
method but catches any IOException and wraps it into a RuntimeException.
TooManySatisfiableMethodsException is thrown by EntryPointResolvers
when the service passed has more than one method that meets the criteria of the
configured EntryPointResolver.ArrayUtils.toString(Object) but considers at most maxElements
values; overflow is indicated by an appended "[..]" ellipsis.
CollectionUtils.toString(Collection, int, boolean) with false
for newline.
IOUtils' toString(InputStream)
method but catches any IOException and wraps it into a RuntimeException.
#TransactedPollingMessageReceiver(Connector,Service,InboundEndpoint,long,TimeUnit)
instead
TransactionConfig defines transaction configuration for a
transactional endpoint.TransactionException is thrown when an exception occurs while
trying to create, start commit or rollback an exceptionTransactionFactory creates a transaction.TransactionInProgressException is thrown if a new transaction is
started when there is one already in progress.TranactionManagerFactory is a factory class for creating a
transaction manager for the MuleServer.TransactionNotificationListener is an observer interface that objects
can implement and then register themselves with the Mule manager to be notified
when a Transaction event occurs.TransactionNotInProgressException TODO (document class)Transformer can be chained together to covert message payloads
from one object type to another.TransformerException is a simple exception that is thrown by
transformers.Transformer instance, an input class and output class
this object will create a weighting for a transformer.TransportFactory can be used for generically creating endpoints
from an url.TransportFactoryException is thrown by the endpoint factory if the
endpoint service cannot be found in the META-INF/services directory or if any part
of the endpoint cannot be instanciated.TransportServiceDescriptor describes the necessary information for
creating a connector from a service descriptor.TransportServiceException is thrown if a ProviderServicedescriptor
has a service error set.TransportServiceNotFoundException is thorown if no matching service
endpoint descriptor is found for the connector protocol.UnauthorisedException is thrown if authentication failsUniqueIdNotSupportedException is thrown by
MessageAdapter.getUniqueId() if the underlying message does not support or have
a unique identifier.UnknownAuthenticationTypeException is thrown if a security context
request is make with an unrecognised Authentication type.AbstractPollingMessageReceiver.schedule().
UnsupportedAuthenticationSchemeException is thrown when a
authentication scheme is being used on the message that the Security filter does
not understandEndpointURIBuilderUrlEndpointBuilder is the default endpointUri strategy suitable for
most connectorsUserInfoEndpointBuilder builds an endpoint with the userinfo and
host details.UUID Generates a UUID using the JUG libraryMessageDispatcherFactory.passivate(OutboundEndpoint, MessageDispatcher).
MessageRequesterFactory.passivate(org.mule.api.endpoint.InboundEndpoint, org.mule.api.transport.MessageRequester).
WildcardFilter is used to match Strings against wildcards.WorkerContext TODOWorkExecutor TODOWorkManager extends the standard JCA WorkManager with lifecycle
methods and util.concurrent bridging.Base64.OutputStream.write(int) repeatedly until len bytes are
written.
WriterMessageAdapter wraps a java.io.StringWriter and allows meta
information to be associated with the Writer.XaTransaction represents an XA transaction in Mule.XaTransactionFactory Is used to create/retrieve a Transaction from
a transaction manager configured on the MuleManager.XMLPrinter prints event processing stats as a XML document
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||