Example #1
0
    def __init__(self, proxy, backend, protocol='tcp', behaviors=None,
                 settings=None, statsd=None, logger=None, **kwargs):
        self.settings = settings
        cfg = self.settings.getsection('vaurien')

        if behaviors is None:
            behaviors = get_behaviors()

        logger.info('Starting the Chaos TCP Server')
        parsed_proxy = parse_address(proxy)
        self.backend = backend
        dest = parse_address(backend)
        backlog = cfg.get('backlog', 8192)
        StreamServer.__init__(self, parsed_proxy, backlog=backlog, **kwargs)
        self.max_accept = 2000  # XXX option ?
        self.pool_max_size = cfg.get('pool_max_size', 1000)
        self.pool_timeout = cfg.get('pool_timeout', 30)
        self.async_mode = not cfg.get('sync', False)
        self._pool = FactoryPool(self._create_connection, self.pool_max_size,
                                 self.pool_timeout)
        self.dest = dest
        self.running = True
        self._statsd = statsd
        self._logger = logger
        self.behaviors = behaviors
        self.behaviors.update(get_prefixed_sections(self.settings, 'behavior',
                                                    logger))
        self.behavior = get_behaviors()['dummy']
        self.behavior_name = 'dummy'
        self.stay_connected = cfg.get('stay_connected', False)
        self.timeout = cfg.get('timeout', 30)
        self.protocol = cfg.get('protocol', protocol)

        # creating the handler with the passed options
        protocols = get_protocols()
        protocols.update(get_prefixed_sections(self.settings, 'protocol',
                                               logger))

        self.handler = protocols[self.protocol]

        # updating the handler settings
        args = settings['args']
        self.handler.update_settings(extract_settings(args, 'protocol',
                                                      self.protocol))

        protocol_specific_settings = self.settings.getsection('protocol.%s' % self.protocol)
        if protocol_specific_settings:
            self.handler.update_settings(protocol_specific_settings)

        self.handler.proxy = self

        logger.info('Options:')
        logger.info('* proxies from %s to %s' % (proxy, backend))
        logger.info('* timeout: %d' % self.timeout)
        logger.info('* stay_connected: %d' % self.stay_connected)
        logger.info('* pool_max_size: %d' % self.pool_max_size)
        logger.info('* pool_timeout: %d' % self.pool_timeout)
        logger.info('* async_mode: %d' % self.async_mode)
Example #2
0
    def __init__(self, proxy, backend, protocol='tcp', behaviors=None,
                 settings=None, statsd=None, logger=None, **kwargs):
        self.settings = settings
        cfg = self.settings.getsection('vaurien')

        if behaviors is None:
            behaviors = get_behaviors()

        logger.info('Starting the Chaos TCP Server')
        parsed_proxy = parse_address(proxy)
        self.backend = backend
        dest = parse_address(backend)
        backlog = cfg.get('backlog', 8192)
        StreamServer.__init__(self, parsed_proxy, backlog=backlog, **kwargs)
        self.max_accept = 2000  # XXX option ?
        self.pool_max_size = cfg.get('pool_max_size', 1000)
        self.pool_timeout = cfg.get('pool_timeout', 30)
        self.async_mode = not cfg.get('sync', False)
        self._pool = FactoryPool(self._create_connection, self.pool_max_size,
                                 self.pool_timeout)
        self.dest = dest
        self.running = True
        self._statsd = statsd
        self._logger = logger
        self.behaviors = behaviors
        self.behaviors.update(get_prefixed_sections(self.settings, 'behavior',
                                                    logger))
        self.behavior = get_behaviors()['dummy']
        self.behavior_name = 'dummy'
        self.stay_connected = cfg.get('stay_connected', False)
        self.timeout = cfg.get('timeout', 30)
        self.protocol = cfg.get('protocol', protocol)

        # creating the handler with the passed options
        protocols = get_protocols()
        protocols.update(get_prefixed_sections(self.settings, 'protocol',
                                               logger))

        self.handler = protocols[self.protocol]

        # updating the handler settings
        args = settings['args']
        self.handler.update_settings(extract_settings(args, 'protocol',
                                                      self.protocol))

        protocol_specific_settings = self.settings.getsection('protocol.%s' % self.protocol)
        if protocol_specific_settings:
            self.handler.update_settings(protocol_specific_settings)

        self.handler.proxy = self

        logger.info('Options:')
        logger.info('* proxies from %s to %s' % (proxy, backend))
        logger.info('* timeout: %d' % self.timeout)
        logger.info('* stay_connected: %d' % self.stay_connected)
        logger.info('* pool_max_size: %d' % self.pool_max_size)
        logger.info('* pool_timeout: %d' % self.pool_timeout)
        logger.info('* async_mode: %d' % self.async_mode)
