async def get(self):
ws = WebSocketResponse()
await ws.prepare(self.request)
self.request.app['websockets'].append(ws)
db = self.request.app['db']
async for msg in ws:
logger.info("MSG: %s", msg)
if msg.tp == WSMsgType.text:
if msg.data == 'close':
await ws.close()
else:
try:
data = json.loads(msg.data)
except:
pass
else:
logger.info("Got request: %s", data)
result = await process_request(data, db)
ws.send_json(result)
elif msg.tp == WSMsgType.error:
pass
self.request.app['websockets'].remove(ws)
return ws
def test_send_json_closed(self):
req = self.make_request('GET', '/')
ws = WebSocketResponse()
self.loop.run_until_complete(ws.prepare(req))
self.loop.run_until_complete(ws.close())
with self.assertRaises(RuntimeError):
ws.send_json({'type': 'json'})
def test_send_json_closed(make_request):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
yield from ws.close()
with pytest.raises(RuntimeError):
ws.send_json({'type': 'json'})
def test_send_json_closed(make_request):
req = make_request("GET", "/")
ws = WebSocketResponse()
yield from ws.prepare(req)
yield from ws.close()
with pytest.raises(RuntimeError):
ws.send_json({"type": "json"})
def test_send_json_closed(make_request):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
yield from ws.close()
with pytest.raises(RuntimeError):
ws.send_json({'type': 'json'})
def test_send_json_closed(self):
req = self.make_request('GET', '/')
ws = WebSocketResponse()
self.loop.run_until_complete(ws.prepare(req))
self.loop.run_until_complete(ws.close())
with self.assertRaises(RuntimeError):
ws.send_json({'type': 'json'})
def function1203(function271, arg476):
var1953 = function271('GET', '/')
var1605 = WebSocketResponse()
yield from var1605.prepare(var1953)
var1605._reader.feed_data(WS_CLOSED_MESSAGE, 0)
yield from var1605.close()
arg476.spy(ws_logger, 'warning')
var1605.send_json({'type': 'json', })
assert ws_logger.warning.called
def test_send_json_closed(make_request, mocker):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
yield from ws.close()
mocker.spy(ws_logger, 'warning')
ws.send_json({'type': 'json'})
assert ws_logger.warning.called
def test_send_json_closed(make_request, mocker):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
ws._reader.feed_data(WS_CLOSED_MESSAGE, 0)
yield from ws.close()
mocker.spy(ws_logger, 'warning')
ws.send_json({'type': 'json'})
assert ws_logger.warning.called
async def test_send_json_closed(make_request, mocker):
req = make_request('GET', '/')
ws = WebSocketResponse()
await ws.prepare(req)
ws._reader.feed_data(WS_CLOSED_MESSAGE, 0)
await ws.close()
mocker.spy(ws_logger, 'warning')
ws.send_json({'type': 'json'})
assert ws_logger.warning.called
def function2225():
var3068 = WebSocketResponse()
with pytest.raises(RuntimeError):
var3068.send_json({'type': 'json', })
def test_nonstarted_send_json(self):
ws = WebSocketResponse()
with self.assertRaises(RuntimeError):
ws.send_json({'type': 'json'})
def test_nonstarted_send_json():
ws = WebSocketResponse()
with pytest.raises(RuntimeError):
ws.send_json({'type': 'json'})
def test_nonstarted_send_json():
ws = WebSocketResponse()
with pytest.raises(RuntimeError):
ws.send_json({"type": "json"})
def test_send_json_nonjson(make_request):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
with pytest.raises(TypeError):
ws.send_json(set())
class WebsocketConnection:
def __init__(self, server, request):
self.client_id = self._get_request_client_id(request)
self.connection_id = self._get_request_connection_id(self.client_id)
self.server = server
self.request = request
self.socket = None
def _get_request_client_id(self, request):
try:
client_id = request.headers[CLIENT_ID_HEADER]
client_token = request.headers[CLIENT_TOKEN_HEADER]
except KeyError:
raise HTTPBadRequest(reason='Missing Client ID or Token Header')
with create_session() as session:
if client_id == 'None':
client = Client(token=randomstring(32))
before_client_create.emit(session=session, client=client)
session.add(client)
session.flush()
after_client_create.emit(session=session, client=client)
else:
client = session.query(Client).filter(
Client.id == client_id).first()
if not client or client.token != client_token:
raise HTTPForbidden(reason='Invalid Client ID or Token')
return client.id
def _get_request_connection_id(self, client_id):
with create_session() as session:
connection = Connection(client_id=client_id)
before_connection_create.emit(session=session,
connection=connection)
session.add(connection)
session.flush()
after_connection_create.emit(session=session,
connection=connection)
return connection.id
def _save_connection_last_activity(self):
with create_session() as session:
connection = session.query(Connection).filter(
Connection.id == self.connection_id).first()
connection.last_activity = current_timestamp()
before_connection_update.emit(session=session,
connection=connection)
session.flush()
after_connection_update.emit(session=session,
connection=connection)
def _save_connection_closed(self):
with create_session() as session:
connection = session.query(Connection).filter(
Connection.id == self.connection_id).first()
connection.closed = current_timestamp()
before_connection_update.emit(session=session,
connection=connection)
session.flush()
after_connection_update.emit(session=session,
connection=connection)
def _process_confirm(self, action):
try:
print(
'Received confirmation of action "{}" with payload: {}'.format(
action.name, action.payload),
flush=True)
action.after_confirm.emit(connection=self, action=action)
after_client_action_confirm.emit(connection=self, action=action)
except Exception as e:
print('Processing confirmation of action "{}" failed: {}'.format(
action.name, e),
flush=True)
def _process_action(self, action):
try:
print('Received action "{}" with payload: {}'.format(
action.name, action.payload),
flush=True)
before_server_action_receive.emit(connection=self, action=action)
action.before_receive.emit(connection=self, action=action)
action.execute(self)
action.after_receive.emit(connection=self, action=action)
after_server_action_receive.emit(connection=self, action=action)
self.socket.send_json(action.send_confirm())
except Exception as e:
print('Executing action "{}" failed: {}'.format(action.name, e),
flush=True)
def _process_message(self, msg):
if msg.type != WSMsgType.TEXT:
return
try:
action = parse_server_action(msg.data)
except Exception as e:
print('Invalid message received: {}; Error: {}'.format(
msg.data, e),
flush=True)
return
if action.confirm:
self._process_confirm(action)
else:
self._process_action(action)
async def connect(self):
before_server_connection_open.emit(connection=self)
self.socket = WebSocketResponse()
await self.socket.prepare(self.request)
after_server_connection_open.emit(connection=self)
self.send_client_id()
async for msg in self.socket:
self._save_connection_last_activity()
self._process_message(msg)
self._save_connection_closed()
after_server_connection_ended.emit(connection=self)
async def close(self):
before_server_connection_close.emit(connection=self)
await self.socket.close(code=WSCloseCode.GOING_AWAY)
after_server_connection_close.emit(connection=self)
def send_action(self, action):
before_client_action_send.emit(connection=self, action=action)
action.before_send.emit(connection=self, action=action)
self.socket.send_json(action.send())
action.after_send.emit(connection=self, action=action)
after_client_action_send.emit(connection=self, action=action)
async def check_send_action(self, action):
future = asyncio.Future()
sent_action = action
def listener(connection, action):
if connection is not self:
return
if action.name != sent_action.name:
return
if action.action_id != sent_action.action_id:
return
if not future.done():
future.set_result(True)
with after_client_action_confirm.connected(listener):
self.send_action(sent_action)
await asyncio.wait_for(future, ACTION_CONFIRM_TIMEOUT)
def send_client_id(self):
with create_session() as session:
client = session.query(Client).filter(
Client.id == self.client_id).first()
self.send_action(
SetIdClientAction(client_id=client.id,
client_token=client.token))
def test_send_json_nonjson(self):
req = self.make_request('GET', '/')
ws = WebSocketResponse()
self.loop.run_until_complete(ws.prepare(req))
with self.assertRaises(TypeError):
ws.send_json(set())
def test_nonstarted_send_json(self):
ws = WebSocketResponse()
with self.assertRaises(RuntimeError):
ws.send_json({'type': 'json'})
def test_send_json_nonjson(make_request):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
with pytest.raises(TypeError):
ws.send_json(set())
def function1324(function271):
var3572 = function271('GET', '/')
var2977 = WebSocketResponse()
yield from var2977.prepare(var3572)
with pytest.raises(TypeError):
var2977.send_json(set())
def test_nonstarted_send_json():
ws = WebSocketResponse()
with pytest.raises(RuntimeError):
ws.send_json({'type': 'json'})
def test_send_json_nonjson(self):
req = self.make_request('GET', '/')
ws = WebSocketResponse()
self.loop.run_until_complete(ws.prepare(req))
with self.assertRaises(TypeError):
ws.send_json(set())
