SimpleMessageListenerContainer (Spring AMQP 1.3.5.RELEASE API)

java.lang.Object
- org.springframework.amqp.rabbit.connection.RabbitAccessor
- - org.springframework.amqp.rabbit.listener.AbstractMessageListenerContainer
  - - org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer

All Implemented Interfaces:

org.springframework.beans.factory.Aware, org.springframework.beans.factory.BeanNameAware, org.springframework.beans.factory.DisposableBean, org.springframework.beans.factory.InitializingBean, org.springframework.context.ApplicationContextAware, org.springframework.context.Lifecycle, org.springframework.context.Phased, org.springframework.context.SmartLifecycle
```
public class SimpleMessageListenerContainer
extends AbstractMessageListenerContainer
```
Since:

1.0

Author:

Mark Pollack, Mark Fisher, Dave Syer, Gary Russell

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static interface SimpleMessageListenerContainer.ContainerDelegate
- Nested classes/interfaces inherited from class org.springframework.amqp.rabbit.listener.AbstractMessageListenerContainer
  AbstractMessageListenerContainer.SharedConnectionNotInitializedException

Nested Classes
Modifier and Type	Class and Description
`static interface`	`SimpleMessageListenerContainer.ContainerDelegate`

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`DEFAULT_PREFETCH_COUNT`
`static long`	`DEFAULT_RECEIVE_TIMEOUT`
`static long`	`DEFAULT_RECOVERY_INTERVAL` The default recovery interval: 5000 ms = 5 seconds.
`static long`	`DEFAULT_SHUTDOWN_TIMEOUT`

Fields inherited from class org.springframework.amqp.rabbit.connection.RabbitAccessor
logger

Constructor Summary

Constructors
Constructor and Description
`SimpleMessageListenerContainer()` Default constructor for convenient dependency injection via setters.
`SimpleMessageListenerContainer(ConnectionFactory connectionFactory)` Create a listener container from the connection factory (mandatory).

Method Summary