Example #3
0
    def __init__(
        self, proxy, backend, protocol="tcp", behaviors=None, settings=None, statsd=None, logger=None, **kwargs
    ):
        self.settings = settings
        cfg = self.settings.getsection("vaurien")

        if behaviors is None:
            behaviors = get_behaviors()

        logger.info("Starting the Chaos TCP Server")
        parsed_proxy = parse_address(proxy)
        self.backend = backend
        dest = parse_address(backend)
        backlog = cfg.get("backlog", 8192)
        StreamServer.__init__(self, parsed_proxy, backlog=backlog, **kwargs)
        self.max_accept = 2000  # XXX option ?
        self.pool_max_size = cfg.get("pool_max_size", 1000)
        self.pool_timeout = cfg.get("pool_timeout", 30)
        self.async_mode = not cfg.get("sync", False)
        self._pool = FactoryPool(self._create_connection, self.pool_max_size, self.pool_timeout)
        self.dest = dest
        self.running = True
        self._statsd = statsd
        self._logger = logger
        self.behaviors = behaviors
        self.behaviors.update(get_prefixed_sections(self.settings, "behavior", logger))
        self.behavior = get_behaviors()["dummy"]
        self.behavior_name = "dummy"
        self.stay_connected = cfg.get("stay_connected", False)
        self.timeout = cfg.get("timeout", 30)
        self.protocol = cfg.get("protocol", protocol)

        # creating the handler with the passed options
        protocols = get_protocols()
        protocols.update(get_prefixed_sections(self.settings, "protocol", logger))

        self.handler = protocols[self.protocol]

        # updating the handler settings
        args = settings["args"]
        self.handler.update_settings(extract_settings(args, "protocol", self.protocol))

        protocol_specific_settings = self.settings.getsection("protocol.%s" % self.protocol)
        if protocol_specific_settings:
            self.handler.update_settings(protocol_specific_settings)

        self.handler.proxy = self

        logger.info("Options:")
        logger.info("* proxies from %s to %s" % (proxy, backend))
        logger.info("* timeout: %d" % self.timeout)
        logger.info("* stay_connected: %d" % self.stay_connected)
        logger.info("* pool_max_size: %d" % self.pool_max_size)
        logger.info("* pool_timeout: %d" % self.pool_timeout)
        logger.info("* async_mode: %d" % self.async_mode)
Example #4
0
    def initialize_choices(self):
        total = 0
        behavior = self.settings.getsection('vaurien')['behavior']
        choices = {}

        for behavior in behavior.split(','):
            choice = behavior.split(':')
            if len(choice) != 2:
                raise ValueError('You need to use percentage:name')

            percent, behavior_name = choice
            percent = int(percent)
            if behavior_name not in self.behaviors:
                choices = self.behaviors.keys()
                msg = "%r is an unknown behavior. Pick one of: %s."
                raise ValueError(msg % (behavior_name,
                                        ', '.join(['%r' % choice
                                                   for choice in choices])))

            choices[behavior_name] = self.behaviors[behavior_name], percent
            total += percent

        if total > 100:
            raise ValueError('The behavior total needs to be 100 or less')
        elif total < 100:
            missing = 100 - total
            if 'dummy' in choices:
                choices['dummy'][1] += missing
            else:
                choices['dummy'] = get_behaviors()['dummy'], missing

        for name, (behavior, percent) in choices.items():
            self.choices.extend(
                [(self.behaviors[name], name) for i in range(percent)])
Example #5
0
    def initialize_choices(self):
        total = 0
        behavior = self.settings.getsection('vaurien')['behavior']
        choices = {}

        for behavior in behavior.split(','):
            choice = behavior.split(':')
            if len(choice) != 2:
                raise ValueError('You need to use percentage:name')

            percent, behavior_name = choice
            percent = int(percent)
            if behavior_name not in self.behaviors:
                choices = self.behaviors.keys()
                msg = "%r is an unknown behavior. Pick one of: %s."
                raise ValueError(msg % (behavior_name, ', '.join(
                    ['%r' % choice for choice in choices])))

            choices[behavior_name] = self.behaviors[behavior_name], percent
            total += percent

        if total > 100:
            raise ValueError('The behavior total needs to be 100 or less')
        elif total < 100:
            missing = 100 - total
            if 'dummy' in choices:
                choices['dummy'][1] += missing
            else:
                choices['dummy'] = get_behaviors()['dummy'], missing

        for name, (behavior, percent) in choices.items():
            self.choices.extend([(self.behaviors[name], name)
                                 for i in range(percent)])
