def __init__(self, pull_info, packet, server):
Greenlet.__init__(self)
self.ps = db6.pubsub()
self.server = server
self.packet = packet
self.pull_info = pull_info
self.token = packet[1:3]
def __init__(self, db, collection, doc, act):
# super(greenlet, self).__init__()
Greenlet.__init__(self)
self.db = db
self.collection = collection
self.doc = doc
self.act = act
def __init__(self, stats, reader_clients, event_push_client):
Greenlet.__init__(self)
self._log = logging.getLogger(str(self))
self._stats = stats
self._reader_clients = reader_clients
self._event_push_client = event_push_client
self._halt_event = Event()
def __init__(self, ctx, manager, config, fs, max_mds):
Greenlet.__init__(self)
self.config = config
self.ctx = ctx
self.e = None
self.logger = log.getChild('fs.[{f}]'.format(f=fs.name))
self.fs = fs
self.manager = manager
self.max_mds = max_mds
self.name = 'thrasher.fs.[{f}]'.format(f=fs.name)
self.stopping = Event()
self.randomize = bool(self.config.get('randomize', True))
self.thrash_max_mds = float(self.config.get('thrash_max_mds', 0.0))
self.max_thrash = int(self.config.get('max_thrash', 1))
self.max_thrash_delay = float(self.config.get('thrash_delay', 120.0))
self.thrash_in_replay = float(
self.config.get('thrash_in_replay', False))
assert self.thrash_in_replay >= 0.0 and self.thrash_in_replay <= 1.0, 'thrash_in_replay ({v}) must be between [0.0, 1.0]'.format(
v=self.thrash_in_replay)
self.max_replay_thrash_delay = float(
self.config.get('max_replay_thrash_delay', 4.0))
self.max_revive_delay = float(self.config.get('max_revive_delay',
10.0))
def __init__(self, address, locals=None):
Greenlet.__init__(self)
if isinstance(address, socket.socket):
self.socket = address
else:
self.socket = socket.tcp_listener(address)
self.locals = locals
def __init__(
self,
context,
server_node_name,
server_address,
client_tag,
client_address,
deliverator,
connect_messages=list(),
):
Greenlet.__init__(self)
self._log = logging.getLogger("ResilientClient-%s" % (server_address,))
self._context = context
self._server_node_name = server_node_name
self._server_address = server_address
self._client_tag = client_tag
self._client_address = client_address
self._deliverator = deliverator
self._send_queue = gevent.queue.Queue()
# prime the send queue with messages to be sent as soon
# as we connect
for connect_message in connect_messages:
if not "message-id" in connect_message:
connect_message["message-id"] = uuid.uuid1().hex
message = message_format(ident=None, control=connect_message, body=None)
self._send_queue.put(message)
self._req_socket = None
self.connected = False
def __init__(self, address, locals=None):
Greenlet.__init__(self)
if isinstance(address, socket.socket):
self.socket = address
else:
self.socket = socket.tcp_listener(address)
self.locals = locals
def __init__(self, stats, reader_clients, event_push_client):
Greenlet.__init__(self)
self._log = logging.getLogger(str(self))
self._stats = stats
self._reader_clients = reader_clients
self._event_push_client = event_push_client
self._halt_event = Event()
def __init__(self, *args, **kwargs):
Greenlet.__init__(self, *args, **kwargs)
self.stdin = None
self.stdout = None
self.prev_stdin = None
self.prev_stdout = None
self.prev_stderr = None
def __init__(self,
func,
iterable,
spawn=None,
maxsize=None,
_zipped=False):
"""
An iterator that.
:keyword int maxsize: If given and not-None, specifies the maximum number of
finished results that will be allowed to accumulated awaiting the reader;
more than that number of results will cause map function greenlets to begin
to block. This is most useful is there is a great disparity in the speed of
the mapping code and the consumer and the results consume a great deal of resources.
Using a bound is more computationally expensive than not using a bound.
.. versionchanged:: 1.1b3
Added the *maxsize* parameter.
"""
from gevent.queue import Queue
Greenlet.__init__(self)
if spawn is not None:
self.spawn = spawn
if _zipped:
self._zipped = _zipped
self.func = func
self.iterable = iterable
self.queue = Queue()
if maxsize:
# Bounding the queue is not enough if we want to keep from
# accumulating objects; the result value will be around as
# the greenlet's result, blocked on self.queue.put(), and
# we'll go on to spawn another greenlet, which in turn can
# create the result. So we need a semaphore to prevent a
# greenlet from exiting while the queue is full so that we
# don't spawn the next greenlet (assuming that self.spawn
# is of course bounded). (Alternatively we could have the
# greenlet itself do the insert into the pool, but that
# takes some rework).
#
# Given the use of a semaphore at this level, sizing the queue becomes
# redundant, and that lets us avoid having to use self.link() instead
# of self.rawlink() to avoid having blocking methods called in the
# hub greenlet.
self._result_semaphore = Semaphore(maxsize)
else:
self._result_semaphore = DummySemaphore()
self.count = 0
self.finished = False
# If the queue size is unbounded, then we want to call all
# the links (_on_finish and _on_result) directly in the hub greenlet
# for efficiency. However, if the queue is bounded, we can't do that if
# the queue might block (because if there's no waiter the hub can switch to,
# the queue simply raises Full). Therefore, in that case, we use
# the safer, somewhat-slower (because it spawns a greenlet) link() methods.
# This means that _on_finish and _on_result can be called and interleaved in any order
# if the call to self.queue.put() blocks..
# Note that right now we're not bounding the queue, instead using a semaphore.
self.rawlink(self._on_finish)
def __init__(self, spawn, func, iterable):
from gevent.queue import Queue
Greenlet.__init__(self)
self.spawn = spawn
self.func = func
self.iterable = iterable
self.queue = Queue()
self.count = 0
def __init__(self, item, server):
Greenlet.__init__(self)
dev_eui = unhexlify(item['channel'].decode().replace(
Channel1.join_accept_alarm, ''))
accept = item['data'].decode()
self.server = server
self.dev_eui = dev_eui
self.data = accept
def __init__(self, spawn, func, iterable):
from gevent.queue import Queue
Greenlet.__init__(self)
self.spawn = spawn
self.func = func
self.iterable = iterable
self.queue = Queue()
self.count = 0
def __init__(self, sock, service=None, close_callback=None):
self._buff = ""
self.sock = sock
self._timeout = 10 # 请求超时时间
self._id_iter = _id_generator() # 消息id生成器
self._request_table = {} # 保存所有的RPC请求的AsyncResult，key对应包ID，范围为30bit，在timeout时间内，理论上不可能重复
self.service = service
self.close_callback = close_callback # 断开毁掉
Greenlet.__init__(self)
def __init__(self, func, iterable, spawn=None, maxsize=None, _zipped=False):
"""
An iterator that.
:keyword int maxsize: If given and not-None, specifies the maximum number of
finished results that will be allowed to accumulated awaiting the reader;
more than that number of results will cause map function greenlets to begin
to block. This is most useful is there is a great disparity in the speed of
the mapping code and the consumer and the results consume a great deal of resources.
Using a bound is more computationally expensive than not using a bound.
.. versionchanged:: 1.1b3
Added the *maxsize* parameter.
"""
from gevent.queue import Queue
Greenlet.__init__(self)
if spawn is not None:
self.spawn = spawn
if _zipped:
self._zipped = _zipped
self.func = func
self.iterable = iterable
self.queue = Queue()
if maxsize:
# Bounding the queue is not enough if we want to keep from
# accumulating objects; the result value will be around as
# the greenlet's result, blocked on self.queue.put(), and
# we'll go on to spawn another greenlet, which in turn can
# create the result. So we need a semaphore to prevent a
# greenlet from exiting while the queue is full so that we
# don't spawn the next greenlet (assuming that self.spawn
# is of course bounded). (Alternatively we could have the
# greenlet itself do the insert into the pool, but that
# takes some rework).
#
# Given the use of a semaphore at this level, sizing the queue becomes
# redundant, and that lets us avoid having to use self.link() instead
# of self.rawlink() to avoid having blocking methods called in the
# hub greenlet.
factory = Semaphore
else:
factory = DummySemaphore
self._result_semaphore = factory(maxsize)
self.count = 0
self.finished = False
# If the queue size is unbounded, then we want to call all
# the links (_on_finish and _on_result) directly in the hub greenlet
# for efficiency. However, if the queue is bounded, we can't do that if
# the queue might block (because if there's no waiter the hub can switch to,
# the queue simply raises Full). Therefore, in that case, we use
# the safer, somewhat-slower (because it spawns a greenlet) link() methods.
# This means that _on_finish and _on_result can be called and interleaved in any order
# if the call to self.queue.put() blocks..
# Note that right now we're not bounding the queue, instead using a semaphore.
self.rawlink(self._on_finish)
def __init__(self, func, iterable, spawn=None):
from gevent.queue import Queue
Greenlet.__init__(self)
if spawn is not None:
self.spawn = spawn
self.func = func
self.iterable = iterable
self.queue = Queue()
self.count = 0
self.rawlink(self._on_finish)
def __init__(self, func, iterable, spawn=None):
from gevent.queue import Queue
Greenlet.__init__(self)
if spawn is not None:
self.spawn = spawn
self.func = func
self.iterable = iterable
self.queue = Queue()
self.count = 0
self.rawlink(self._on_finish)
def __init__(self, ctx, manager, config, thrashers):
Greenlet.__init__(self)
self.ctx = ctx
self.config = config
self.e = None
self.logger = log.getChild('daemon_watchdog')
self.manager = manager
self.name = 'watchdog'
self.stopping = Event()
self.thrashers = thrashers
def __init__(self, sock, service=None, close_callback=None):
self._buff = ''
self.sock = sock
self._timeout = 10 # 请求超时时间
self._id_iter = _id_generator() # 消息id生成器
self._request_table = {
} # 保存所有的RPC请求的AsyncResult，key对应包ID，范围为30bit，在timeout时间内，理论上不可能重复
self.service = service
self.close_callback = close_callback # 断开毁掉
Greenlet.__init__(self)
def __init__(self, ctx, manager, config, thrashers):
Greenlet.__init__(self)
self.ctx = ctx
self.config = config
self.e = None
self.logger = log.getChild('daemon_watchdog')
self.manager = manager
self.name = 'watchdog'
self.stopping = Event()
self.thrashers = thrashers
def __init__(self, stream_id , bit_rate_in_kbps = 128.0):
Greenlet.__init__(self)
self.stream_id = stream_id
if(not AudioStreamReader.stream_buffers.get(self.stream_id, None)):
buffer = Buffer()
byte_rate = ((bit_rate_in_kbps/8)*1024)
sleep_time = (buffer.chunk_byte_size*1.0)/byte_rate
AudioStreamReader.stream_buffers[stream_id] = [buffer , byte_rate, sleep_time]
self.buffer, self.byte_rate , self.sleep_time = AudioStreamReader.stream_buffers[self.stream_id]
def __init__(self, context, node_name, address):
Greenlet.__init__(self)
self._log = logging.getLogger("DealerClient-%s" % (node_name, ))
self._dealer_socket = context.socket(zmq.XREQ)
self._dealer_socket.setsockopt(zmq.LINGER, 1000)
self._log.debug("connecting to %s" % (address, ))
self._dealer_socket.connect(address)
self._send_queue = Queue(maxsize=None)
self._delivery_queues = dict()
def __init__(self, context, node_name, address):
Greenlet.__init__(self)
self._log = logging.getLogger("DealerClient-%s" % (node_name, ))
self._dealer_socket = context.socket(zmq.XREQ)
self._dealer_socket.setsockopt(zmq.LINGER, 1000)
self._log.debug("connecting to %s" % (address, ))
self._dealer_socket.connect(address)
self._send_queue = Queue(maxsize=None)
self._delivery_queues = dict()
def __init__(self, conf, input_queue, filtered_queue, db):
LOGGER.info("Init Contract Proforma Filter.")
Greenlet.__init__(self)
self.config = conf
self.cache_db = db
self.input_queue = input_queue
self.filtered_queue = filtered_queue
self.resource = self.config['resource']
self.resource_id = "{}_ID".format(self.resource[:-1]).upper()
self.statusmap = self.config['filter_config'].get('statusmap', {})
self.timeout = self.config['filter_config']['timeout']
def __init__(self, func, iterable, spawn=None):
from gevent.queue import Queue
Greenlet.__init__(self)
if spawn is not None:
self.spawn = spawn
self.func = func
self.iterable = iterable
self.queue = Queue()
self.count = 0
self.waiting = [] # QQQ maybe deque will work faster there?
self.index = 0
self.maxindex = -1
self.rawlink(self._on_finish)
def __init__(self, func, iterable, spawn=None):
from gevent.queue import Queue
Greenlet.__init__(self)
if spawn is not None:
self.spawn = spawn
self.func = func
self.iterable = iterable
self.queue = Queue()
self.count = 0
self.waiting = [] # QQQ maybe deque will work faster there?
self.index = 0
self.maxindex = -1
self.rawlink(self._on_finish)
def __init__(self, context, address, deliverator):
Greenlet.__init__(self)
self._log = logging.getLogger("PULLServer-%s" % (address, ))
# we need a valid path for IPC sockets
if address.startswith("ipc://"):
prepare_ipc_path(address)
self._pull_socket = context.socket(zmq.PULL)
self._log.debug("binding")
self._pull_socket.bind(address)
self._deliverator = deliverator
def __init__(self, conf, input_queue, filtered_queue, db):
logger.info("Init Close Framework Agreement Filter.")
Greenlet.__init__(self)
self.config = conf
self.cache_db = db
self.input_queue = input_queue
self.filtered_queue = filtered_queue
self.resource = self.config['resource']
self.resource_id = "{}_ID".format(self.resource[:-1]).upper()
self.procurement_method_types = tuple(
self.config['filter_config']['procurementMethodTypes'])
self.statuses = tuple(self.config['filter_config']['statuses'])
self.lot_status = self.config['filter_config']['lot_status']
self.timeout = self.config['filter_config']['timeout']
def __init__(self, conf, input_queue, filtered_queue, db):
logger.info('Init Basic CouchDB Filter')
Greenlet.__init__(self)
self.config = conf
self.input_queue = input_queue
self.filtered_queue = filtered_queue
self.db = db
self.resource = self.config['resource']
self.view_path = '_design/{}/_view/by_dateModified'.format(
self.resource)
self.bulk_query_interval = self.config['storage_config'][
'bulk_query_interval']
self.bulk_query_limit = self.config['storage_config'][
'bulk_query_limit']
def __init__(self, context, address, deliverator):
Greenlet.__init__(self)
self._log = logging.getLogger("PULLServer-%s" % (address, ))
# we need a valid path for IPC sockets
if address.startswith("ipc://"):
prepare_ipc_path(address)
self._pull_socket = context.socket(zmq.PULL)
self._log.debug("binding")
self._pull_socket.bind(address)
self._deliverator = deliverator
def __init__(self, conf, input_queue, filtered_queue, db):
logger.info("Init Close Framework Agreement JMESPath Filter.")
Greenlet.__init__(self)
self.config = conf
self.cache_db = db
self.input_queue = input_queue
self.filtered_queue = filtered_queue
self.resource = self.config['resource']
self.resource_id = "{}_ID".format(self.resource[:-1]).upper()
self.filters = [
jmespath.compile(expression['expression'])
for expression in self.config['filter_config'].get('filters', [])
]
self.timeout = self.config['filter_config']['timeout']
def __init__(self, desc, locals):
Greenlet.__init__(self)
self.locals = locals
# mangle the socket
self.desc = desc
readline = desc.readline
self.old = {}
self.fixups = {
'softspace': 0,
'isatty': lambda: True,
'flush': lambda: None,
'readline': lambda *a: readline(*a).replace('\r\n', '\n'),
}
for key, value in self.fixups.iteritems():
if hasattr(desc, key):
self.old[key] = getattr(desc, key)
setattr(desc, key, value)
def __init__(self, desc, locals):
Greenlet.__init__(self)
self.locals = locals
# mangle the socket
self.desc = desc
readline = desc.readline
self.old = {}
self.fixups = {
'softspace': 0,
'isatty': lambda: True,
'flush': lambda: None,
'readline': lambda *a: readline(*a).replace('\r\n', '\n'),
}
for key, value in self.fixups.iteritems():
if hasattr(desc, key):
self.old[key] = getattr(desc, key)
setattr(desc, key, value)
def __init__(self, ctx, config, cluster, daemons):
Greenlet.__init__(self)
self.ctx = ctx
self.config = config
self.cluster = cluster
self.daemons = daemons
self.e = None
self.logger = log
self.name = 'thrasher.rbd_mirror.[{cluster}]'.format(cluster = cluster)
self.stopping = Event()
self.randomize = bool(self.config.get('randomize', True))
self.max_thrash = int(self.config.get('max_thrash', 1))
self.max_thrash_delay = float(self.config.get('thrash_delay', 60.0))
self.max_revive_delay = float(self.config.get('max_revive_delay', 10.0))
def __init__(self, ctx, config, cluster, daemons):
Greenlet.__init__(self)
self.ctx = ctx
self.config = config
self.cluster = cluster
self.daemons = daemons
self.e = None
self.logger = log
self.name = 'thrasher.rbd_mirror.[{cluster}]'.format(cluster = cluster)
self.stopping = Event()
self.randomize = bool(self.config.get('randomize', True))
self.max_thrash = int(self.config.get('max_thrash', 1))
self.min_thrash_delay = float(self.config.get('min_thrash_delay', 60.0))
self.max_thrash_delay = float(self.config.get('max_thrash_delay', 120.0))
self.max_revive_delay = float(self.config.get('max_revive_delay', 10.0))
def __init__(self, ctx, manager, config, fs, max_mds):
Greenlet.__init__(self)
self.config = config
self.ctx = ctx
self.e = None
self.logger = log.getChild('fs.[{f}]'.format(f = fs.name))
self.fs = fs
self.manager = manager
self.max_mds = max_mds
self.name = 'thrasher.fs.[{f}]'.format(f = fs.name)
self.stopping = Event()
self.randomize = bool(self.config.get('randomize', True))
self.thrash_max_mds = float(self.config.get('thrash_max_mds', 0.0))
self.max_thrash = int(self.config.get('max_thrash', 1))
self.max_thrash_delay = float(self.config.get('thrash_delay', 120.0))
self.thrash_in_replay = float(self.config.get('thrash_in_replay', False))
assert self.thrash_in_replay >= 0.0 and self.thrash_in_replay <= 1.0, 'thrash_in_replay ({v}) must be between [0.0, 1.0]'.format(
v=self.thrash_in_replay)
self.max_replay_thrash_delay = float(self.config.get('max_replay_thrash_delay', 4.0))
self.max_revive_delay = float(self.config.get('max_revive_delay', 10.0))
def __init__(
self,
context,
server_node_name,
server_address,
client_tag,
client_address,
deliverator,
connect_messages=list()
):
Greenlet.__init__(self)
self._log = logging.getLogger("ResilientClient-%s" % (
server_address,
))
self._context = context
self._server_node_name = server_node_name
self._server_address = server_address
self._client_tag = client_tag
self._client_address = client_address
self._deliverator = deliverator
self._send_queue = gevent.queue.Queue()
# prime the send queue with messages to be sent as soon
# as we connect
for connect_message in connect_messages:
if not "message-id" in connect_message:
connect_message["message-id"] = uuid.uuid1().hex
message = message_format(
ident=None, control=connect_message, body=None
)
self._send_queue.put(message)
self._req_socket = None
self.connected = False
def __init__(self, locals, conn):
Greenlet.__init__(self)
self.locals = locals
self.desc = _fileobject(conn)
def __init__(self, seconds):
Greenlet.__init__(self)
self.seconds = seconds
def __init__(self, run=None, restart=True, *args, **kwargs):
self.run_target = run
self.run_target_args = args
self.run_target_kwargs = kwargs
self.restart = restart
Greenlet.__init__(self, run, *args, **kwargs)
def __init__(self, data_writer, message):
Greenlet.__init__(self)
self._resilient_client = data_writer._resilient_client
self._message = message
def __init__(self, queue: Queue, processor: Processor, on_event):
Greenlet.__init__(self)
self.queue = queue
self.processor = processor
self.on_event = on_event
def __init__(self, locals, conn, banner=None):
Greenlet.__init__(self)
self.locals = locals
self.desc = _fileobject(conn)
self.banner = banner
def __init__(self, test_number, delay_interval):
Greenlet.__init__(self)
self._test_number = test_number
self._delay_interval = delay_interval
def __init__(self, locals, conn, banner=None):
Greenlet.__init__(self)
self.locals = locals
self.desc = _fileobject(conn)
self.banner = banner
def __init__(self, delay_interval):
Greenlet.__init__(self)
self._delay_interval = delay_interval
def __init__(self, halt_event, user_identity, test_script):
Greenlet.__init__(self)
BaseCustomer.__init__(self, halt_event, user_identity, test_script)
def __init__(self, connection_pool, test_number, delay_interval):
Greenlet.__init__(self)
self._connection_pool = connection_pool
self._test_number = test_number
self._delay_interval = delay_interval
def __init__(self, imsi, apid, aid):
# super(greenlet, self).__init__()
Greenlet.__init__(self)
self.imsi = imsi
self.apid = apid
self.aid = aid
def __init__(self, mobile, apid, aid):
# super(greenlet, self).__init__()
Greenlet.__init__(self)
self.mobile = mobile
self.apid = apid
self.aid = aid
def __init__(self, locals, conn, banner=None):
Greenlet.__init__(self)
self.locals = locals
self.desc = _SocketIO(conn)
self.banner = banner
def __init__(self, halt_event, user_identity, test_script):
Greenlet.__init__(self)
BaseCustomer.__init__(self, halt_event, user_identity, test_script)
def __init__(self, locals, conn, banner=None):
Greenlet.__init__(self)
self.locals = locals
self.desc = _fileobject(conn, mode='rw', close=True)
self.banner = banner
def __init__(self, current):
# super(greenlet, self).__init__()
Greenlet.__init__(self)
self.current = current
def __init__(self, connection_pool, delay_interval):
Greenlet.__init__(self)
self._connection_pool = connection_pool
self._delay_interval = delay_interval
def __init__(self, info):
# super(greenlet, self).__init__()
Greenlet.__init__(self)
self.info = info