Methods
Modifier and Type	Method and Description
`protected void`	`addAndStartConsumers(int delta)`
`void`	`addQueueNames(String... queueName)` Add queue(s) to this container's list of queues.
`void`	`addQueues(Queue... queue)` Add queue(s) to this container's list of queues.
`protected BlockingQueueConsumer`	`createBlockingQueueConsumer()`
`protected void`	`doInitialize()` Creates the specified number of concurrent consumers, in the form of a Rabbit Channel plus associated MessageConsumer.
`protected void`	`doShutdown()` Close the registered invokers.
`protected void`	`doStart()` Re-initializes this container's Rabbit message consumers, if not initialized already.
`protected void`	`doStop()` This method is invoked when the container is stopping.
`int`	`getActiveConsumerCount()`
`protected RabbitAdmin`	`getRabbitAdmin()`
`protected void`	`handleStartupFailure(Throwable t)` Wait for a period determined by the `recoveryInterval` to give the container a chance to recover from consumer startup failure, e.g.
`protected int`	`initializeConsumers()`
`protected void`	`invokeListener(com.rabbitmq.client.Channel channel, Message message)` Invoke the specified listener: either as standard MessageListener or (preferably) as SessionAwareMessageListener.
`protected boolean`	`isChannelLocallyTransacted(com.rabbitmq.client.Channel channel)` Check whether the given Channel is locally transacted, that is, whether its transaction is managed by this listener container's Channel handling and not by an external transaction coordinator.
`boolean`	`removeQueueNames(String... queueName)` Remove queues from this container's list of queues.
`boolean`	`removeQueues(Queue... queue)` Remove queue(s) from this container's list of queues.
`void`	`setAdviceChain(org.aopalliance.aop.Advice[] adviceChain)` Public setter for the `Advice` to apply to listener executions.
`void`	`setConcurrentConsumers(int concurrentConsumers)` Specify the number of concurrent consumers to create.
`void`	`setConsecutiveActiveTrigger(int consecutiveActiveTrigger)` If `maxConcurrentConsumers` is greater then `concurrentConsumers`, and `maxConcurrentConsumers` has not been reached, specifies the number of consecutive cycles when a single consumer was active, in order to consider starting a new consumer.
`void`	`setConsecutiveIdleTrigger(int consecutiveIdleTrigger)` If `maxConcurrentConsumers` is greater then `concurrentConsumers`, and the number of consumers exceeds `concurrentConsumers`, specifies the number of consecutive receive attempts that return no data; after which we consider stopping a consumer.
`void`	`setConsumerArguments(Map<String,Object> args)`
`void`	`setDefaultRequeueRejected(boolean defaultRequeueRejected)` Determines the default behavior when a message is rejected, for example because the listener threw an exception.
`void`	`setExclusive(boolean exclusive)` Set to true for an exclusive consumer - if true, the concurrency must be 1.
`void`	`setMaxConcurrentConsumers(int maxConcurrentConsumers)` Sets an upper limit to the number of consumers; defaults to 'concurrentConsumers'.
`void`	`setMessagePropertiesConverter(MessagePropertiesConverter messagePropertiesConverter)` Set the `MessagePropertiesConverter` for this listener container.
`void`	`setMissingQueuesFatal(boolean missingQueuesFatal)` If all of the configured queue(s) are not available on the broker, this setting determines whether the condition is fatal (default true).
`void`	`setPrefetchCount(int prefetchCount)` Tells the broker how many messages to send to each consumer in a single request.
`void`	`setQueueNames(String... queueName)` Set the name of the queue(s) to receive messages from.
`void`	`setQueues(Queue... queues)` Set the name of the queue(s) to receive messages from.
`void`	`setRabbitAdmin(RabbitAdmin rabbitAdmin)` Set the `RabbitAdmin`, used to declare any auto-delete queues, bindings etc when the container is started.
`void`	`setReceiveTimeout(long receiveTimeout)` The time (in milliseconds) that a consumer should wait for data.
`void`	`setRecoveryInterval(long recoveryInterval)` Specify the interval between recovery attempts, in milliseconds.
`void`	`setShutdownTimeout(long shutdownTimeout)` The time to wait for workers in milliseconds after the container is stopped, and before the connection is forced closed.
`void`	`setStartConsumerMinInterval(long startConsumerMinInterval)` If `maxConcurrentConsumers` is greater then `concurrentConsumers`, and `maxConcurrentConsumers` has not been reached, specifies the minimum time (milliseconds) between starting new consumers on demand.
`void`	`setStopConsumerMinInterval(long stopConsumerMinInterval)` If `maxConcurrentConsumers` is greater then `concurrentConsumers`, and the number of consumers exceeds `concurrentConsumers`, specifies the minimum time (milliseconds) between stopping idle consumers.
`void`	`setTaskExecutor(Executor taskExecutor)`
`void`	`setTransactionAttribute(org.springframework.transaction.interceptor.TransactionAttribute transactionAttribute)`
`void`	`setTransactionManager(org.springframework.transaction.PlatformTransactionManager transactionManager)`
`void`	`setTxSize(int txSize)` Tells the container how many messages to process in a single transaction (if the channel is transactional).
`protected boolean`	`sharedConnectionEnabled()` Always use a shared Rabbit Connection.
`protected void`	`validateConfiguration()` Avoid the possibility of not configuring the CachingConnectionFactory in sync with the number of concurrent consumers.

Methods inherited from class org.springframework.amqp.rabbit.connection.RabbitAccessor
convertRabbitAccessException, createConnection, getChannel, getConnection, getConnectionFactory, getTransactionalResourceHolder, isChannelTransacted, setChannelTransacted, setConnectionFactory

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - DEFAULT_RECEIVE_TIMEOUT
```
public static final long DEFAULT_RECEIVE_TIMEOUT
```
    See Also:
    Constant Field Values
  - DEFAULT_PREFETCH_COUNT
```
public static final int DEFAULT_PREFETCH_COUNT
```
    See Also:
    Constant Field Values
  - DEFAULT_SHUTDOWN_TIMEOUT
```
public static final long DEFAULT_SHUTDOWN_TIMEOUT
```
    See Also:
    Constant Field Values
  - DEFAULT_RECOVERY_INTERVAL
```
public static final long DEFAULT_RECOVERY_INTERVAL
```
    The default recovery interval: 5000 ms = 5 seconds.
    
    See Also:
    Constant Field Values
- Constructor Detail
  - SimpleMessageListenerContainer
