def test_multiple_receive_on_close_connection(self): req = self.make_request("GET", "/") ws = WebSocketResponse() self.loop.run_until_complete(ws.prepare(req)) self.loop.run_until_complete(ws.close()) self.loop.run_until_complete(ws.receive()) self.loop.run_until_complete(ws.receive()) self.loop.run_until_complete(ws.receive()) self.loop.run_until_complete(ws.receive()) self.assertRaises(RuntimeError, self.loop.run_until_complete, ws.receive())
def test_multiple_receive_on_close_connection(self): req = self.make_request('GET', '/') ws = WebSocketResponse() ws.start(req) self.loop.run_until_complete(ws.close()) self.loop.run_until_complete(ws.receive()) self.loop.run_until_complete(ws.receive()) self.loop.run_until_complete(ws.receive()) self.loop.run_until_complete(ws.receive()) self.assertRaises( RuntimeError, self.loop.run_until_complete, ws.receive())
def test_multiple_receive_on_close_connection(make_request): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) yield from ws.close() yield from ws.receive() yield from ws.receive() yield from ws.receive() yield from ws.receive() with pytest.raises(RuntimeError): yield from ws.receive()
def test_multiple_receive_on_close_connection(make_request): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) ws._reader.feed_data(WS_CLOSED_MESSAGE, 0) yield from ws.close() yield from ws.receive() yield from ws.receive() yield from ws.receive() yield from ws.receive() with pytest.raises(RuntimeError): yield from ws.receive()
def wso(request): global wsk global wst wsk0 = WebSocketResponse() wsk0.start(request) unauth = True while True: msg = yield from wsk0.receive() if msg.tp == MsgType.text: print("Screen") print(msg.data) if unauth: wsk0.auth = msg.data wsk[wsk0.auth] = wsk0 unauth = False continue if msg.data == 'close': yield from wsk0.close() wsk.pop(wsk0.auth, None) break else: wst[wsk0.auth].send_str(msg.data) elif msg.tp == MsgType.close: break elif msg.tp == MsgType.error: break wsk.pop(wsk0.auth, None) return wsk0
def wshandler(request): resp = WebSocketResponse() ok, protocol = resp.can_start(request) if not ok: with open(WS_FILE, 'rb') as fp: return Response(body=fp.read(), content_type='text/html') yield from resp.prepare(request) request.app['sockets'].append(resp) while True: msg = yield from resp.receive() print('msg: {}'.format(msg.data)) if msg.tp == MsgType.text: for ws in request.app['sockets']: ws.send_str('---------------') if msg.data == 'on': ws.send_str(turnOn()) elif msg.data == 'off': ws.send_str(turnOff()) elif msg.data == 'true': f = open("cb_state.txt",'w') f.write('1') f.close() elif msg.data == 'false': f = open("cb_state.txt",'w') f.write('0') f.close() else: f = open("cb_state.txt") ws.send_str(f.read()) f.close() else: break request.app['sockets'].remove(resp) return resp
def wsHandler(request): resp = WebSocketResponse() ok, protocol = resp.can_start(request) if not ok: with open(WS_FILE, 'rb') as fp: return Response(body=fp.read(), content_type='text/html') yield from resp.prepare(request) print('Someone joined.') for ws in request.app['sockets']: ws.send_str('Someone joined') request.app['sockets'].append(resp) while True: msg = yield from resp.receive() if msg.tp == MsgType.text: obj = json.loads(msg.data) retVal = parseRequest(obj) for ws in request.app['sockets']: if ws is resp: ws.send_str(json.dumps(retVal)) else: break request.app['sockets'].remove(resp) print('Someone disconnected.') for ws in request.app['sockets']: ws.send_str('Someone disconnected.') return resp
def wshandler(request): resp = WebSocketResponse() ok, protocol = resp.can_start(request) if not ok: with open(WS_FILE, "rb") as fp: return Response(body=fp.read(), content_type="text/html") yield from resp.prepare(request) print("Someone joined.") for ws in request.app["sockets"]: ws.send_str("Someone joined") request.app["sockets"].append(resp) while True: msg = yield from resp.receive() if msg.tp == MsgType.text: for ws in request.app["sockets"]: if ws is not resp: ws.send_str(msg.data) else: break request.app["sockets"].remove(resp) print("Someone disconnected.") for ws in request.app["sockets"]: ws.send_str("Someone disconnected.") return resp
def wshandler(request): print("wshandler", request) resp = WebSocketResponse() ok, protocol = resp.can_start(request) if not ok: print("http") with open(WS_FILE, 'rb') as fp: return Response(body=fp.read(), content_type='text/html') print("ws") resp.start(request) print('Someone joined.') for ws in request.app['sockets']: ws.send_str('Someone joined') request.app['sockets'].append(resp) while True: msg = yield from resp.receive() if msg.tp == MsgType.text: for ws in request.app['sockets']: if ws is not resp: ws.send_str(msg.data) else: break request.app['sockets'].remove(resp) print('Someone disconnected.') for ws in request.app['sockets']: ws.send_str('Someone disconnected.') return resp
def wshandler(request): resp = WebSocketResponse() ok, protocol = resp.can_start(request) if not ok: with open(WS_FILE, 'rb') as fp: return Response(body=fp.read(), content_type='text/html') yield from resp.prepare(request) print('Someone joined.') for ws in request.app['sockets']: ws.send_str('Someone joined') request.app['sockets'].append(resp) while True: msg = yield from resp.receive() if msg.tp == MsgType.text: for ws in request.app['sockets']: if ws is not resp: ws.send_str(msg.data) else: break request.app['sockets'].remove(resp) print('Someone disconnected.') for ws in request.app['sockets']: ws.send_str('Someone disconnected.') return resp
def test_concurrent_receive(self): req = self.make_request("GET", "/") ws = WebSocketResponse() self.loop.run_until_complete(ws.prepare(req)) ws._waiting = True self.assertRaises(RuntimeError, self.loop.run_until_complete, ws.receive())
def test_concurrent_receive(make_request): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) ws._waiting = True with pytest.raises(RuntimeError): yield from ws.receive()
def test_concurrent_receive(self): req = self.make_request('GET', '/') ws = WebSocketResponse() ws.start(req) ws._waiting = True self.assertRaises( RuntimeError, self.loop.run_until_complete, ws.receive())
def test_receive_timeouterror(self): req = self.make_request("GET", "/") ws = WebSocketResponse() self.loop.run_until_complete(ws.prepare(req)) res = asyncio.Future(loop=self.loop) res.set_exception(asyncio.TimeoutError()) ws._reader.read.return_value = res self.assertRaises(asyncio.TimeoutError, self.loop.run_until_complete, ws.receive())
def wshandler(request): resp = WebSocketResponse() ok, protocol = resp.can_start(request) if not ok: with open(WS_FILE, 'rb') as fp: return Response(body=fp.read(), content_type='text/html') sockets = request.app['sockets'] if len(sockets) == 0: restart_game() sockets.append(resp) resp.start(request) # login msg = yield from resp.receive() keycode = msg.data existing = USERMAP.get(keycode) if not existing or not existing.closed: random.seed(random.SystemRandom()) keycode = ''.join(random.sample(string.ascii_letters, 32)) USERMAP[keycode] = resp # communicate update_id_info(sockets) resp.send_str(json.dumps(ACTIONS)) while True: msg = yield from resp.receive() if msg.tp == MsgType.text: move = json.loads(msg.data)+[len(ACTIONS)] ACTIONS.append(move) for ws in sockets: ws.send_str(json.dumps([move])) else: break sockets.remove(resp) update_id_info(sockets) return resp
def test_receive_timeouterror(self): req = self.make_request('GET', '/') ws = WebSocketResponse() self.loop.run_until_complete(ws.prepare(req)) res = helpers.create_future(self.loop) res.set_exception(asyncio.TimeoutError()) ws._reader.read.return_value = res self.assertRaises(asyncio.TimeoutError, self.loop.run_until_complete, ws.receive())
def function2486(function271): var1174 = function271('GET', '/') var4064 = WebSocketResponse() yield from var4064.prepare(var1174) @asyncio.coroutine def function1900(): return WSMessage(WSMsgType.BINARY, b'data', b'') var4064.receive = function1900 with pytest.raises(TypeError): yield from var4064.receive_str()
def test_receive_cancelled(make_request, loop, reader): req = make_request("GET", "/") ws = WebSocketResponse() yield from ws.prepare(req) res = helpers.create_future(loop) res.set_exception(asyncio.CancelledError()) reader.read = make_mocked_coro(res) with pytest.raises(asyncio.CancelledError): yield from ws.receive()
def test_receive_timeouterror(self): req = self.make_request('GET', '/') ws = WebSocketResponse() ws.start(req) res = asyncio.Future(loop=self.loop) res.set_exception(asyncio.TimeoutError()) ws._reader.read.return_value = res self.assertRaises(asyncio.TimeoutError, self.loop.run_until_complete, ws.receive())
def test_receive_cancelled(self): req = self.make_request('GET', '/') ws = WebSocketResponse() self.loop.run_until_complete(ws.prepare(req)) res = asyncio.Future(loop=self.loop) res.set_exception(asyncio.CancelledError()) ws._reader.read.return_value = res self.assertRaises(asyncio.CancelledError, self.loop.run_until_complete, ws.receive())
def test_receive_timeouterror(make_request, loop, reader): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) res = helpers.create_future(loop) res.set_exception(asyncio.TimeoutError()) reader.read = make_mocked_coro(res) with pytest.raises(asyncio.TimeoutError): yield from ws.receive()
def function2630(function271): var2339 = function271('GET', '/') var3483 = WebSocketResponse() yield from var3483.prepare(var2339) @asyncio.coroutine def function1900(): return WSMessage(WSMsgType.TEXT, 'data', b'') var3483.receive = function1900 with pytest.raises(TypeError): yield from var3483.receive_bytes()
async def test_receive_bytes_nonsbytes(make_request): req = make_request('GET', '/') ws = WebSocketResponse() await ws.prepare(req) async def receive(): return WSMessage(WSMsgType.TEXT, 'data', b'') ws.receive = receive with pytest.raises(TypeError): await ws.receive_bytes()
async def test_receive_str_nonstring(make_request) -> None: req = make_request('GET', '/') ws = WebSocketResponse() await ws.prepare(req) async def receive(): return WSMessage(WSMsgType.BINARY, b'data', b'') ws.receive = receive with pytest.raises(TypeError): await ws.receive_str()
def test_receive_cancelled(make_request, loop): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) ws._reader = mock.Mock() res = helpers.create_future(loop) res.set_exception(asyncio.CancelledError()) ws._reader.read = make_mocked_coro(res) with pytest.raises(asyncio.CancelledError): yield from ws.receive()
def test_receive_cancelled(self): req = self.make_request('GET', '/') ws = WebSocketResponse() ws.start(req) res = asyncio.Future(loop=self.loop) res.set_exception(asyncio.CancelledError()) ws._reader.read.return_value = res self.assertRaises( asyncio.CancelledError, self.loop.run_until_complete, ws.receive())
def test_receive_cancelled(self): req = self.make_request('GET', '/') ws = WebSocketResponse() self.loop.run_until_complete(ws.prepare(req)) res = helpers.create_future(self.loop) res.set_exception(asyncio.CancelledError()) ws._reader.read.return_value = res self.assertRaises( asyncio.CancelledError, self.loop.run_until_complete, ws.receive())
def test_receive_bytes_nonsbytes(make_request): req = make_request("GET", "/") ws = WebSocketResponse() yield from ws.prepare(req) @asyncio.coroutine def receive(): return WSMessage(WSMsgType.TEXT, "data", b"") ws.receive = receive with pytest.raises(TypeError): yield from ws.receive_bytes()
def test_receive_str_nonstring(make_request): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) @asyncio.coroutine def receive(): return WSMessage(WSMsgType.BINARY, b'data', b'') ws.receive = receive with pytest.raises(TypeError): yield from ws.receive_str()
def go(): req = self.make_request('GET', '/') ws = WebSocketResponse() ws.start(req) @asyncio.coroutine def receive(): return websocket.Message(websocket.MSG_BINARY, b'data', b'') ws.receive = receive with self.assertRaises(TypeError): yield from ws.receive_str()
def go(): req = self.make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) @asyncio.coroutine def receive(): return websocket.Message(websocket.MSG_TEXT, 'data', b'') ws.receive = receive with self.assertRaises(TypeError): yield from ws.receive_bytes()
def test_receive_bytes_nonsbytes(make_request): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) @asyncio.coroutine def receive(): return WSMessage(WSMsgType.TEXT, 'data', b'') ws.receive = receive with pytest.raises(TypeError): yield from ws.receive_bytes()
def test_receive_bytes_nonsbytes(make_request): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) @asyncio.coroutine def receive(): return websocket.Message(websocket.MSG_TEXT, 'data', b'') ws.receive = receive with pytest.raises(TypeError): yield from ws.receive_bytes()
def go(): req = self.make_request("GET", "/") ws = WebSocketResponse() yield from ws.prepare(req) @asyncio.coroutine def receive(): return websocket.Message(websocket.MSG_BINARY, b"data", b"") ws.receive = receive with self.assertRaises(TypeError): yield from ws.receive_str()
def test_receive_exc_in_reader(make_request, loop, reader): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) exc = ValueError() res = helpers.create_future(loop) res.set_exception(exc) reader.read = make_mocked_coro(res) msg = yield from ws.receive() assert msg.tp == WSMsgType.error assert msg.data is exc assert ws.exception() is exc
def test_receive_exc_in_reader(make_request, loop, reader): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) exc = ValueError() res = helpers.create_future(loop) res.set_exception(exc) reader.read = make_mocked_coro(res) msg = yield from ws.receive() assert msg.tp == MsgType.error assert msg.data is exc assert ws.exception() is exc
def test_receive_client_disconnected(make_request, loop, reader): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) exc = errors.ClientDisconnectedError() res = helpers.create_future(loop) res.set_exception(exc) reader.read = make_mocked_coro(res) msg = yield from ws.receive() assert ws.closed assert msg.tp == WSMsgType.close assert msg.data is None assert ws.exception() is None
def test_receive_client_disconnected(make_request, loop, reader): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) exc = errors.ClientDisconnectedError() res = helpers.create_future(loop) res.set_exception(exc) reader.read = make_mocked_coro(res) msg = yield from ws.receive() assert ws.closed assert msg.tp == MsgType.close assert msg.data is None assert ws.exception() is None
def wsi(request): global wst wst = WebSocketResponse() wst.start(request) while True: msg = yield from wst.receive() if msg.tp == MsgType.text: if msg.data == 'close': yield from wst.close() break elif msg.tp == MsgType.close: break elif msg.tp == MsgType.error: break return wst
def test_receive_exc_in_reader(make_request, loop, reader): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) exc = ValueError() res = helpers.create_future(loop) res.set_exception(exc) reader.read = make_mocked_coro(res) ws._resp_impl.transport.drain.return_value = helpers.create_future(loop) ws._resp_impl.transport.drain.return_value.set_result(True) msg = yield from ws.receive() assert msg.type == WSMsgType.ERROR assert msg.type is msg.tp assert msg.data is exc assert ws.exception() is exc
def socket(request): resp = WebSocketResponse() yield from resp.prepare(request) if 'amqp' not in request.app: transport, protocol = yield from aioamqp.connect() request.app['amqp'] = protocol @asyncio.coroutine def cleanup(app): yield from protocol.close(timeout=1.0) transport.close() request.app.register_on_finish(cleanup) amqp = request.app['amqp'] channel = yield from amqp.channel() yield from channel.exchange_declare(exchange_name='demo-room', type_name='fanout') result = yield from channel.queue_declare('', exclusive=True) yield from channel.queue_bind(result['queue'], 'demo-room', routing_key='') # Consume messages from the queue @asyncio.coroutine def message(channel, body, envelope, properties): if not resp.closed: resp.send_str(body.decode('utf-8')) yield from channel.basic_client_ack(envelope.delivery_tag) yield from channel.basic_consume(message, queue_name=result['queue']) # Broadcast messages to the queue while True: msg = yield from resp.receive() if msg.tp == MsgType.text: yield from channel.publish(msg.data, exchange_name='demo-room', routing_key='') else: break # Client requested close yield from channel.close() return resp
def test_receive_exc_in_reader(make_request, loop): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) ws._reader = mock.Mock() exc = ValueError() res = helpers.create_future(loop) res.set_exception(exc) ws._reader.read = make_mocked_coro(res) ws._payload_writer.drain = mock.Mock() ws._payload_writer.drain.return_value = helpers.create_future(loop) ws._payload_writer.drain.return_value.set_result(True) msg = yield from ws.receive() assert msg.type == WSMsgType.ERROR assert msg.type is msg.tp assert msg.data is exc assert ws.exception() is exc
def wshandler(request): resp = WebSocketResponse() ok, protocol = resp.can_prepare(request) if not ok: return HTTPFound('/index.html') yield from resp.prepare(request) print('Client connected.') request.app['sockets'].append(resp) box.command({"command": "state"}) while True: msg = yield from resp.receive() if msg.tp == MsgType.text: box.command(json.loads(msg.data)) else: break request.app['sockets'].remove(resp) print('Someone disconnected.') return resp
def socket(request): resp = WebSocketResponse() yield from resp.prepare(request) if 'amqp' not in request.app: transport, protocol = yield from aioamqp.connect() request.app['amqp'] = protocol @asyncio.coroutine def cleanup(app): yield from protocol.close(timeout=1.0) transport.close() request.app.register_on_finish(cleanup) amqp = request.app['amqp'] channel = yield from amqp.channel() yield from channel.exchange_declare( exchange_name='demo-room', type_name='fanout') result = yield from channel.queue_declare('', exclusive=True) yield from channel.queue_bind(result['queue'], 'demo-room', routing_key='') # Consume messages from the queue @asyncio.coroutine def message(channel, body, envelope, properties): if not resp.closed: resp.send_str(body.decode('utf-8')) yield from channel.basic_client_ack(envelope.delivery_tag) yield from channel.basic_consume(message, queue_name=result['queue']) # Broadcast messages to the queue while True: msg = yield from resp.receive() if msg.tp == MsgType.text: yield from channel.publish(msg.data, exchange_name='demo-room', routing_key='') else: break # Client requested close yield from channel.close() return resp