Uses of Interface
org.mule.api.lifecycle.Stoppable

Packages that use Stoppable
org.mule The Mule implementation of the Universal Message Objects(tm) API specification. 
org.mule.agent Admin components and Agents used to control and Monitor Mule 
org.mule.api The Universal Message Object(tm) API provides a way for components to interact without needing to know about the protocol or delivery mechanisms of information passed between them 
org.mule.api.agent   
org.mule.api.callback   
org.mule.api.component   
org.mule.api.endpoint Endpoint interfaces. 
org.mule.api.lifecycle Lifecycle interfaces for all Components. 
org.mule.api.model Contains the interfaces for the Model and supporting objects such as the CompoenntResolver, EntryPointResolver, etc. 
org.mule.api.routing Interfaces that define inbound and outbound routing API. 
org.mule.api.schedule   
org.mule.api.service   
org.mule.api.transport Contains the interfaces that comprise a provider implementation. 
org.mule.component   
org.mule.component.simple A collection of simple mule components that can be useful to simplify configuration while testing. 
org.mule.config.dsl.routers   
org.mule.config.support   
org.mule.construct   
org.mule.devkit.processor   
org.mule.endpoint Implemtation of Mule endpoint uris. 
org.mule.endpoint.dynamic   
org.mule.enricher   
org.mule.example.loanbroker.routers   
org.mule.example.notifications   
org.mule.exception   
org.mule.management.stats Jmx statistics support used to monitor messaging status for various Mule components. 
org.mule.model   
org.mule.model.seda   
org.mule.module.atom   
org.mule.module.bpm   
org.mule.module.client.remoting   
org.mule.module.cxf   
org.mule.module.cxf.component   
org.mule.module.cxf.config   
org.mule.module.jersey   
org.mule.module.launcher.coreextension   
org.mule.module.management.agent Management agents including agents for Jdmk, MX4J, and Log4J 
org.mule.module.management.mbean Jmx Management beans for mule components, the model and the Mule server. 
org.mule.module.scripting.component Base classes for script based components such as BeanShell or Groovy. 
org.mule.module.sxc   
org.mule.module.ws.construct   
org.mule.modules.schedulers.cron   
org.mule.processor   
org.mule.processor.chain   
org.mule.routing Defines the core routing patterns supported by mule. 
org.mule.routing.correlation   
org.mule.routing.outbound Outbound router implementation as described in the Enterprise Integration Patterns book. 
org.mule.routing.requestreply   
org.mule.security.oauth   
org.mule.security.oauth.processor   
org.mule.service   
org.mule.service.processor   
org.mule.source   
org.mule.streaming.processor   
org.mule.tck.functional Helper classes and interfaces used by Mule fnctional tests. 
org.mule.tck.testmodels.services   
org.mule.transport Contains Abstract classes providing common functionality for all Mule providers. 
org.mule.transport.ajax   
org.mule.transport.ajax.container A AJAX transport allows Mule applications to send a receive events to the web browser. 
org.mule.transport.ajax.embedded A AJAX transport allows Mule applications to send a receive events to the web browser. 
org.mule.transport.ejb   
org.mule.transport.email Provides pop3, smtp and imap connectivity for Mule
org.mule.transport.file Provides file transport in the form of a directory listeners and file dispatchers. 
org.mule.transport.ftp   
org.mule.transport.http Provides http transport including proxy support. 
org.mule.transport.http.components   
org.mule.transport.http.construct   
org.mule.transport.jdbc Provides jdbc transport. 
org.mule.transport.jms Provides Jms transport connectivity with support for all Jms features. 
org.mule.transport.jms.activemq Provides Jms connectivity with ActiveMQ-specific workarounds and improvements. 
org.mule.transport.jms.jndi   
org.mule.transport.jms.mulemq   
org.mule.transport.jms.weblogic Provides Jms connectivity with Weblogic-specific workarounds and improvements. 
org.mule.transport.jms.websphere Provides Jms connectivity with Websphere-specific workarounds and improvements. 
org.mule.transport.jnp   
org.mule.transport.multicast IP multicast connectivity for Mule
org.mule.transport.polling   
org.mule.transport.polling.schedule   
org.mule.transport.quartz   
org.mule.transport.quartz.jobs   
org.mule.transport.rmi   
org.mule.transport.servlet   
org.mule.transport.servlet.jetty   
org.mule.transport.sftp   
org.mule.transport.soap.axis Provides an Axis soap transport for Mule
org.mule.transport.soap.axis.wsdl   
org.mule.transport.ssl Provides tcp connectivity over Ssl for Mule
org.mule.transport.stdio   
org.mule.transport.tcp Provides tcp connectivity for Mule
org.mule.transport.udp Provides Udp connectivity for Mule
org.mule.transport.vm A connector implementation allowing events to be passed between Mule sessions via in-memory queues. 
org.mule.transport.xmpp   
org.mule.util.pool   
org.mule.util.queue A resource manager that allow access to transactional queues with optional persistence. 
 

Uses of Stoppable in org.mule
 

Subinterfaces of Stoppable in org.mule
 interface MuleCoreExtension
          Allows Mule modules and transports to extend core functionality in an application-independent fashion.
 

Classes in org.mule that implement Stoppable
 class AbstractAgent
          Implements common methods for all Agents.
 class DefaultMuleContext
           
 

Uses of Stoppable in org.mule.agent
 

Classes in org.mule.agent that implement Stoppable
 class AbstractNotificationLoggerAgent
          AbstractNotificationLoggerAgent Receives Mule server notifications and logs them and can optionally route them to an endpoint.
 class EndpointNotificationLoggerAgent
          EndpointAbstractEventLoggerAgent will forward server notifications to a configurered endpoint uri.
 class Log4jNotificationLoggerAgent
          AbstractNotificationLoggerAgent Receives Mule server notifications and logs them and can optionally route them to an endpoint
 

