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)
