def setup_app(path, server_url, loop):
app = web.Application()
# app.add_routes([web.get('/socket', websocket_handler)])
# cors = aiohttp_cors.setup(app)
# resource = cors.add(app.router.add_resource(path))
# route = cors.add(
# resource.add_route("GET", websocket_handler), {
# server_url: aiohttp_cors.ResourceOptions(
# allow_credentials=True,
# expose_headers="*",
# allow_headers="*",
# max_age=3600,
# )})
# https://github.com/aio-libs/sockjs/issues/38
name = 'changes'
manager = sockjs.SessionManager(name,
app,
ActiveSocket.sockjs_handler,
loop,
heartbeat=10,
timeout=timedelta(seconds=30))
sockjs.add_endpoint(app,
ActiveSocket.sockjs_handler,
name=name,
prefix=path + "/",
manager=manager)
return app
def decorate(conn):
conn.GLOBAL = global_route
async def handler(msg, session):
try:
if msg.tp == sockjs.MSG_OPEN:
await session.prepare()
await session.on_open()
elif msg.tp == sockjs.MSG_MESSAGE:
await session.on_message(**json.decode(msg.data))
elif msg.tp == sockjs.MSG_CLOSED:
await session.on_close()
except error.UserFacingError as e:
_logger.warning("Websocket user facing error: %s", repr(e))
session.close(4000, {'error': e.to_dict()})
class Manager(sockjs.SessionManager):
def __init__(self, *args):
super(Manager, self).__init__(*args)
self.factory = conn
self.timeout = datetime.timedelta(seconds=60)
loop = asyncio.get_event_loop()
sockjs.add_endpoint(Application(), handler, name=name, prefix=prefix,
manager=Manager(name, Application(), handler, loop))
sockjs.add_endpoint(
Application(), handler, name=name + '_with_domain_id', prefix='/d/{domain_id}' + prefix,
manager=Manager(name + '_with_domain_id', Application(), handler, loop))
return conn
def setup_routes(self):
self.router.add_route('GET', '/', self.index)
self.router.add_static('/static/', '/vagrant/static/', name='static')
sockjs.add_endpoint(self,
self.sockjs_handler,
name="game",
prefix="/sockjs/")
def decorate(conn):
async def handler(msg, session):
try:
if msg.tp == sockjs.MSG_OPEN:
await session.prepare()
await session.on_open()
elif msg.tp == sockjs.MSG_MESSAGE:
await session.on_message(**json.decode(msg.data))
elif msg.tp == sockjs.MSG_CLOSE:
await session.on_close()
except error.UserFacingError as e:
_logger.warning("Websocket user facing error: %s", repr(e))
session.close(4000, {'error': e.to_dict()})
class Manager(sockjs.SessionManager):
def get(self, id, create=False, request=None):
if id not in self and create:
self[id] = self._add(
conn(request,
id,
self.handler,
timeout=self.timeout,
loop=self.loop,
debug=self.debug))
return self[id]
sockjs.add_endpoint(Application(),
handler,
name=name,
prefix=prefix,
manager=Manager(name, Application(), handler,
Application().loop))
return conn
def __init__(self, ADStream, app, path, ad):
self.AD = ad
self.ADStream = ADStream
self.app = app
self.logger = ad.logging.get_child("_stream")
self.access = ad.logging.get_access()
sockjs.add_endpoint(app, prefix=path, handler=self.sockjshandler)
def setup_app(self, app):
manager = SessionManager(
"sockjs",
app,
self.handle,
self.loop,
timeout=timedelta(seconds=settings.SESSION_LIFE))
sockjs.add_endpoint(app,
self.handle,
name="sockjs",
prefix="/sockjs/{pk}/",
manager=manager)
return app
def newApi(loop, msgHandler):
app = Application(loop=loop, middlewares=[jsonParseMiddleware])
async def handleWebSocketRequest(data):
# TODO:SC Add version in route as well
try:
res = await msgHandler.handleMsg(data['route'], data)
return dumps(res)
except SignatureError as err:
return err
except (TypeError, KeyError, ValidationError):
return dumps(INVALID_DATA)
async def webSocketConnectionHandler(msg, session):
if msg.tp == sockjs.MSG_OPEN:
session.manager.broadcast(SOCKET_CONNECTED)
elif msg.tp == sockjs.MSG_MESSAGE:
# TODO:SC handle json parse error, schema error
requestData = json.loads(msg.data)
responseData = await handleWebSocketRequest(requestData)
session.manager.broadcast(responseData)
elif msg.tp == sockjs.MSG_CLOSED:
session.manager.broadcast(SOCKET_CLOSED)
sockjs.add_endpoint(app,
prefix='/v1/wsConnection',
handler=webSocketConnectionHandler)
async def v1(request, data):
res = await msgHandler.handleMsg(request.match_info['resource'], data)
return json_response(data=res)
app.router.add_post('/v1/{resource}', v1)
# Enable CORS on all APIs
cors = aiohttp_cors.setup(app, defaults={
"*": aiohttp_cors.ResourceOptions(
allow_credentials=True,
expose_headers="*",
allow_headers="*",
)
})
for route in list(app.router.routes()):
if route.name is not None and not route.name.startswith('sock'):
cors.add(route)
# In memory list of registered users, not using any database intentionally
app['users'] = {}
return app
def __init__(self, name, sensor, actor, logic, agitator=None, targetTemp=0.0, initiallyEnabled=False):
self.name = name
self._enabled = initiallyEnabled
self._autoMode = False
self.sensor = sensor
self.actor = actor
self.agitator = agitator
self.targetTemp = targetTemp
self.logic = logic
self.timestamp_history = deque(maxlen=100)
self.power_history = deque(maxlen=100)
self.temp_history = deque(maxlen=100)
self.setpoint_history = deque(maxlen=100)
sockjs.add_endpoint(app, prefix='/controllers/%s/ws'%self.name, name='%s-ws'%self.name, handler=self.websocket_handler)
asyncio.ensure_future(self.run())
async def factory():
loop = asyncio.get_event_loop()
app = Application(loop=loop)
cors = aiohttp_cors.setup(app,
defaults={
"*":
aiohttp_cors.ResourceOptions(
allow_credentials=True,
expose_headers="*",
allow_headers="*",
)
})
sockjs.add_endpoint(app, ws_poll, name='ws', prefix='/ws/')
return app
def __init__(self,
queue_size,
loop=None,
session_timeout=3600,
heart_beat_interval=3,
max_digits=3,
keypad_port='off',
disable_input_page=False):
self._queue = deque(maxlen=queue_size)
self._app = web.Application(loop=loop)
self._sockjs_manager = None
self._session_timeout = session_timeout
self._session_screensaver_status = False
self._session_last_event = time.time()
self._max_digits = max_digits
# Custom keypad support
if keypad_port != 'off':
self._keypad_handler = KeypadHandler(keypad_port, loop,
self._on_keypad_input)
else:
self._keypad_handler = None
# Initialize routes
self._app.router.add_get('/', self._index)
self._app.router.add_static('/static', self.WEB_ASSETS)
self._app.router.add_get('/api/queue', self._get_queue)
if not disable_input_page:
self._app.router.add_post('/api/queue', self._new_call)
self._app.router.add_delete('/api/queue', self._delete_call)
self._app.router.add_post('/api/screensaver',
self._activate_screen_saver)
self._app.router.add_get('/api/screensaver',
self._get_session_screen_saver)
# Initialize websockets
self._last_broadcast = time.time()
if heart_beat_interval > 0:
self._heart_beat_interval = heart_beat_interval
else:
raise Exception("Heart beat interval 0 or less is not allowed.")
sockjs.add_endpoint(self._app,
self._sockjs_handler,
name='notifier',
prefix='/api/notifications/')
def init_aiohttp_app(loop):
flask_app = init_flask_app()
from wcapp.view_helpers import add_message
from wcapp.my_redis import get_redis
with flask_app.app_context():
get_redis().delete('users')
get_redis().delete('messages')
add_message('system', "welcome to the chat <3")
def _get_username_from_aiohttp_request(request):
environ = _aiohttp_request_2_wsgi_environ(request)
return _get_username_from_flask_app_and_wsgi_environ(
flask_app, environ)
app = aioweb.Application(loop=loop)
sockjs_session_manager = SockjsSessionManager(
_get_username_from_aiohttp_request,
app,
sockjs_session_handler,
app.loop,
heartbeat=3.0,
timeout=timedelta(seconds=10),
heartbeat_close=True,
debug=False,
)
sockjs.add_endpoint(
app,
sockjs_session_handler,
name=sockjs_session_manager.name,
prefix='/sockjs', # default
manager=sockjs_session_manager,
)
app.on_shutdown.append(sockjs_on_app_shutdown)
#### must attach socket stuffs before the WSGI handler's glob
app.router.add_route(
"*", "/{path_info:.*}",
WSGIHandler(flask_app.wsgi_app))
return app
def create_app():
loop = asyncio.get_event_loop()
app = web.Application(loop=loop)
# routing
app.router.add_route('GET', '/', index)
app.router.add_static('/assets', './client/assets')
sockjs.add_endpoint(app,
chat_msg_handler,
name=SOCKJS_MNGR,
prefix='/sockjs/')
# add serial port connection
# app[ARDUINO_PORT] = serial.Serial('COM1', 9600)
# bind lifecycle hooks
app.on_startup.append(open_browser)
# app.on_startup.append(start_background_tasks)
# app.on_cleanup.append(cleanup_background_tasks)
# app.on_shutdown.append(close_open_connections)
return app
def decorate(conn):
async def handler(msg, session):
try:
if msg.tp == sockjs.MSG_OPEN:
await session.prepare()
await session.on_open()
elif msg.tp == sockjs.MSG_MESSAGE:
await session.on_message(**json.decode(msg.data))
elif msg.tp == sockjs.MSG_CLOSE:
await session.on_close()
except error.UserFacingError as e:
_logger.warning("Websocket user facing error: %s", repr(e))
session.close(4000, {'error': e.to_dict()})
class Manager(sockjs.SessionManager):
def get(self, id, create=False, request=None):
if id not in self and create:
self[id] = self._add(conn(request, id, self.handler,
timeout=self.timeout, loop=self.loop, debug=self.debug))
return self[id]
sockjs.add_endpoint(Application(), handler, name=name, prefix=prefix,
manager=Manager(name, Application(), handler, Application().loop))
return conn
session.manager.broadcast(msg.data)
if __name__ == '__main__':
""" Sockjs tests server """
loop = asyncio.get_event_loop()
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s %(levelname)s %(message)s')
HTMLFileTransport.maxsize = 4096
EventsourceTransport.maxsize = 4096
XHRStreamingTransport.maxsize = 4096
app = web.Application(loop=loop)
sockjs.add_endpoint(app, echoSession, name='echo', prefix='/echo')
sockjs.add_endpoint(app, closeSessionHander, name='close', prefix='/close')
sockjs.add_endpoint(app,
broadcastSession,
name='broadcast',
prefix='/broadcast')
sockjs.add_endpoint(app,
echoSession,
name='wsoff',
prefix='/disabled_websocket_echo',
disable_transports=('websocket', ))
sockjs.add_endpoint(app,
echoSession,
name='cookie',
prefix='/cookie_needed_echo',
cookie_needed=True)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
sockjs.add_endpoint(self, self.__handle_message, name="ddp_server")
self.ddp_sessions = {}
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
sockjs.add_endpoint(self, self._handle_message, name="ddp_server")
self.ddp_sessions = {}
self._on_connection_callbacks = []
print('sockjs close')
os.kill(pid, signal.SIGHUP)
os.kill(pid, signal.SIGCONT)
ret = os.waitpid(pid)
print(' subproc died', ret)
def terminal_out(session, fd):
data = os.read(fd, 1024)
session.send(data.decode('utf8'))
async def index(request):
content = (here / 'templates' / 'index.html').read_text()
return web.Response(text=content, content_type='text/html')
if __name__ == '__main__':
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
loop = asyncio.get_event_loop()
app = web.Application()
app.router.add_get('/', index)
app.router.add_static('/static', str(here / 'static'))
sockjs.add_endpoint(app, terminal_handler, prefix='/pty')
try:
web.run_app(app, port=5000)
except (KeyboardInterrupt, SystemExit):
loop.stop()
finally:
loop.close()
def add_sock_endpoint(self,
handler: Callable,
name: str,
route: str = "/sockjs/") -> None:
app = self.get_app()
sockjs.add_endpoint(app, handler, name=name, prefix=route)
CHAT_FILE = open(os.path.join(os.path.dirname(__file__), 'chat.html'),
'rb').read()
async def chat_msg_handler(msg, session):
if session.manager is None:
return
if msg.type == sockjs.MSG_OPEN:
session.manager.broadcast("Someone joined.")
elif msg.type == sockjs.MSG_MESSAGE:
session.manager.broadcast(msg.data)
elif msg.type == sockjs.MSG_CLOSED:
session.manager.broadcast("Someone left.")
def index(request):
return web.Response(body=CHAT_FILE, content_type='text/html')
if __name__ == '__main__':
"""Simple sockjs chat."""
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s %(levelname)s %(message)s')
app = web.Application()
app.router.add_route('GET', '/', index)
sockjs.add_endpoint(app, chat_msg_handler, name='chat', prefix='/sockjs/')
web.run_app(app)
import sockjs
CHAT_FILE = open(
os.path.join(os.path.dirname(__file__), 'chat.html'), 'rb').read()
async def chat_msg_handler(msg, session):
if msg.type == sockjs.MSG_OPEN:
session.manager.broadcast("Someone joined.")
elif msg.type == sockjs.MSG_MESSAGE:
session.manager.broadcast(msg.data)
elif msg.type == sockjs.MSG_CLOSED:
session.manager.broadcast("Someone left.")
def index(request):
return web.Response(body=CHAT_FILE, content_type='text/html')
if __name__ == '__main__':
"""Simple sockjs chat."""
loop = asyncio.get_event_loop()
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s %(levelname)s %(message)s')
app = web.Application(loop=loop)
app.router.add_route('GET', '/', index)
sockjs.add_endpoint(app, chat_msg_handler, name='chat', prefix='/sockjs/')
web.run_app(app)
elif frame.command == 'SUBSCRIBE':
subscription = frame.headers['id']
session.subscriptions[frame.headers['destination']] = subscription
elif frame.command == 'UNSUBSCRIBE':
del session.subscriptions[frame.headers['destination']]
elif msg.tp == sockjs.MSG_CLOSE:
pass
elif msg.tp == sockjs.MSG_CLOSED:
pass
sockjs.add_endpoint(app,
socks_backend,
name='clients',
prefix='/socks-backends/')
# Our REST API endpoints which the web interface uses.
async def backends_list(request):
details = [info for name, url, info in backend_details.values()]
return web.json_response(details)
app.router.add_get('/ws/backends/list', backends_list)
async def data_all(request):
service = request.rel_url.query['service']
}))
except:
traceback.print_exc()
session.send(json.dumps({'error': traceback.format_exc()}))
def index(request):
return web.Response
if __name__ == '__main__':
loop = asyncio.get_event_loop()
app = web.Application(loop=loop)
app.router.add_route('GET', '/', index)
sockjs.add_endpoint(app, prefix='/sockjs', handler=handle_msg)
handler = app.make_handler()
server = loop.run_until_complete(
loop.create_server(handler, '127.0.0.1', 8081))
print('Server started at http://127.0.0.1:8081')
sys.stdout.flush()
try:
loop.run_forever()
except KeyboardInterrupt:
server.close()
loop.run_until_complete(handler.finish_connections())
session.manager.broadcast(msg.data)
if __name__ == '__main__':
""" Sockjs tests server """
loop = asyncio.get_event_loop()
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s %(levelname)s %(message)s')
HTMLFileTransport.maxsize = 4096
EventsourceTransport.maxsize = 4096
XHRStreamingTransport.maxsize = 4096
app = web.Application(loop=loop)
sockjs.add_endpoint(
app, echoSession, name='echo', prefix='/echo')
sockjs.add_endpoint(
app, closeSessionHander, name='close', prefix='/close')
sockjs.add_endpoint(
app, broadcastSession, name='broadcast', prefix='/broadcast')
sockjs.add_endpoint(
app, echoSession, name='wsoff', prefix='/disabled_websocket_echo',
disable_transports=('websocket',))
sockjs.add_endpoint(
app, echoSession, name='cookie', prefix='/cookie_needed_echo',
cookie_needed=True)
handler = app.make_handler()
srv = loop.run_until_complete(
loop.create_server(handler, '127.0.0.1', 8081))
print("Server started at http://127.0.0.1:8081")
session.manager.broadcast("Someone joined.")
elif msg.tp == sockjs.MSG_MESSAGE:
session.manager.broadcast(msg.data)
elif msg.tp == sockjs.MSG_CLOSED:
session.manager.broadcast("Someone left.")
def index(request):
return web.Response(body=CHAT_FILE, content_type='text/html')
if __name__ == '__main__':
"""Simple sockjs chat."""
loop = asyncio.get_event_loop()
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s %(levelname)s %(message)s')
app = web.Application(loop=loop)
app.router.add_route('GET', '/', index)
sockjs.add_endpoint(app, chatSession, prefix='/sockjs/')
handler = app.make_handler()
srv = loop.run_until_complete(
loop.create_server(handler, '127.0.0.1', 8080))
print("Server started at http://127.0.0.1:8080")
try:
loop.run_forever()
except KeyboardInterrupt:
srv.close()
loop.run_until_complete(handler.finish_connections())
dt = {'action': 'loading', 'status': True, 'data': dt}
try:
_SESSION.manager.broadcast(json.dumps(dt))
except Exception as e:
print(e)
# do actual thing due to state
if data['status']:
_DOOR.lock('Web')
else:
_DOOR.unlock('Web')
# _db.layers.update(data['id'], position = json.dumps(data['position']))
return web.json_response({'status': _DOOR.DOOR_STATE})
if __name__ == '__main__':
sockjs.add_endpoint(app, prefix='/sockjs', handler=websocket)
handler = app.make_handler()
srv = loop.run_until_complete(loop.create_server(handler, '0.0.0.0', 8080))
print("Server started at http://0.0.0.0:8080")
# _db.device.insert('omron','omron',datetime.datetime.now().isoformat(), json.dumps([0,0]), json.dumps([]))
# loop.create_task(olr.run())
try:
loop.run_forever()
except KeyboardInterrupt:
srv.close()
loop.run_until_complete(handler.finish_connections())
