Exemplos de PLUGGABLE_ACTION_REGISTRY em Python

Exemplo n.º 1

 def parse_module_config(self, plug_set, plug_name, plug_config):
     """Parse module config and update the pluggable module set"""
     if self.local_event_registry.check(plug_name):
         plug_class = self.local_event_registry.get_class(plug_name)
         plug_set["events"].append(
             plug_class(self.test_object, self.event_triggered, plug_config))
     elif self.local_action_registry.check(plug_name):
         plug_class = self.local_action_registry.get_class(plug_name)
         plug_set["actions"].append(
             plug_class(self.test_object, plug_config))
     elif PLUGGABLE_EVENT_REGISTRY.check(plug_name):
         plug_class = PLUGGABLE_EVENT_REGISTRY.get_class(plug_name)
         plug_set["events"].append(
             plug_class(self.test_object, self.event_triggered, plug_config))
     elif PLUGGABLE_ACTION_REGISTRY.check(plug_name):
         plug_class = PLUGGABLE_ACTION_REGISTRY.get_class(plug_name)
         plug_set["actions"].append(
             plug_class(self.test_object, plug_config))
     else:
         raise Exception("Pluggable component '%s' not recognized"
                         % plug_name)

Exemplo n.º 2

Arquivo: pluggable_modules.py Projeto: kickstandproject/asterisk-testsuite-temporary

 def parse_module_config(self, plug_set, plug_name, plug_config):
     """Parse module config and update the pluggable module set"""
     if self.local_event_registry.check(plug_name):
         plug_class = self.local_event_registry.get_class(plug_name)
         plug_set["events"].append(
             plug_class(self.test_object, self.event_triggered, plug_config))
     elif self.local_action_registry.check(plug_name):
         plug_class = self.local_action_registry.get_class(plug_name)
         plug_set["actions"].append(
             plug_class(self.test_object, plug_config))
     elif PLUGGABLE_EVENT_REGISTRY.check(plug_name):
         plug_class = PLUGGABLE_EVENT_REGISTRY.get_class(plug_name)
         plug_set["events"].append(
             plug_class(self.test_object, self.event_triggered, plug_config))
     elif PLUGGABLE_ACTION_REGISTRY.check(plug_name):
         plug_class = PLUGGABLE_ACTION_REGISTRY.get_class(plug_name)
         plug_set["actions"].append(
             plug_class(self.test_object, plug_config))
     else:
         raise Exception("Pluggable component '%s' not recognized"
                         % plug_name)

Exemplo n.º 3

Arquivo: ami.py Projeto: colinsung/testsuite

                                                            self))
PLUGGABLE_EVENT_REGISTRY.register("ami-events", AMIPluggableEventModule)


def replace_ami_vars(mydict, values):
    outdict = {}
    for key, value in mydict.iteritems():
        outdict[key] = var_replace(value, values)

    return outdict


class AMIPluggableActionModule(object):
    """Pluggable AMI action module.
    """

    def __init__(self, test_object, config):
        """Setup the AMI event observer"""
        self.test_object = test_object
        if not isinstance(config, list):
            config = [config]
        self.config = config

    def run(self, triggered_by, source, extra):
        """Callback called when this action is triggered."""
        for instance in self.config:
            action = replace_ami_vars(instance["action"], extra)
            ami_id = instance.get("id", 0)
            self.test_object.ami[ami_id].sendMessage(action)
PLUGGABLE_ACTION_REGISTRY.register("ami-actions", AMIPluggableActionModule)

Exemplo n.º 4

Arquivo: pluggable_modules.py Projeto: kickstandproject/asterisk-testsuite-temporary

        """Notify the event-action mapper that the test has started."""
        self.triggered_callback(self, ast)
PLUGGABLE_EVENT_REGISTRY.register("test-start", TestStartEventModule)

class LogActionModule(object):
    """An action module that logs a message when triggered."""

    def __init__(self, test_object, config):
        """Setup the test start observer"""
        self.test_object = test_object
        self.message = config["message"]

    def run(self, triggered_by, source, extra):
        """Log a message."""
        LOGGER.info(self.message)
PLUGGABLE_ACTION_REGISTRY.register("logger", LogActionModule)

