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