def run(loop, fut):
thread_loop = tulip.new_event_loop()
tulip.set_event_loop(thread_loop)
socks = thread_loop.run_until_complete(
thread_loop.start_serving(lambda: TestHttpServer(keep_alive=0.5),
host,
port,
ssl=sslcontext))
waiter = tulip.Future(loop=thread_loop)
loop.call_soon_threadsafe(
fut.set_result, (thread_loop, waiter, socks[0].getsockname()))
thread_loop.run_until_complete(waiter)
# close opened trnsports
for tr in transports:
tr.close()
run_briefly(thread_loop) # call close callbacks
for s in socks:
thread_loop.stop_serving(s)
thread_loop.stop()
thread_loop.close()
gc.collect()
def setUp(self):
self.loop = tulip.new_event_loop()
tulip.set_event_loop(self.loop)
self.transport = unittest.mock.Mock()
self.stream = tulip.StreamBuffer()
self.response = HttpResponse('get', 'http://python.org')
def run(loop, fut):
thread_loop = tulip.new_event_loop()
tulip.set_event_loop(thread_loop)
server = thread_loop.run_until_complete(
thread_loop.create_server(
lambda: TestHttpServer(keep_alive=0.5),
host, port, ssl=sslcontext))
waiter = tulip.Future(loop=thread_loop)
loop.call_soon_threadsafe(
fut.set_result, (thread_loop, waiter,
server.sockets[0].getsockname()))
try:
thread_loop.run_until_complete(waiter)
finally:
# call pending connection_made if present
run_briefly(thread_loop)
# close opened trnsports
for tr in transports:
tr.close()
run_briefly(thread_loop) # call close callbacks
server.close()
thread_loop.stop()
thread_loop.close()
gc.collect()
def run(loop, fut):
thread_loop = tulip.new_event_loop()
tulip.set_event_loop(thread_loop)
socks = thread_loop.run_until_complete(
thread_loop.start_serving(
lambda: TestHttpServer(keep_alive=0.5),
host, port, ssl=sslcontext))
waiter = tulip.Future()
loop.call_soon_threadsafe(
fut.set_result, (thread_loop, waiter, socks[0].getsockname()))
thread_loop.run_until_complete(waiter)
# close opened trnsports
for tr in transports:
tr.close()
run_once(thread_loop) # call close callbacks
for s in socks:
thread_loop.stop_serving(s)
thread_loop.stop()
thread_loop.close()
gc.collect()
def setUp(self):
self.loop = tulip.new_event_loop()
tulip.set_event_loop(self.loop)
self.transport = unittest.mock.Mock()
self.stream = tulip.StreamBuffer()
self.response = HttpResponse('get', 'http://python.org')
def init_process(self):
# create new event_loop after fork
tulip.get_event_loop().close()
self.ev_loop = tulip.new_event_loop()
tulip.set_event_loop(self.ev_loop)
super().init_process()
def init_process(self):
# create new event_loop after fork
tulip.get_event_loop().close()
self.ev_loop = tulip.new_event_loop()
tulip.set_event_loop(self.ev_loop)
super().init_process()
def run_server(cls, host, port):
handler = StaticFilesHandler(get_internal_wsgi_application())
# Save the event loop for the thread in a class variable
# so we can unblock it when the tests are finished.
cls.server_thread_loop = tulip.new_event_loop()
tulip.set_event_loop(cls.server_thread_loop)
cls.server_stop = tulip.Future()
run(host, port, handler, cls.server_thread_loop, cls.server_stop)
cls.server_thread_loop.close()
def setUp(self):
super().setUp()
self.loop = tulip.new_event_loop()
tulip.set_event_loop(self.loop)
self.protocol = WebSocketCommonProtocol()
self.transport = unittest.mock.Mock()
self.transport.close = unittest.mock.Mock(
side_effect=lambda: self.protocol.connection_lost(None))
self.protocol.connection_made(self.transport)
def run_server(cls, host, port):
handler = StaticFilesHandler(get_internal_wsgi_application())
# Save the event loop for the thread in a class variable
# so we can unblock it when the tests are finished.
cls.server_thread_loop = tulip.new_event_loop()
tulip.set_event_loop(cls.server_thread_loop)
cls.server_stop = tulip.Future()
run(host, port, handler, cls.server_thread_loop, cls.server_stop)
cls.server_thread_loop.close()
def start(self):
# start server
self.loop = loop = tulip.new_event_loop()
tulip.set_event_loop(loop)
def stop():
self.loop.stop()
os._exit(0)
loop.add_signal_handler(signal.SIGINT, stop)
# heartbeat
tulip.Task(self.heartbeat())
tulip.get_event_loop().run_forever()
os._exit(0)
def setUp(self):
self.loop = tulip.new_event_loop()
tulip.set_event_loop(None)
self.wsgi = unittest.mock.Mock()
self.stream = unittest.mock.Mock()
self.transport = unittest.mock.Mock()
self.transport.get_extra_info.return_value = '127.0.0.1'
self.headers = []
self.message = protocol.RawRequestMessage(
'GET', '/path', (1, 0), self.headers, True, 'deflate')
self.payload = tulip.DataBuffer()
self.payload.feed_data(b'data')
self.payload.feed_data(b'data')
self.payload.feed_eof()
def start(self):
# start server
self.loop = loop = tulip.new_event_loop()
tulip.set_event_loop(loop)
def stop():
self.loop.stop()
os._exit(0)
loop.add_signal_handler(signal.SIGINT, stop)
# heartbeat
self.heartbeat()
tulip.get_event_loop().run_forever()
os._exit(0)
def run(addr, port, wsgi_handler, **options):
"""
Alternate version of django.core.servers.basehttp.run running on Tulip.
"""
loop = tulip.get_event_loop()
if loop is None:
# The auto-reloader runs in the main thread and starts the server
# in another thread. Create an event loop for that thread.
loop = tulip.new_event_loop()
tulip.set_event_loop(loop)
# The code that reads environ['wsgi.input'] is deep inside Django and hard
# to make asynchronous. Pre-loading the payload is the simplest option.
protocol_factory = lambda: tulip.http.WSGIServerHttpProtocol(
wsgi_handler, readpayload=True)
loop.start_serving(protocol_factory, addr, port)
loop.run_forever()
def run(addr, port, wsgi_handler, **options):
"""
Alternate version of django.core.servers.basehttp.run running on Tulip.
"""
loop = tulip.get_event_loop()
if loop is None:
# The auto-reloader runs in the main thread and starts the server
# in another thread. Create an event loop for that thread.
loop = tulip.new_event_loop()
tulip.set_event_loop(loop)
# The code that reads environ['wsgi.input'] is deep inside Django and hard
# to make asynchronous. Pre-loading the payload is the simplest option.
protocol_factory = lambda: tulip.http.WSGIServerHttpProtocol(
wsgi_handler, readpayload=True)
loop.start_serving(protocol_factory, addr, port)
loop.run_forever()
def run(addr, port, wsgi_handler, ipv6=False, threading=False):
"""
Alternate version of django.core.servers.basehttp.run running on Tulip.
"""
assert not ipv6, "IPv6 isn't supported"
assert threading, "threading is irrelevant"
httpd = WSGIServer(addr, port, WSGIRequestHandler)
httpd.set_app(wsgi_handler)
# The auto-reloader runs in the main thread and starts the server in
# another thread. Since the event loop in thread-local we must create one.
loop = tulip.get_event_loop()
if loop is None:
loop = tulip.new_event_loop()
tulip.set_event_loop(loop)
loop.start_serving(httpd, addr, port)
loop.run_forever()
def run(addr, port, wsgi_handler, loop=None, stop=None, **options):
"""
Alternate version of django.core.servers.basehttp.run running on Tulip.
"""
if loop is None:
loop = tulip.new_event_loop()
tulip.set_event_loop(loop)
# The code that reads environ['wsgi.input'] is deep inside Django and hard
# to make asynchronous. Pre-loading the payload is the simplest option.
protocol_factory = lambda: tulip.http.WSGIServerHttpProtocol(
wsgi_handler, readpayload=True)
sockets = loop.start_serving(protocol_factory, addr, port)
if stop is None:
loop.run_forever()
else:
loop.run_until_complete(stop)
for socket in sockets:
loop.stop_serving(socket)
def run(addr, port, wsgi_handler, loop=None, stop=None, **options):
"""
Alternate version of django.core.servers.basehttp.run running on Tulip.
"""
if loop is None:
loop = tulip.new_event_loop()
tulip.set_event_loop(loop)
# The code that reads environ['wsgi.input'] is deep inside Django and hard
# to make asynchronous. Pre-loading the payload is the simplest option.
protocol_factory = lambda: tulip.http.WSGIServerHttpProtocol(
wsgi_handler, readpayload=True)
sockets = loop.start_serving(protocol_factory, addr, port)
if stop is None:
loop.run_forever()
else:
loop.run_until_complete(stop)
for socket in sockets:
loop.stop_serving(socket)
def start(self):
# start server
self.loop = loop = tulip.new_event_loop()
tulip.set_event_loop(loop)
def stop():
self.loop.stop()
os._exit(0)
loop.add_signal_handler(signal.SIGINT, stop)
f = loop.start_serving(
lambda: HttpServer(debug=True, keep_alive=75), sock=self.sock)
x = loop.run_until_complete(f)[0]
print('Starting srv worker process {} on {}'.format(
os.getpid(), x.getsockname()))
# heartbeat
self.heartbeat()
tulip.get_event_loop().run_forever()
os._exit(0)
def start(self):
# start server
self.loop = loop = tulip.new_event_loop()
tulip.set_event_loop(loop)
def stop():
self.loop.stop()
os._exit(0)
loop.add_signal_handler(signal.SIGINT, stop)
f = loop.start_serving(
self.protocol_factory, sock=self.sock, ssl=self.ssl)
x = loop.run_until_complete(f)[0]
print('Starting srv worker process {} on {}'.format(
os.getpid(), x.getsockname()))
# heartbeat
self.heartbeat()
tulip.get_event_loop().run_forever()
os._exit(0)
def start(self):
# start server
self.loop = loop = tulip.new_event_loop()
tulip.set_event_loop(loop)
def stop():
self.loop.stop()
os._exit(0)
loop.add_signal_handler(signal.SIGINT, stop)
f = loop.start_serving(lambda: HttpServer(debug=True, keep_alive=75),
sock=self.sock)
x = loop.run_until_complete(f)[0]
print('Starting srv worker process {} on {}'.format(
os.getpid(), x.getsockname()))
# heartbeat
self.heartbeat()
tulip.get_event_loop().run_forever()
os._exit(0)
def start(self):
# start server
self.loop = loop = tulip.new_event_loop()
tulip.set_event_loop(loop)
def stop():
self.loop.stop()
os._exit(0)
loop.add_signal_handler(signal.SIGINT, stop)
f = loop.start_serving(self.protocol_factory,
sock=self.sock,
ssl=self.ssl)
x = loop.run_until_complete(f)[0]
print('Starting srv worker process {} on {}'.format(
os.getpid(), x.getsockname()))
# heartbeat
self.heartbeat()
tulip.get_event_loop().run_forever()
os._exit(0)
def setUp(self):
self.loop = tulip.new_event_loop()
tulip.set_event_loop(None)
self.transport = unittest.mock.Mock()
self.stream = tulip.StreamBuffer(loop=self.loop)
def setUp(self):
self.event_loop = tulip.new_event_loop()
tulip.set_event_loop(self.event_loop)
self.server = HttpServer(HttpClientFunctional, self.event_loop)
self.server.start()
def setUp(self):
self.loop = tulip.new_event_loop()
tulip.set_event_loop(self.loop)
self.stream = tulip.StreamReader()
def setUp(self):
self.event_loop = tulip.new_event_loop()
tulip.set_event_loop(self.event_loop)
self.server = HttpServer(HttpClientFunctional, self.event_loop)
self.server.start()
def setUp(self):
self.loop = tulip.new_event_loop()
tulip.set_event_loop(None)
self.worker = TestWorker()
def setUp(self):
self.lines_parser = parsers.LinesParser()
self.loop = tulip.new_event_loop()
tulip.set_event_loop(None)
def setUp(self):
self.loop = tulip.new_event_loop()
tulip.set_event_loop(None)
def setUp(self):
self.loop = tulip.new_event_loop()
tulip.set_event_loop(None)
def setUp(self):
self.loop = tulip.new_event_loop()
tulip.set_event_loop(self.loop)
self.start_server()
