Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
class Broker:
def subscribe(self, subscriber):
for idx, _ in enumerate(LIFECYCLE_EVENTS):
subscriber.put(event(idx))
subscriber.put(StopIteration)
def unsubscribe(self, queue):
queue.put(StopIteration)
app = vadvisor.app.rest.app
broker = Broker()
app.eventBroker = broker
app.eventStore = InMemoryStore()
q = queue.Queue()
broker.subscribe(q)
for element in q:
app.eventStore.put(element)
return app
patcher = patch('steam.core.crypto.symmetric_decrypt')
self.addCleanup(patcher.stop)
self.s_dec = patcher.start()
self.s_dec.side_effect = lambda c, k: c
patcher = patch('steam.core.crypto.symmetric_decrypt_HMAC')
self.addCleanup(patcher.stop)
self.s_dec_hmac = patcher.start()
self.s_dec_hmac.side_effect = lambda c, k, mac: c
# mock out TCPConnection
patcher = patch('steam.core.cm.TCPConnection', autospec=True)
self.addCleanup(patcher.stop)
self.conn = patcher.start().return_value
self.conn_in = gevent.queue.Queue()
self.conn.__iter__.return_value = self.conn_in
# mock out CMServerList
patcher = patch('steam.core.cm.CMServerList', autospec=True)
self.addCleanup(patcher.stop)
self.server_list = patcher.start().return_value
self.server_list.__iter__.return_value = [(127001, 20000+i) for i in range(10)]
self.server_list.bootstrap_from_webapi.return_value = False
self.server_list.bootstrap_from_dns.return_value = False
def destroy(self):
if self._ref and self._ref():
ref = self._ref() # grab the ref before we stop, otherwise ref() returns a dead ref
self.stopped = True
ref._cell = None
self._ref = None
else:
self.stopped = True
ref = self.ref
while True:
try:
sender, m = self.queue.get_nowait()
except gevent.queue.Empty:
break
if m == ('_watched', ANY):
self._watched(m[1])
elif m == ('__error', ANY, ANY):
_, exc, tb = m
self.report((exc, tb))
elif not (m == ('terminated', ANY) or m == ('_unwatched', ANY) or m == ('_node_down', ANY) or m == '_stop' or m == '_kill' or m == '__done' or m == '__undone'):
Events.log(DeadLetter(ref, m, sender))
self.parent_actor.send(('_child_terminated', ref))
for watcher in (self.watchers or []):
watcher << ('terminated', ref)
self.actor = self.inbox = self.queue = self.parent_actor = None
sock.send("\r\n")
slave = HaystackSlave()
slave.last_fileno = last_fileno
slaves.append(slave)
try:
while True:
while slave.last_fileno < haystack.haystack_last_fileno:
if not post_file(sock, slave.last_fileno+1):
return False
slave.last_fileno += 1
try:
slave.waiting = True
slave.channel.get(timeout=5)
except queue.Empty:
if not heartbeat(sock):
return False
finally:
slave.waiting = False
finally:
slaves.remove(slave)
) # Event when we are trying to send a file.
self._data_channel_recv = gevent.event.Event() # Event for receiving a file.
self.cli_ip, self.cli_port = (
None,
None,
) # IP and port received from client in active/passive mode.
self._data_sock = None
self._data_listener_sock = None
# socket for accepting cli_ip and cli_port in passive mode.
self._rnfr = None # For RNFR and RNTO
self.metrics = FTPMetrics() # track session related metrics.
# Input and output queues.
self._command_channel_input_q = gevent.queue.Queue()
self._command_channel_output_q = gevent.queue.Queue()
self._data_channel_output_q = gevent.queue.Queue()
self._data_channel_input_q = gevent.queue.Queue()
self.ftp_greenlets = None # Keep track of all greenlets
socketserver.BaseRequestHandler.__init__(
self, request=request, client_address=client_address, server=server
)
... message.finish()
Or give it to a pool::
>>> gevent.pool.Pool().map(queue, my_handler)
:param maxsize: maximum number of messages that can be queued. If less than
or equal to zero or None, the queue size is infinite.
"""
def __call__(self, consumer, message):
message.enable_async()
self.put(message)
class ChannelHandler(gevent.queue.Channel):
"""Iterator like api for gnsq.
Like :class:`QueueHandler` with a ``maxsize`` of ``1``.
"""
def __call__(self, consumer, message):
message.enable_async()
self.put(message)
def __init__(self, host, port):
self._ibuffer = ''
self._obuffer = ''
self.iqueue = queue.Queue()
self.oqueue = queue.Queue()
self.host = host
self.port = port
self._socket = self._create_socket()
self.jobs = None
# Simple Python script for searching & downloading samples from VirusTotal.
import gevent.monkey
import gevent.queue
gevent.monkey.patch_all()
import click
import os.path
import requests
import time
VT_SEARCH = "https://www.virustotal.com/vtapi/v2/file/search"
VT_DOWNLOAD = "https://www.virustotal.com/vtapi/v2/file/download"
apikey = open(os.path.expanduser("~/.vtdl"), "rb").read().strip()
queue = gevent.queue.Queue()
@click.group()
def vtdl():
pass
@vtdl.command()
@click.argument("query")
@click.option("-c", "--count", default=100)
def search(query, count):
data = {
"apikey": apikey,
"query": query,
}
r = requests.post(VT_SEARCH, data=data)
if brace_count > 0:
brace_count -= 1
if sub.find('{next_sub}') >= 0:
for _ in self.next_subs:
self.queue.put((0, sub.replace('{next_sub}', _)))
if sub.find('{alphnum}') >= 0:
for _ in 'abcdefghijklmnopqrstuvwxyz0123456789':
self.queue.put((brace_count, sub.replace('{alphnum}', _, 1)))
elif sub.find('{alpha}') >= 0:
for _ in 'abcdefghijklmnopqrstuvwxyz':
self.queue.put((brace_count, sub.replace('{alpha}', _, 1)))
elif sub.find('{num}') >= 0:
for _ in '0123456789':
self.queue.put((brace_count, sub.replace('{num}', _, 1)))
continue
except gevent.queue.Empty as e:
break
try:
if sub in self.found_subs:
continue
self.scan_count_local += 1
cur_domain = sub + '.' + self.domain
answers = self.resolvers[j].query(cur_domain)
if answers:
self.found_subs.add(sub)
ips = ', '.join(sorted([answer.address for answer in answers]))
if ips in ['1.1.1.1', '127.0.0.1', '0.0.0.0', '0.0.0.1']:
continue
def __init__(self, socket):
self._socket = socket
self._recv_queue = gevent.queue.Channel()
self._recv_task = gevent.spawn(self._recver)