def run(loop, fut): thread_loop = asyncio.new_event_loop() asyncio.set_event_loop(thread_loop) host, port = listen_addr server_coroutine = thread_loop.create_server( lambda: TestHttpServer(keepalive_timeout=0.5), host, port, ssl=sslcontext) server = thread_loop.run_until_complete(server_coroutine) waiter = helpers.create_future(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 transports 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 = asyncio.new_event_loop() asyncio.set_event_loop(thread_loop) host, port = listen_addr server_coroutine = thread_loop.create_server( lambda: TestHttpServer( web.Server(handler, loop=thread_loop), keepalive_timeout=0.5), host, port, ssl=sslcontext) server = thread_loop.run_until_complete(server_coroutine) waiter = helpers.create_future(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 transports for tr in transports: tr.close() run_briefly(thread_loop) # call close callbacks server.close() thread_loop.stop() thread_loop.close() gc.collect()
def go(): server = yield from self.loop.create_server( Proto, '127.0.0.1', unused_port()) addr = server.sockets[0].getsockname() connector = aiohttp.TCPConnector(loop=self.loop, capacity=1) url = 'http://{}:{}/'.format(*addr) r = yield from client.request('GET', url, connector=connector, loop=self.loop) yield from r.read() self.assertEqual(1, len(connector._conns)) with self.assertRaises(aiohttp.ClientError): yield from client.request('GET', url, connector=connector, loop=self.loop) self.assertEqual(0, len(connector._conns)) connector.close() server.close() yield from server.wait_closed()
def run(loop, fut): thread_loop = asyncio.new_event_loop() asyncio.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 = asyncio.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 go(): server = yield from self.loop.create_server( Proto, '127.0.0.1', unused_port()) addr = server.sockets[0].getsockname() connector = aiohttp.TCPConnector(loop=self.loop) url = 'http://{}:{}/'.format(*addr) r = yield from client.request('GET', url, connector=connector, loop=self.loop) yield from r.read() self.assertEqual(1, len(connector._conns)) with self.assertRaises(aiohttp.ClientError): yield from client.request('GET', url, connector=connector, loop=self.loop) self.assertEqual(0, len(connector._conns)) connector.close() server.close() yield from server.wait_closed()
def main(args): logging.info('starting picamera') if ENABLE_STATS: INFO.info({'host': socket.gethostname(), 'version':'0.1.0'}) camera = picamera.PiCamera(resolution=(args.width,args.height), framerate=args.framerate) #camera.resolution = (1440, 1080) # camera.resolution = (1640, 1248) # camera.framerate = 24 logging.info('creating socket server') # server = SocketServer('0.0.0.0', args.video_port) server = VideoServer('0.0.0.0', args.video_port) logging.info('creating mjpeg outputer') output = StreamingOutput() if args.notify != "": logging.info('creating notifier') notifier = Notifier(url=args.notify, data=args.notify_data) # motionOutput = MotionOutput() else: notifier = None detectMotion = DetectMotion(camera, magnitude=args.macroblock_magnitude, threshold=args.motion_threshold, notifier=notifier) logging.info('creating webserver') webServer = WebServer(output, ('', args.http_port), WebHandler) try: logging.info('starting mjpeg recorder') camera.start_recording(output, format='mjpeg', splitter_port=2, resize=(args.jpeg_width,args.jpeg_height)) logging.info('starting h264 recorder') camera.start_recording(server, format='h264', level=args.h264_level, profile=args.h264_profile, intra_refresh='cyclic', inline_headers=True, sps_timing=True, motion_output=detectMotion) logging.info('starting webserver') webServer.serve_forever() except KeyboardInterrupt: pass print('stopping recording') camera.stop_recording() print('stopping recording splitter_port=2') camera.stop_recording(splitter_port=2) print('server close') server.close() if not notifier is None: print('notifier stop') notifier.stop() print('camera close') camera.close() print('webServer shutdown') webServer.shutdown() print('done')
def go(): server = yield from self.loop.create_server(Proto, "127.0.0.1", unused_port()) addr = server.sockets[0].getsockname() connector = aiohttp.TCPConnector(loop=self.loop) url = "http://{}:{}/".format(*addr) for i in range(2): r = yield from client.request("GET", url, connector=connector, loop=self.loop) yield from r.read() self.assertEqual(0, len(connector._conns)) connector.close() server.close() yield from server.wait_closed()
def go(): server = yield from self.loop.create_server( Proto, '127.0.0.1', unused_port()) addr = server.sockets[0].getsockname() connector = aiohttp.TCPConnector(loop=self.loop, limit=1) url = 'http://{}:{}/'.format(*addr) for i in range(2): r = yield from client.request('GET', url, connector=connector, loop=self.loop) yield from r.read() self.assertEqual(0, len(connector._conns)) connector.close() server.close() yield from server.wait_closed()
async def go(): server = await self.loop.create_server( Proto, '127.0.0.1', unused_port()) addr = server.sockets[0].getsockname() connector = aiohttp.TCPConnector(loop=self.loop, limit=1) session = client.ClientSession(loop=self.loop, connector=connector) url = 'http://{}:{}/'.format(*addr) for i in range(2): r = await session.request('GET', url) await r.read() self.assertEqual(0, len(connector._conns)) session.close() connector.close() server.close() await server.wait_closed()
def go(): server = yield from self.loop.create_server( Proto, '127.0.0.1', unused_port()) addr = server.sockets[0].getsockname() connector = aiohttp.TCPConnector(loop=self.loop, limit=1) session = client.ClientSession(loop=self.loop, connector=connector) url = 'http://{}:{}/'.format(*addr) for i in range(2): r = yield from session.request('GET', url) yield from r.read() self.assertEqual(0, len(connector._conns)) session.close() connector.close() server.close() yield from server.wait_closed()
def run(loop, fut): thread_loop = asyncio.new_event_loop() asyncio.set_event_loop(thread_loop) if isinstance(listen_addr, tuple): host, port = listen_addr server_coroutine = thread_loop.create_server( lambda: TestHttpServer(keep_alive=0.5), host, port, ssl=sslcontext) else: try: os.unlink(listen_addr) except FileNotFoundError: pass server_coroutine = thread_loop.create_unix_server( lambda: TestHttpServer(keep_alive=0.5, timeout=15), listen_addr, ssl=sslcontext) server = thread_loop.run_until_complete(server_coroutine) waiter = helpers.create_future(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 transports 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 = asyncio.new_event_loop() asyncio.set_event_loop(thread_loop) if isinstance(listen_addr, tuple): host, port = listen_addr server_coroutine = thread_loop.create_server( lambda: TestHttpServer(keep_alive=0.5), host, port, ssl=sslcontext) else: try: os.unlink(listen_addr) except FileNotFoundError: pass server_coroutine = thread_loop.create_unix_server( lambda: TestHttpServer(keep_alive=0.5), listen_addr, ssl=sslcontext) server = thread_loop.run_until_complete(server_coroutine) waiter = asyncio.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 go(): server = yield from self.loop.create_server( Proto, '127.0.0.1', unused_port()) addr = server.sockets[0].getsockname() connector = aiohttp.TCPConnector(loop=self.loop, limit=1) session = client.ClientSession(loop=self.loop, connector=connector) url = 'http://{}:{}/'.format(*addr) r = yield from session.request('GET', url) yield from r.read() self.assertEqual(1, len(connector._conns)) with self.assertRaises(aiohttp.ServerDisconnectedError): yield from session.request('GET', url) self.assertEqual(0, len(connector._conns)) session.close() connector.close() server.close() yield from server.wait_closed()
if VERBOSE and data != b'': print("▲", data) await websocket.send(data) except Exception as e: #print(e) break async def handler(websocket, path): global serial_connected if not serial_connected: await connect_serial() #asyncio.gather(uplink(websocket),downlink(websocket)) page2mcu = asyncio.ensure_future(downlink(websocket)) mcu2page = asyncio.ensure_future(uplink(websocket)) done, pending = await asyncio.wait([page2mcu, mcu2page], return_when=asyncio.FIRST_COMPLETED) for task in pending: task.cancel() try: server = websockets.serve(handler, "127.0.0.1", PORT) asyncio.get_event_loop().run_until_complete(server) asyncio.get_event_loop().run_forever() except KeyboardInterrupt: print('\nCtrl-C') finally: server.close() asyncio.get_event_loop.close()
def process(): global server global conn global queue_in global queue_out global queue_out_list inputs = [ server, ] outputs = [] s_to_addr = {} addr_to_s = {} s_timer = {} # Outgoing message queues message_queues = {} while True: print("Loop ...") print("queue_out_list size: " + str(len(queue_out_list))) ready_to_read = [] ready_to_write = [] in_error = [] try: ready_to_read, ready_to_write, in_error = \ select.select(inputs, outputs, inputs, 5) except: server.shutdown( 2) # 0 = done receiving, 1 = done sending, 2 = both server.close() print('Connection error, reserverecting ...') connection, client_address = server.accept() inputs = [ server, ] outputs = [] client_address = str(client_address[0]) + "_" + str( client_address[1]) s_to_addr[connection] = client_address addr_to_s[client_address] = connection s_timer[connection] = 0 print('Connected by: ' + str(client_address)) pass print(str(ready_to_read)) print(str(ready_to_write)) print(str(in_error)) for s in ready_to_read: if s is server: # A "readable" server socket is ready to accept a connection connection, client_address = s.accept() connection.setblocking(0) inputs.append(connection) client_address = str(client_address[0]) + "_" + str( client_address[1]) s_to_addr[connection] = client_address addr_to_s[client_address] = connection s_timer[connection] = 0 message_queues[connection] = queue.Queue() else: data = s.recv(256 * 4096) if data: message_queues[s].put(data) print("8080: Receiving data") print(data) data = str(base64.b64encode(data), "ascii") queue_in.put(s_to_addr[s] + ":" + data) print("queue_in: " + s_to_addr[s] + ":" + data) if s not in outputs: outputs.append(s) s_timer[s] = 0 else: inputs.remove(s) pass time.sleep(0.1) next_msg = None i = 0 del_i = [] while i < len(queue_out_list): client_address = queue_out_list[i][0] next_msg = queue_out_list[i][1] s = addr_to_s[client_address] if next_msg != None and s and s in ready_to_write: print("WRITE") try: print("SEND") s.send(next_msg) if s in outputs: outputs.remove(s) del_i.append(i) s_timer[s] = 0 except: if s is not server: print("REMOVE") if s in outputs: outputs.remove(s) if s in ready_to_write: ready_to_write.remove(s) del_i.append(i) i = i + 1 # Delete items from queue_out_list new_queue_out_list = [] for i in range(len(queue_out_list)): if i not in del_i: new_queue_out_list.append(queue_out_list[i]) queue_out_list = new_queue_out_list del_i = [] i = 0 for q in queue_out_list: q[2] = q[2] + 1 if q[2] > 10000: del_i.append(i) i = i + 1 for s in ready_to_write: if s is not server: s_timer[s] = s_timer[s] + 1 if (s_timer[s] > 1000): if s in outputs: outputs.remove(s) for s in in_error: # Stop listening for input on the connection inputs.remove(s) if s is not server: if s in outputs: outputs.remove(s) s.close() # Remove message queue del message_queues[s] server.shutdown(socket.SHUT_RDWR) server.close()
def runmain(): clparse = argparse.ArgumentParser( description='runs a simple python webserver.') clparse.add_argument('-c', '--config', help='path to configuration file.') clparse.add_argument( '-l', '--logfile', help= 'if present sets logging to log to this file (overrides config logfile)' ) clparse.add_argument( '-v', '--consolelog', type=int, help= 'level of logging for the console log (stderr), if absent / 0 there is no console log' ) clparse.add_argument( '-i', '--interactive', action='store_true', help= 'run webserver in separate thread to allow interaction with python interpreter from console while running' ) clparse.add_argument( '-s', '--settings', help= "path to settings file for app's settings. Overrides settings file named in config file" ) args = clparse.parse_args() if args.config is None: sys.exit('no configuration file given.') configpath = pathlib.Path(args.config).expanduser() if not configpath.with_suffix('.py').is_file(): sys.exit('cannot find configuration file ' + str(configpath.with_suffix('.py'))) if not str(configpath.parent) == '.' and not configpath.parent in sys.path: sys.path.insert(1, str(configpath.parent)) configmodule = importlib.import_module(configpath.stem) # setup logging loglevel = getattr(configmodule, 'loglevel', 50) if loglevel < 0 or loglevel > 100: sys.exit( 'invalid loglevel in config file - must be between 0..100, found %s' % loglevel) toplog = logging.getLogger() toplog.setLevel(loglevel) if args.logfile and args.consolelog is None: print('no console log') else: if args.consolelog is None: print('setting console log to default (40)') cloglvl = 40 else: print('setting console log, loglevel', args.consolelog) cloglvl = args.consolelog chandler = logging.StreamHandler() if hasattr(configmodule, 'consolelogformat'): chandler.setFormatter( logging.Formatter(**configmodule.consolelogformat)) chandler.setLevel(cloglvl) toplog.addHandler(chandler) logfile = args.logfile if args.logfile else config.logfile if hasattr( configmodule, 'logfile') else None if logfile is None: print('No logfile') else: print('using logfile', logfile) logp = pathlib.Path(args.logfile).expanduser() lfh = logging.FileHandler(str(logp)) if hasattr(configmodule, 'filelogformat'): lfh.setFormatter(logging.Formatter(**configmodule.filelogformat)) toplog.addHandler(lfh) assert hasattr(configmodule, 'webport') assert hasattr(configmodule, 'setup') assert hasattr(configmodule, 'httpserverclass') assert hasattr(configmodule, 'httprequestclass') config = configmodule.setup( settings=args.settings if hasattr(args, 'settings') else None) assert isinstance(config, dict) ips = netinf.allIP4() if len(ips) == 0: smsg = 'starting webserver on internal IP only (no external IP addresses found), port %d' % ( configmodule.webport) elif len(ips) == 1: smsg = 'Starting webserver on %s:%d' % (ips[0], configmodule.webport) else: smsg = 'Starting webserver on multiple ip addresses (%s), port:%d' % ( str(ips), configmodule.webport) if args.consolelog is None: print(smsg) toplog.info(smsg) server = configmodule.httpserverclass(('', configmodule.webport), configmodule.httprequestclass, config=config) assert isinstance(server, http.server.HTTPServer) if args.interactive: toplog.info('interactive mode - start at server.mypyobjects') sthread = threading.Thread(target=server.serve_forever) sthread.start() else: toplog.info('normal mode') sthread = threading.Thread(target=server.serve_forever) sthread.start() try: while sthread.isAlive(): sthread.join(10) except KeyboardInterrupt: smsg = 'webserver got KeyboardInterrupt - should terminate in a few seconds' except Exception as e: smsg = 'webserver exception ' + type(e).__name__ + ' with ' + e.msg server.close() if args.consolelog is None: print(smsg) toplog.info(smsg)