Uses of Stoppable in org.mule.api
 

Subinterfaces of Stoppable in org.mule.api
 interface MuleContext
           
 

Uses of Stoppable in org.mule.api.agent
 

Subinterfaces of Stoppable in org.mule.api.agent
 interface Agent
          Agent is a server plugin that can be initialised, started and destroyed along with the MuleContext itself.
 

Uses of Stoppable in org.mule.api.callback
 

Subinterfaces of Stoppable in org.mule.api.callback
 interface HttpCallback
          Base interface for components that publish a http callback.
 

Uses of Stoppable in org.mule.api.component
 

Subinterfaces of Stoppable in org.mule.api.component
 interface LifecycleAdapter
          LifecycleAdapter is a wrapper around a pojo service that adds Lifecycle methods to the pojo.
 

Uses of Stoppable in org.mule.api.endpoint
 

Subinterfaces of Stoppable in org.mule.api.endpoint
 interface InboundEndpoint
           
 

Uses of Stoppable in org.mule.api.lifecycle
 

Subinterfaces of Stoppable in org.mule.api.lifecycle
 interface Lifecycle
          DefaultLifecyclePhase adds lifecycle methods start, stop and dispose.
 

Constructors in org.mule.api.lifecycle with parameters of type Stoppable
StopException(Message message, Stoppable component)
           
StopException(Message message, Throwable cause, Stoppable component)
           
StopException(Throwable cause, Stoppable component)
           
 

Uses of Stoppable in org.mule.api.model
 

Subinterfaces of Stoppable in org.mule.api.model
 interface Model
          Deprecated. 
 

Uses of Stoppable in org.mule.api.routing
 

Subinterfaces of Stoppable in org.mule.api.routing
 interface OutboundRouter
          OutboundRouter is used to control outbound routing behaviour for an event.
 

Uses of Stoppable in org.mule.api.schedule
 

Subinterfaces of Stoppable in org.mule.api.schedule
 interface Scheduler
           An scheduler is a class that arrange jobs in a define schedule.
 

Uses of Stoppable in org.mule.api.service
 

Subinterfaces of Stoppable in org.mule.api.service
 interface Service
          Deprecated. 
 

Uses of Stoppable in org.mule.api.transport
 

Subinterfaces of Stoppable in org.mule.api.transport
 interface Connectable
          Interface for objects that should connect to a resource.
 interface Connector
          Connector is the mechanism used to connect to external systems and protocols in order to send and receive data.
 interface MessageDispatcher
          Combine MessageDispatching with various lifecycle methods for the actual instances doing message sending.
 interface MessageReceiver
          MessageReceiver is used to receive data from an external system.
 interface MessageRequester
          Combine MessageRequesting with various lifecycle methods for the actual instances doing message sending.
 

Uses of Stoppable in org.mule.component
 

Classes in org.mule.component that implement Stoppable
 class AbstractComponent
          Abstract Component to be used by all Component implementations.
 class AbstractJavaComponent
          Abstract implementation of JavaComponent adds JavaComponent specifics like EntryPointResolverSet and ObjectFactory.
 class DefaultComponentLifecycleAdapter
          DefaultComponentLifecycleAdapter is a default implementation of LifecycleAdapter for use with JavaComponent that expects component instances to implement Mule lifecycle interfaces in order to receive lifecycle.
 class DefaultJavaComponent
          Default implementation of JavaComponent.
 class NullLifecycleAdapter
          NullLifecycleAdapter is a lifecycle adaptor implementation that performs no Mule lifecycle propagation to Mule service component implementations.
 class PooledJavaComponent
          PooledJavaComponent implements pooling.
 class SimpleCallableJavaComponent
          Simple 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) component bindings are not used.
An ObjectFactory can be set but must return object instances that implement Callable.
 

Uses of Stoppable in org.mule.component.simple
 

Classes in org.mule.component.simple that implement Stoppable
 class PassThroughComponent
          PassThroughComponent will simply return the payload back as the result.
 

Uses of Stoppable in org.mule.config.dsl.routers
 

Classes in org.mule.config.dsl.routers that implement Stoppable
 class ContentBasedRouter
          Deprecated. 
 

Uses of Stoppable in org.mule.config.support
 

Classes in org.mule.config.support that implement Stoppable
 class InheritedModel
          Deprecated. 
 

Uses of Stoppable in org.mule.construct
 

Classes in org.mule.construct that implement Stoppable
 class AbstractConfigurationPattern
          A template class for configuration patterns, which takes care of setting common message processors and optional transformers defined on the pattern.
 class AbstractFlowConstruct
          Abstract implementation of FlowConstruct that: Is constructed with unique name and MuleContext.
 class AbstractPipeline
          Abstract implementation of AbstractFlowConstruct that allows a list of AbstractPipeline.ProcessIfPipelineStartedMessageProcessors that will be used to process messages to be configured.
 class Bridge
          A simple bridge between a single inbound endpoint and a single outbound endpoint.
 class Flow
          This implementation of AbstractPipeline adds the following functionality: Rejects inbound events when Flow is not started Gathers statistics and processing time data Implements MessagePorcessor allowing direct invocation of the pipeline Supports the optional configuration of a ProcessingStrategy that determines how message processors are processed.
 class SimpleService
          In-out SOA-style simple service, with no outbound router.
 class Validator
           
 

Uses of Stoppable in org.mule.devkit.processor
 

Classes in org.mule.devkit.processor that implement Stoppable
 class DevkitBasedMessageProcessor
           
 

Uses of Stoppable in org.mule.endpoint
 

Classes in org.mule.endpoint that implement Stoppable
 class DefaultInboundEndpoint
           
 class DynamicURIInboundEndpoint
          Allow's EndpointURI to be set and changed dynamically by wrapping up an immutable endpoint instance.
 

