def kill_current_test(self):
""" Unblock save_join() call inside LuaTest.execute(), which doing
necessary servers/greenlets clean up.
"""
# current_test_greenlet is None for PythonTest
if self.current_test.current_test_greenlet:
gevent.kill(self.current_test.current_test_greenlet)
def close(self):
''' Do here all close conection logic '''
for greenlet in self.greenlets:
gevent.kill(greenlet)
if self.user:
KITTEN_SEARCH_JOBS.pop(self.user.id)
CONNECTIONS_POOL.pop(self.user.id)
def cleanup(self):
if self.reconnect_job is not None:
gevent.kill(self.reconnect_job)
self._clean_socket()
self.decoder.remove_listeners_by_key(id(self))
self.decoder.destroy()
def test_gevent_kill(self):
g = gevent.spawn(self.should_never_run, 0) # create but do not switch to
g2 = gevent.spawn(self.should_never_run, 1) # create but do not switch to
# Using gevent.kill
gevent.kill(g)
gevent.kill(g2)
self.check(g, g2)
def keepalive_token(self, token_id):
if isinstance(token_id, Token):
token = token_id
token_id = self.lookup_token_id(token)
else:
token = self.lookup_token(token_id)
if not token:
raise TokenException('Token not found or expired')
if token.lifetime:
gevent.kill(token.timer)
if token.revocation_function is not None:
token.timer = gevent.spawn_later(
token.lifetime,
token.revocation_function,
self,
token,
token_id
)
else:
token.timer = gevent.spawn_later(
token.lifetime,
self.revoke_token,
token_id
)
def killall_servers(self, server, ts, crash_occured):
""" kill all servers and crash detectors before stream swap """
color_log('Kill all servers ...\n', schema='info')
check_list = ts.servers.values() + [server, ]
# check that all servers stopped correctly
for server in check_list:
bad_returncode = server.process.returncode not in (None,
0,
-signal.SIGKILL,
-signal.SIGTERM)
# if non-default server crashed but it was expected
# don't kill the default server and crash detectors
crash_occured = crash_occured or \
bad_returncode and not server.crash_expected
for server in check_list:
server.process.poll()
if crash_occured:
# kill all servers and crash detectors on crash
if server.process.returncode is None:
server.process.kill()
if server.crash_detector is not None:
gevent.kill(server.crash_detector)
elif server.process.returncode is not None:
# join crash detectors of stopped servers
if server.crash_detector is not None:
save_join(server.crash_detector)
def on_close(self):
try:
gevent.kill(self._keepalive_greenlet)
except Exception:
log.exception('Failed to kill keepalive greenlet')
super(IVTSession, self).on_close()
self._ivt.session_closed()
def do_rebalance(self):
"""Rebalance the group."""
pt = ['%s-%s' % (bid, n)
for (bid, np) in self.partitions.items()
for n in range(np)]
cg = [cid for cid in self.consumer.clients.keys()]
self.log.info('rebalance: pt=%r cg=%r' % (pt, cg))
pt.sort()
cg.sort()
n = len(pt) / len(cg)
e = len(pt) % len(cg)
i = cg.index(self.consumer.consumer_id)
start = n * i + min(i, e)
stop = start + n + (0 if (i + 1) > e else 1)
partitions = pt[start:stop]
self.log.info('rebalance: won %r' % (partitions,))
for to_remove in (set(self.owned) - set(partitions)):
self.log.info("stop consuming %s" % (to_remove,))
# Step 1. Stop consuming the topic.
greenlet = self.readers.pop(to_remove, None)
if greenlet is not None:
gevent.kill(greenlet)
# Step 2. Remove the owner node from the group.
self.framework.delete().for_path(
'/consumers/%s/owners/%s/%s' % (self.consumer.group_id,
self.topic_name, to_remove))
self.owned.remove(to_remove)
# Step 3. We remove the offsets entry so that we re-read
# it if we ever get ownership of the partition again.
self.offsets.pop(to_remove, None)
# Iterate through the partitions that we just won and try to
# create the "owner" node in zookeeper. If we fail to create
# at least one of them, make sure that False is returned so
# that the process is restarted.
fail = False
for partition in (set(partitions) - set(self.owned)):
try:
self.framework.create().as_ephemeral().with_data(
self.consumer.consumer_id).parents_if_needed().for_path(
'/consumers/%s/owners/%s/%s' % (self.consumer.group_id,
self.topic_name, partition))
except zookeeper.NodeExistsException:
self.log.info('%s: failed to create ownership' % (partition,))
fail = True
continue
self.owned.append(partition)
if partition not in self.readers:
broker_id, part_id = partition.split('-')
self.readers[partition] = gevent.spawn(
self._reader, partition, self.consumer.brokers[broker_id],
int(part_id))
return fail != True
def subscribe_socket(ws):
'''Fufill the websocket URL of /subscribe, every update notify the
websocket and read updates from the websocket '''
# XXX: TODO IMPLEMENT ME
#
# get from client, send to socket
#
client = Client()
clients.append(client)
g = gevent.spawn( read_ws, ws, client )
try:
while True:
# block here
jdata = client.get()
print "Got a message!"
ws.send(jdata)
except Exception as e:
print "WS Error %s" % e
finally:
clients.remove(client)
gevent.kill(g)
return None
def invitation(self, remote_addr, gn):
print '(INVITATION) [%s] : invites [%s]' % (remote_addr, self.addr)
if self.s != "Normal":
return
'''CALL STOP ! '''
if len(self.greenletList) > 0:
self.greenletList.pop()
if len(self.greenletList) > 0:
for g in self.greenletList:
gevent.kill(g)
self.greenletList = []
temp = self.c
tempSet = self.Up
self.s = "Election"
self.c = remote_addr
self.g = gn
if temp == self.addr:
for k in tempSet:
try:
self.connections[k].invitation(remote_addr, gn)
print '(INVITATION) [%s] : invites [%s].' % (remote_addr, self.servers[k])
except zerorpc.TimeoutExpired:
print '(INVITATION) [%s] : [%s] timeout!' % (self.servers[k], remote_addr)
continue
m = self.servers.index(remote_addr)
try:
self.connections[m].accept(self.addr, gn)
print '(INVITATION) [%s] : accepts [%s]\'s invitation.'% (self.addr, remote_addr)
except zerorpc.TimeoutExpired:
print '(INVITATION) [%s] : [%s] timeout!' % (self.addr, remote_addr)
self.recovery()
self.s = "Reorganization"
def subscribe_socket(ws):
'''Fufill the websocket URL of /subscribe, every update notify the
websocket and read updates from the websocket '''
client = Client()
clients.append(client)
g = gevent.spawn( read_ws, ws, client )
try:
while True:
msg = client.get()
if "new" in msg:
ws.send(json.dumps(myWorld.world()))
else:
for key in msg:
if "data" in key:
data = msg[key]
elif "entity" in key:
entity = msg[key]
myWorld.set(entity, data)
ws.send(json.dumps(data))
#for freetest.py data format
else:
ws.send(json.dumps(msg))
except Exception as e:# WebSocketError as e:
print "WS Error %s" % e
finally:
clients.remove(client)
gevent.kill(g)
def initial_sync_impl(self, crispin_client):
# We wrap the block in a try/finally because the change_poller greenlet
# needs to be killed when this greenlet is interrupted
change_poller = None
try:
assert crispin_client.selected_folder_name == self.folder_name
remote_uids = crispin_client.all_uids()
with self.syncmanager_lock:
with mailsync_session_scope() as db_session:
local_uids = common.all_uids(self.account_id, db_session,
self.folder_id)
self.remove_deleted_uids(db_session, local_uids,
remote_uids)
new_uids = set(remote_uids) - local_uids
download_stack = UIDStack()
for uid in sorted(new_uids):
download_stack.put(uid, GenericUIDMetadata(self.throttled))
with mailsync_session_scope() as db_session:
self.update_uid_counts(
db_session,
remote_uid_count=len(remote_uids),
# This is the initial size of our download_queue
download_uid_count=len(new_uids))
change_poller = spawn(self.poll_for_changes, download_stack)
bind_context(change_poller, 'changepoller', self.account_id,
self.folder_id)
self.download_uids(crispin_client, download_stack)
finally:
if change_poller is not None:
# schedule change_poller to die
kill(change_poller)
def stop_task(self, task_name):
for greenlet in self.active[task_name]:
try:
gevent.kill(greenlet)
self.active[task_name] = []
except BaseException:
pass
def subscribe_socket(ws):
'''Fufill the websocket URL of /subscribe, every update notify the
websocket and read updates from the websocket '''
client = Client()
clients.append(client)
g = gevent.spawn( read_ws, ws, client )
print "Subscribing"
#Sends the current status of the canvas
client.put(json.dumps(myWorld.world()))
print('F: Sending: ' + json.dumps(myWorld.world()))
try:
while True:
# block here
msg = client.get()
print "Got a message! %s" %msg
ws.send(msg)
except Exception as e:# WebSocketError as e:
print "WS Error %s" % e
finally:
clients.remove(client)
gevent.kill(g)
return None
def test_zmqserver_exc(self):
import gevent
from synapse.node import ZMQServer, ZMQClient, NodeException
conf_srv = {'uri': 'tcp://*:5557',
'name': 'zmqsrv'}
conf_cli = {'uri': 'tcp://localhost:5557',
'name': 'zmqcli'}
def srv_handler(msg):
raise NodeException("buggy", "exc_result")
server = ZMQServer(conf_srv, srv_handler)
self.assertTrue(server.socket is None)
server.start()
self.assertTrue(server.socket is not None)
self.assertRaises(NotImplementedError, server.send,
"unimplemented")
serverlet = gevent.spawn(server.loop)
client = ZMQClient(conf_cli)
self.assertTrue(client.socket is None)
client.connect()
self.assertTrue(client.socket is not None)
client.send("sync_message")
response = client.recv()
self.assertEquals(response, "exc_result")
gevent.kill(serverlet)
client.close()
server.stop()
def subscribe_socket(ws):
'''Fufill the websocket URL of /subscribe, every update notify the
websocket and read updates from the websocket '''
client = Client()
clients.append(client)
#add the new client to the world
myWorld.add_set_listener(client)
g = gevent.spawn( read_ws, ws, client )
print "Subscribing"
try:
while True:
# block here
msg = client.get()
print msg
print "Got a message!"
ws.send(msg)
except Exception as e:# WebSocketError as e:
print "WS Error %s" % e
finally:
clients.remove(client)
myWorld.update_listeners(clients)
gevent.kill(g)
return None
def test_zmqserver_sync(self):
import gevent
from synapse.zmq_node import ZMQServer, ZMQClient
conf_srv = {'uri': 'tcp://*:5555',
'name': 'zmq_srv_sync'}
conf_cli = {'uri': 'tcp://localhost:5555',
'name': 'zmq_cli_sync'}
def srv_handler(msg):
return "sync_response"
server = ZMQServer(conf_srv, srv_handler)
self.assertTrue(server.socket is None)
server.start()
self.assertTrue(server.socket is not None)
self.assertRaises(NotImplementedError, server.send,
"unimplemented")
serverlet = gevent.spawn(server.loop)
client = ZMQClient(conf_cli)
self.assertTrue(client.socket is None)
client.connect()
self.assertTrue(client.socket is not None)
client.send("message")
response = client.recv()
self.assertEquals(response, "sync_response")
gevent.kill(serverlet)
client.close()
server.stop()
def fcgi_abort_request(self, record, request):
logger.warn('Request %s abortion' % request.id)
greenlet = request.greenlet
if greenlet is not None:
kill(request.greenlet)
else:
del self.requests[request.id]
def stop(self):
gevent.kill(self.greenlet)
try:
self.proc.kill()
except OSError as e:
pass
def on_close(self, reason):
MONGO.close()
self.MQ.release()
gevent.kill(self.node_greenlet)
gevent.kill(self.presence_greenlet)
current = self.ws.handler.active_client
logging.info("Client Left: {}".format(current.address))
def on_packet(packet):
if "ping" == packet["type"] and "probe" == packet["data"]:
transport.send([{
"type": "pong",
"data": "probe"
}])
if self.check_eventlet is not None:
gevent.kill(self.check_eventlet)
def loop():
while True:
gevent.sleep(1)
check()
self.check_eventlet = gevent.Greenlet.spawn(loop)
elif 'upgrade' == packet["type"] and self.ready_state == self.STATE_OPEN:
self.debug("got upgrade packet - upgrading")
transport.remove_listener('packet', on_packet)
self._clear_transport()
self._set_transport(transport)
self.upgraded = True
self._set_ping_timeout_eventlet()
gevent.kill(self.upgrade_eventlet)
self.flush_nowait()
else:
transport.close()
def stop(self):
if self._pygics_task:
self._pygics_task_sw = False
gevent.kill(self._pygics_task)
gevent.joinall([self._pygics_task])
self._pygics_task = None
return self
def run(self):
self.socket.setblocking(1)
env = self.base_env.copy()
env.update({
'SERVER_NAME': self.address[0],
'SERVER_PORT': str(self.address[1])
})
self.base_env = env
http = core.http()
http.set_gencb(self.handle_request)
self.pool = Pool(self.worker_connections)
self.application = self.wsgi
acceptor = gevent.spawn(http.accept, self.socket.fileno())
try:
while self.alive:
self.notify()
if self.ppid != os.getppid():
self.log.info("Parent changed, shutting down: %s" % self)
gevent.kill(acceptor)
break
gevent.sleep(0.1)
self.pool.join(timeout=self.timeout)
except KeyboardInterrupt:
pass
def handle_stop(self, args):
"""
Halt a feed.
We can't look the feed up from the database here because we may have
already deleted it from our records, so instead we iterate through
all of our green threads until something sticks.
"""
key, name = args
for id, ct in self.crontabs.items():
feed = ct.events[0].feed
if feed.name == name and feed.key.key == key.key:
if self.app.debug:
self.app.log('%s: %s: Unscheduling "%s". [thread %s]' % \
(key.name, feed.group.name, feed.name, id))
else:
self.app.log('%s: %s: Unscheduling "%s".' % \
(key.name, feed.group.name, feed.name))
for t in self.threads:
if t.name == id:
gevent.kill(t)
break
self.threads.remove(t)
del ct
del self.crontabs[id]
return True
return False
def remove_recipe(self, recipe):
"""
Remove a scheduled job from the list of scheduled jobs.
"""
print 'Removing: {} at {}'.format(recipe, dates.now())
self._running_recipes.pop(recipe.id)
gevent.kill(self._greenlets[recipe.id])
self._greenlets.pop(recipe.id)
def close(self):
self.started = False
if self.eloop:
gevent.kill(self.eloop)
if self.sock:
self.sock.close()
self.reqs.clear()
self.connect_lock.clear()
def start_sim(self, delay, size=1):
if self.SIM_RUNNING:
kill(self.sim_thread)
self.updates = []
Room.objects.all().update(avail=True)
self.sim_thread = spawn(self.run_sim, delay=delay, size=size)
self.SIM_RUNNING = True
return HttpResponse('Started Simulation with delay %d' % delay)
def gevent_stop(self):
"""
Helper method to stop the node for gevent-based applications.
"""
import gevent
gevent.kill(self._poller_greenlet)
self.remove()
self._select = select.select
def stop(self):
if self.state == VirtualMachineState.STOPPED:
raise RuntimeError()
gevent.kill(self.console_thread)
self.bhyve_process.terminate()
subprocess.call('/usr/sbin/bhyvectl --destroy --vm={0}'.format(self.name))
self.set_state(VirtualMachineState.STOPPED)
def setup_darwin(self):
"""
Setup for headset on the OS X platform.
Receives packets from headset and sends them to a Queue to be processed
by the crypto greenlet.
"""
#Â Set this to True if the OS is performing the encryption of the packets
_os_decryption = False
# Change these values to the hex equivalent from the output of hid_enumerate. If they are incorrect.
# Current values = VendorID: 8609 ProductID: 1
#hidraw = hid.device(0x31a1, 0x2001)
hidraw = hid.device(0x1234,0xed02)
hidraw.open(0x1234, 0xed02)
self.serial_number = 'SN20120229000290'
if not hidraw:
hidraw = hid.device(0x21a1, 0x1234)
if not hidraw:
hidraw = hid.device(0xed02, 0x1234)
if not hidraw:
print "Device not found. Uncomment the code in setup_darwin and modify hid.device(vendor_id, product_id)"
raise ValueError
if self.serial_number == "":
print "Serial number needs to be specified manually in __init__()."
raise ValueError
print "Serial number:" + self.serial_number
crypto = gevent.spawn(self.setup_crypto, self.serial_number)
console_updater = gevent.spawn(self.update_console)
zero = 0
while self.running:
try:
# Doesn't seem to matter how big we make the buffer 32 returned every time, 33 for other platforms
data = hidraw.read(34,10)
#data = [48]*32
if len(data) == 32:
# Most of the time the 0 is truncated? That's ok we'll add it...
data = [zero] + data
if data != "":
if _os_decryption:
self.packets.put_nowait(EmotivPacket(data))
else:
#Queue it!
print ('Queuing package:'+len(data))
tasks.put_nowait(''.join(map(chr, data[1:])))
self.packets_received += 1
print ('Waiting...')
gevent.sleep(0.01)
else:
# No new data from the device; yield
# We cannot sleep(0) here because that would go 100% CPU if both queues are empty.
gevent.sleep(DEVICE_POLL_INTERVAL)
except KeyboardInterrupt:
self.running = False
hidraw.close()
gevent.kill(crypto, KeyboardInterrupt)
gevent.kill(console_updater, KeyboardInterrupt)
def subscribe_socket(ws):
client = Client()
clients.append(client)
g = gevent.spawn(read_ws, ws, client)
try:
while True:
# block here
msg = client.get()
ws.send(msg)
except Exception as e: # WebSocketError as e:
print "WS Error %s" % e
finally:
clients.remove(client)
gevent.kill(g)
def handle(self, r):
input = r.input_buffer
output = r.output_buffer
assert r.input_buffer is input
assert r.output_buffer is output
assert input._obj
assert output._obj
r.detach()
assert not input._obj
assert not output._obj
assert input.read() == ''
assert output.read() == ''
self.handled = True
gevent.kill(self.current, Exception('test done'))
def _get(self):
from selenium import webdriver
if self._timeout is not None:
gevent.kill(self._timeout)
self._timeout = None
if self._driver is None:
_log.info('create driver')
options = webdriver.ChromeOptions()
options.debugger_address = conf.chromeAddress
self._driver = webdriver.Chrome(chrome_options=options)
self._driver.implicitly_wait(30) # wait at most 30 seconds
return self._driver
def test_csv_stats_writer_full_history(self):
stats_writer = StatsCSVFileWriter(self.environment,
PERCENTILES_TO_REPORT,
self.STATS_BASE_NAME,
full_history=True)
for i in range(10):
self.runner.stats.log_request("GET", "/", 100, content_length=666)
greenlet = gevent.spawn(stats_writer)
gevent.sleep(10)
for i in range(10):
self.runner.stats.log_request("GET", "/", 10, content_length=666)
gevent.sleep(5)
gevent.sleep(_TEST_CSV_STATS_INTERVAL_WAIT_SEC)
gevent.kill(greenlet)
stats_writer.close_files()
self.assertTrue(os.path.exists(self.STATS_FILENAME))
self.assertTrue(os.path.exists(self.STATS_HISTORY_FILENAME))
self.assertTrue(os.path.exists(self.STATS_FAILURES_FILENAME))
self.assertTrue(os.path.exists(self.STATS_EXCEPTIONS_FILENAME))
with open(self.STATS_HISTORY_FILENAME) as f:
reader = csv.DictReader(f)
rows = [r for r in reader]
self.assertGreaterEqual(len(rows), 130)
self.assertEqual("/", rows[0]["Name"])
self.assertEqual("Aggregated", rows[1]["Name"])
self.assertEqual("/", rows[2]["Name"])
self.assertEqual("Aggregated", rows[3]["Name"])
self.assertEqual("20", rows[-1]["Total Request Count"])
saw100 = False
saw10 = False
for row in rows:
if not saw100 and row["95%"] == "100":
saw100 = True
elif saw100 and row["95%"] == "10":
saw10 = True
break
self.assertTrue(saw100, "Never saw 95th percentile increase to 100")
self.assertTrue(saw10, "Never saw 95th percentile decrease to 10")
def shutdown(self):
gevent.kill(self.input_loop)
gevent.idle()
self.worker_collection.shutdown_workers()
self.logger.info("Waiting for all workers to shutdown...")
while len(self.worker_collection.workers) > 0:
self.logger.debug("{num} worker(s) still active".format(num=len(self.worker_collection.workers)))
gevent.sleep(1)
self.logger.info("Waiting for all responses to be delivered...")
while self.response_queue.unfinished_tasks > 0:
self.logger.debug("{num} responses to be delivered".format(num=self.response_queue.unfinished_tasks))
gevent.sleep(1)
gevent.kill(self.output_loop)
self.logger.info("ActionHandler shut down, {num} actions processed".format(num=next(self.counter)-1))
def test_stats_history(self):
env1 = Environment(events=locust.events, catch_exceptions=False)
runner1 = env1.create_master_runner("127.0.0.1", 5558)
env2 = Environment(events=locust.events, catch_exceptions=False)
runner2 = env2.create_worker_runner("127.0.0.1", 5558)
greenlet1 = gevent.spawn(stats_history, runner1)
greenlet2 = gevent.spawn(stats_history, runner2)
gevent.sleep(1)
hs1 = runner1.stats.history
hs2 = runner2.stats.history
gevent.kill(greenlet1)
gevent.kill(greenlet2)
self.assertEqual(1, len(hs1))
self.assertEqual(0, len(hs2))
def setup_posix(self):
"""
Setup for headset on the Linux platform.
Receives packets from headset and sends them to a Queue to be processed
by the crypto greenlet.
"""
_os_decryption = False
if os.path.exists('/dev/eeg/raw'):
# The decryption is handled by the Linux epoc daemon. We don't need to handle it.
_os_decryption = True
hidraw = open("/dev/eeg/raw")
else:
serial, hidraw_filename = get_linux_setup() #error line
self.serial_number = serial
if os.path.exists("/dev/" + hidraw_filename):
print('os.path.exists')
hidraw = open("/dev/" + hidraw_filename)
else: #doesn't go here
hidraw = open("/dev/hidraw4")
crypto = gevent.spawn(self.setup_crypto, self.serial_number)
print('crypto line 430')
console_updater = gevent.spawn(self.update_console)
print('console_updater line 432')
while self.running:
try:
data = hidraw.read(32) #doesn't execute, stops
print('running line 435')
if data != "":
print(
'data still in queue (still coming from headset) line 438'
)
if _os_decryption:
self.packets.put_nowait(EmotivPacket(data))
else:
#Queue it!
self.packets_received += 1
tasks.put_nowait(data)
gevent.sleep(0)
else:
print('no new data from device line 454')
# No new data from the device; yield
# We cannot sleep(0) here because that would go 100% CPU if both queues are empty
gevent.sleep(DEVICE_POLL_INTERVAL)
except KeyboardInterrupt:
print('not running')
self.running = False
hidraw.close()
if not _os_decryption:
gevent.kill(crypto, KeyboardInterrupt)
gevent.kill(console_updater, KeyboardInterrupt)
def send_104frame(self, frame):
# send s_frame
if frame.name == "s_frame":
frame.RecvSeq = self.rsn
if self.t2_caller:
gevent.kill(self.t2_caller)
self.telegram_count = 0
response_string = (" ".join(hex(n) for n in frame.build()))
logger.info('%s <--- s_frame %s (%s)', self.address,
response_string, self.session_id)
return frame.build()
# send i_frame
elif frame.name == "i_frame":
if self.allow_DT:
if self.t2_caller:
gevent.kill(self.t2_caller)
frame.SendSeq = self.ssn
frame.RecvSeq = self.rsn
self.increment_sendseq()
self.telegram_count = 0
iframe = frame_object_with_timer(frame)
self.sentmsgs.append(iframe)
iframe.restart_t1()
response_string = (" ".join(hex(n) for n in frame.build()))
logger.debug('%s <--- i_frame %s (%s)', self.address,
response_string, self.session_id)
logger.info('%s <--- i_frame %s (%s)', self.address,
frame.payload, self.session_id)
return frame.build()
else:
logger.info("StartDT missing, buffer data. (%s)",
self.session_id)
# Limitation for buffer, arbitrary number
if len(self.send_buffer) < 50:
self.send_buffer.append(frame)
# send u_frame
elif frame.name == "u_frame":
if frame.getfieldval("Type") == 0x07 or frame.getfieldval(
"Type") == 0x43:
uframe = frame_object_with_timer(frame)
self.sentmsgs.append(uframe)
uframe.restart_t1()
response_string = (" ".join(hex(n) for n in frame.build()))
logger.info('%s <--- u_frame %s (%s)', self.address,
response_string, self.session_id)
return frame.build()
def keepalive_token(self, token_id):
token = self.lookup_token(token_id)
if not token:
raise TokenException('Token not found or expired')
if token.lifetime:
gevent.kill(token.timer)
if token.revocation_function is not None:
token.timer = gevent.spawn_later(token.lifetime,
token.revocation_function,
token.revocation_reason)
else:
token.timer = gevent.spawn_later(token.lifetime,
self.revoke_token,
token_id)
def subscribe_socket(ws):
"""Fufill the websocket URL of /subscribe, every update notify the
websocket and read updates from the websocket """
# XXX: TODO IMPLEMENT ME
client = pool.add()
group = gevent.spawn(read_ws, ws, client)
try:
while True:
ws.send(client.get())
except Exception:
pass # whatever
finally:
pool.remove(client)
gevent.kill(group)
return None
def subscribe_socket(ws):
'''Fufill the websocket URL of /subscribe, every update notify the
websocket and read updates from the websocket '''
client = Client()
websocket_clients.append(client)
g = gevent.spawn(read_ws, ws, client)
try:
while True:
message = client.get()
ws.send(message)
except Exception as e:
print("WS Error %s" % e)
finally:
websocket_clients.remove(client)
gevent.kill(g)
def _receive(self, event):
if event.op_code == 10:
self.print('hello received')
self.heartbeat_interval = event.payload['heartbeat_interval'] / 1000
if self._ping_greenlet: gevent.killall([self._ping_greenlet])
self._ping_greenlet = gevent.spawn(self.ping)
self.print(f'ping began with {self.heartbeat_interval} interval')
elif event.op_code == 1:
self.print('ping required')
self.ws.send(11, None)
elif event.op_code == 11:
self.print('ping ack received')
gevent.kill(self._ack_timeout)
def _rimt(exc):
_logger.info('YELLOW<<killing main thread greenlet>>')
main_thread_greenlet = threading.main_thread()._greenlet
orig_throw = main_thread_greenlet.throw
# we must override "throw" method so exception will be raised with the original traceback
def throw(*args):
if len(args) == 1:
ex = args[0]
return orig_throw(ex.__class__, ex, ex.__traceback__)
return orig_throw(*args)
main_thread_greenlet.throw = throw
gevent.kill(main_thread_greenlet, exc)
_logger.debug('exiting the thread that failed')
raise exc
def watch_for_unlock_failures(*apps, retry_timeout=DEFAULT_RETRY_TIMEOUT):
"""
Context manager to assure there are no failing unlocks during transfers in integration tests.
"""
def watcher_function():
while True:
for app in apps:
assert not has_unlock_failure(app.raiden)
gevent.sleep(retry_timeout)
watcher = gevent.spawn(watcher_function)
try:
yield
finally:
gevent.kill(watcher)
def subscribe_socket(ws):
listener = Listener()
myWorld.add_set_listener(listener)
g = gevent.spawn(read_ws, ws, listener) # listener thread
try:
while True:
# block here
msg = listener.get()
print(msg)
ws.send(msg)
except Exception as e: # WebSocketError as e:
print("WS Error %s" % e)
finally:
myWorld.listeners.remove(listener)
gevent.kill(g)
def delete_token(self, token_id):
if isinstance(token_id, Token):
token = token_id
token_id = self.lookup_token_id(token)
else:
token = self.lookup_token(token_id)
if not token:
logger.trace('Tried to delete token but it was not found or expired')
return
if token.lifetime:
gevent.kill(token.timer)
token.revocation_reason = 'Token explicitly deleted'
token.revocation_function(self, token, token_id)
else:
self.tokens.pop(token)
def test_polling(self):
transport = XHRPollingTransport(host="127.0.0.1",
port=self.port,
path="/socket.io/")
context = {}
def on_packet(packet):
context['packet'] = packet
transport.on('packet', on_packet)
job = gevent.spawn(transport.poll)
gevent.sleep(.5)
self.assertIsNotNone(context['packet'])
gevent.kill(job)
def subscribe_socket(ws):
'''Fufill the websocket URL of /subscribe, every update notify the
websocket and read updates from the websocket '''
# XXX: TODO IMPLEMENT ME
client = Client()
Clients.append(client)
gev = gevent.spawn(read_ws, ws, client)
try:
while True:
ws.send(client.get())
except Exception as e:
print(e)
finally:
Clients.remove(clinet)
gevent.kill(gev)
def test_csv_stats_writer(self):
greenlet = gevent.spawn(stats_writer, self.environment, self.STATS_BASE_NAME)
gevent.sleep(0.21)
gevent.kill(greenlet)
self.assertTrue(os.path.exists(self.STATS_FILENAME))
self.assertTrue(os.path.exists(self.STATS_HISTORY_FILENAME))
self.assertTrue(os.path.exists(self.STATS_FAILURES_FILENAME))
with open(self.STATS_HISTORY_FILENAME) as f:
reader = csv.DictReader(f)
rows = [r for r in reader]
self.assertEqual(2, len(rows))
self.assertEqual("Aggregated", rows[0]["Name"])
self.assertEqual("Aggregated", rows[1]["Name"])
def send_frame_imm(self, frame):
# send s_frame
if frame.name == "s_frame":
frame.RecvSeq = self.rsn
if self.t2_caller:
gevent.kill(self.t2_caller)
self.telegram_count = 0
response_string = " ".join(hex(n) for n in frame.build())
logger.info(
"%s <--- s_frame %s (%s)",
self.address,
response_string,
self.session_id,
)
return self.sock.send(frame.build())
def test_run(self):
# confirm server is offline
with self.assertRaises(requests.exceptions.ConnectionError):
requests.get('http://localhost:8080')
# start and query server
greenlet = gevent.Greenlet(run=self.engine.run)
greenlet.start()
ret = requests.get('http://localhost:8080')
self.assertIsNotNone(ret)
# confirm server is offline again
gevent.kill(greenlet)
with self.assertRaises(requests.exceptions.ConnectionError):
requests.get('http://localhost:8080')
def gen(username):
if username in pollers:
del pollers[username]
my_queue = gevent.queue.Queue()
my_poller = greenlet.Greenlet.spawn(poller.poller_function, username,
my_queue)
pollers[username] = my_poller
try:
while True:
yield str(my_queue.get())
except GeneratorExit: # Or maybe use flask signals
gevent.kill(my_poller)
del pollers[username]
def destroy(self):
if self.connected:
log.debug("Disconnecting")
self.role.stack.disconnect()
self.role = None
if self.socket_handler is not None:
log.debug("Connection quit(), killing remaining connection threads")
gevent.kill(self.socket_handler_thread)
self.socket_handler = None
self.socket_handler_thread = None
if self.event_handler is not None:
self.event_handler.__del__()
self.event_handler = None
def subscribe_socket(ws):
'''Fufill the websocket URL of /subscribe, every update notify the
websocket and read updates from the websocket '''
# XXX: TODO IMPLEMENT ME
g = gevent.spawn(read_ws, ws, myWorld.world())
print("Subscribing")
try:
msg = json.dumps(myWorld.world())
print("Got world: %s" % msg)
ws.send(msg)
except Exception as e:
print('WS Error %s' % e)
finally:
gevent.kill(g)
return None
def test_2_workers_wait_1_job(self):
g1 = gevent.spawn(self.pull)
g2 = gevent.spawn(self.pull)
gevent.idle()
self.assertEqual(self.post(['foo']), [1])
ready_greenlets = gevent.joinall([g1, g2], timeout=0.2)
self.assertEqual(len(ready_greenlets), 1)
g = ready_greenlets[0]
messages = g.get()
self.assertDictContainsSubset({'id': 1, 'message': 'foo'}, messages[0])
if g == g1:
g = g2
else:
g = g1
gevent.kill(g)
def initial_sync_impl(self, crispin_client):
# We wrap the block in a try/finally because the change_poller greenlet
# needs to be killed when this greenlet is interrupted
change_poller = None
try:
assert crispin_client.selected_folder_name == self.folder_name
remote_uids = crispin_client.all_uids()
with self.syncmanager_lock:
with session_scope(self.namespace_id) as db_session:
local_uids = common.local_uids(self.account_id, db_session,
self.folder_id)
common.remove_deleted_uids(
self.account_id,
self.folder_id,
set(local_uids).difference(remote_uids),
)
new_uids = set(remote_uids).difference(local_uids)
with session_scope(self.namespace_id) as db_session:
account = db_session.query(Account).get(self.account_id)
throttled = account.throttled
self.update_uid_counts(
db_session,
remote_uid_count=len(remote_uids),
# This is the initial size of our download_queue
download_uid_count=len(new_uids),
)
change_poller = gevent.spawn(self.poll_for_changes)
bind_context(change_poller, "changepoller", self.account_id,
self.folder_id)
uids = sorted(new_uids, reverse=True)
for count, uid in enumerate(uids, start=1):
# The speedup from batching appears to be less clear for
# non-Gmail accounts, so for now just download one-at-a-time.
self.download_and_commit_uids(crispin_client, [uid])
self.heartbeat_status.publish()
if throttled and count >= THROTTLE_COUNT:
# Throttled accounts' folders sync at a rate of
# 1 message/ minute, after the first approx. THROTTLE_COUNT
# messages per folder are synced.
# Note this is an approx. limit since we use the #(uids),
# not the #(messages).
gevent.sleep(THROTTLE_WAIT)
finally:
if change_poller is not None:
# schedule change_poller to die
gevent.kill(change_poller)
def test_return_values(default_settings, sim_action, return_type):
default_settings['exec_numSlotframesPerRun'] = 1
if sim_action == 'start':
if return_type == 'success':
# use the default settings; do nothing
pass
elif return_type == 'failure_on_sim_existence':
# set a dummy object to _sim_engine
backend.sim._sim_engine = {}
else:
# make an error in settings
del default_settings['exec_numMotes']
ret_val = backend.sim.start(default_settings, stderr_redirect=False)
if return_type == 'failure_on_sim_existence':
# revert _sim_engine
backend.sim._sim_engine = None
else:
assert backend.sim._sim_engine is None
else:
method_to_call = getattr(backend.sim, sim_action)
greenlet = gevent.spawn(backend.sim.start, default_settings)
if return_type == 'success':
# start a simulation
gevent.sleep(backend.sim.GEVENT_SLEEP_SECONDS_IN_SIM_ENGINE)
if sim_action == 'resume':
# make the simulation pause
backend.sim.pause()
else:
# do nothing; _sim_engine is not available yet
pass
ret_val = method_to_call()
if backend.sim._sim_engine is not None:
backend.sim._destroy_sim()
gevent.kill(greenlet)
assert backend.sim._sim_engine is None
if return_type == 'success':
assert ret_val['status'] == backend.sim.RETURN_STATUS_SUCCESS
assert 'message' not in ret_val
assert 'trace' not in ret_val
else:
assert ret_val['status'] == backend.sim.RETURN_STATUS_FAILURE
assert ret_val['message'] is not None
def subscribe_socket(ws):
'''Fufill the websocket URL of /subscribe, every update notify the
websocket and read updates from the websocket '''
client = Client()
clients.append(client)
g = gevent.spawn( read_ws, ws, client )
try:
while True:
# block here
msg = client.get()
ws.send(msg)
except Exception as e:# WebSocketError as e:
print(f"WS Error {e}")
finally:
clients.remove(client)
gevent.kill(g)
def subscribe_socket(ws):
'''Fufill the websocket URL of /subscribe, every update notify the
websocket and read updates from the websocket '''
# XXX: TODO IMPLEMENT ME
client = Client()
clients.append(client)
g = gevent.spawn(read_ws, ws, client)
try:
while True:
msg = client.get()
ws.send(msg)
except Exception as e:
print "WS Error %s" % e
finally:
clients.remove(client)
gevent.kill(g)
def subscribe_socket(ws):
'''Fufill the websocket URL of /subscribe, every update notify the
websocket and read updates from the websocket '''
listener = Listener()
myWorld.add_set_listener(listener)
g = gevent.spawn(read_ws, ws, listener)
try:
while True:
msg = listener.get()
ws.send(msg)
except Exception as e: # WebSocketError as e:
print("WS Error %s" % e)
finally:
gevent.kill(g)
