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 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 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, 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 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.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(self.loop) self.start_server()