Uses of Stoppable in org.mule.endpoint.dynamic
 

Classes in org.mule.endpoint.dynamic that implement Stoppable
 class NullConnector
          A placeholder for a connector that has not been created yet.
 

Uses of Stoppable in org.mule.enricher
 

Classes in org.mule.enricher that implement Stoppable
 class MessageEnricher
          The Message Enricher allows the current message to be augmented using data from a seperate resource.
 

Uses of Stoppable in org.mule.example.loanbroker.routers
 

Classes in org.mule.example.loanbroker.routers that implement Stoppable
 class BankQuotesInboundAggregator
          BankQuotesInboundAggregator receives a number of quotes and selects the lowest
 class BankQuotesResponseAggregator
          BankQuotesInboundAggregator receives a number of quotes and selects the lowest
 

Uses of Stoppable in org.mule.example.notifications
 

Classes in org.mule.example.notifications that implement Stoppable
 class HeartbeatAgent
          A simple agent that fire HeartbeatNotification events at a given frequency to notify that the server is alive and well.
 

Uses of Stoppable in org.mule.exception
 

Classes in org.mule.exception that implement Stoppable
 class AbstractExceptionListener
          This is the base class for exception strategies which contains several helper methods.
 class AbstractExceptionStrategy
          Deprecated. use AbstractExceptionListener
 class AbstractMessagingExceptionStrategy
          Fire a notification, log exception, increment statistics, route the problematic message to a destination if one is configured (DLQ pattern), commit or rollback transaction if one exists, close any open streams.
 class AbstractSystemExceptionStrategy
          Fire a notification, log exception, clean up transaction if any, and trigger reconnection strategy if this is a ConnectException.
 class CatchMessagingExceptionStrategy
           
 class ChoiceMessagingExceptionStrategy
          Selects which exception strategy to execute based on filtering.
 class DefaultMessagingExceptionStrategy
          This is the default exception handler for flows and services.
 class DefaultServiceExceptionStrategy
          Deprecated. use DefaultMessagingExceptionStrategy instead
 class DefaultSystemExceptionStrategy
          This is the default exception handler for any exception which does not inherit from MessagingException, i.e, when no message is in play.
 class MessagingExceptionStrategyAcceptorDelegate
          Allows to use MessagingExceptionHandler as MessagingExceptionHandlerAcceptor.
 class RollbackMessagingExceptionStrategy
           
 class TemplateMessagingExceptionStrategy
           
 

Uses of Stoppable in org.mule.management.stats
 

Subinterfaces of Stoppable in org.mule.management.stats
 interface ProcessingTimeWatcher
          Watches ProcessingTime instances to detect when they are weakly reachable.
 

Classes in org.mule.management.stats that implement Stoppable
 class DefaultProcessingTimeWatcher
           
 

Uses of Stoppable in org.mule.model
 

Classes in org.mule.model that implement Stoppable
 class AbstractModel
          Deprecated. 
 

Uses of Stoppable in org.mule.model.seda
 

Classes in org.mule.model.seda that implement Stoppable
 class SedaModel
          Deprecated. 
 class SedaService
          Deprecated. 
 

Uses of Stoppable in org.mule.module.atom
 

Classes in org.mule.module.atom that implement Stoppable
 class AbderaServiceComponent
          This component receives requests from Mule and passes them off to Abdera.
 

Uses of Stoppable in org.mule.module.bpm
 

Classes in org.mule.module.bpm that implement Stoppable
 class ProcessComponent
          A service backed by the execution of a business process such as jBPM.
 class RulesComponent
          A service backed by a Business Rules engine such as Drools.
 

Uses of Stoppable in org.mule.module.client.remoting
 

Classes in org.mule.module.client.remoting that implement Stoppable
 class RemoteDispatcherAgent
          RemoteDispatcherAgent manages the server endpoint that receives Admin and remote client requests
 

Uses of Stoppable in org.mule.module.cxf
 

Classes in org.mule.module.cxf that implement Stoppable
 class CxfComponentExceptionStrategy
          Deprecated. Currently the result is the same if no exception strategy is defined within the flow. The only difference is that when you set the CxfComponentExceptionStrategy the exception is unwrapped inside of the exception block, but the exceptionPayload doesn't change.
 class CxfInboundMessageProcessor
          The CxfInboundMessageProcessor performs inbound CXF processing, sending an event through the CXF service, then on to the next MessageProcessor.
 

Uses of Stoppable in org.mule.module.cxf.component
 

Classes in org.mule.module.cxf.component that implement Stoppable
 class AbstractWebServiceWrapperComponent
           
 class WebServiceWrapperComponent
          Deprecated. 
 

Uses of Stoppable in org.mule.module.cxf.config
 

Classes in org.mule.module.cxf.config that implement Stoppable
 class FlowConfiguringMessageProcessor
          Wraps a MessageProcessorBuilder and configures it lazily so it can be injected with the FlowConstruct.
 

Uses of Stoppable in org.mule.module.jersey
 

Classes in org.mule.module.jersey that implement Stoppable
 class JerseyResourcesComponent
          Wraps a set of components which can get invoked by Jersey.
 

Uses of Stoppable in org.mule.module.launcher.coreextension
 

Subinterfaces of Stoppable in org.mule.module.launcher.coreextension
 interface MuleCoreExtensionManager
          Manages lifecycle and dependency injection for MuleCoreExtension
 

Classes in org.mule.module.launcher.coreextension that implement Stoppable
 class DefaultMuleCoreExtensionManager
           
 

Uses of Stoppable in org.mule.module.management.agent
 