```
public SimpleMessageListenerContainer()
```
    Default constructor for convenient dependency injection via setters.
  - SimpleMessageListenerContainer
```
public SimpleMessageListenerContainer(ConnectionFactory connectionFactory)
```
    Create a listener container from the connection factory (mandatory).
    
    Parameters:
    connectionFactory - the ConnectionFactory
- Method Detail
  - setAdviceChain
```
public void setAdviceChain(org.aopalliance.aop.Advice[] adviceChain)
```
    Public setter for the Advice to apply to listener executions. If txSize>1 then multiple listener executions will all be wrapped in the same advice up to that limit.
    
    If a transactionManager is provided as well, then separate advice is created for the transaction and applied first in the chain. In that case the advice chain provided here should not contain a transaction interceptor (otherwise two transactions would be be applied).
    
    Parameters:
    adviceChain - the advice chain to set
  - setRecoveryInterval
```
public void setRecoveryInterval(long recoveryInterval)
```
    Specify the interval between recovery attempts, in milliseconds. The default is 5000 ms, that is, 5 seconds.
    
    Parameters:
    recoveryInterval - The recovery interval.
  - setConcurrentConsumers
```
public void setConcurrentConsumers(int concurrentConsumers)
```
    Specify the number of concurrent consumers to create. Default is 1.
    Raising the number of concurrent consumers is recommended in order to scale the consumption of messages coming in from a queue. However, note that any ordering guarantees are lost once multiple consumers are registered. In general, stick with 1 consumer for low-volume queues. Cannot be less than maxConcurrentConsumers (if set).
    
    Parameters:
    concurrentConsumers - the minimum number of consumers to create.
    See Also:
    setMaxConcurrentConsumers(int)
  - setMaxConcurrentConsumers
```
public void setMaxConcurrentConsumers(int maxConcurrentConsumers)
```
    Sets an upper limit to the number of consumers; defaults to 'concurrentConsumers'. Consumers will be added on demand. Cannot be less than concurrentConsumers.
    
    Parameters:
    maxConcurrentConsumers - the maximum number of consumers.
    See Also:
    setConcurrentConsumers(int), setStartConsumerMinInterval(long), setStopConsumerMinInterval(long), setConsecutiveActiveTrigger(int), setConsecutiveIdleTrigger(int)
  - setExclusive
```
public final void setExclusive(boolean exclusive)
```
    Set to true for an exclusive consumer - if true, the concurrency must be 1.
    
    Parameters:
    exclusive - true for an exclusive consumer.
  - setStartConsumerMinInterval
```
public final void setStartConsumerMinInterval(long startConsumerMinInterval)
```
    If maxConcurrentConsumers is greater then concurrentConsumers, and maxConcurrentConsumers has not been reached, specifies the minimum time (milliseconds) between starting new consumers on demand. Default is 10000 (10 seconds).
    
    Parameters:
    startConsumerMinInterval - The minimum interval between new consumer starts.
    See Also:
    setMaxConcurrentConsumers(int), setStartConsumerMinInterval(long)
  - setStopConsumerMinInterval
```
public final void setStopConsumerMinInterval(long stopConsumerMinInterval)
```
    If maxConcurrentConsumers is greater then concurrentConsumers, and the number of consumers exceeds concurrentConsumers, specifies the minimum time (milliseconds) between stopping idle consumers. Default is 60000 (1 minute).
    
    Parameters:
    stopConsumerMinInterval - The minimum interval between consumer stops.
    See Also:
    setMaxConcurrentConsumers(int), setStopConsumerMinInterval(long)
  - setConsecutiveActiveTrigger
```
public final void setConsecutiveActiveTrigger(int consecutiveActiveTrigger)
```
    If maxConcurrentConsumers is greater then concurrentConsumers, and maxConcurrentConsumers has not been reached, specifies the number of consecutive cycles when a single consumer was active, in order to consider starting a new consumer. If the consumer goes idle for one cycle, the counter is reset. This is impacted by the txSize. Default is 10 consecutive messages.
    
    Parameters:
    consecutiveActiveTrigger - The number of consecutive receives to trigger a new consumer.
    See Also:
    setMaxConcurrentConsumers(int), setStartConsumerMinInterval(long), setTxSize(int)
  - setConsecutiveIdleTrigger