Example #6
0
    def initialize_choices(self):
        total = 0
        behavior = self.settings.getsection("vaurien")["behavior"]
        choices = {}

        for behavior in behavior.split(","):
            choice = behavior.split(":")
            if len(choice) != 2:
                raise ValueError("You need to use percentage:name")

            percent, behavior_name = choice
            percent = int(percent)
            if behavior_name not in self.behaviors:
                choices = self.behaviors.keys()
                msg = "%r is an unknown behavior. Pick one of: %s."
                raise ValueError(msg % (behavior_name, ", ".join(["%r" % choice for choice in choices])))

            choices[behavior_name] = self.behaviors[behavior_name], percent
            total += percent

        if total > 100:
            raise ValueError("The behavior total needs to be 100 or less")
        elif total < 100:
            missing = 100 - total
            if "dummy" in choices:
                choices["dummy"][1] += missing
            else:
                choices["dummy"] = get_behaviors()["dummy"], missing

        for name, (behavior, percent) in choices.items():
            self.choices.extend([(self.behaviors[name], name) for i in range(percent)])
Example #7
0
def generate_behaviors(app):
    return generate_plugins_doc(app, 'behaviors',
                                get_behaviors().items(), _BEHAVIOR)
Example #8
0
 def get_behavior_names(self):
     keys = get_behaviors().keys()
     keys.sort()
     return keys
Example #9
0
 def get_behavior_names(self):
     keys = get_behaviors().keys()
     keys.sort()
     return keys
Example #10
0
def generate_behaviors(app):
    return generate_plugins_doc(app, 'behaviors', get_behaviors().items(),
                                _BEHAVIOR)
Example #11
0
def main():
    # get the values from the default config
    defaults = DEFAULT_SETTINGS.items()
    defaults.sort()

    parser = argparse.ArgumentParser(description='Runs a Chaos TCP proxy.')

    # other arguments
    parser.add_argument('--config', help='Configuration file', default=None)
    parser.add_argument('--version', action='store_true', default=False,
                        help='Displays version and exits.')
    parser.add_argument('--http', action='store_true', default=False,
                        help='Start a simple http server to control vaurien')
    parser.add_argument('--http-host', default='localhost',
                        help='Host of the http server, if any')
    parser.add_argument('--http-port', default=8080, type=int,
                        help='Port of the http server, if any')
    parser.add_argument('--protocol', default='tcp', choices=get_protocols(),
                        help='Protocol used')

    for key, default in defaults:
        if key.startswith('vaurien'):
            key = key[len('vaurien.'):]
        key = key.replace('_', '-')
        type_ = default.__class__
        if type_ is bool:
            parser.add_argument('--%s' % key, default=default,
                                action='store_true')
        else:
            parser.add_argument('--%s' % key, default=default,
                                type=type_)

    parser.add_argument('--log-level', dest='loglevel', default='info',
                        choices=LOG_LEVELS.keys() + [key.upper() for key in
                                                     LOG_LEVELS.keys()],
                        help="log level")
    parser.add_argument('--log-output', dest='logoutput', default='-',
                        help="log output")

    # now for each registered behavior, we are going to provide its options
    build_args(parser, get_behaviors().items(), 'behavior')

    # same thing for the protocols
    build_args(parser, get_protocols().items(), 'protocol')

    # parsing the provided args
    args = parser.parse_args()

    if args.version:
        print(__version__)
        sys.exit(0)

    # configure the logger
    configure_logger(logger, args.loglevel, args.logoutput)

    # load the defaults
    settings = DEFAULT_SETTINGS.copy()

    # overwrite with the command line arguments
    for key in settings.keys():
        prefix = ''
        if key.startswith('vaurien'):
            key = key[len('vaurien.'):]
            prefix = 'vaurien.'

        try:
            value = getattr(args, key)
        except AttributeError:
            value = None

        if value is not None:
            settings[prefix + key] = value

    # overwrite with the config file if any
    if args.config is not None:
        try:
            load_into_settings(args.config, settings)
        except ValueError, e:
            print(e)
            sys.exit(1)
