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',
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,
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):
StreamServer.__init__(self, listener, **kwargs)
self.dest = dest
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, handle, spawn='default', worker=None):
StreamServer.__init__(self, listener, spawn=spawn)
self.handle_func = handle
self.worker = worker
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)
