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())