def start(self, *args, **kwargs): self.listener = (self.config['address'], self.config['port'] + self.manager.config['server_number']) StreamServer.__init__(self, self.listener, spawn=Pool()) self.algo = self.manager.algos[self.config['algo']] if not self.config['reporter'] and len(self.manager.component_types['Reporter']) == 1: self.reporter = self.manager.component_types['Reporter'][0] elif not self.config['reporter']: raise ConfigurationError( "There are more than one Reporter components, target reporter" "must be specified explicitly!") else: self.reporter = self._lookup(self.config['reporter']) if not self.config['jobmanager'] and len(self.manager.component_types['Jobmanager']) == 1: self.jobmanager = self.manager.component_types['Jobmanager'][0] elif not self.config['jobmanager']: raise ConfigurationError( "There are more than one Jobmanager components, target jobmanager " "must be specified explicitly!") else: self.jobmanager = self._lookup(self.config['jobmanager']) self.jobmanager.new_job.rawlink(self.new_job) self.logger.info("Stratum server starting up on {}".format(self.listener)) for serv in self.agent_servers: serv.start() StreamServer.start(self, *args, **kwargs) Component.start(self)
def __init__(self, listener, profiler=None, interval=INTERVAL, log=LOG, pickle_protocol=PICKLE_PROTOCOL, **server_kwargs): StreamServer.__init__(self, listener, **server_kwargs) ProfilingServer.__init__(self, profiler, interval, log, pickle_protocol) self.lock = Semaphore() self.profiling_greenlet = None
def __init__(self, host, port): self.behavior = Dummy() self.behavior_name = 'dummy' self.host = gethostbyname(host) self.port = port location = self.host, self.port StreamServer.__init__(self, location)
def __init__(self, listener, cli_timeout=60): StreamServer.__init__(self, listener) self.listener = listener self.cli_timeout = cli_timeout self.php_cons = dict() self.msg_queue = Queue() self.cli_conns = cppsconn.CppsConn(self.msg_queue)
def __init__(self, listener, application=None, backlog=None, spawn='default', log='default', error_log='default', handler_class=None, environ=None, **ssl_args): StreamServer.__init__(self, listener, backlog=backlog, spawn=spawn, **ssl_args) if application is not None: self.application = application if handler_class is not None: self.handler_class = handler_class # Note that we can't initialize these as class variables: # sys.stderr might get monkey patched at runtime. def _make_log(l, level=20): if l == 'default': return sys.stderr if l is None: return _NoopLog() if not hasattr(l, 'write') and hasattr(l, 'log'): return LoggingLogAdapter(l, level) return l self.log = _make_log(log) self.error_log = _make_log(error_log, 40) # logging.ERROR self.set_environ(environ) self.set_max_accept()
def __init__(self, config): self._configure(config) self.agent_servers = [] listener = (self.config['address'], self.config['port']) # Start a corresponding agent server if self.config['agent']['enabled']: serv = AgentServer(self) self.agent_servers.append(serv) StreamServer.__init__(self, listener, spawn=Pool()) # A dictionary of all connected clients indexed by id self.clients = {} self.agent_clients = {} # A dictionary of lists of connected clients indexed by address self.address_lut = {} # A dictionary of lists of connected clients indexed by address and # worker tuple self.address_worker_lut = {} # counters that allow quick display of these numbers. stratum only self.authed_clients = 0 self.idle_clients = 0 # Unique client ID counters for stratum and agents self.stratum_id_count = 0 self.agent_id_count = 0
def start(self, *args, **kwargs): self.listener = (self.config['address'], self.config['port'] + self.manager.config['server_number']) StreamServer.__init__(self, self.listener, spawn=Pool()) # Interpolate a list of tiers based on minimum and maximum difficulty # as long as they haven't manually specified tiers. This allows # graceful backwards compatability as well min_diff = self.config['vardiff']['minimum_difficulty'] max_diff = self.config['vardiff']['maximum_difficulty'] if (self.config['vardiff']['enabled'] and self.config['vardiff']['tiers'] == None and min_diff and max_diff): tiers = [min_diff] diff = min_diff while diff < max_diff: diff *= 2 tiers.append(diff) if tiers[-1] != max_diff: # don't add a duplicate tier tiers.append(max_diff) self.config['vardiff']['tiers'] = tiers if __debug__: self.logger.debug( "Interpolated {} tiers from minimum_difficulty of {} and maximum_difficulty of {}" .format(tiers, min_diff, max_diff)) # Check to make sure we have tiers to work with, either manually # defined or interpolated if not self.config['vardiff']['tiers']: raise ConfigurationError( "No tiers for vardiff. Please specify vaild minimum_difficulty and " "maximum_difficulty, or a tiers array in the vardiff config block") self.algo = self.manager.algos[self.config['algo']] if not self.config['reporter'] and len(self.manager.component_types['Reporter']) == 1: self.reporter = self.manager.component_types['Reporter'][0] elif not self.config['reporter']: raise ConfigurationError( "There are more than one Reporter components, target reporter" "must be specified explicitly!") else: self.reporter = self._lookup(self.config['reporter']) if not self.config['jobmanager'] and len(self.manager.component_types['Jobmanager']) == 1: self.jobmanager = self.manager.component_types['Jobmanager'][0] elif not self.config['jobmanager']: raise ConfigurationError( "There are more than one Jobmanager components, target jobmanager " "must be specified explicitly!") else: self.jobmanager = self._lookup(self.config['jobmanager']) self.jobmanager.new_job.rawlink(self.new_job) self.logger.info("Stratum server starting up on {}".format(self.listener)) for serv in self.agent_servers: serv.start() StreamServer.start(self, *args, **kwargs) Component.start(self)
def __init__(self, listener, script, name=None, backlog=None, spawn='default', **sslargs): StreamServer.__init__(self, listener, backlog=backlog, spawn=spawn, **sslargs) self.name = name self.script = script self.nb_connections = 0 self.route = None
def __init__(self, listener=None, backlog=None, noisy=None, policy=None): if listener is None: listener = ('0.0.0.0', 843) if noisy is not None: self.noisy = noisy if policy is not None: self.policy = policy StreamServer.__init__(self, listener=listener, backlog=backlog)
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)
def __init__(self, *args, **kwargs): listener = kwargs.pop('url') if isinstance(listener, list): listener = tuple(listener) device = kwargs.pop('device') e_kwargs = dict(baudrate=kwargs.pop('baudrate', None), newline=kwargs.pop('newline', None)) StreamServer.__init__(self, listener, *args, **kwargs) EmulatorServerMixin.__init__(self, device, **e_kwargs)
def __init__(self, listener, script, backlog=None, spawn='default', **sslargs): StreamServer.__init__(self, listener, backlog=backlog, spawn=spawn, **sslargs) self.script = script self.nb_connections = 0 self.route = None self.rewrite_request = None self.rewrite_response = None
def start(self, *args, **kwargs): self.logger = self.server.logger self.listener = ( self.config["address"], self.config["port"] + self.config["agent"]["port_diff"] + self.server.manager.config["server_number"], ) StreamServer.__init__(self, self.listener, spawn=Pool()) self.logger.info("Agent server starting up on {}".format(self.listener)) StreamServer.start(self, *args, **kwargs) Component.start(self)
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)
def __init__(self, listener, processor, inputTransportFactory=None, outputTransportFactory=None, inputProtocolFactory=None, outputProtocolFactory=None, **kwargs): StreamServer.__init__(self, listener=listener, handle=self._process_socket, **kwargs) self.processor = processor self.inputTransportFactory = inputTransportFactory self.outputTransportFactory = outputTransportFactory or inputTransportFactory self.inputProtocolFactory = inputProtocolFactory self.outputProtocolFactory = outputProtocolFactory or inputProtocolFactory
def __init__(self, listener, application=None, backlog=256, spawn='default', log='default', handler_class=None, environ=None, **ssl_args): StreamServer.__init__(self, listener, backlog=backlog, spawn=spawn, **ssl_args) if application is not None: self.application = application if handler_class is not None: self.handler_class = handler_class if log == 'default': self.log = sys.stderr else: self.log = log self.set_environ(environ)
def __init__(self, log, listener, processor, inputTransportFactory=None, outputTransportFactory=None, inputProtocolFactory=None, outputProtocolFactory=None, **kwargs): StreamServer.__init__(self, listener, self._process_socket, **kwargs) self.log = log self.processor = processor self.inputTransportFactory = (inputTransportFactory or TTransport.TFramedTransportFactory()) self.outputTransportFactory = (outputTransportFactory or TTransport.TFramedTransportFactory()) self.inputProtocolFactory = (inputProtocolFactory or TBinaryProtocol.TBinaryProtocolFactory()) self.outputProtocolFactory = (outputProtocolFactory or TBinaryProtocol.TBinaryProtocolFactory())
def __init__(self, listener, locals=None, banner=None, **server_args): """ :keyword locals: If given, a dictionary of "builtin" values that will be available at the top-level. :keyword banner: If geven, a string that will be printed to each connecting user. """ StreamServer.__init__(self, listener, spawn=_Greenlet_stdreplace.spawn, **server_args) _locals = {'__doc__': None, '__name__': '__console__'} if locals: _locals.update(locals) self.locals = _locals self.banner = banner self.stderr = sys.stderr
def __init__(self, listener, app, keyfile=None, certfile=None): self.app = app self.keyfile = keyfile self.certfile = certfile if keyfile and certfile: StreamServer.__init__( self, listener, self.handle, keyfile=keyfile, certfile=certfile ) else: StreamServer.__init__(self, listener, self.handle)
def __init__(self, listener, sessionClass=ServerSession, backlog=None, spawn='default', verbose=False, **ssl_args): ''' Create a new RPC server. :param listener: Tuple (address, port). :type listener: tuple. :param sessionClass: The class of Session. :type sessionClass: Derived class of ServerSession. ''' StreamServer.__init__(self, listener, self._handle_socket, backlog, spawn, **ssl_args) self.SessionClass = sessionClass self.clients = {} self.verbose = verbose
def __init__(self, config): self.config = config self.upstream = None listener = ("0.0.0.0", config.get("port", 7070)) StreamServer.__init__(self, listener, backlog=1024, ) config_upstream = config.get("upstream", {'type': 'direct'}) type = config_upstream.get('type', None) if type is None: raise ConfigError(u'[upstream]未配置代理类型!详细信息:%s' % config_upstream) Upstream = upstream.get_upstream(type) if Upstream is None: raise ConfigError(u'[upstream]不支持 %s 类型代理!' % type) self.upstream = Upstream(config_upstream)
def __init__(self, *args, **kwargs): StreamServer.__init__(self, *args, **kwargs) self.server_address, self.port = None, None if kwargs.has_key("server_address"): server_address = kwargs.get("server_address") if isinstance(server_address, tuple): self.server_address = server_address[0] self.port = server_address[1] self.max_pool = None if kwargs.has_key("max_pool"): self.pool = kwargs.get("max_pool") self.debug = False self.server_packet_cnt = 1 self.enable_signals()
def __init__ (self, listener, remote_host, remote_port, ssh_transport, session_instance=None, session_name=None, subsystem=None, logger=None, loglevel=log.loglevel_DEFAULT,): """\ @param listener: listen on TCP/IP socket C{(<IP>, <Port>)} @type listener: C{tuple} @param remote_host: hostname or IP of remote host (in case of X2Go mostly 127.0.0.1) @type remote_host: C{str} @param remote_port: port of remote host @type remote_port: C{int} @param ssh_transport: a valid Paramiko/SSH transport object @type ssh_transport: C{obj} @param session_instance: the complete L{X2GoSession} instance of the X2Go session this port forwarding server belongs to. Note: for new L{X2GoSession} instances the object has the session name not yet set(!!!) @type session_instance: C{obj} @param session_name: the session name of the X2Go session this port forwarding server belongs to @type session_name: C{str} @param logger: you can pass an L{X2GoLogger} object to the L{X2GoFwServer} constructor @type logger: C{obj} @param loglevel: if no L{X2GoLogger} object has been supplied a new one will be constructed with the given loglevel @type loglevel: C{int} """ if logger is None: self.logger = log.X2GoLogger(loglevel=loglevel) else: self.logger = copy.deepcopy(logger) self.logger.tag = __NAME__ self.chan = None self.is_active = False self.failed = False self.keepalive = None self.listener = listener self.chain_host = remote_host self.chain_port = remote_port self.ssh_transport = ssh_transport self.session_name = session_name self.session_instance = session_instance self.subsystem = subsystem self.fw_socket = None StreamServer.__init__(self, self.listener, self.x2go_forward_tunnel_handle)
def __init__(self, host='0.0.0.0', port=9999, backlog=256, spawn=50, security_by_host=False, allow_hosts=None, error_action=None, connection_timeout=None, no_stress=False, no_verify_protocol=False, close_socket=False, policy=None, debug=False, verbose=1 ): StreamServer.__init__(self, (host, port), handle=self.handler, backlog=backlog, spawn=spawn) self._host = host self._port = port self._concurency = spawn self._max_clients = backlog self._security_by_host = security_by_host self._allow_hosts = allow_hosts self._action_error = error_action self._connection_timeout = connection_timeout self._no_stress = no_stress self._no_verify_protocol = no_verify_protocol self._close_socket = close_socket self._policy = policy self._debug = debug self._verbose = verbose
def __init__(self, listener, aclmap, spawn=100, log=None, webport=8308, interval=1, querytimeout=3, conntimeout=3, activetimeout=1800): StreamServer.__init__(self, listener, spawn=spawn) self.listener = listener self.webport = webport self.interval = interval self.querytimeout = querytimeout self.activetimeout = activetimeout self.aclmap = aclmap if log is None: self.log = logging logging.basicConfig(fromat="%(asctime)s %(levelname)-8s %(message)s", level='DEBUG') # 默认logging是没有write的,在pywsgi里输出log用了write,会报错 # default loggins have not method of write(), buy pywsgi need it logging.write = logging.info setattr(self.log, "critical", partial(self.log.critical, exc_info=True)) setattr(self.log, "error", partial(self.log.error, exc_info=True)) setattr(self.log, "warning", partial(self.log.warning, exc_info=True)) else: self.log = log # 非常重要handlers={} ,每有一个客户端连接,就添加个新 item < handler:greenlet >,便于通过 handler 去处理对应的greenlet # handlers={} is very import struct, when a new client to connect, append it with new item < handler: greenlet>, we can process some greenlet throght the handler self.handlers = {} """ sbT:server begin time tcC:total connect count, 总链接次数 ncC:normal close connect count,链接正常断开数 ecC:error close connect count, 链接非正常断开 taC:total auth count, auth 总次数 eaC:error auth count, auth 失败次数 tqC:total query count, query 总次数 eqC:error qurey count, 错误query 总次数 """ self.state = {'sbT': time.time(), 'tcC': 0, 'ncC': 0, 'ecC': 0, 'taC': 0, 'eaC': 0, 'tqC': 0, 'eqC': 0} self.log.info("%-8s: %s@%s" % ( 'svrstart', repr(listener), time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time.time()))) ) self.webviewer(webport) if interval > 0: if querytimeout <= 0: querytimeout = 3 self.gm = gevent.spawn(self.monitor, interval, conntimeout, querytimeout, activetimeout)
def __init__(self, listener, middlewares=[], linked_servers=[], **kwargs): StreamServer.__init__(self, listener, **kwargs) self.clients = set() from middleware import StatisticsMiddleware, MultiplexingMiddleware, ChecksumMiddleware if len(middlewares) == 0: self.middlewares = [StatisticsMiddleware(), ChecksumMiddleware(), MultiplexingMiddleware()] else: self.middlewares = middlewares self.link_to_servers = Queue() for linked_server in linked_servers: self.link_to_servers.put(linked_server) self.linker = Greenlet.spawn(self._linker) self.unregistrable = Queue() self.client_manager = Greenlet.spawn(self._client_manager) self.timer = Timer(self) self.timer.start()
def __init__(self, listener, application=None, backlog=None, spawn='default', log='default', handler_class=None, environ=None, **ssl_args): StreamServer.__init__(self, listener, backlog=backlog, spawn=spawn, **ssl_args) if application is not None: self.application = application if handler_class is not None: self.handler_class = handler_class if log == 'default': self.log = sys.stderr else: self.log = log self.set_environ(environ) self.set_max_accept()
def __init__(self, listener, middlewares=[], linked_servers=[], **kwargs): StreamServer.__init__(self, listener, **kwargs) self.clients = set() from middleware import StatisticsMiddleware, MultiplexingMiddleware, ChecksumMiddleware if len(middlewares) == 0: self.middlewares = [ StatisticsMiddleware(), ChecksumMiddleware(), MultiplexingMiddleware() ] else: self.middlewares = middlewares self.link_to_servers = Queue() for linked_server in linked_servers: self.link_to_servers.put(linked_server) self.linker = Greenlet.spawn(self._linker) self.unregistrable = Queue() self.client_manager = Greenlet.spawn(self._client_manager) self.timer = Timer(self) self.timer.start()
class Server(StreamServer): """ socket 服务器 """ def __init__(self, address, async=False): for sign in SHUT_DOWN_SIGN: ''' 关服信号 ''' gevent.signal(sign, self.shutdown) pool = Pool(conf_server.ASYNC_SIZE) StreamServer.__init__(self, address, self.connection_handler, spawn=pool) self.serverData = ServerData(self) self.sockets = Queue(conf_server.SOCKET_SIZE) # 绑定了服务器实例的 socket # 处理收到的数据 self.spawn(self.receive)
def __init__(self, listener, profiler=None, interval=INTERVAL, log=LOG, pickle_protocol=PICKLE_PROTOCOL, **server_kwargs): StreamServer.__init__(self, listener, **server_kwargs) ProfilingServer.__init__(self, profiler, interval, log, pickle_protocol) self.lock = Semaphore()
def start(self, *args, **kwargs): self.listener = (self.config['address'], self.config['port'] + self.manager.config['server_number']) StreamServer.__init__(self, self.listener, spawn=Pool()) # Interpolate a list of tiers based on minimum and maximum difficulty # as long as they haven't manually specified tiers. This allows # graceful backwards compatability as well min_diff = self.config['vardiff']['minimum_difficulty'] max_diff = self.config['vardiff']['maximum_difficulty'] if (self.config['vardiff']['enabled'] and self.config['vardiff']['tiers'] == None and min_diff and max_diff): tiers = [min_diff] diff = min_diff while diff < max_diff: diff *= 2 tiers.append(diff) if tiers[-1] != max_diff: # don't add a duplicate tier tiers.append(max_diff) self.config['vardiff']['tiers'] = tiers if __debug__: self.logger.debug( "Interpolated {} tiers from minimum_difficulty of {} and maximum_difficulty of {}" .format(tiers, min_diff, max_diff)) # Check to make sure we have tiers to work with, either manually # defined or interpolated if not self.config['vardiff']['tiers']: raise ConfigurationError( "No tiers for vardiff. Please specify vaild minimum_difficulty and " "maximum_difficulty, or a tiers array in the vardiff config block" ) self.algo = self.manager.algos[self.config['algo']] if not self.config['reporter'] and len( self.manager.component_types['Reporter']) == 1: self.reporter = self.manager.component_types['Reporter'][0] elif not self.config['reporter']: raise ConfigurationError( "There are more than one Reporter components, target reporter" "must be specified explicitly!") else: self.reporter = self._lookup(self.config['reporter']) if not self.config['jobmanager'] and len( self.manager.component_types['Jobmanager']) == 1: self.jobmanager = self.manager.component_types['Jobmanager'][0] elif not self.config['jobmanager']: raise ConfigurationError( "There are more than one Jobmanager components, target jobmanager " "must be specified explicitly!") else: self.jobmanager = self._lookup(self.config['jobmanager']) self.jobmanager.new_job.rawlink(self.new_job) self.logger.info("Stratum server starting up on {}".format( self.listener)) for serv in self.agent_servers: serv.start() StreamServer.start(self, *args, **kwargs) Component.start(self)
def __init__(self, *args, **kwargs): self.server = UsherServer() StreamServer.__init__(self, *args, **kwargs)
def __init__(self, listener, dest, destport, method, password): StreamServer.__init__(self, listener) self.remotehost = "ws://" + dest + ":" + str(destport) + "/" log('dest: %s' % self.remotehost) self.method = method self.key = self.md5key(password)
def __init__(self, listener, publisher, subscriber): StreamServer.__init__(self, listener, self.proto) self.publisher = publisher self.subscriber = subscriber
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)
def __init__(self, listener, mongo, **kwargs): StreamServer.__init__(self, listener, **kwargs) self.mongo = mongo
def __init__(self, listener=None, backlog=None): if listener is None: listener = ('0.0.0.0', 843) StreamServer.__init__(self, listener=listener, backlog=backlog)
def __init__(self, listener, application=None, backlog=None, spawn='default', flow=BaseFlow, **ssl_args): StreamServer.__init__(self, listener, backlog=backlog, spawn=spawn, **ssl_args) self.flow = flow self.getLog( )
def __init__(self, listener, handle, spawn='default', worker=None): StreamServer.__init__(self, listener, spawn=spawn) self.handle_func = handle self.worker = worker
def __init__(self, listener, protocol, backlog=None, spawn='default'): StreamServer.__init__(self, listener, backlog=backlog, spawn=spawn) self.protocol = protocol
def __init__(self, listener, **kwargs): StreamServer.__init__(self, listener, **kwargs) self.closed = False
def __init__(self, listener, **server_args): self.nodes = {} # 所有RPC客户端节点 self.service = Services() self.service.dispatch('call_node', self.call_node) self.service.dispatch('register', self._handle_register) StreamServer.__init__(self, listener, spawn=None, **server_args)
def __init__(self, listener_addr, backend_addr, auth_func, **kwargs): StreamServer.__init__(self, listener_addr, **kwargs) self.backend_addr = backend_addr self.auth_func = auth_func
def __init__(self, listener, logger, **server_args): StreamServer.__init__(self, listener, spawn=_Greenlet_stdreplace.spawn, **server_args) self.logger = logger
def __init__(self, listener, **kwargs): StreamServer.__init__(self, listener, **kwargs)
def __init__(self, listener, destinations, **kwargs): StreamServer.__init__(self, listener, **kwargs) self.destinations = destinations logging.debug('Starting up the port forwarder.')
def __init__(self, conn_data=None, *args, **kwargs): StreamServer.__init__(self, *args, **kwargs) DBG("xcc NetoolTcpServer") self.conn_data = conn_data self.accept_count = 0
def __init__(self, addr, handlecls): StreamServer.__init__(self, addr) self._handlecls = handlecls
def __init__(self, listener, dest, **kwargs): StreamServer.__init__(self, listener, **kwargs) self.dest = dest
def __init__(self, port): StreamServer.__init__(self, ('0.0.0.0', port), self.handler)
def __init__(self, listener, locals=None, banner=None, **server_args): StreamServer.__init__(self, listener, spawn=_Greenlet_stdreplace.spawn, **server_args) self.locals = locals self.banner = banner self.stderr = sys.stderr
def __init__(self, services, bind=("127.0.0.1", DEFAULT_PORT), spawn=1): StreamServer.__init__(self, bind, spawn=spawn) BaseServer.__init__(self, services)
def __init__(self, listener, dest, **kwargs): print(listener, dest) # :8080 ('216.239.32.21', 80) StreamServer.__init__(self, listener, **kwargs) self.dest = dest
def __init__(self, listener=None, backlog=None, noisy=None): if listener is None: listener = ('0.0.0.0', 843) if noisy is not None: self.noisy = noisy StreamServer.__init__(self, listener=listener, backlog=backlog)
def __init__(self, listener, locals=None, banner=None, **server_args): StreamServer.__init__(self, listener, spawn=None, **server_args) self.locals = locals self.banner = banner
def __init__(self, addr, module, handlercls, framed, spawn): StreamServer.__init__(self, addr, spawn=spawn) ThriftHandler.__init__(self, module, handlercls, framed=framed)