org.wandora.modules

Class ScopedModuleManager

java.lang.Object

org.wandora.modules.ModuleManager

org.wandora.modules.ScopedModuleManager

All Implemented Interfaces:

Module, XMLOptionsHandler

Direct Known Subclasses:

ModuleBundle, WandoraModuleManager

public class ScopedModuleManager
extends ModuleManager
implements Module, XMLOptionsHandler

A module manager that can be placed inside other module managers in a hierarchical fashion. Each child module manager can import modules from the direct parent manager using import elements. Otherwise, child managers are isolated from the parent, or sibling, managers. This makes it practical to import module bundles that implement specific features without worry of them conflicting with existing modules.

The ScopedModuleManager itself is a Module and can be placed in any other module manager, scoped or otherwise. Its dependencies will be all the modules that are specifically imported into it. All the contained modules that are marked for autostart are started when the module manager itself is started and stopped when the manager is stopped. The child modules are initialised when the manager is initialised.

Author:

olli

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	ScopedModuleManager.Import

Nested classes/interfaces inherited from class org.wandora.modules.ModuleManager

ModuleManager.ModuleSettings

Field Summary

Fields

Modifier and Type	Field and Description
protected java.util.ArrayList<ScopedModuleManager.Import>	imports
protected boolean	initialized
protected ModuleManager	parentManager
protected boolean	running

Fields inherited from class org.wandora.modules.ModuleManager

isRequiredBy, log, moduleListeners, moduleParams, modules, moduleSettings, variables

Constructor Summary

Constructors

Constructor and Description
ScopedModuleManager()

Method Summary

Modifier and Type	Method and Description
void	addImport(java.lang.Class<? extends Module> cls, boolean optional)
void	addImport(ScopedModuleManager.Import im)
<A extends Module> A	findModule(Module context, java.lang.String instanceName, java.lang.Class<A> cls) Finds a module that is of the specified class or one extending it.
<A extends Module> java.util.ArrayList<A>	findModulesRecursive(java.lang.Class<A> cls)
java.util.Collection<Module>	getDependencies(ModuleManager manager) Returns all the modules this module depends on.
void	init(ModuleManager manager, java.util.HashMap<java.lang.String,java.lang.Object> parameters) Initialises the module.
boolean	isInitialized() Checks if the module is initialised.
boolean	isRunning() Checks if the module is running.
java.util.Collection<Module>	parseXMLConfigElement(org.w3c.dom.Node doc, java.lang.String source) Parses an XML element as if it was the root element of a full configuration file.
protected void	parseXMLImport(org.w3c.dom.Element e)
java.util.HashMap<java.lang.String,java.lang.Object>	parseXMLOptionsElement(ModuleManager manager, org.w3c.dom.Element e, java.lang.String source) Parses the given module element and returns a map containing the module parameters.
void	setParentManager(ModuleManager manager)
void	start(ModuleManager manager) Starts the module.
void	stop(ModuleManager manager) Stops the module.

Methods inherited from class org.wandora.modules.ModuleManager

addModule, addModule, addModule, addModule, addModule, addModuleListener, autostartModules, autostartModules, findModule, findModule, findModule, findModules, getAllModules, getLogger, getModuleName, getModuleSettings, getVariable, initAllModules, isModuleAutoStart, moduleToString, moduleToString, optionalModule, optionalModule, optionalModule, optionalModule, optionalModules, parseXMLInclude, parseXMLModuleElement, parseXMLModuleSettings, parseXMLOptionsElement, parseXMLParamElement, parseXMLVariable, readXMLOptionsFile, removeModule, removeModuleListener, replaceVariables, requireModule, requireModule, requireModule, requireModule, setLogging, setVariable, startAllModules, startModule, startModuleWithDependencies, stopAllModules, stopCascading, stopModule

Methods inherited from class java.lang.Object

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

Field Detail

running

protected boolean running

initialized

protected boolean initialized

parentManager

protected ModuleManager parentManager

imports

protected final java.util.ArrayList<ScopedModuleManager.Import> imports

Constructor Detail

ScopedModuleManager

public ScopedModuleManager()

Method Detail

findModule

public <A extends Module> A findModule(Module context,
                                       java.lang.String instanceName,
                                       java.lang.Class<A> cls)

Description copied from class: ModuleManager

Finds a module that is of the specified class or one extending it. Typically you look for modules with an interface and will then get a module that implements the interface. This method takes the name of the module requested. No other module will be returned except the module named such.

Overrides:

findModule in class ModuleManager

Parameters:

context - The module which is requesting the module. This may affect what module is returned.

instanceName - The instance name of the requested module.

cls - The class or interface that the module has to implement or extend or be a direct instance of.

Returns:

The module found or null if no such module exists.

findModulesRecursive

