Add context menu support
This patch adds support for adding context menu entries to connected users. As these callbacks are - in contrast to all others in mumo - user specific they do not fit well with the existing mumo architecture. To cope with this creating these callbacks is now handled directly inside the manager on behalf of the remote manager. The remote manager then handles forwarding any context menu actions to a user selected handler. This patch also removes the vestigial parts of context menu handling already present but unused in mumo as they were an architectural dead end.
This commit is contained in:
Stefan Hacker
321
mumo_manager.py
321
mumo_manager.py
@@ -34,6 +34,7 @@ from worker import Worker, local_thread, local_thread_blocking
|
||||
from config import Config
|
||||
import sys
|
||||
import os
|
||||
import uuid
|
||||
|
||||
class FailedLoadModuleException(Exception):
|
||||
pass
|
||||
@@ -54,7 +55,7 @@ def debug_log(enable = True):
|
||||
log = self.log()
|
||||
skwargs = ','.join(['%s=%s' % (karg,repr(arg)) for karg, arg in kwargs])
|
||||
sargs = ','.join([str(arg) for arg in args[1:]]) + '' if not skwargs else (',' + str(skwargs))
|
||||
|
||||
|
||||
call = "%s(%s)" % (fu.__name__, sargs)
|
||||
log.debug(call)
|
||||
res = fu(*args, **kwargs)
|
||||
@@ -63,7 +64,7 @@ def debug_log(enable = True):
|
||||
return new_fu if enable else fu
|
||||
return new_dec
|
||||
|
||||
|
||||
|
||||
|
||||
debug_me = True
|
||||
|
||||
@@ -74,129 +75,201 @@ class MumoManagerRemote(object):
|
||||
can register/unregister to/from callbacks as well
|
||||
as do other signaling to the master MumoManager.
|
||||
"""
|
||||
|
||||
|
||||
SERVERS_ALL = [-1] ## Applies to all servers
|
||||
|
||||
|
||||
def __init__(self, master, name, queue):
|
||||
self.__master = master
|
||||
self.__name = name
|
||||
self.__queue = queue
|
||||
|
||||
|
||||
self.__context_callbacks = {} # server -> action -> callback
|
||||
|
||||
def getQueue(self):
|
||||
return self.__queue
|
||||
|
||||
|
||||
def subscribeMetaCallbacks(self, handler, servers = SERVERS_ALL):
|
||||
"""
|
||||
Subscribe to meta callbacks. Subscribes the given handler to the following
|
||||
callbacks:
|
||||
|
||||
|
||||
>>> started(self, server, context = None)
|
||||
>>> stopped(self, server, context = None)
|
||||
|
||||
|
||||
@param servers: List of server IDs for which to subscribe. To subscribe to all
|
||||
servers pass SERVERS_ALL.
|
||||
@param handler: Object on which to call the callback functions
|
||||
@param handler: Object on which to call the callback functions
|
||||
"""
|
||||
return self.__master.subscribeMetaCallbacks(self.__queue, handler, servers)
|
||||
|
||||
|
||||
def unsubscribeMetaCallbacks(self, handler, servers = SERVERS_ALL):
|
||||
"""
|
||||
Unsubscribe from meta callbacks. Unsubscribes the given handler from callbacks
|
||||
for the given servers.
|
||||
|
||||
|
||||
@param servers: List of server IDs for which to unsubscribe. To unsubscribe from all
|
||||
servers pass SERVERS_ALL.
|
||||
@param handler: Subscribed handler
|
||||
"""
|
||||
return self.__master.unscubscribeMetaCallbacks(self.__queue, handler, servers)
|
||||
|
||||
|
||||
def subscribeServerCallbacks(self, handler, servers = SERVERS_ALL):
|
||||
"""
|
||||
Subscribe to server callbacks. Subscribes the given handler to the following
|
||||
callbacks:
|
||||
|
||||
>>> userConnected(self, state, context = None)
|
||||
|
||||
>>> userConnected(self, state, context = None)
|
||||
>>> userDisconnected(self, state, context = None)
|
||||
>>> userStateChanged(self, state, context = None)
|
||||
>>> channelCreated(self, state, context = None)
|
||||
>>> channelRemoved(self, state, context = None)
|
||||
>>> channelStateChanged(self, state, context = None)
|
||||
|
||||
|
||||
@param servers: List of server IDs for which to subscribe. To subscribe to all
|
||||
servers pass SERVERS_ALL.
|
||||
@param handler: Object on which to call the callback functions
|
||||
@param handler: Object on which to call the callback functions
|
||||
"""
|
||||
return self.__master.subscribeServerCallbacks(self.__queue, handler, servers)
|
||||
|
||||
|
||||
def unsubscribeServerCallbacks(self, handler, servers = SERVERS_ALL):
|
||||
"""
|
||||
Unsubscribe from server callbacks. Unsubscribes the given handler from callbacks
|
||||
for the given servers.
|
||||
|
||||
|
||||
@param servers: List of server IDs for which to unsubscribe. To unsubscribe from all
|
||||
servers pass SERVERS_ALL.
|
||||
@param handler: Subscribed handler
|
||||
"""
|
||||
return self.__master.unsubscribeServerCallbacks(self.__queue, handler, servers)
|
||||
|
||||
def subscribeContextCallbacks(self, handler, servers = SERVERS_ALL):
|
||||
|
||||
def getUniqueAction(self):
|
||||
"""
|
||||
Subscribe to context callbacks. Subscribes the given handler to the following
|
||||
callbacks:
|
||||
|
||||
>>> contextAction(self, action, user, session, channelid, context = None)
|
||||
|
||||
@param servers: List of server IDs for which to subscribe. To subscribe to all
|
||||
servers pass SERVERS_ALL.
|
||||
@param handler: Object on which to call the callback functions
|
||||
Returns a unique action string that can be used in addContextMenuEntry.
|
||||
|
||||
:return: Unique action string
|
||||
"""
|
||||
return self.__master.subscribeContextCallbacks(self.__queue, handler, servers)
|
||||
|
||||
def unsubscribeContextCallbacks(self, handler, servers = SERVERS_ALL):
|
||||
return str(uuid.uuid4())
|
||||
|
||||
def addContextMenuEntry(self, server, user, action, text, handler, context):
|
||||
"""
|
||||
Unsubscribe from context callbacks. Unsubscribes the given handler from callbacks
|
||||
for the given servers.
|
||||
|
||||
@param servers: List of server IDs for which to unsubscribe. To unsubscribe from all
|
||||
servers pass SERVERS_ALL.
|
||||
@param handler: Subscribed handler
|
||||
Adds a new context callback menu entry with the given text for the given user.
|
||||
|
||||
You can use the same action identifier for multiple users entries to
|
||||
simplify your handling. However make sure an action identifier is unique
|
||||
to your module. The easiest way to achieve this is to use getUniqueAction
|
||||
to generate a guaranteed unique one.
|
||||
|
||||
Your handler should be of form:
|
||||
>>> handler(self, server, action, user, target)
|
||||
|
||||
Here server is the server the user who triggered the action resides on.
|
||||
Target identifies what the context action was invoked on. It can be either
|
||||
a User, Channel or None.
|
||||
|
||||
@param server: Server the user resides on
|
||||
@param user: User to add entry for
|
||||
@param action: Action identifier passed to your callback (see above)
|
||||
@param text: Text for the menu entry
|
||||
@param handler: Handler function to call when the menu item is used
|
||||
@param context: Contexts to show entry in (can be a combination of ContextServer, ContextChannel and ContextUser)
|
||||
"""
|
||||
return self.__master.unsubscribeContextCallbacks(self.__queue, handler, servers)
|
||||
|
||||
|
||||
server_actions = self.__context_callbacks.get(server.id())
|
||||
if not server_actions:
|
||||
server_actions = {}
|
||||
self.__context_callbacks[server.id()] = server_actions
|
||||
|
||||
action_cb = server_actions.get(action)
|
||||
if not action_cb:
|
||||
# We need to create an register a new context callback
|
||||
action_cb = self.__master.createContextCallback(self.__handle_context_callback, handler, server)
|
||||
server_actions[action] = action_cb
|
||||
|
||||
server.addContextCallback(user.session, action, text, action_cb, context)
|
||||
|
||||
def __handle_context_callback(self, handler, server, action, user, target_session, target_channelid, current=None):
|
||||
"""
|
||||
Small callback wrapper for context menu operations.
|
||||
|
||||
Translates the given target into the corresponding object and
|
||||
schedules a call to the actual user context menu handler which
|
||||
will be executed in the modules thread.
|
||||
"""
|
||||
|
||||
if target_session != 0:
|
||||
target = server.getState(target_session)
|
||||
elif target_channelid != -1:
|
||||
target = server.getChannelState(target_channelid)
|
||||
else:
|
||||
target = None
|
||||
|
||||
# Schedule a call to the handler
|
||||
self.__queue.put((None, handler, [server, action, user, target], {}))
|
||||
|
||||
def removeContextMenuEntry(self, server, action):
|
||||
"""
|
||||
Removes a previously created context action callback from a server.
|
||||
|
||||
Applies to all users that share the action on this server.
|
||||
|
||||
@param server Server the action should be removed from.
|
||||
@param action Action to remove
|
||||
"""
|
||||
|
||||
try:
|
||||
cb = self.__context_callbacks[server.id()].pop(action)
|
||||
except KeyError:
|
||||
# Nothing to unregister
|
||||
return
|
||||
|
||||
server.removeContextCallback(cb)
|
||||
|
||||
def getMurmurModule(self):
|
||||
"""
|
||||
Returns the Murmur module generated from the slice file
|
||||
"""
|
||||
return self.__master.getMurmurModule()
|
||||
|
||||
|
||||
def getMeta(self):
|
||||
"""
|
||||
Returns the connected servers meta module or None if it is not available
|
||||
"""
|
||||
return self.__master.getMeta()
|
||||
|
||||
|
||||
|
||||
class MumoManager(Worker):
|
||||
MAGIC_ALL = -1
|
||||
|
||||
cfg_default = {'modules':(('mod_dir', str, "modules/"),
|
||||
('cfg_dir', str, "modules-enabled/"),
|
||||
('timeout', int, 2))}
|
||||
|
||||
def __init__(self, murmur, cfg = Config(default = cfg_default)):
|
||||
|
||||
def __init__(self, murmur, context_callback_type, cfg = Config(default = cfg_default)):
|
||||
Worker.__init__(self, "MumoManager")
|
||||
self.queues = {} # {queue:module}
|
||||
self.modules = {} # {name:module}
|
||||
self.imports = {} # {name:import}
|
||||
self.cfg = cfg
|
||||
|
||||
|
||||
self.murmur = murmur
|
||||
self.meta = None
|
||||
|
||||
self.client_adapter = None
|
||||
|
||||
self.metaCallbacks = {} # {sid:{queue:[handler]}}
|
||||
self.serverCallbacks = {}
|
||||
self.contextCallbacks = {}
|
||||
|
||||
|
||||
self.context_callback_type = context_callback_type
|
||||
|
||||
def setClientAdapter(self, client_adapter):
|
||||
"""
|
||||
Sets the ice adapter used for client-side callbacks. This is needed
|
||||
in case per-module callbacks have to be attached during run-time
|
||||
as is the case for context callbacks.
|
||||
|
||||
:param client_adapter: Ice object adapter
|
||||
"""
|
||||
self.client_adapter = client_adapter
|
||||
|
||||
def __add_to_dict(self, mdict, queue, handler, servers):
|
||||
for server in servers:
|
||||
if server in mdict:
|
||||
@@ -207,32 +280,32 @@ class MumoManager(Worker):
|
||||
mdict[server][queue] = [handler]
|
||||
else:
|
||||
mdict[server] = {queue:[handler]}
|
||||
|
||||
|
||||
def __rem_from_dict(self, mdict, queue, handler, servers):
|
||||
for server in servers:
|
||||
try:
|
||||
mdict[server][queue].remove(handler)
|
||||
except KeyError, ValueError:
|
||||
pass
|
||||
|
||||
|
||||
def __announce_to_dict(self, mdict, server, function, *args, **kwargs):
|
||||
"""
|
||||
Call function on handlers for specific servers in one of our handler
|
||||
dictionaries.
|
||||
|
||||
|
||||
@param mdict Dictionary to announce to
|
||||
@param server Server to announce to, ALL is always implied
|
||||
@param function Function the handler should call
|
||||
@param args Arguments for the function
|
||||
@param kwargs Keyword arguments for the function
|
||||
"""
|
||||
|
||||
|
||||
# Announce to all handlers of the given serverlist
|
||||
if server == self.MAGIC_ALL:
|
||||
servers = mdict.iterkeys()
|
||||
else:
|
||||
servers = [self.MAGIC_ALL, server]
|
||||
|
||||
|
||||
for server in servers:
|
||||
try:
|
||||
for queue, handlers in mdict[server].iteritems():
|
||||
@@ -241,7 +314,7 @@ class MumoManager(Worker):
|
||||
except KeyError:
|
||||
# No handler registered for that server
|
||||
pass
|
||||
|
||||
|
||||
def __call_remote(self, queue, handler, function, *args, **kwargs):
|
||||
try:
|
||||
func = getattr(handler, function) # Find out what to call on target
|
||||
@@ -257,11 +330,11 @@ class MumoManager(Worker):
|
||||
else:
|
||||
self.log().exception(e)
|
||||
|
||||
|
||||
|
||||
#
|
||||
#-- Module multiplexing functionality
|
||||
#
|
||||
|
||||
|
||||
@local_thread
|
||||
def announceConnected(self, meta = None):
|
||||
"""
|
||||
@@ -270,7 +343,7 @@ class MumoManager(Worker):
|
||||
self.meta = meta
|
||||
for queue, module in self.queues.iteritems():
|
||||
self.__call_remote(queue, module, "connected")
|
||||
|
||||
|
||||
@local_thread
|
||||
def announceDisconnected(self):
|
||||
"""
|
||||
@@ -283,41 +356,30 @@ class MumoManager(Worker):
|
||||
def announceMeta(self, server, function, *args, **kwargs):
|
||||
"""
|
||||
Call a function on the meta handlers
|
||||
|
||||
|
||||
@param server Server to announce to
|
||||
@param function Name of the function to call on the handler
|
||||
@param args List of arguments
|
||||
@param kwargs List of keyword arguments
|
||||
"""
|
||||
self.__announce_to_dict(self.metaCallbacks, server, function, *args, **kwargs)
|
||||
|
||||
|
||||
@local_thread
|
||||
def announceServer(self, server, function, *args, **kwargs):
|
||||
"""
|
||||
Call a function on the server handlers
|
||||
|
||||
@param server Server to announce to
|
||||
@param function Name of the function to call on the handler
|
||||
@param args List of arguments
|
||||
@param kwargs List of keyword arguments
|
||||
"""
|
||||
self.__announce_to_dict(self.serverCallbacks, server, function, *args, **kwargs)
|
||||
|
||||
@local_thread
|
||||
def announceContext(self, server, function, *args, **kwargs):
|
||||
"""
|
||||
Call a function on the context handlers
|
||||
|
||||
|
||||
@param server Server to announce to
|
||||
@param function Name of the function to call on the handler
|
||||
@param args List of arguments
|
||||
@param kwargs List of keyword arguments
|
||||
"""
|
||||
self.__announce_to_dict(self.serverCallbacks, server, function, *args, **kwargs)
|
||||
|
||||
#
|
||||
#--- Module self management functionality
|
||||
#
|
||||
|
||||
|
||||
@local_thread
|
||||
def subscribeMetaCallbacks(self, queue, handler, servers):
|
||||
"""
|
||||
@@ -325,7 +387,7 @@ class MumoManager(Worker):
|
||||
@see MumoManagerRemote
|
||||
"""
|
||||
return self.__add_to_dict(self.metaCallbacks, queue, handler, servers)
|
||||
|
||||
|
||||
@local_thread
|
||||
def unsubscribeMetaCallbacks(self, queue, handler, servers):
|
||||
"""
|
||||
@@ -333,7 +395,7 @@ class MumoManager(Worker):
|
||||
@see MumoManagerRemote
|
||||
"""
|
||||
return self.__rem_from_dict(self.metaCallbacks, queue, handler, servers)
|
||||
|
||||
|
||||
@local_thread
|
||||
def subscribeServerCallbacks(self, queue, handler, servers):
|
||||
"""
|
||||
@@ -341,7 +403,7 @@ class MumoManager(Worker):
|
||||
@see MumoManagerRemote
|
||||
"""
|
||||
return self.__add_to_dict(self.serverCallbacks, queue, handler, servers)
|
||||
|
||||
|
||||
@local_thread
|
||||
def unsubscribeServerCallbacks(self, queue, handler, servers):
|
||||
"""
|
||||
@@ -349,39 +411,34 @@ class MumoManager(Worker):
|
||||
@see MumoManagerRemote
|
||||
"""
|
||||
return self.__rem_from_dict(self.serverCallbacks, queue, handler, servers)
|
||||
|
||||
@local_thread
|
||||
def subscribeContextCallbacks(self, queue, handler, servers):
|
||||
"""
|
||||
@param queue Target worker queue
|
||||
@see MumoManagerRemote
|
||||
"""
|
||||
|
||||
#TODO: Implement context callbacks
|
||||
self.log().error("Context callbacks not implemented at this point")
|
||||
|
||||
return self.__add_to_dict(self.contextCallbacks, queue, handler, servers)
|
||||
|
||||
@local_thread
|
||||
def unsubscribeContextCallbacks(self, queue, handler, servers):
|
||||
"""
|
||||
@param queue Target worker queue
|
||||
@see MumoManagerRemote
|
||||
"""
|
||||
return self.__rem_from_dict(self.contextCallbacks, queue, handler, servers)
|
||||
|
||||
def getMurmurModule(self):
|
||||
"""
|
||||
Returns the Murmur module generated from the slice file
|
||||
"""
|
||||
return self.murmur
|
||||
|
||||
|
||||
def createContextCallback(self, callback, *ctx):
|
||||
"""
|
||||
Creates a new context callback handler class instance.
|
||||
|
||||
@param callback Callback to set for handler
|
||||
@param *ctx Additional context parameters passed to callback
|
||||
before the actual parameters.
|
||||
@return Murmur ServerContextCallbackPrx object for the context
|
||||
callback handler class.
|
||||
"""
|
||||
contextcbprx = self.client_adapter.addWithUUID(self.context_callback_type(callback, *ctx))
|
||||
contextcb = self.murmur.ServerContextCallbackPrx.uncheckedCast(contextcbprx)
|
||||
|
||||
return contextcb
|
||||
|
||||
def getMeta(self):
|
||||
"""
|
||||
Returns the connected servers meta module or None if it is not available
|
||||
"""
|
||||
return self.meta
|
||||
|
||||
|
||||
#--- Module load/start/stop/unload functionality
|
||||
#
|
||||
@local_thread_blocking
|
||||
@@ -389,39 +446,39 @@ class MumoManager(Worker):
|
||||
def loadModules(self, names = None):
|
||||
"""
|
||||
Loads a list of modules from the mumo directory structure by name.
|
||||
|
||||
|
||||
@param names List of names of modules to load
|
||||
@return: List of modules loaded
|
||||
"""
|
||||
loadedmodules = {}
|
||||
|
||||
|
||||
if not names:
|
||||
# If no names are given load all modules that have a configuration in the cfg_dir
|
||||
if not os.path.isdir(self.cfg.modules.cfg_dir):
|
||||
msg = "Module configuration directory '%s' not found" % self.cfg.modules.cfg_dir
|
||||
self.log().error(msg)
|
||||
raise FailedLoadModuleImportException(msg)
|
||||
|
||||
|
||||
names = []
|
||||
for f in os.listdir(self.cfg.modules.cfg_dir):
|
||||
if os.path.isfile(self.cfg.modules.cfg_dir + f):
|
||||
base, ext = os.path.splitext(f)
|
||||
if not ext or ext.lower() == ".ini" or ext.lower() == ".conf":
|
||||
names.append(base)
|
||||
|
||||
|
||||
for name in names:
|
||||
try:
|
||||
modinst = self._loadModule_noblock(name)
|
||||
loadedmodules[name] = modinst
|
||||
except FailedLoadModuleException:
|
||||
pass
|
||||
|
||||
|
||||
return loadedmodules
|
||||
|
||||
|
||||
@local_thread_blocking
|
||||
def loadModuleCls(self, name, modcls, module_cfg = None):
|
||||
return self._loadModuleCls_noblock(name, modcls, module_cfg)
|
||||
|
||||
|
||||
@debug_log(debug_me)
|
||||
def _loadModuleCls_noblock(self, name, modcls, module_cfg = None):
|
||||
log = self.log()
|
||||
@@ -429,10 +486,10 @@ class MumoManager(Worker):
|
||||
if name in self.modules:
|
||||
log.error("Module '%s' already loaded", name)
|
||||
return
|
||||
|
||||
|
||||
modqueue = Queue.Queue()
|
||||
modmanager = MumoManagerRemote(self, name, modqueue)
|
||||
|
||||
|
||||
try:
|
||||
modinst = modcls(name, modmanager, module_cfg)
|
||||
except Exception, e:
|
||||
@@ -440,40 +497,40 @@ class MumoManager(Worker):
|
||||
log.error(msg)
|
||||
log.exception(e)
|
||||
raise FailedLoadModuleInitializationException(msg)
|
||||
|
||||
|
||||
# Remember it
|
||||
self.modules[name] = modinst
|
||||
self.queues[modqueue] = modinst
|
||||
|
||||
|
||||
return modinst
|
||||
|
||||
|
||||
@local_thread_blocking
|
||||
def loadModule(self, name):
|
||||
"""
|
||||
Loads a single module either by name
|
||||
|
||||
|
||||
@param name Name of the module to load
|
||||
@return Module instance
|
||||
"""
|
||||
self._loadModule_noblock(name)
|
||||
|
||||
|
||||
@debug_log(debug_me)
|
||||
def _loadModule_noblock(self, name):
|
||||
def _loadModule_noblock(self, name):
|
||||
# Make sure this module is not already loaded
|
||||
log = self.log()
|
||||
log.debug("loadModuleByName('%s')", name)
|
||||
|
||||
|
||||
if name in self.modules:
|
||||
log.warning("Tried to load already loaded module %s", name)
|
||||
return
|
||||
|
||||
|
||||
# Check whether there is a configuration file for this module
|
||||
confpath = self.cfg.modules.cfg_dir + name + '.ini'
|
||||
if not os.path.isfile(confpath):
|
||||
msg = "Module configuration file '%s' not found" % confpath
|
||||
log.error(msg)
|
||||
raise FailedLoadModuleConfigException(msg)
|
||||
|
||||
|
||||
# Make sure the module directory is in our python path and exists
|
||||
if not self.cfg.modules.mod_dir in sys.path:
|
||||
if not os.path.isdir(self.cfg.modules.mod_dir):
|
||||
@@ -481,7 +538,7 @@ class MumoManager(Worker):
|
||||
log.error(msg)
|
||||
raise FailedLoadModuleImportException(msg)
|
||||
sys.path.insert(0, self.cfg.modules.mod_dir)
|
||||
|
||||
|
||||
# Import the module and instanciate it
|
||||
try:
|
||||
mod = __import__(name)
|
||||
@@ -490,7 +547,7 @@ class MumoManager(Worker):
|
||||
msg = "Failed to import module '%s', reason: %s" % (name, str(e))
|
||||
log.error(msg)
|
||||
raise FailedLoadModuleImportException(msg)
|
||||
|
||||
|
||||
try:
|
||||
try:
|
||||
modcls = mod.mumo_module_class # First check if there's a magic mumo_module_class variable
|
||||
@@ -503,23 +560,23 @@ class MumoManager(Worker):
|
||||
raise FailedLoadModuleInitializationException(msg)
|
||||
|
||||
return self._loadModuleCls_noblock(name, modcls, confpath)
|
||||
|
||||
|
||||
@local_thread_blocking
|
||||
@debug_log(debug_me)
|
||||
def startModules(self, names = None):
|
||||
"""
|
||||
Start a module by name
|
||||
|
||||
|
||||
@param names List of names of modules to start
|
||||
@return A dict of started module names and instances
|
||||
"""
|
||||
log = self.log()
|
||||
startedmodules = {}
|
||||
|
||||
|
||||
if not names:
|
||||
# If no names are given start all models
|
||||
names = self.modules.iterkeys()
|
||||
|
||||
|
||||
for name in names:
|
||||
try:
|
||||
modinst = self.modules[name]
|
||||
@@ -531,9 +588,9 @@ class MumoManager(Worker):
|
||||
startedmodules[name] = modinst
|
||||
except KeyError:
|
||||
log.error("Could not start unknown module '%s'", name)
|
||||
|
||||
|
||||
return startedmodules
|
||||
|
||||
|
||||
@local_thread_blocking
|
||||
@debug_log(debug_me)
|
||||
def stopModules(self, names = None, force = False):
|
||||
@@ -541,18 +598,18 @@ class MumoManager(Worker):
|
||||
Stop a list of modules by name. Note that this only works
|
||||
for well behaved modules. At this point if a module is really going
|
||||
rampant you will have to restart mumo.
|
||||
|
||||
|
||||
@param names List of names of modules to unload
|
||||
@param force Unload the module asap dropping messages queued for it
|
||||
@return A dict of stopped module names and instances
|
||||
"""
|
||||
log = self.log()
|
||||
stoppedmodules = {}
|
||||
|
||||
|
||||
if not names:
|
||||
# If no names are given start all models
|
||||
names = self.modules.iterkeys()
|
||||
|
||||
|
||||
for name in names:
|
||||
try:
|
||||
modinst = self.modules[name]
|
||||
@@ -560,7 +617,7 @@ class MumoManager(Worker):
|
||||
except KeyError:
|
||||
log.warning("Asked to stop unknown module '%s'", name)
|
||||
continue
|
||||
|
||||
|
||||
if force:
|
||||
# We will have to drain the modules queues
|
||||
for queue, module in self.queues.iteritems():
|
||||
@@ -575,13 +632,17 @@ class MumoManager(Worker):
|
||||
log.debug("Module '%s' is being stopped", name)
|
||||
else:
|
||||
log.debug("Module '%s' already stopped", name)
|
||||
|
||||
|
||||
for modinst in stoppedmodules.itervalues():
|
||||
modinst.join(timeout = self.cfg.modules.timeout)
|
||||
|
||||
|
||||
return stoppedmodules
|
||||
|
||||
|
||||
def stop(self, force = True):
|
||||
"""
|
||||
Stops all modules and shuts down the manager.
|
||||
"""
|
||||
self.log().debug("Stopping")
|
||||
self.stopModules()
|
||||
Worker.stop(self, force)
|
||||
|
||||
|
||||
Reference in New Issue
Block a user