def start(q): loadData() app = web.Application(middlewares=[IndexMiddleware()]) # API endpoints app.router.add_get("/api/v1/info/", apiInfoHandle) app.router.add_put("/api/v1/mqtt_publish/", mqttPublishHandle) app.router.add_static("/", common.PATH + "components/web/") sslContext = None if c.config["ssl"]["enabled"] and c.config["web"]["inside_port"] == None: sslContext = ssl.create_default_context( ssl.Purpose.CLIENT_AUTH, cafile=c.config["ssl"]["chain_file"]) sslContext.load_cert_chain(c.config["ssl"]["cert_file"], c.config["ssl"]["key_file"]) webPort = c.config["web"]["port"] if c.config["web"][ "inside_port"] == None else c.config["web"]["inside_port"] logger.info("Starting web server on {}".format(webPort)) asyncio.set_event_loop(asyncio.new_event_loop()) server = asyncio.get_event_loop().create_server(app.make_handler(), host="0.0.0.0", port=webPort, ssl=sslContext) asyncio.get_event_loop().run_until_complete(server) q.put(0) asyncio.get_event_loop().run_forever()
def _server_handler(self): loop = self.loop asyncio.set_event_loop(loop) app = self.app = web.Application(loop=self.loop, middlewares=[IndexMiddleware()]) async def websocket_handler(request): ws = web.WebSocketResponse() await ws.prepare(request) while not ws.closed: ws.send_str(json.dumps(self.get_bitmap().tolist())) try: await asyncio.sleep(1 / self.fps) except CancelledError: break return ws app.router.add_get('/ws', websocket_handler) static_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'static') app.router.add_static('/', static_path) handler = app.make_handler() print('Server start at 0.0.0.0:60000') coro = loop.create_server(handler, '0.0.0.0', 60000) server = loop.run_until_complete(coro) loop.run_forever()
def __init__(self, driver=Drivers.RPI, frame_rate=24, cam_data_dir=CAM_DATA_DIR, client_build_dir=CLIENT_BUILD_DIR, log_level=logging.INFO, shoot_at_startup=False, preview_sensor_mode=DEFAULT_PREVIEW_SENSOR_MODE, preview_resolution=DEFAULT_PREVIEW_RESOLUTION, **web_app_args): self.sio = socketio.AsyncServer() self.logger = get_logger('rpi_cam.server', level=log_level, sio=self.sio, namespace='/cam') self.app = web.Application(middlewares=[IndexMiddleware()]) self.sio.attach(self.app) self.frame_rate = frame_rate self.default_auto_shoot = False self.auto_shoot = False self.shoot_timeout = 5 self.clients = 0 self.idle_when_alone = True self.report_timeout = 30 self.camera_idle_timeout = 5 self.camera_stop_task = None self.shoot_at_startup = shoot_at_startup self.startup_shooting_timeout = 300 self.latest_preview = None self.frame_manager = get_frame_manager( driver, cam_data_dir, url_prefix='/cam_data', logger=get_logger('rpi_cam.capture.frame_manager', level=log_level, sio=self.sio, namespace='/cam'), preview_sensor_mode=preview_sensor_mode, preview_resolution=preview_resolution, ) self.web_app_args = web_app_args self.app.router.add_static('/cam_data', cam_data_dir, show_index=True) self.app.router.add_get('/latest', self.get_latest_preview) self.app.router.add_static('/', client_build_dir) self.logger.warning('Starting background tasks.') self.sio.start_background_task(self.stream_thumbs) self.sio.start_background_task(self.auto_shoot_task) self.sio.start_background_task(self.send_fps_updates) self.sio.start_background_task(self.send_status_reports) self.startup_shooting_task = self.sio.start_background_task( self.startup_shooting) self._define_events()
def app_factory(args=()): app = web.Application(middlewares=[IndexMiddleware()]) app.on_startup.append(start_sensor) app.router.add_get('/metrics', aio.web.server_stats) app.router.add_get('/api/v1/sensor', get_sensor) app.router.add_get('/api/v1/sensor/ws', websocket_sensor) app.router.add_static('/', 'static') return app
def init(): app = web.Application(middlewares=[ IndexMiddleware(), error_middleware, security_middleware, ]) app.on_startup.append(async_setup) oauth_kwargs = dict( github_id=GH_ID, github_secret=GH_SECRET, github_org=GH_ORG, cookie_name=COOKIE_NAME, cookie_key=COOKIE_KEY, whitelist_handlers=[ toggles.get_toggle_states_for_env, features.get_features, health.get_health ], oauth_url='/oauth_callback/github', auth_callback=employees.check_employee, ) if LOCAL_DEV: oauth_kwargs['dummy'] = True aiohttp_oauth.add_oauth_middleware(app, **oauth_kwargs) # make index middleware very first one # app._middlewares = [IndexMiddleware()] + app.middlewares app.router.add_get('/api/envs/{name}/toggles', toggles.get_toggle_states_for_env) app.router.add_get('/api/toggles', toggles.get_all_toggle_states) app.router.add_patch('/api/toggles', toggles.set_toggle_state) app.router.add_get('/api/features', features.get_features) app.router.add_post('/api/features', features.create_feature) app.router.add_delete('/api/features/{name}', features.delete_feature) app.router.add_get('/api/envs', environments.get_envs) app.router.add_post('/api/envs', environments.add_env) app.router.add_delete('/api/envs/{name}', environments.delete_env) app.router.add_get('/api/auditlog', auditing.get_audit_events) app.router.add_get('/heartbeat', health.get_health) # Add static handler app.router.add_static('/', os.path.dirname(__file__) + '/static') client = None if SENTRY_URL: client = Client(SENTRY_URL, transport=AioHttpTransport, environment=ENV_NAME) app.raven = client return app
def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument('--occlude-root', action='store_true', help='Add an explicit handler function for /.') args = parser.parse_args() app = web.Application(middlewares=[IndexMiddleware()]) app.router.add_route('GET', '/test/', make_handler('test')) if args.occlude_root: app.router.add_route('GET', '/', make_handler('I occluded /index.html.')) app.router.add_static('/', APP_PATH / 'static') web.run_app(app)
def __init__(self, port=80, ip='localhost', resolution='640x480'): self.on_new_message_listener = None self.__is_running = False self.__camera_preview = WebRTCServer.CameraPreview() self.__pcs = set() self.__channels = set() self.__request_id_channels = {} self.__port = port self.__ip = ip self.__resolution = resolution self.__app = web.Application(middlewares=[IndexMiddleware()]) self.__app.router.add_post('/offer', self.offer) self.__app.router.add_static('/', path=str('../public/')) self.__loop = None self.__site = None
def __init__(self, host=None, port=8090, remote_host='localhost', remote_port=8000, frame_rate=24, side_in=2**3, octaves=6, tone_shift=-18, synth_type=sound_drivers.PY_GAME, retriever_type=RetrieverTypes.PyGame, log_level=logging.INFO, profile=False, save_images=False, sigma=2, initial_mul=32, decrease=1.2, **server_args): self.logger = get_logger('acoustic_sight_server.server', level=log_level) self.sio = socketio.AsyncServer() self.app = web.Application(middlewares=[IndexMiddleware()]) self.sio.attach(self.app) self.clients = 0 self.host = host self.port = port self.server_args = server_args self.remote_image_sonification = ImageSonificator( frame_rate=frame_rate, remote_host=remote_host, remote_port=remote_port, side_in=side_in, octaves=octaves, tone_shift=tone_shift, synth_type=synth_type, retriever_type=retriever_type, logger=self.logger, profile=profile, save_images=save_images, sigma=sigma, initial_mul=initial_mul, decrease=decrease, ) self.setup_events()
def main(): logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG, format="%(asctime)s;%(levelname)s;%(message)s") logging.getLogger().addHandler(logging.StreamHandler()) app = web.Application(middlewares=[IndexMiddleware()]) sio.attach(app) if hasattr(sys, 'frozen'): async def handler(request): path = str(request.rel_url) if path[0] == '/': path = path[1:] if path == '': path = 'index.html' print(path) resolvedPath = os.path.join('frontend/', path) print('try1', resolvedPath) if not os.path.exists(resolvedPath): resolvedPath = os.path.join(os.path.dirname(db_path), 'collection.media/', path) print('try2', resolvedPath) if not os.path.exists(resolvedPath): return web.Response(status=404, text='Not found') try: with open(resolvedPath, 'rb') as f: return web.Response( content_type=mimetypes.guess_type(resolvedPath)[0], body=f.read(), ) except: return web.Response(status=404, text='Not found') app.router.add_route('GET', '/{tail:.*}', handler) print("Opening localhost:%d" % NET_PORT) import webbrowser webbrowser.open('http://localhost:%d/' % NET_PORT) web.run_app(app, host='127.0.0.1', port=NET_PORT)
async def socketio_server(async_q): sio = socketio.AsyncServer() app = web.Application(middlewares=[IndexMiddleware()]) sio.attach(app) @sio.event def connect(sid, environ): logging.info(f"New Socket.IO listener connected: {sid}") @sio.event def disconnect(sid): logging.info(f"New Socket.IO listener disconnected: {sid}") app.router.add_static('/', './data/website') # Serve the website & Socket.IO server runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, settings.WEB_BIND, settings.WEB_PORT) await site.start() # Start the message sender task task = asyncio.create_task(send_messages(sio, async_q))
def main(verbose, quiet, x_plane_port, port): with logbook.NullHandler(), logbook.StreamHandler(sys.stderr, level=logbook.WARNING - verbose + quiet, bubble=False): loop = asyncio.get_event_loop() console = Console() webapp = web.Application(middlewares=[IndexMiddleware()]) webapp['console'] = console webapp.router.add_get('/status', handle_status) webapp.router.add_post('/command', handle_command) webapp.router.add_static('/', _PROJECT_ROOT / 'webapp' / 'dist') loop.run_until_complete( loop.create_server(webapp.make_handler(), '0.0.0.0', port)) loop.run_until_complete( loop.create_datagram_endpoint(lambda: XPlaneDataProtocol(console), local_addr=('0.0.0.0', x_plane_port))) loop.run_forever() loop.close()
def run(self, port=8000): """Runs the web interface.""" self.loop = asyncio.new_event_loop() asyncio.set_event_loop(self.loop) self.app = web.Application(middlewares=[IndexMiddleware()], loop=self.loop) self.app.event_queue = asyncio.Queue() self.app.image_encode_settings = {'format': 'png'} self.app.wss = [] self.app.task_process_events = self.loop.create_task( process_events(self.app)) self.app.router.add_route('GET', '/websocket', handle_websocket) self.app.router.add_static('/', STATIC_PATH) try: web.run_app(self.app, port=port, shutdown_timeout=1, handle_signals=False) except KeyboardInterrupt: pass
async def handle_runmode(request): return web.Response(text=runMode) async def handle_payload_put(request): if runMode != "private": return web.Response(status=405) # method not allowed payloadName = request.match_info['payload'] payload = await request.text() with open(path.join(PAYLOADS_ROOT, payloadName), 'w+') as file: file.write(payload) return web.Response(status=204) app = web.Application(middlewares=[IndexMiddleware()]) app.router.add_route('GET', path='/payloads/manifest.json', handler=handle_manifest) app.router.add_route('PUT', path='/payloads/{payload}', handler=handle_payload_put) app.router.add_route('PATCH', path='/rename-payload/{payload}', handler=handle_rename) app.router.add_route('GET', path='/runmode', handler=handle_runmode)
async def create_app(): app = web.Application(middlewares=[IndexMiddleware()]) sio.attach(app) app.router.add_get('/', index) app.router.add_static('/', './frontend/dist/') return app
} users[payload['username']] = user session = await get_session(request) session['username'] = payload['username'] return web.Response() def get_avatar(request): username = request.rel_url.query['username'] if username in users: return web.Response(body=users[username]['avatar'], content_type='image/png') return web.Response(status=404) app = web.Application(middlewares=(IndexMiddleware(), )) fernet_key = fernet.Fernet.generate_key() secret_key = urlsafe_b64decode(fernet_key) setup(app, EncryptedCookieStorage(secret_key)) app.router.add_post('/messages', new_message) app.router.add_get('/messages', list_messages) app.router.add_get('/sub', listen_messages) app.router.add_get('/whoami', whoami) app.router.add_post('/register', register) app.router.add_get('/avatar', get_avatar) app.router.add_static('/js', '../frontend/dist') app.router.add_static('/', '../frontend/public')
def init_aiohttp_app(self): self.aiohttp_app = aiohttp.web.Application( loop=self.loop, middlewares=[IndexMiddleware()]) self.aiohttp_app['server'] = self