Example #12
0
def main():
    # get the values from the default config
    defaults = DEFAULT_SETTINGS.items()
    defaults.sort()

    parser = argparse.ArgumentParser(description='Runs a Chaos TCP proxy.')

    # other arguments
    parser.add_argument('--config', help='Configuration file', default=None)
    parser.add_argument('--version',
                        action='store_true',
                        default=False,
                        help='Displays version and exits.')
    parser.add_argument('--http',
                        action='store_true',
                        default=False,
                        help='Start a simple http server to control vaurien')
    parser.add_argument('--http-host',
                        default='localhost',
                        help='Host of the http server, if any')
    parser.add_argument('--http-port',
                        default=8080,
                        type=int,
                        help='Port of the http server, if any')
    parser.add_argument('--protocol',
                        default='tcp',
                        choices=get_protocols(),
                        help='Protocol used')

    for key, default in defaults:
        if key.startswith('vaurien'):
            key = key[len('vaurien.'):]
        key = key.replace('_', '-')
        type_ = default.__class__
        if type_ is bool:
            parser.add_argument('--%s' % key,
                                default=default,
                                action='store_true')
        else:
            parser.add_argument('--%s' % key, default=default, type=type_)

    parser.add_argument('--log-level',
                        dest='loglevel',
                        default='info',
                        choices=LOG_LEVELS.keys() +
                        [key.upper() for key in LOG_LEVELS.keys()],
                        help="log level")
    parser.add_argument('--log-output',
                        dest='logoutput',
                        default='-',
                        help="log output")

    # now for each registered behavior, we are going to provide its options
    build_args(parser, get_behaviors().items(), 'behavior')

    # same thing for the protocols
    build_args(parser, get_protocols().items(), 'protocol')

    # parsing the provided args
    args = parser.parse_args()

    if args.version:
        print(__version__)
        sys.exit(0)

    # configure the logger
    configure_logger(logger, args.loglevel, args.logoutput)

    # load the defaults
    settings = DEFAULT_SETTINGS.copy()

    # overwrite with the command line arguments
    for key in settings.keys():
        prefix = ''
        if key.startswith('vaurien'):
            key = key[len('vaurien.'):]
            prefix = 'vaurien.'

        try:
            value = getattr(args, key)
        except AttributeError:
            value = None

        if value is not None:
            settings[prefix + key] = value

    # overwrite with the config file if any
    if args.config is not None:
        try:
            load_into_settings(args.config, settings)
        except ValueError, e:
            print(e)
            sys.exit(1)
Example #13
0
def main():
    # get the values from the default config
    defaults = DEFAULT_SETTINGS.items()
    defaults.sort()

    parser = argparse.ArgumentParser(description="Runs a Chaos TCP proxy.")

    # other arguments
    parser.add_argument("--config", help="Configuration file", default=None)
    parser.add_argument("--version", action="store_true", default=False, help="Displays version and exits.")
    parser.add_argument(
        "--http", action="store_true", default=False, help="Start a simple http server to control vaurien"
    )
    parser.add_argument("--http-host", default="localhost", help="Host of the http server, if any")
    parser.add_argument("--http-port", default=8080, type=int, help="Port of the http server, if any")
    parser.add_argument("--protocol", default="tcp", choices=get_protocols(), help="Protocol used")

    for key, default in defaults:
        if key.startswith("vaurien"):
            key = key[len("vaurien.") :]
        key = key.replace("_", "-")
        type_ = default.__class__
        if type_ is bool:
            parser.add_argument("--%s" % key, default=default, action="store_true")
        else:
            parser.add_argument("--%s" % key, default=default, type=type_)

    parser.add_argument(
        "--log-level",
        dest="loglevel",
        default="info",
        choices=LOG_LEVELS.keys() + [key.upper() for key in LOG_LEVELS.keys()],
        help="log level",
    )
    parser.add_argument("--log-output", dest="logoutput", default="-", help="log output")

    # now for each registered behavior, we are going to provide its options
    build_args(parser, get_behaviors().items(), "behavior")

    # same thing for the protocols
    build_args(parser, get_protocols().items(), "protocol")

    # parsing the provided args
    args = parser.parse_args()

    if args.version:
        print(__version__)
        sys.exit(0)

    # configure the logger
    configure_logger(logger, args.loglevel, args.logoutput)

    # load the defaults
    settings = DEFAULT_SETTINGS.copy()

    # overwrite with the command line arguments
    for key in settings.keys():
        prefix = ""
        if key.startswith("vaurien"):
            key = key[len("vaurien.") :]
            prefix = "vaurien."

        try:
            value = getattr(args, key)
        except AttributeError:
            value = None

        if value is not None:
            settings[prefix + key] = value

    # overwrite with the config file if any
    if args.config is not None:
        try:
            load_into_settings(args.config, settings)
        except ValueError, e:
            print(e)
            sys.exit(1)