```
public final void setConsecutiveIdleTrigger(int consecutiveIdleTrigger)
```
    If maxConcurrentConsumers is greater then concurrentConsumers, and the number of consumers exceeds concurrentConsumers, specifies the number of consecutive receive attempts that return no data; after which we consider stopping a consumer. The idle time is effectively receiveTimeout * txSize * this value because the consumer thread waits for a message for up to receiveTimeout up to txSize times. Default is 10 consecutive idles.
    
    Parameters:
    consecutiveIdleTrigger - The number of consecutive timeouts to trigger stopping a consumer.
    See Also:
    setMaxConcurrentConsumers(int), setStopConsumerMinInterval(long), setReceiveTimeout(long), setTxSize(int)
  - setReceiveTimeout
```
public void setReceiveTimeout(long receiveTimeout)
```
    The time (in milliseconds) that a consumer should wait for data. Default 1000 (1 second).
    
    Parameters:
    receiveTimeout - the timeout.
    See Also:
    setConsecutiveIdleTrigger(int)
  - setShutdownTimeout
```
public void setShutdownTimeout(long shutdownTimeout)
```
    The time to wait for workers in milliseconds after the container is stopped, and before the connection is forced closed. If any workers are active when the shutdown signal comes they will be allowed to finish processing as long as they can finish within this timeout. Otherwise the connection is closed and messages remain unacked (if the channel is transactional). Defaults to 5 seconds.
    
    Parameters:
    shutdownTimeout - the shutdown timeout to set
  - setTaskExecutor
```
public void setTaskExecutor(Executor taskExecutor)
```
  - setPrefetchCount
```
public void setPrefetchCount(int prefetchCount)
```
    Tells the broker how many messages to send to each consumer in a single request. Often this can be set quite high to improve throughput. It should be greater than or equal to the transaction size.
    
    Parameters:
    prefetchCount - the prefetch count
  - setTxSize
```
public void setTxSize(int txSize)
```
    Tells the container how many messages to process in a single transaction (if the channel is transactional). For best results it should be less than or equal to the prefetch count. Also affects how often acks are sent when using AcknowledgeMode.AUTO - one ack per txSize. Default is 1.
    
    Parameters:
    txSize - the transaction size
  - setTransactionManager
```
public void setTransactionManager(org.springframework.transaction.PlatformTransactionManager transactionManager)
```
  - setTransactionAttribute
```
public void setTransactionAttribute(org.springframework.transaction.interceptor.TransactionAttribute transactionAttribute)
```
    Parameters:
    transactionAttribute - the transaction attribute to set
  - setMessagePropertiesConverter
```
public void setMessagePropertiesConverter(MessagePropertiesConverter messagePropertiesConverter)
```
    Set the MessagePropertiesConverter for this listener container.
    
    Parameters:
    messagePropertiesConverter - The properties converter.
  - setDefaultRequeueRejected
```
public void setDefaultRequeueRejected(boolean defaultRequeueRejected)
```
    Determines the default behavior when a message is rejected, for example because the listener threw an exception. When true, messages will be requeued, when false, they will not. For versions of Rabbit that support dead-lettering, the message must not be requeued in order to be sent to the dead letter exchange. Setting to false causes all rejections to not be requeued. When true, the default can be overridden by the listener throwing an AmqpRejectAndDontRequeueException. Default true.
    
    Parameters:
    defaultRequeueRejected - true to reject by default.
  - setConsumerArguments
```
public void setConsumerArguments(Map<String,Object> args)
```
  - getRabbitAdmin
```
protected RabbitAdmin getRabbitAdmin()
```
  - setRabbitAdmin
```
public void setRabbitAdmin(RabbitAdmin rabbitAdmin)
```
    Set the RabbitAdmin, used to declare any auto-delete queues, bindings etc when the container is started. Only needed if those queues use conditional declaration (have a 'declared-by' attribute). If not specified, an internal admin will be used which will attempt to declare all elements not having a 'declared-by' attribute.
    
    Parameters:
    rabbitAdmin - The admin.
  - setMissingQueuesFatal