Classes in org.mule.module.management.agent that implement Stoppable
 class DefaultJmxSupportAgent
           
 class JdmkAgent
          JdmkAgent configures an Jdmk Http Adaptor for Jmx management, statistics and configuration viewing of a Mule instance.
 class JmxAgent
          JmxAgent registers Mule Jmx management beans with an MBean server.
 class JmxServerNotificationAgent
          An agent that propergates Mule Server notifications to Jmx.
 class Log4jAgent
          Log4jAgent exposes the configuration of the Log4J instance running in Mule for Jmx management
 class Mx4jAgent
          Mx4jAgent configures an Mx4J Http Adaptor for Jmx management, statistics and configuration viewing of a Mule instance.
 class RmiRegistryAgent
          Binds to an existing RMI registry or creates a new one on a defined URI.
 class WrapperManagerAgent
          This agent integrates Java Service Wrapper into Mule.
 class YourKitProfilerAgent
           
 

Uses of Stoppable in org.mule.module.management.mbean
 

Subinterfaces of Stoppable in org.mule.module.management.mbean
 interface ServiceServiceMBean
          Deprecated. 
 

Classes in org.mule.module.management.mbean that implement Stoppable
 class ServiceService
          ServiceService exposes service information about a Mule Managed service.
 

Uses of Stoppable in org.mule.module.scripting.component
 

Classes in org.mule.module.scripting.component that implement Stoppable
 class ScriptComponent
          A Script service backed by a JSR-223 compliant script engine such as Groovy, JavaScript, or Rhino.
 

Uses of Stoppable in org.mule.module.sxc
 

Classes in org.mule.module.sxc that implement Stoppable
 class SxcFilteringOutboundRouter
          FilteringRouter is a router that accepts events based on a filter set.
 

Uses of Stoppable in org.mule.module.ws.construct
 

Classes in org.mule.module.ws.construct that implement Stoppable
 class WSProxy
          This class is implemented to act as a Proxy for a Web Service.
 

Uses of Stoppable in org.mule.modules.schedulers.cron
 

Classes in org.mule.modules.schedulers.cron that implement Stoppable
 class CronScheduler
           Cron Scheduler implemented with Quartz.
 

Uses of Stoppable in org.mule.processor
 

Classes in org.mule.processor that implement Stoppable
 class AbstractMessageProcessorOwner
          An object that owns message processors and delegates startup/shutdown events to them.
 class AbstractMuleObjectOwner<T>
          An object that owns Mule objects and delegates startup/shutdown events to them.
 class AbstractRedeliveryPolicy
          Implement a redelivery policy for Mule.
 class AsyncDelegateMessageProcessor
          Processes MuleEvent's asynchronously using a MuleWorkManager to schedule asynchronous processing of MessageProcessor delegate configured the next MessageProcessor.
 class AsyncInterceptingMessageProcessor
          Processes MuleEvent's asynchronously using a MuleWorkManager to schedule asynchronous processing of the next MessageProcessor.
 class IdempotentRedeliveryPolicy
          Implement a retry policy for Mule.
 class LaxAsyncInterceptingMessageProcessor
           
 class LaxSedaStageInterceptingMessageProcessor
          Processes MuleEvent's asynchronously using a MuleWorkManager to schedule asynchronous processing of the next MessageProcessor.
 class ResponseMessageProcessorAdapter
           
 class SedaStageInterceptingMessageProcessor
          Processes MuleEvent's asynchronously using a MuleWorkManager to schedule asynchronous processing of the next MessageProcessor.
 class TransactionalInterceptingMessageProcessor
          Wraps the invocation of the next MessageProcessor with a transaction.
 

Uses of Stoppable in org.mule.processor.chain
 

Classes in org.mule.processor.chain that implement Stoppable
 class AbstractMessageProcessorChain
          Builder needs to return a composite rather than the first MessageProcessor in the chain.
 class DefaultMessageProcessorChain
           
 class InterceptingChainLifecycleWrapper
          Builder needs to return a composite rather than the first MessageProcessor in the chain.
 class SimpleMessageProcessorChain
           
 class SubflowInterceptingChainLifecycleWrapper
          Generates message processor identfiers specific for subflows.
 

Uses of Stoppable in org.mule.routing
 

