def test_queue_simple():
results = []
def consumer(q):
while True:
item = q.get()
if item is None:
break
results.append(item)
q.task_done()
q.task_done()
def producer(q):
results.append('start')
for n in range(3):
q.put(n)
q.put(None)
q.join()
results.append('done')
def main():
q = thredo.Queue()
t1 = thredo.spawn(consumer, q)
t2 = thredo.spawn(producer, q)
t1.join()
t2.join()
thredo.run(main)
assert results == ['start', 0, 1, 2, 'done']
def test_lock_race():
lock = thredo.Lock()
evt = thredo.Event()
n = 0
def incr(count):
nonlocal n
evt.wait()
while count > 0:
with lock:
n += 1
count -=1
def decr(count):
nonlocal n
evt.wait()
while count > 0:
with lock:
n -= 1
count -= 1
def main():
t1 = thredo.spawn(incr, 10000)
t2 = thredo.spawn(decr, 10000)
evt.set()
t1.join()
t2.join()
thredo.run(main)
assert n == 0
def test_ignore():
def main():
thredo.ignore_after(0.25, thredo.sleep, 1)
start = time.time()
thredo.run(main)
end = time.time()
assert (end - start) < 1
def test_good_spawn():
result = []
def main():
t = thredo.spawn(basic_thread, 2, 2)
result.append(t.join())
thredo.run(main)
assert result == [4]
def test_ignore_context():
def main():
with thredo.ignore_after(0.25):
thredo.sleep(1)
start = time.time()
thredo.run(main)
end = time.time()
assert (end - start) < 1
def test_timeout():
result = []
def main():
try:
thredo.timeout_after(0.25, thredo.sleep, 1)
except thredo.ThreadTimeout:
result.append('timeout')
thredo.run(main)
assert result == ['timeout']
def test_sleep():
result = []
def main():
start = time.time()
thredo.sleep(1.0)
end = time.time()
result.append(end - start)
thredo.run(main)
assert result[0] > 1.0
def test_bad_spawn():
result = []
def main():
t = thredo.spawn(basic_thread, 2, '2')
try:
t.join()
except thredo.ThreadError as e:
result.append('error')
result.append(type(e.__cause__))
thredo.run(main)
assert result == ['error', TypeError]
def test_readall():
results = []
evt = thredo.Event()
def server(address):
sock = socket(AF_INET, SOCK_STREAM)
sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, True)
sock.bind(address)
sock.listen(1)
evt.set()
client, addr = sock.accept()
try:
results.append('handler start')
client.send(b'OK')
with client.as_stream() as s:
data = s.readall()
results.append(data)
results.append('handler done')
finally:
client.close()
sock.close()
def test_client(address):
evt.wait()
sock = socket(AF_INET, SOCK_STREAM)
sock.connect(address)
sock.recv(8)
sock.send(b'Msg1\n')
thredo.sleep(0.1)
sock.send(b'Msg2\n')
thredo.sleep(0.1)
sock.send(b'Msg3\n')
thredo.sleep(0.1)
sock.close()
def main():
serv = thredo.spawn(server, ('',25000))
client = thredo.spawn(test_client, ('localhost', 25000))
serv.join()
client.join()
thredo.run(main)
assert results == [
'handler start',
b'Msg1\nMsg2\nMsg3\n',
'handler done'
]
def test_readlines_timeout():
evt = thredo.Event()
results = []
def server(address):
sock = socket(AF_INET, SOCK_STREAM)
sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, True)
sock.bind(address)
sock.listen(1)
evt.set()
client, addr = sock.accept()
try:
client.send(b'OK')
results.append('handler start')
s = client.as_stream()
try:
thredo.timeout_after(0.5, s.readlines)
except thredo.ThreadTimeout as e:
results.extend(e.lines_read)
results.append('handler done')
finally:
client.close()
sock.close()
def test_client(address):
evt.wait()
sock = socket(AF_INET, SOCK_STREAM)
sock.connect(address)
sock.recv(8)
sock.send(b'Msg1\nMsg2\n')
thredo.sleep(1)
sock.send(b'Msg3\n')
sock.close()
def main():
serv = thredo.spawn(server, ('', 25000))
client = thredo.spawn(test_client, ('localhost', 25000))
serv.join()
client.join()
thredo.run(main)
assert results == [
'handler start',
b'Msg1\n',
b'Msg2\n',
'handler done'
]
def test_sleep_cancel():
result = []
def child():
try:
thredo.sleep(10)
except thredo.ThreadCancelled:
result.append('cancel')
def main():
t = thredo.spawn(child)
thredo.sleep(0.1)
t.cancel()
thredo.run(main)
assert result == ['cancel']
def test_sendall_cancel():
evt = thredo.Event()
start = thredo.Event()
results = {}
def server(address):
sock = socket(AF_INET, SOCK_STREAM)
sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, True)
sock.bind(address)
sock.listen(1)
evt.set()
client, addr = sock.accept()
try:
start.wait()
nrecv = 0
while True:
data = client.recv(1000000)
if not data:
break
nrecv += len(data)
results['handler'] = nrecv
finally:
client.close()
sock.close()
def test_client(address):
evt.wait()
sock = socket(AF_INET, SOCK_STREAM)
sock.connect(address)
try:
sock.sendall(b'x'*10000000)
except thredo.ThreadCancelled as e:
results['sender'] = e.bytes_sent
sock.close()
def main():
serv = thredo.spawn(server, ('', 25000))
client = thredo.spawn(test_client, ('localhost', 25000))
thredo.sleep(0.1)
client.cancel()
start.set()
serv.join()
thredo.run(main)
assert results['handler'] == results['sender']
def test_writelines_timeout():
evt = thredo.Event()
results = []
def server(address):
sock = socket(AF_INET, SOCK_STREAM)
sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, True)
sock.bind(address)
sock.listen(1)
evt.set()
client, addr = sock.accept()
try:
client.send(b'OK')
s = client.as_stream()
thredo.sleep(1)
results.append(s.readall())
finally:
client.close()
sock.close()
def line_generator():
n = 0
while True:
yield b'Msg%d\n' % n
n += 1
def test_client(address):
evt.wait()
sock = socket(AF_INET, SOCK_STREAM)
sock.connect(address)
sock.recv(8)
s = sock.as_stream()
try:
thredo.timeout_after(0.5, s.writelines, line_generator())
except thredo.ThreadTimeout as e:
results.append(e.bytes_written)
sock.close()
def main():
serv = thredo.spawn(server, ('', 25000))
client = thredo.spawn(test_client, ('localhost', 25000))
serv.join()
client.join()
thredo.run(main)
assert results[0] == len(results[1])
def test_event_wait_cancel():
evt = thredo.Event()
result = []
def waiter():
try:
evt.wait()
result.append('waiter')
except thredo.ThreadCancelled:
result.append('cancel')
def main():
t = thredo.spawn(waiter)
result.append('start')
t.cancel()
thredo.run(main)
assert result == ['start', 'cancel']
def test_event_wait():
evt = thredo.Event()
result = []
def waiter():
evt.wait()
result.append('waiter')
def main():
t = thredo.spawn(waiter)
result.append('start')
evt.set()
t.join()
thredo.run(main)
assert result == ['start', 'waiter']
evt.clear()
assert not evt.is_set()
def test_queue_get_cancel():
results = []
def consumer(q):
while True:
try:
item = q.get()
except thredo.ThreadCancelled:
results.append('cancel')
raise
def main():
q = thredo.Queue()
t = thredo.spawn(consumer, q)
results.append('start')
t.cancel()
thredo.run(main)
assert results == ['start', 'cancel']
def test_semaphore():
lock = thredo.Semaphore()
result = []
def child():
with lock:
result.append('child')
def main():
lock.acquire()
result.append(lock.value)
try:
t = thredo.spawn(child)
result.append('parent')
finally:
lock.release()
t.join()
thredo.run(main)
assert result == [0, 'parent', 'child']
def test_queue_join_cancel():
results = []
def producer(q):
q.put(True)
try:
q.join()
except thredo.ThreadCancelled:
results.append('cancel')
raise
def main():
q = thredo.Queue(maxsize=1)
t = thredo.spawn(producer, q)
results.append('start')
thredo.sleep(0.1)
t.cancel()
thredo.run(main)
assert results == ['start', 'cancel']
def test_write_timeout():
evt = thredo.Event()
results = []
def server(address):
sock = socket(AF_INET, SOCK_STREAM)
sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, True)
sock.bind(address)
sock.listen(1)
evt.set()
client, addr = sock.accept()
try:
client.send(b'OK')
s = client.as_stream()
thredo.sleep(1)
results.append(s.readall())
finally:
client.close()
sock.close()
def test_client(address):
evt.wait()
sock = socket(AF_INET, SOCK_STREAM)
sock.connect(address)
sock.recv(8)
s = sock.as_stream()
try:
msg = b'x'*10000000 # Must be big enough to fill buffers
thredo.timeout_after(0.5, s.write, msg)
except thredo.ThreadTimeout as e:
results.append(e.bytes_written)
sock.close()
def main():
serv = thredo.spawn(server, ('', 25000))
client = thredo.spawn(test_client, ('localhost', 25000))
serv.join()
client.join()
thredo.run(main)
assert results[0] == len(results[1])
def test_lock():
lock = thredo.Lock()
result = []
def child():
with lock:
result.append('child')
def main():
lock.acquire()
if lock.locked():
result.append('locked')
try:
t = thredo.spawn(child)
result.append('parent')
finally:
lock.release()
t.join()
thredo.run(main)
assert result == ['locked', 'parent', 'child']
def test_lock_cancel():
lock = thredo.Lock()
result = []
def child():
try:
with lock:
result.append('child')
except thredo.ThreadCancelled:
result.append('cancel')
def main():
lock.acquire()
try:
t = thredo.spawn(child)
result.append('parent')
t.cancel()
finally:
lock.release()
thredo.run(main)
assert result == ['parent', 'cancel']
def test_readall_partial():
results = []
evt = thredo.Event()
def server(address):
sock = socket(AF_INET, SOCK_STREAM)
sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, True)
sock.bind(address)
sock.listen(1)
evt.set()
client, addr = sock.accept()
try:
client.send(b'OK')
s = client.as_stream()
line = s.readline()
results.append(line)
data = s.readall()
results.append(data)
s.close()
finally:
client.close()
def test_client(address):
evt.wait()
sock = socket(AF_INET, SOCK_STREAM)
sock.connect(address)
sock.recv(8)
sock.send(b'hello\nworld\n')
sock.close()
def main():
serv = thredo.spawn(server, ('',25000))
client = thredo.spawn(test_client, ('localhost', 25000))
serv.join()
client.join()
thredo.run(main)
assert results == [b'hello\n', b'world\n']
def test_read_exactly_incomplete():
evt = thredo.Event()
results = []
def server(address):
sock = socket(AF_INET, SOCK_STREAM)
sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, True)
sock.bind(address)
sock.listen(1)
evt.set()
client, addr = sock.accept()
try:
client.send(b'OK')
s = client.as_stream()
try:
s.read_exactly(100)
except EOFError as e:
results.append(e.bytes_read)
finally:
client.close()
sock.close()
def test_client(address):
evt.wait()
sock = socket(AF_INET, SOCK_STREAM)
sock.connect(address)
sock.recv(8)
sock.send(b'Msg1\nMsg2\nMsg3\n')
sock.close()
def main():
serv = thredo.spawn(server, ('', 25000))
client = thredo.spawn(test_client, ('localhost', 25000))
serv.join()
client.join()
thredo.run(main)
assert results[0] == b'Msg1\nMsg2\nMsg3\n'
def test_condition_wait_notify():
n = 0
lock = thredo.Condition(thredo.Lock())
result = []
def waiter():
current = n
while True:
with lock:
while current == n:
lock.wait()
result.append(('consume', n))
current = n
if n >= 5:
break
def producer():
nonlocal n
while n < 5:
thredo.sleep(0.1)
with lock:
n += 1
result.append(('produce', n))
lock.notify()
def main():
t1 = thredo.spawn(waiter)
t2 = thredo.spawn(producer)
t1.join()
t2.join()
thredo.run(main)
assert result == [('produce',1), ('consume',1),
('produce',2), ('consume',2),
('produce',3), ('consume',3),
('produce',4), ('consume',4),
('produce',5), ('consume',5)]
print('Connection from', addr)
try:
f = client.makefile('rb')
g = client.makefile('wb')
for line in f:
g.write(line)
finally:
print('Connection closed')
f.close()
g.close()
client.close()
def killer(delay, t):
thredo.sleep(delay)
t.cancel()
def echo_server(host, port):
sock = socket(AF_INET, SOCK_STREAM)
sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
sock.bind((host, port))
sock.listen(5)
while True:
client, addr = sock.accept()
t = thredo.spawn(echo_handler, client, addr, daemon=True)
thredo.spawn(killer, 30, t)
thredo.run(echo_server, '', 25000)
def test_good():
result = thredo.run(basic_thread, 2, 2)
assert result == 4
def test_bad():
try:
result = thredo.run(basic_thread, 2, '2')
assert False
except BaseException as e:
assert type(e) == TypeError
import thredo
import thredo.requests
def get(session, url):
try:
return session.get(url)
except thredo.ThreadCancelled as e:
print("Cancelled", url)
def main():
s = thredo.requests.get_session()
with thredo.ThreadGroup(wait=any) as g:
g.spawn(get, s, 'http://www.dabeaz.com/cgi-bin/saas.py?s=5')
g.spawn(get, s, 'http://www.dabeaz.com/cgi-bin/saas.py?s=10')
g.spawn(get, s, 'http://www.dabeaz.com/cgi-bin/fib.py?n=10')
print(g.completed.result.text)
if __name__ == '__main__':
thredo.run(main)
print('Fine. Saving my work.')
raise
def parent():
goodbye = thredo.SignalEvent(signal.SIGINT, signal.SIGTERM)
kid_task = thredo.spawn(kid)
thredo.sleep(5)
print("Yes, go play")
start_evt.set()
goodbye.wait()
del goodbye
print("Let's go")
count_task = thredo.spawn(countdown, 10)
count_task.join()
print("We're leaving!")
try:
thredo.timeout_after(10, kid_task.join)
except thredo.ThreadTimeout:
kid_task.cancel()
thredo.sleep(3)
print('Parent Leaving')
if __name__ == '__main__':
thredo.run(parent)
return sock
except OSError as e:
errors.append(e)
sock.close()
return None
def connector(group):
for *sockargs, _, addr in targets:
sock = socket.socket(*sockargs)
task = group.spawn(try_connect, sock, addr)
with ignore_after(happy_eyeballs_delay):
task.wait()
print("here!")
with ThreadGroup(wait=any) as g:
g.spawn(connector, g)
if g.completed:
return g.completed.result
else:
raise OSError(errors)
def main():
result = open_tcp_stream('www.python.org', 80)
print(result)
if __name__ == '__main__':
run(main)
