org.mule.context.notification
Class ServerNotificationManager

java.lang.Object
  org.mule.context.notification.ServerNotificationManager

All Implemented Interfaces:

Runnable, javax.resource.spi.work.Work, ServerNotificationHandler, Disposable

public class ServerNotificationManager
extends Object
implements javax.resource.spi.work.Work, Disposable, ServerNotificationHandler

A reworking of the event manager that allows efficient behaviour without global on/off switches in the config.

The configuration and resulting policy are separate; the policy is a summary of the configuration that contains information to decide whether a particular message can be handled, and which updates that with experience gained handling messages. When the configuration is changed the policy is rebuilt. In this way we get a fairly efficient system without needing controls elsewhere.

However, measurements showed that there was still a small impact on speed in some cases. To improve behaviour further the OptimisedNotificationHandler was added. This allows a service that generates notifications to cache locally a handler optimised for a particular class.

The dynamic flag stops this caching from occurring. This reduces efficiency slightly (about 15% cost on simple VM messages, less on other transports)

Note that, because of subclass relationships, we need to be very careful about exactly what is enabled and disabled:

• Disabling an event or interface disables all uses of that class or any subclass.
• Enquiring whether an event is enabled returns true if any subclass is enabled.

Field Summary

protected Log	logger
static String	NULL_SUBSCRIPTION

Fields inherited from interface org.mule.api.lifecycle.Disposable

PHASE_NAME

Constructor Summary

ServerNotificationManager()

Method Summary

void	addInterfaceToType(Class iface, Class event)
void	addListener(ServerNotificationListener listener)
void	addListenerSubscription(ServerNotificationListener listener, String subscription)
void	addListenerSubscriptionPair(ListenerSubscriptionPair pair)
void	disableInterface(Class iface)
void	disableType(Class type)
void	dispose() A lifecycle method where implementor should free up any resources.
void	fireNotification(ServerNotification notification)
Map	getInterfaceToTypes()
Collection	getListeners()
boolean	isNotificationDynamic()
boolean	isNotificationEnabled(Class type) This returns a very "conservative" value - it is true if the notification or any subclass would be accepted.
protected void	notifyListeners(ServerNotification notification)
void	release()
void	removeAllListeners(Collection listeners)
void	removeListener(ServerNotificationListener listener) This removes *all* registrations that reference this listener
void	run()
void	setAllListenerSubscriptionPairs(Collection pairs)
void	setDisabledInterfaces(Collection interfaces)
void	setDisabledTypes(Collection types)
void	setInterfaceToTypes(Map interfaceToEvents)
void	setNotificationDynamic(boolean dynamic)
void	start(WorkManager workManager, javax.resource.spi.work.WorkListener workListener)
static Class	toClass(Object value) Support string or class parameters

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

NULL_SUBSCRIPTION

public static final String NULL_SUBSCRIPTION

See Also:

Constant Field Values

logger

protected Log logger

Constructor Detail

ServerNotificationManager

public ServerNotificationManager()

Method Detail

isNotificationDynamic

public boolean isNotificationDynamic()

Specified by:

isNotificationDynamic in interface ServerNotificationHandler

setNotificationDynamic

public void setNotificationDynamic(boolean dynamic)

start

public void start(WorkManager workManager,
                  javax.resource.spi.work.WorkListener workListener)
           throws LifecycleException

Throws:

LifecycleException

addInterfaceToType

public void addInterfaceToType(Class iface,
                               Class event)

setInterfaceToTypes

public void setInterfaceToTypes(Map interfaceToEvents)
                         throws ClassNotFoundException

Throws:

ClassNotFoundException

addListenerSubscriptionPair

public void addListenerSubscriptionPair(ListenerSubscriptionPair pair)

addListener

public void addListener(ServerNotificationListener listener)

addListenerSubscription

public void addListenerSubscription(ServerNotificationListener listener,
                                    String subscription)

setAllListenerSubscriptionPairs

public void setAllListenerSubscriptionPairs(Collection pairs)

removeListener

public void removeListener(ServerNotificationListener listener)

This removes *all* registrations that reference this listener

removeAllListeners

public void removeAllListeners(Collection listeners)

disableInterface

public void disableInterface(Class iface)
                      throws ClassNotFoundException

Throws:

ClassNotFoundException

setDisabledInterfaces

public void setDisabledInterfaces(Collection interfaces)
                           throws ClassNotFoundException

Throws:

ClassNotFoundException

disableType

public void disableType(Class type)
                 throws ClassNotFoundException

Throws:

ClassNotFoundException

setDisabledTypes

public void setDisabledTypes(Collection types)
                      throws ClassNotFoundException

Throws:

ClassNotFoundException

fireNotification

public void fireNotification(ServerNotification notification)

Specified by:

fireNotification in interface ServerNotificationHandler

isNotificationEnabled

public boolean isNotificationEnabled(Class type)

Description copied from interface: ServerNotificationHandler

This returns a very "conservative" value - it is true if the notification or any subclass would be accepted. So if it returns false then you can be sure that there is no need to send the notification. On the other hand, if it returns true there is no guarantee that the notification "really" will be dispatched to any listener.

Specified by:

isNotificationEnabled in interface ServerNotificationHandler

Parameters:

type - Either the notification class being generated or some superclass

Returns:

false if there is no need to dispatch the notification

dispose

public void dispose()

Description copied from interface: Disposable

A lifecycle method where implementor should free up any resources. If an exception is thrown it should just be logged and processing should continue. This method should not throw Runtime exceptions.

Specified by:

dispose in interface Disposable

notifyListeners

protected void notifyListeners(ServerNotification notification)

release

public void release()

Specified by:

release in interface javax.resource.spi.work.Work

run

public void run()

Specified by:

run in interface Runnable

toClass

public static Class toClass(Object value)
                     throws ClassNotFoundException

Support string or class parameters

Throws:

ClassNotFoundException

getInterfaceToTypes

public Map getInterfaceToTypes()

getListeners

public Collection getListeners()