Source code for core.plugs

# core/plugs.py
#
#

""" core plugins. """

__copyright__ = "Copyright 2015, B.H.J Thate"

## IMPORTS

from core.dispatcher import Dispatcher
from core.errors import error
from core.thing import Thing

import importlib
import logging
import pkgutil

## PLUGINS

class Plugs(Dispatcher):

    """ register plugins. """

    plugnames = ""

    def __init__(zelf, *args, **kwargs): Dispatcher.__init__(zelf, *args, **kwargs)

    ## INIT

    def init(zelf, *args, **kwargs):
        """ initialize plugins, """
        plugnames = args[0]
        modnames = plugnames.split(",") 
        for modname in sorted(modnames, reverse=True):
            if not modname: continue
            objs = zelf.find(modname)
            for obj in objs:
                logging.warn("# init  %s" % modname.upper())
                if modname == "xmpp": obj.init() ; continue
                try: obj.init()
                except: error()
        zelf.ready()

    def boot(zelf, *args, **kwargs):
        packages = args[0]
        for package in packages:
            mod = zelf.load(package)
            init = getattr(mod, "init", None)
            if init: init()

    def shutdown(zelf, *args, **kwargs):
        for name, obj in zelf.items():
            logging.warn("stop %s" % str(name))
            if "shutdown" in dir(obj): obj.shutdown()

    ## SEARCH

    def search(zelf, *args, **kwargs):
        """ find matching name. """
        n = args[0]
        for name in zelf.names():
            if n in name: yield name

    ## LOAD

    def load(zelf, *args, **kwargs):
        """ load plugins from the plugin directory. """
        from core.kernel import cfg
        modname = args[0]
        logging.warn("# plugs %s" % modname)
        zelf[modname] = mod = zelf.loading(modname)
        if "__path__" in dir(mod):
            for pkg in pkgutil.walk_packages(mod.__path__, mod.__name__+'.'):
                name = pkg[1]
                zelf[name] = zelf.loading(name, modname)
        return zelf[modname]

    def loading(zelf, name, package=None, force=True):
        """ load module. """
        logging.info("! load %s" % ".".join(name.split(".")[1:]))
        if name in zelf and not force: mod = zelf.reload(name)
        else: mod = importlib.import_module(name, package)
        return mod

    ## RELOAD

    def reload(zelf, *args, **kwargs):
        name = args[0]
        logging.warn("# reload %s" % name)
        zelf[name] = importlib.reload(zelf[name])
        return zelf[name]

    def reloading(zelf, *args, **kwargs):
        names = zelf.find(args[0])
        for name in names: zelf.reload(name)

## CMNDS

def plugs_stop(event):
    from core.kernel import kernel
    args = event.parsed.args
    if args and kernel.stop(*args): event.ok()

def plugs_start(event):
    from core.kernel import plugs
    args = event.parsed.args
    if args:
        plugnames = plugs.search(*args)
        for pname in plugnames:
            plugs.load(pname)
            plugs.init(event.parsed.args[0])
            event.ok(pname)

def plugs_reload(event):
    from core.kernel import plugs
    args = event.parsed.args
    if args:
        result = plugs.reloading(*args)
        if result: event.ok(named(result))

## HELPERS

def get_cfg(*args, **kwargs):
    try: return getattr(cfg, "cfg_%s" % args[0])
    except AttributeError: pass


def init(*args, **kwargs):
    from core.kernel import kernel
    kernel.register("plugs.stop", plugs_stop)
    kernel.register("plugs.start", plugs_start)
    kernel.register("plugs.reload", plugs_reload)