class CallbackActionModule(object):
    """An action module that calls the specified callback."""

    def __init__(self, test_object, config):
        """Setup the test start observer"""
        self.test_object = test_object
        self.module = config["module"]
        self.method = config["method"]

    def run(self, triggered_by, source, extra):
        """Call the callback."""
        module = __import__(self.module)
        method = getattr(module, self.method)
        self.test_object.set_passed(method(self.test_object, triggered_by,

Exemplo n.º 5

Arquivo: pluggable_modules.py Projeto: colinsung/testsuite

        self.triggered_callback(self, ast)
PLUGGABLE_EVENT_REGISTRY.register("test-start", TestStartEventModule)


class LogActionModule(object):
    """An action module that logs a message when triggered."""

    def __init__(self, test_object, config):
        """Setup the test start observer"""
        self.test_object = test_object
        self.message = config["message"]

    def run(self, triggered_by, source, extra):
        """Log a message."""
        LOGGER.info(self.message)
PLUGGABLE_ACTION_REGISTRY.register("logger", LogActionModule)


class ValidateLogActionModule(object):
    """An action module that validates a log files existence."""

    def __init__(self, test_object, config):
        self.test_object = test_object
        self.logfile = config["logfile"]
        self.pass_if_present = config["pass-if-present"]

    def run(self, triggered_by, source, extra):
        """Check to see if log file is present or not."""
        files = []
        testpath = ('%s/var/log/asterisk' %
                    (self.test_object.ast[0].base))

Exemplo n.º 6

    def __init__(self, test_object, config):
        """Setup the ARI event observer"""
        self.test_object = test_object
        if not isinstance(config, list):
            config = [config]
        self.requests = [
            ARIRequest(test_object.ari, request_config)
            for request_config in config
        ]
        self.count = 0

    def run(self, triggered_by, source, extra):
        """Callback called when this action is triggered."""
        self.count += 1
        for request in self.requests:
            if request.instance and request.instance != self.count:
                continue
            if request.delay:
                reactor.callLater(request.delay, request.send, extra)
            else:
                result = request.send(extra)
                if isinstance(result, bool) and not result:
                    self.test_object.set_passed(False)
                else:
                    self.test_object.set_passed(True)


PLUGGABLE_ACTION_REGISTRY.register("ari-requests", ARIPluggableRequestModule)

# vim:sw=4:ts=4:expandtab:textwidth=79

Exemplo n.º 7

Arquivo: pluggable_modules.py Projeto: thiagovice/testsuite

PLUGGABLE_EVENT_REGISTRY.register("test-start", TestStartEventModule)


class LogActionModule(object):
    """An action module that logs a message when triggered."""
    def __init__(self, test_object, config):
        """Setup the test start observer"""
        self.test_object = test_object
        self.message = config["message"]

    def run(self, triggered_by, source, extra):
        """Log a message."""
        LOGGER.info(self.message)


PLUGGABLE_ACTION_REGISTRY.register("logger", LogActionModule)


class ValidateLogActionModule(object):
    """An action module that validates a log files existence."""
    def __init__(self, test_object, config):
        self.test_object = test_object
        self.logfile = config["logfile"]
        self.pass_if_present = config["pass-if-present"]

    def run(self, triggered_by, source, extra):
        """Check to see if log file is present or not."""
        files = []
        testpath = ('%s/var/log/asterisk' % (self.test_object.ast[0].base))
        for (dirpath, dirnames, filenames) in os.walk(testpath):
            files.extend(filenames)

Exemplo n.º 8

Arquivo: ari.py Projeto: rchicoli/asterisk-testsuite

class ARIPluggableRequestModule(object):
    """Pluggable ARI action module.
    """

    def __init__(self, test_object, config):
        """Setup the ARI event observer"""
        self.test_object = test_object
        if not isinstance(config, list):
            config = [config]
        self.requests = [ARIRequest(test_object.ari, request_config)
                         for request_config in config]
        self.count = 0

    def run(self, triggered_by, source, extra):
        """Callback called when this action is triggered."""
        self.count += 1
        for request in self.requests:
            if request.instance and request.instance != self.count:
                continue
            if request.delay:
                reactor.callLater(request.delay, request.send, extra)
            else:
                result = request.send(extra)
                if isinstance(result, bool) and not result:
                    self.test_object.set_passed(False)
                else:
                    self.test_object.set_passed(True)
PLUGGABLE_ACTION_REGISTRY.register("ari-requests", ARIPluggableRequestModule)

# vim:sw=4:ts=4:expandtab:textwidth=79

Exemplo n.º 9

PLUGGABLE_EVENT_REGISTRY.register("test-start", TestStartEventModule)


class LogActionModule(object):
    """An action module that logs a message when triggered."""
    def __init__(self, test_object, config):
        """Setup the test start observer"""
        self.test_object = test_object
        self.message = config["message"]

    def run(self, triggered_by, source, extra):
        """Log a message."""
        LOGGER.info(self.message)


PLUGGABLE_ACTION_REGISTRY.register("logger", LogActionModule)


class CallbackActionModule(object):
    """An action module that calls the specified callback."""
    def __init__(self, test_object, config):
        """Setup the test start observer"""
        self.test_object = test_object
        self.module = config["module"]
        self.method = config["method"]

    def run(self, triggered_by, source, extra):
        """Call the callback."""
        module = __import__(self.module)
        method = getattr(module, self.method)
        self.test_object.set_passed(

Exemplo n.º 10

PLUGGABLE_EVENT_REGISTRY.register("ami-events", AMIPluggableEventModule)


def replace_ami_vars(mydict, values):
    outdict = {}
    for key, value in mydict.iteritems():
        outdict[key] = var_replace(value, values)

    return outdict


class AMIPluggableActionModule(object):
    """Pluggable AMI action module.
    """
    def __init__(self, test_object, config):
        """Setup the AMI event observer"""
        self.test_object = test_object
        if not isinstance(config, list):
            config = [config]
        self.config = config

    def run(self, triggered_by, source, extra):
        """Callback called when this action is triggered."""
        for instance in self.config:
            action = replace_ami_vars(instance["action"], extra)
            ami_id = instance.get("id", 0)
            self.test_object.ami[ami_id].sendMessage(action)


PLUGGABLE_ACTION_REGISTRY.register("ami-actions", AMIPluggableActionModule)