Classes in org.mule.routing that implement Stoppable
 class AbstractAggregator
          AbstractEventAggregator will aggregate a set of messages into a single message.
 class AbstractCorrelationAggregator
          AbstractCorrelationAggregatingMessageProcessor uses the CorrelationID and CorrelationGroupSize properties of the MuleMessage to manage message groups.
 class AbstractSelectiveRouter
           
 class AsynchronousUntilSuccessfulProcessingStrategy
          Until successful asynchronous processing strategy.
 class ChoiceRouter
          Routes the event to a singleMessageProcessor using a Filter to evaluate the event being processed and find the first route that can be used.
 class FirstSuccessful
          FirstSuccessful routes an event to the first target route that can accept it without throwing or returning an exception.
 class Foreach
          ` * The Foreach MessageProcessor allows iterating over a collection payload, or any collection obtained by an expression, generating a message for each element.
 class MessageChunkAggregator
           
 class MessageFilter
          Implementation of InterceptingMessageProcessor that filters message flow using a Filter.
 class MessageProcessorFilterPair
          A holder for a pair of MessageProcessor and Filter.
 class Resequencer
          Resequencer is used to resequence events according to their dispatch sequence in the correlation group.
 class RoundRobin
          RoundRobin divides the messages it receives among its target routes in round-robin fashion.
 class ScatterGatherRouter
           The Scatter-Gather router will broadcast copies of the current message to every endpoint registered with the router in parallel.
 class SimpleCollectionAggregator
          This router will return all aggregated events as a MuleMessageCollection.
 class UntilSuccessful
          UntilSuccessful attempts to route a message to the message processor it contains.
 class WireTap
          The WireTap MessageProcessor allows inspection of messages in a flow.
 

Uses of Stoppable in org.mule.routing.correlation
 

Classes in org.mule.routing.correlation that implement Stoppable
 class EventCorrelator
           
 

Uses of Stoppable in org.mule.routing.outbound
 

Classes in org.mule.routing.outbound that implement Stoppable
 class AbstractMessageSplitter
          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.
 class AbstractOutboundRouter
          AbstractOutboundRouter is a base router class that tracks statistics about message processing through the router.
 class AbstractRecipientList
          AbstractRecipientList is used to dispatch a single event to multiple recipients over the same transport.
 class AbstractRoundRobinMessageSplitter
          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.
 class AbstractSequenceRouter
          Defines a router that sequentially routes a given message to the list of registered endpoints and returns the aggregate responses as the result.
 class ChainingRouter
          ChainingRouter is used to pass a Mule event through multiple targets using the result of the first as the input for the second.
 class EndpointSelector
          EndpointSelector selects the outgoing endpoint based on a an expression evaluator ("header:endpoint" by default).
 class ExceptionBasedRouter
          ExceptionBasedRouter Will send the current event to the first endpoint that doesn't throw an exception.
 class ExpressionMessageSplitter
          Evaluates a single expression and adds the results of the expression as individual message parts.
 class ExpressionRecipientList
           
 class FilteringOutboundRouter
          FilteringRouter is a router that accepts events based on a filter set.
 class ListMessageSplitter
          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.
 class MessageChunkingRouter
          A router that breaks up the current message onto smaller parts and sends them to the same destination.
 class MulticastingRouter
          MulticastingRouter will broadcast the current message to every endpoint registered with the router.
 class OutboundPassThroughRouter
          OutboundPassThroughRouter allows outbound routing over a single endpoint without any filtering.
 class SequenceRouter
          Defines a AbstractSequenceRouter that stops the routing of a given message when a synchronous endpoint has returned a null or an exception message.
 class StaticRecipientList
          StaticRecipientList is used to dispatch a single event to multiple recipients over the same transport.
 class TransformerRouter
          Deprecated.  
 

Uses of Stoppable in org.mule.routing.requestreply
 

Classes in org.mule.routing.requestreply that implement Stoppable
 class AbstractAsyncRequestReplyRequester
           
 class SimpleAsyncRequestReplyRequester
           
 

Uses of Stoppable in org.mule.security.oauth
 

Classes in org.mule.security.oauth that implement Stoppable
 class BaseOAuth2Manager<C extends OAuth2Adapter>
           
 class DefaultHttpCallback
          Default implementation of HttpCallback.
 

Uses of Stoppable in org.mule.security.oauth.processor
 

Classes in org.mule.security.oauth.processor that implement Stoppable
 class AbstractAuthorizeMessageProcessor
           
 class AbstractListeningMessageProcessor
           
 class BaseOAuth1AuthorizeMessageProcessor
           
 class BaseOAuth1UnauthorizeMessageProcessor
           
 class BaseOAuth2AuthorizeMessageProcessor<T extends OAuth2Manager<OAuth2Adapter>>
           
 class BaseOAuth2UnauthorizeMessageProcessor<T extends OAuth2Manager<OAuth2Adapter>>
           
 class FetchAccessTokenMessageProcessor
           
 class OAuth1FetchAccessTokenMessageProcessor
           
 class OAuth2FetchAccessTokenMessageProcessor
           
 

Uses of Stoppable in org.mule.service
 

Classes in org.mule.service that implement Stoppable
 class AbstractService
          Deprecated. 
 class ForwardingConsumer
          Deprecated.  
 class ServiceAsyncReplyCompositeMessageSource
          Deprecated. 
 class ServiceCompositeMessageSource
          Deprecated. 
 

Uses of Stoppable in org.mule.service.processor
 

Classes in org.mule.service.processor that implement Stoppable
 class ServiceAsyncRequestReplyRequestor
          Deprecated. 
 

Uses of Stoppable in org.mule.source
 

Classes in org.mule.source that implement Stoppable
 class ClusterizableMessageSourceWrapper
          Wraps a ClusterizableMessageSource in order to manage the lifecycle of the wrapped instance differently depending if the node is primary or not inside a cluster.
 class StartableCompositeMessageSource
          Implementation of CompositeMessageSource that propagates both injection of FlowConstruct and lifecycle to nested MessageSources.
 

Uses of Stoppable in org.mule.streaming.processor
 

Classes in org.mule.streaming.processor that implement Stoppable
 class AbstractDevkitBasedPageableMessageProcessor
          Base class for devkit generated pageable message processors.
 

Uses of Stoppable in org.mule.tck.functional
 

Classes in org.mule.tck.functional that implement Stoppable
 class FunctionalTestComponent
          FunctionalTestComponent is a service that can be used by functional tests.
 class QuietExceptionStrategy
          Restrict exceptions to debug log messages
 class TransactionalFunctionalTestComponent
          This service is useful for unit tests involving transactionality because it will roll back the current transaction upon message arrival.
 

Uses of Stoppable in org.mule.tck.testmodels.services
 

Classes in org.mule.tck.testmodels.services that implement Stoppable
 class TestServiceComponent
          TestServiceComponent is a test WebServices service.
 

Uses of Stoppable in org.mule.transport
 

Classes in org.mule.transport that implement Stoppable
 class AbstractConnector
          AbstractConnector provides base functionality for all connectors provided with Mule.
 class AbstractJndiConnector
          This class acts as common baseclass for both Rmi & EjbConnector Resolves Jndi root for connector usage
 class AbstractMessageDispatcher
          Abstract implementation of an outbound channel adaptors.
 class AbstractMessageReceiver
          AbstractMessageReceiver provides common methods for all Message Receivers provided with Mule.
 class AbstractMessageRequester
          The Message Requester is used to explicitly request messages from a message channel or resource rather than subscribing to inbound events or polling for messages.
 class AbstractPollingMessageReceiver
          AbstractPollingMessageReceiver implements a base class for polling message receivers.
 class AbstractTransportMessageHandler<O>
          Provide a default dispatch (client) support for handling threads lifecycle and validation.
 class TransactedPollingMessageReceiver
          The TransactedPollingMessageReceiver is an abstract receiver that handles polling and transaction management.
 class UnsupportedMessageDispatcher
           
 class UnsupportedMessageRequester
           
 

Uses of Stoppable in org.mule.transport.ajax
 

Classes in org.mule.transport.ajax that implement Stoppable
 class AjaxMessageDispatcher
          Will dispatch Mule events to ajax clients available in Bayeux that are listening to this endpoint.
 class AjaxMessageReceiver
          Registers a receiver service with Bayeux.
 

Uses of Stoppable in org.mule.transport.ajax.container
 

Classes in org.mule.transport.ajax.container that implement Stoppable
 class AjaxServletConnector
          A servlet connector that binds to the container and makes a configured Bayeux available to dispatchers and receivers.
 

Uses of Stoppable in org.mule.transport.ajax.embedded
 

Classes in org.mule.transport.ajax.embedded that implement Stoppable
 class AjaxConnector
          Creates an 'embedded' Ajax server using Jetty and allows Mule to receiver and send events to browsers.
 

Uses of Stoppable in org.mule.transport.ejb
 

Classes in org.mule.transport.ejb that implement Stoppable
 class EjbConnector
          Provides Connection configurstion for EJB endpoints
 class EjbMessageDispatcher
          Invokes a method on an EJB object stored in Jndi.
 class EjbMessageReceiver
          Will repeatedly call a method on an EJB object.
 

Uses of Stoppable in org.mule.transport.email
 

Classes in org.mule.transport.email that implement Stoppable
 class AbstractMailConnector
          Abstract superclass for mail connectors.
 class AbstractRetrieveMailConnector
          Support for connecting to and receiving email from a mailbox (the exact protocol depends on the subclass).
 class AbstractTlsRetrieveMailConnector
          Support for connecting to and receiving email from a secure mailbox (the exact protocol depends on the subclass).
 class GmailSmtpConnector
          This class just sets some extra SMTP properties so it works with GMail.
 class ImapConnector
          Receives messages from an IMAP mailbox
 class ImapsConnector
          Creates a secure IMAP connection
 class Pop3Connector
          Pop3Connector is used to connect and receive mail from a POP3 mailbox.
 class Pop3sConnector
          Creates a secure connection to a POP3 mailbox
 class RetrieveMessageReceiver
          Poll a mailbox for messages, remove the messages and route them as events into Mule.
 class RetrieveMessageRequester
          This dispatcher can only be used to receive message (as opposed to listening for them).
 class SmtpConnector
          SmtpConnector is used to connect to and send data to an SMTP mail server
 class SmtpMessageDispatcher
          SmtpMessageDispatcher will dispatch Mule events as Mime email messages over an SMTP gateway.
 class SmtpsConnector
          Creates a secure SMTP connection
 

Uses of Stoppable in org.mule.transport.file
 

Classes in org.mule.transport.file that implement Stoppable
 class FileConnector
          FileConnector is used for setting up listeners on a directory and for writing files to a directory.
 class FileMessageDispatcher
          FileMessageDispatcher is used to read/write files to the filesystem
 class FileMessageReceiver
          FileMessageReceiver is a polling listener that reads files from a directory.
 class FileMessageRequester
          FileMessageRequester is used to read/write files to the filesystem
 

Uses of Stoppable in org.mule.transport.ftp
 

Classes in org.mule.transport.ftp that implement Stoppable
 class FtpConnector
           
 class FtpMessageDispatcher
           
 class FtpMessageReceiver
           
 class FtpMessageRequester
           
 

Uses of Stoppable in org.mule.transport.http
 

Classes in org.mule.transport.http that implement Stoppable
 class HttpClientMessageDispatcher
          HttpClientMessageDispatcher dispatches Mule events over HTTP.
 class HttpClientMessageRequester
          Rquests Mule events over HTTP.
 class HttpConnector
          HttpConnector provides a way of receiving and sending http requests and responses.
 class HttpMessageReceiver
          HttpMessageReceiver is a simple http server that can be used to listen for HTTP requests on a particular port.
 class HttpPollingConnector
          The HttpPollingConnectors allows for inbound Http endpoints to be configured with an address which it shall use to poll for a result.
 class HttpsClientMessageDispatcher
           
 class HttpsConnector
          HttpsConnector provides Secure http connectivity on top of what is already provided with the Mule HttpConnector.
 class HttpsMessageReceiver
           
 class HttpsPollingConnector
          HttpsPollingConnector provides Secure http connectivity on top of what is already provided with the Mule HttpPollingConnector.
 class OldHttpMessageReceiver
          HttpMessageReceiver is a simple http server that can be used to listen for HTTP requests on a particular port.
 class OldHttpsMessageReceiver
           
 class PollingHttpMessageReceiver
          Will poll an http URL and use the response as the input for a service request.
 class PollingHttpsMessageReceiver
           
 

Uses of Stoppable in org.mule.transport.http.components
 

Classes in org.mule.transport.http.components that implement Stoppable
 class HttpResponseBuilder
           
 class RestServiceWrapper
          This service can used to proxy REST style services as local Mule Components.
 

Uses of Stoppable in org.mule.transport.http.construct
 

Classes in org.mule.transport.http.construct that implement Stoppable
 class HttpProxy
          A simple HTTP proxy that supports transformation and caching.
 

Uses of Stoppable in org.mule.transport.jdbc
 

Classes in org.mule.transport.jdbc that implement Stoppable
 class JdbcConnector
           
 class JdbcMessageDispatcher
          The Jdbc Message dispatcher is responsible for executing SQL queries against a database.
 class JdbcMessageReceiver
          Implements TransactedPollingMessageReceiver reading data from a database.
 class JdbcMessageRequester
           
 

Uses of Stoppable in org.mule.transport.jms
 

Classes in org.mule.transport.jms that implement Stoppable
 class JmsConnector
          JmsConnector is a JMS 1.0.2b compliant connector that can be used by a Mule endpoint.
 class JmsMessageDispatcher
          JmsMessageDispatcher is responsible for dispatching messages to JMS destinations.
 class JmsMessageReceiver
          Deprecated. use MultiConsumerJmsMessageReceiver (set by default).
 class JmsMessageRequester
          JmsMessageDispatcher is responsible for dispatching messages to JMS destinations.
 class MultiConsumerJmsMessageReceiver
          In Mule an endpoint corresponds to a single receiver.
 class SingleJmsMessageReceiver
          Registers a single Jms MessageListener for an endpoint
 class TransactedSingleResourceJmsMessageReceiver
           
 class XaTransactedJmsMessageReceiver
           
 

Uses of Stoppable in org.mule.transport.jms.activemq
 

Classes in org.mule.transport.jms.activemq that implement Stoppable
 class ActiveMQJmsConnector
          ActiveMQ 4.x-specific JMS connector.
 class ActiveMQXAJmsConnector
           
 

Uses of Stoppable in org.mule.transport.jms.jndi
 

Subinterfaces of Stoppable in org.mule.transport.jms.jndi
 interface JndiNameResolver
          Defines a strategy for lookup objects by name using JNDI.
 

Classes in org.mule.transport.jms.jndi that implement Stoppable
 class AbstractJndiNameResolver
           
 class CachedJndiNameResolver
          Defines a JndiNameResolver that uses a cache in order to store the already resolved names.
 class SimpleJndiNameResolver
          Defines a simple JndiNameResolver that maintains a Context instance opened all the time and always relies on the context to do the look ups.
 

Uses of Stoppable in org.mule.transport.jms.mulemq
 

Classes in org.mule.transport.jms.mulemq that implement Stoppable
 class MuleMQJmsConnector
           
 class MuleMQXAJmsConnector
           
 

Uses of Stoppable in org.mule.transport.jms.weblogic
 

Classes in org.mule.transport.jms.weblogic that implement Stoppable
 class WeblogicJmsConnector
          Weblogic-specific JMS connector.
 

Uses of Stoppable in org.mule.transport.jms.websphere
 

Classes in org.mule.transport.jms.websphere that implement Stoppable
 class WebsphereJmsConnector
          Websphere-specific JMS connector.
 class WebsphereTransactedJmsMessageReceiver
           
 

Uses of Stoppable in org.mule.transport.jnp
 

Classes in org.mule.transport.jnp that implement Stoppable
 class JnpConnector
          JnpConnector uses the Java Naming protocol to bind to remote objects
 

Uses of Stoppable in org.mule.transport.multicast
 

Classes in org.mule.transport.multicast that implement Stoppable
 class MulticastConnector
          MulticastConnector can dispatch mule events using ip multicasting
 class MulticastMessageReceiver
           
 

Uses of Stoppable in org.mule.transport.polling
 

Classes in org.mule.transport.polling that implement Stoppable
 class MessageProcessorPollingConnector
           
 class MessageProcessorPollingMessageReceiver
           Polling MessageSource.
 

Uses of Stoppable in org.mule.transport.polling.schedule
 

Classes in org.mule.transport.polling.schedule that implement Stoppable
 class FixedFrequencyScheduler<T extends Runnable>
           Scheduler that runs a task giving a fixed period of time.
 class PollScheduler<T extends Runnable>
           Abstract definition of a Scheduler for poll.
 

Uses of Stoppable in org.mule.transport.quartz
 

Classes in org.mule.transport.quartz that implement Stoppable
 class QuartzConnector
          Creates a connection to a Quartz scheduler.
 class QuartzMessageDispatcher
          Can schedule a Job with the Quartz scheduler.
 class QuartzMessageReceiver
          Listens for Quartz sheduled events using the Receiver Job and fires events to the service associated with this receiver.
 

Uses of Stoppable in org.mule.transport.quartz.jobs
 

Classes in org.mule.transport.quartz.jobs that implement Stoppable
 class PollEndpointJob
           
 

Uses of Stoppable in org.mule.transport.rmi
 

Classes in org.mule.transport.rmi that implement Stoppable
 class RmiCallbackMessageReceiver
          TODO
 class RmiConnector
          RmiConnector can bind or send to a given RMI port on a given host.
 class RmiMessageDispatcher
          RmiMessageDispatcher will send transformed mule events over RMI-JRMP.
 class RmiMessageReceiver
          Will repeatedly call a method on a Remote object.
 

Uses of Stoppable in org.mule.transport.servlet
 

Classes in org.mule.transport.servlet that implement Stoppable
 class ServletConnector
          ServletConnector is a channel adapter between Mule and a servlet engine.
 class ServletMessageReceiver
          ServletMessageReceiver is a receiver that is invoked from a Servlet when an event is received.
 

Uses of Stoppable in org.mule.transport.servlet.jetty
 

Classes in org.mule.transport.servlet.jetty that implement Stoppable
 class JettyHttpConnector
          The JettyConnector can be using to embed a Jetty server to receive requests on an http inbound endpoint.
 class JettyHttpMessageReceiver
          JettyHttpMessageReceiver is a simple http server that can be used to listen for http requests on a particular port
 class JettyHttpsConnector
          The JettyHttpsConnector can be using to embed a Jetty server to receive requests on an http inbound endpoint.
 class JettyWebappServerAgent
          A 'proxy' agent that displays info about any webapps deployed together with their entry-point url.
 

Uses of Stoppable in org.mule.transport.sftp
 

Classes in org.mule.transport.sftp that implement Stoppable
 class SftpConnector
          SftpConnector sends and receives file messages over sftp using jsch library Improves on SFTP with VFS Connector in the following ways: 1.
 class SftpMessageDispatcher
          SftpMessageDispatcher dispatches files via sftp to a remote sftp service.
 class SftpMessageReceiver
          SftpMessageReceiver polls and receives files from an sftp service using jsch.
 class SftpMessageRequester
          SftpMessageRequester polls files on request (e.g.
 

Uses of Stoppable in org.mule.transport.soap.axis
 

Classes in org.mule.transport.soap.axis that implement Stoppable
 class AxisConnector
          AxisConnector is used to maintain one or more Services for Axis server instance.
 class AxisMessageDispatcher
          AxisMessageDispatcher is used to make soap requests via the Axis soap client.
 class AxisMessageReceiver
          AxisMessageReceiver is used to register a component as a service with a Axis server.
 class AxisMessageRequester
          AxisMessageDispatcher is used to make soap requests via the Axis soap client.
 

Uses of Stoppable in org.mule.transport.soap.axis.wsdl
 

Classes in org.mule.transport.soap.axis.wsdl that implement Stoppable
 class AxisWsdlConnector
          TODO document
 class AxisWsdlMessageDispatcher
          Creates and Axis client services from WSDL and invokes it.
 

Uses of Stoppable in org.mule.transport.ssl
 

Classes in org.mule.transport.ssl that implement Stoppable
 class SslConnector
          SslConnector provides a connector for SSL connections.
 class SslMessageReceiver
           
 class TlsConnector
          TlsConnector Provides TLS connections
 

Uses of Stoppable in org.mule.transport.stdio
 

Classes in org.mule.transport.stdio that implement Stoppable
 class PromptStdioConnector
          PromptStdioConnector connects to the System streams in and out by default and add some basic fuctionality for writing out prompt messages.
 class StdioConnector
          StdioConnector can send and receive Mule events over IO streams.
 class StdioMessageDispatcher
          StdioMessageDispatcher is a simple stream dispatcher that obtains a stream from the Stream Connector to write to.
 class StdioMessageReceiver
          StdioMessageReceiver is a listener for events from Mule components which then simply passes the events on to the target components.
 

Uses of Stoppable in org.mule.transport.tcp
 

Classes in org.mule.transport.tcp that implement Stoppable
 class ExceptionReturnTcpMessageReceiver
          Extends TcpMessageReceiver providing managing of protocol error conditions.
 class LocalSocketTcpMessageDispatcher
          LocalSocketTcpMessageDispatcher will send transformed Mule events over TCP.
 class PollingTcpConnector
          PollingTcpMessageReceiver acts as a polling TCP connector.
 class PollingTcpMessageReceiver
          PollingTcpMessageReceiver acts like a TCP client polling for new messages.
 class TcpConnector
          TcpConnector can bind or sent to a given TCP port on a given host.
 class TcpMessageDispatcher
          Send transformed Mule events over TCP.
 class TcpMessageReceiver
          TcpMessageReceiver acts like a TCP server to receive socket requests.
 class TcpMessageRequester
          Request transformed Mule events from TCP.
 

Uses of Stoppable in org.mule.transport.udp
 

Classes in org.mule.transport.udp that implement Stoppable
 class UdpConnector
          UdpConnector can send and receive Mule events as Datagram packets.
 class UdpMessageDispatcher
          UdpMessageDispatcher is responsible for dispatching MuleEvents as UDP packets on the network
 class UdpMessageReceiver
          UdpMessageReceiver receives UDP message packets.
 class UdpMessageRequester
          Responsible for requesting MuleEvents as UDP packets on the network
 

Uses of Stoppable in org.mule.transport.vm
 

Classes in org.mule.transport.vm that implement Stoppable
 class VMConnector
          VMConnector A simple endpoint wrapper to allow a Mule service to

be accessed from an endpoint

 class VMMessageDispatcher
          VMMessageDispatcher is used for providing in memory interaction between components.
 class VMMessageReceiver
          VMMessageReceiver is a listener for events from a Mule service which then simply passes the events on to the target service.
 class VMMessageRequester
          VMMessageDispatcher is used for providing in memory interaction between components.
 

Uses of Stoppable in org.mule.transport.xmpp
 

Classes in org.mule.transport.xmpp that implement Stoppable
 class XmppConnector
          XmppConnector represents a connection to a Jabber server.
 class XmppMessageDispatcher
          Allows Mule events to be sent over Xmpp
 class XmppMessageReceiver
          XmppMessageReceiver is responsible for receiving Mule events over XMPP.
 class XmppMessageRequester
          Allows Mule messages to be received over XMPP
 class XmppPollingMessageReceiver
           
 

Uses of Stoppable in org.mule.util.pool
 

Subinterfaces of Stoppable in org.mule.util.pool
 interface LifecyleEnabledObjectPool
          An ObjectPool that allows Start and Stop life-cycle to be propagated pooled object.
 

Classes in org.mule.util.pool that implement Stoppable
 class DefaultLifecycleEnabledObjectPool
          A LifecyleEnabledObjectPool implementation for pooling LifecycleAdapter instances for implementations of JavaComponent that require LifecycleAdapter pooling such as PooledJavaComponent.
 

Uses of Stoppable in org.mule.util.queue
 

Subinterfaces of Stoppable in org.mule.util.queue
 interface QueueManager
          A Queue manager is responsible for managing one or more Queue resources and providing common support for transactions and persistence.
 

Classes in org.mule.util.queue that implement Stoppable
 class TransactionalQueueManager
          The Transactional Queue Manager is responsible for creating and Managing transactional Queues.
 



Copyright © 2003-2014 MuleSoft, Inc.. All Rights Reserved.