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