```
public void setMissingQueuesFatal(boolean missingQueuesFatal)
```
    If all of the configured queue(s) are not available on the broker, this setting determines whether the condition is fatal (default true). When true, and the queues are missing during startup, the context refresh() will fail. If the queues are removed while the container is running, the container is stopped.
    When false, the condition is not considered fatal and the container will continue to attempt to start the consumers according to the setRecoveryInterval(long). Note that each consumer will make 3 attempts (at 5 second intervals) on each recovery attempt.
    
    Parameters:
    missingQueuesFatal - the missingQueuesFatal to set.
    Since:
    
    1.3.5
  - setQueueNames
```
public void setQueueNames(String... queueName)
```
    Description copied from class: AbstractMessageListenerContainer
    
    Set the name of the queue(s) to receive messages from.
    
    Overrides:
    
    setQueueNames in class AbstractMessageListenerContainer
    
    Parameters:
    queueName - the desired queueName(s) (can not be null)
  - setQueues
```
public void setQueues(Queue... queues)
```
    Description copied from class: AbstractMessageListenerContainer
    
    Set the name of the queue(s) to receive messages from.
    
    Overrides:
    
    setQueues in class AbstractMessageListenerContainer
    
    Parameters:
    queues - the desired queue(s) (can not be null)
  - addQueueNames
```
public void addQueueNames(String... queueName)
```
    Add queue(s) to this container's list of queues. The existing consumers will be cancelled after they have processed any pre-fetched messages and new consumers will be created. The queue must exist to avoid problems when restarting the consumers.
    
    Overrides:
    
    addQueueNames in class AbstractMessageListenerContainer
    
    Parameters:
    queueName - The queue to add.
  - addQueues
```
public void addQueues(Queue... queue)
```
    Add queue(s) to this container's list of queues. The existing consumers will be cancelled after they have processed any pre-fetched messages and new consumers will be created. The queue must exist to avoid problems when restarting the consumers.
    
    Overrides:
    
    addQueues in class AbstractMessageListenerContainer
    
    Parameters:
    queue - The queue to add.
  - removeQueueNames
```
public boolean removeQueueNames(String... queueName)
```
    Remove queues from this container's list of queues. The existing consumers will be cancelled after they have processed any pre-fetched messages and new consumers will be created. At least one queue must remain.
    
    Overrides:
    
    removeQueueNames in class AbstractMessageListenerContainer
    
    Parameters:
    queueName - The queue to remove.
    
    Returns:
    the boolean result of removal on the target queueNames List.
  - removeQueues
```
public boolean removeQueues(Queue... queue)
```
    Remove queue(s) from this container's list of queues. The existing consumers will be cancelled after they have processed any pre-fetched messages and new consumers will be created. At least one queue must remain.
    
    Overrides:
    
    removeQueues in class AbstractMessageListenerContainer
    
    Parameters:
    queue - The queue to remove.
    
    Returns:
    the boolean result of removal on the target queueNames List.
  - validateConfiguration
```
protected void validateConfiguration()
```
    Avoid the possibility of not configuring the CachingConnectionFactory in sync with the number of concurrent consumers.
    
    Overrides:
    
    validateConfiguration in class AbstractMessageListenerContainer
  - sharedConnectionEnabled
```
protected final boolean sharedConnectionEnabled()
```
    Always use a shared Rabbit Connection.
    
    Returns:
    true
  - doInitialize
```
protected void doInitialize()
                     throws Exception
```
    Creates the specified number of concurrent consumers, in the form of a Rabbit Channel plus associated MessageConsumer.
    
    Specified by:
    
    doInitialize in class AbstractMessageListenerContainer
    
    Throws:
    
    Exception - Any Exception.
  - getActiveConsumerCount
```
@ManagedMetric(metricType=GAUGE)
public int getActiveConsumerCount()
```
  - doStart
```
protected void doStart()
                throws Exception
```
    Re-initializes this container's Rabbit message consumers, if not initialized already. Then submits each consumer to this container's task executor.
    
    Overrides:
    
    doStart in class AbstractMessageListenerContainer
    
    Throws:
    
    Exception - Any Exception.
  - doStop
```
protected void doStop()
```
    Description copied from class: AbstractMessageListenerContainer
    
    This method is invoked when the container is stopping. The default implementation does nothing, but subclasses may override.
    
    Overrides:
    
    doStop in class AbstractMessageListenerContainer
  - doShutdown