public <A extends Module> java.util.ArrayList<A> findModulesRecursive(java.lang.Class<A> cls)

init

public void init(ModuleManager manager,
                 java.util.HashMap<java.lang.String,java.lang.Object> parameters)
          throws ModuleException

Description copied from interface: Module

Initialises the module. After constructor, this is the first method called in the life cycle of a module. It should not perform anything time consuming or anything with notable outside side effects. It should only read the parameters and initialise the module so that it can later be started. Note that a module being initialised doesn't mean that it necessarily will ever be started.

A ModuleException may be thrown if something vital is missing from the parameters or they are not sensible. In some cases you may not want to throw an exception even if vital initialisation information is missing. If, for example, it is possible that the module is initialised in some other way between the init and the start method calls. A ModuleException may also be thrown at the start method if the module is still not initialised.

Specified by:

init in interface Module

Parameters:

manager - The module manager handling this module. You may keep a reference to it if needed.

Throws:

ModuleException

getDependencies

public java.util.Collection<Module> getDependencies(ModuleManager manager)
                                             throws ModuleException

Description copied from interface: Module

Returns all the modules this module depends on. This method will be called after init and the dependencies are allowed to depend on the parameters passed to init. The modules that this module depends on must be returned as a collection. In addition, if any required module is not present, a MissingDependencyException should be thrown. Typically you will use the requireModule and optionalModule methods of the manager to make sure that the modules exist and add them to the collection. requireModule will automatically throw the exception too if the module is not found whereas optionalModule does not.

Specified by:

getDependencies in interface Module

Parameters:

manager - The module manager handling this module.

Returns:

A collection of modules this module depends on.

Throws:

ModuleException

start

public void start(ModuleManager manager)
           throws ModuleException

Description copied from interface: Module

Starts the module. This will be called after init and getDependencies and signals that the module should now begin to perform whatever it was designed to do. This method call however should not block for long, so any time consuming tasks should be started in their own threads. You will typically get references to the required modules again in start using the findModule method of the manager and then store those references to instance variables for later use. You may throw a ModuleException if the module is not in a state where it can be started or it immediately becomes obvious that it cannot be started with the provided settings.

Specified by:

start in interface Module

Parameters:

manager - The module manager handling this module.

Throws:

ModuleException

stop

public void stop(ModuleManager manager)

Description copied from interface: Module

Stops the module. Should stop all threads used by the module, free any large data structures and perform other cleanup. It is possible that the module will be started again later with a start method call (and foregoing init and getDependencies calls). The module should be left in a state where this is possible.

Specified by:

stop in interface Module

Parameters:

manager - The module manager handling this module.

isInitialized

public boolean isInitialized()

Description copied from interface: Module

Checks if the module is initialised. Should return true if init has been called and it did not throw an exception.

Specified by:

isInitialized in interface Module

Returns:

isRunning

public boolean isRunning()

Description copied from interface: Module

Checks if the module is running. Should return true if start has been called and it did not throw an exception and stop has not been called yet.

Specified by:

isRunning in interface Module

Returns:

addImport

public void addImport(ScopedModuleManager.Import im)

addImport

public void addImport(java.lang.Class<? extends Module> cls,
                      boolean optional)

parseXMLImport

protected void parseXMLImport(org.w3c.dom.Element e)

parseXMLConfigElement

public java.util.Collection<Module> parseXMLConfigElement(org.w3c.dom.Node doc,
                                                          java.lang.String source)

Description copied from class: ModuleManager

Parses an XML element as if it was the root element of a full configuration file. Creates all the modules defined in the element. Also sets whatever variables are defined and uses those when parsing the rest of the element.

Overrides:

parseXMLConfigElement in class ModuleManager

Parameters:

doc - The element which contains the config definitions.

source - The source identifier, e.g. file name, where this element came from.

Returns:

A list of all the modules added.

parseXMLOptionsElement

public java.util.HashMap<java.lang.String,java.lang.Object> parseXMLOptionsElement(ModuleManager manager,
                                                                                   org.w3c.dom.Element e,
                                                                                   java.lang.String source)
                                                                            throws java.lang.ReflectiveOperationException,
                                                                                   javax.script.ScriptException

Description copied from interface: XMLOptionsHandler

Parses the given module element and returns a map containing the module parameters. The module parameters will later be passed to your module again in init method. You may of course retain parsed information outside this map as well and refer to it later in the initialisation.

Specified by:

parseXMLOptionsElement in interface XMLOptionsHandler

Parameters:

manager - The module manager handling this module.

e - The module element which is to be parsed.

source - The source identifier for the module, could be the file name where the module comes from or something else.

Returns:

The parsed module parameters which will be passed to the init method of your module later.

Throws:

java.lang.ReflectiveOperationException

javax.script.ScriptException

setParentManager

public void setParentManager(ModuleManager manager)