```
protected void doShutdown()
```
    Description copied from class: AbstractMessageListenerContainer
    
    Close the registered invokers.
    Subclasses need to implement this method for their specific invoker management process.
    A shared Rabbit Connection, if any, will automatically be closed afterwards.
    
    Specified by:
    
    doShutdown in class AbstractMessageListenerContainer
    
    See Also:
    AbstractMessageListenerContainer.shutdown()
  - initializeConsumers
```
protected int initializeConsumers()
```
  - addAndStartConsumers
```
protected void addAndStartConsumers(int delta)
```
  - isChannelLocallyTransacted
```
protected boolean isChannelLocallyTransacted(com.rabbitmq.client.Channel channel)
```
    Description copied from class: AbstractMessageListenerContainer
    
    Check whether the given Channel is locally transacted, that is, whether its transaction is managed by this listener container's Channel handling and not by an external transaction coordinator.
    Note:This method is about finding out whether the Channel's transaction is local or externally coordinated.
    
    Overrides:
    
    isChannelLocallyTransacted in class AbstractMessageListenerContainer
    
    Parameters:
    channel - the Channel to check
    
    Returns:
    whether the given Channel is locally transacted
    See Also:
    RabbitAccessor.isChannelTransacted()
  - createBlockingQueueConsumer
```
protected BlockingQueueConsumer createBlockingQueueConsumer()
```
  - invokeListener
```
protected void invokeListener(com.rabbitmq.client.Channel channel,
                  Message message)
                       throws Exception
```
    Description copied from class: AbstractMessageListenerContainer
    
    Invoke the specified listener: either as standard MessageListener or (preferably) as SessionAwareMessageListener.
    
    Overrides:
    
    invokeListener in class AbstractMessageListenerContainer
    
    Parameters:
    channel - the Rabbit Channel to operate on
    message - the received Rabbit Message
    
    Throws:
    
    Exception - if thrown by Rabbit API methods
    See Also:
    AbstractMessageListenerContainer.setMessageListener(java.lang.Object)
  - handleStartupFailure
```
protected void handleStartupFailure(Throwable t)
                             throws Exception
```
    Wait for a period determined by the recoveryInterval to give the container a chance to recover from consumer startup failure, e.g. if the broker is down.
    
    Parameters:
    t - the exception that stopped the startup
    
    Throws:
    
    Exception - if the shared connection still can't be established

Class SimpleMessageListenerContainer

Nested Class Summary

Nested classes/interfaces inherited from class org.springframework.amqp.rabbit.listener.AbstractMessageListenerContainer

Field Summary

Fields inherited from class org.springframework.amqp.rabbit.connection.RabbitAccessor

Constructor Summary

Method Summary

Methods inherited from class org.springframework.amqp.rabbit.listener.AbstractMessageListenerContainer

Methods inherited from class org.springframework.amqp.rabbit.connection.RabbitAccessor

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_RECEIVE_TIMEOUT

DEFAULT_PREFETCH_COUNT

DEFAULT_SHUTDOWN_TIMEOUT

DEFAULT_RECOVERY_INTERVAL

Constructor Detail

SimpleMessageListenerContainer

SimpleMessageListenerContainer

Method Detail

setAdviceChain

setRecoveryInterval

setConcurrentConsumers

setMaxConcurrentConsumers

setExclusive

setStartConsumerMinInterval

setStopConsumerMinInterval

setConsecutiveActiveTrigger

setConsecutiveIdleTrigger

setReceiveTimeout

setShutdownTimeout

setTaskExecutor

setPrefetchCount

setTxSize

setTransactionManager

setTransactionAttribute

setMessagePropertiesConverter

setDefaultRequeueRejected

setConsumerArguments

getRabbitAdmin

setRabbitAdmin

setMissingQueuesFatal

setQueueNames

setQueues

addQueueNames

addQueues

removeQueueNames

removeQueues

validateConfiguration

sharedConnectionEnabled

doInitialize

getActiveConsumerCount

doStart

doStop

doShutdown

initializeConsumers

addAndStartConsumers

isChannelLocallyTransacted

createBlockingQueueConsumer

invokeListener

handleStartupFailure