async def ws_handler(request):
channel = request.match_info['channel']
ws = WebSocketResponse()
await ws.prepare(request)
print('Someone joined channel : %s.' % channel)
try:
request.app['sockets'][channel].append(ws)
except KeyError:
request.app['sockets'][channel] = []
request.app['sockets'][channel].append(ws)
while not ws.closed:
msg = await ws.receive()
if msg.tp == MsgType.text:
if msg.data == 'close':
await ws.close()
else:
print('The client responded: ' + msg.data)
elif msg.tp == MsgType.close:
print('websocket connection closed')
elif msg.tp == MsgType.error:
print('ws connection closed with exception %s' % ws.exception())
request.app['sockets'][channel].remove(ws)
print('Someone disconnected from channel : %s.' % channel)
return ws
async def controller(self, request: Request):
ws = WebSocketResponse()
await ws.prepare(request)
clients.append(ws)
logger.info("New client connected to the sync service")
async for msg in ws:
if msg.type == WSMsgType.TEXT:
if msg.data == 'close':
await ws.close()
else:
message = json.loads(msg.data)
action = message['action']
diff = message['diff']
if not self._config.dashboard_config_loader.is_loaded:
self._config.dashboard_config_loader.data = default_dashboard_data
dict_merge(diff['added'],
self._config.dashboard_config_loader.data)
dict_merge(diff['updated'],
self._config.dashboard_config_loader.data)
find_removed_node(
diff['deleted'],
self._config.dashboard_config_loader.data)
# TODO: delay with some sec (and add if new trigger)
self._config.save()
dispatch_clients = list(filter(lambda c: c != ws, clients))
if dispatch_clients:
action['time'] = time()
action_msg = json.dumps(action)
logger.debug("Action dispatch to %s clients(s)",
len(dispatch_clients))
for client in dispatch_clients:
await client.send_str(action_msg)
elif msg.type == WSMsgType.ERROR:
logger.error("ws connection closed with exception %s",
ws.exception())
logger.info("websocket connection closed")
clients.remove(ws)
return ws
async def handle_web_socket(self, request):
"""
Handles a new arriving web socket
:param request: request received.
:return:
"""
self.logger.debug('starting handle_web_socket')
ws = WebSocketResponse()
await ws.prepare(request)
session_id = str(uuid.uuid1())
ip_address = self.server_data.ip_address4
if self.server_data.use_ipv6:
ip_address = self.server_data.ip_address6
peername = request.transport.get_extra_info('peername')
host, port = peername
from auction_server.auction_session import AuctionSession
session = AuctionSession(session_id, ip_address,
self.server_data.local_port, host, port,
self.server_data.protocol)
client_connection = ClientConnection(session_id)
client_connection.set_web_socket(ws)
client_connection.set_session(session)
session.set_connection(client_connection)
self.session_manager.add_session(session)
try:
async for msg in ws:
if msg.type == WSMsgType.text:
await self.process_message(session, msg.data)
elif msg.type == WSMsgType.error:
self.logger.debug(
'ws connection closed with exception %s' %
ws.exception())
elif msg.type == WSMsgType.close:
self.logger.debug('ws connection closed')
finally:
if session_id in self.session_manager.get_session_keys():
self.session_manager.del_session(session_id)
self.logger.debug('# active sessions: {0}'.format(
str(len(self.session_manager.session_objects))))
self.logger.debug('websocket connection closed')
return ws
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
async def on_connect(self, request):
web_socket = WebSocketResponse()
await web_socket.prepare(request)
self.app['websockets'].add(web_socket)
try:
async for msg in web_socket:
if msg.type == WSMsgType.TEXT:
await self.on_status(None)
elif msg.type == WSMsgType.ERROR:
print('web socket connection closed with exception %s' %
web_socket.exception())
finally:
self.app['websockets'].discard(web_socket)
return web_socket
def function113(function271):
var2027 = function271('GET', '/')
var2897 = WebSocketResponse()
yield from var2897.prepare(var2027)
var962 = ValueError()
var2897._writer = mock.Mock()
var2897._writer.close.side_effect = var962
yield from var2897.close()
assert var2897.closed
assert (var2897.exception() is var962)
var2897._closed = False
var2897._writer.close.side_effect = asyncio.CancelledError()
with pytest.raises(asyncio.CancelledError):
yield from var2897.close()
async def _receive_msg(self, ws: web.WebSocketResponse):
msg = await ws.receive()
if msg.tp == MsgType.text:
if msg.data == self.stop_msg:
print('Got stop msg')
await ws.close()
else:
await self.process_msg(msg.data)
elif msg.tp == MsgType.close:
print('websocket connection closed')
elif msg.tp == MsgType.error:
print('ws connection closed with exception %s' %
ws.exception())
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
async def log(self, request):
web_socket = WebSocketResponse()
await web_socket.prepare(request)
self.app['websockets'].add(web_socket)
try:
async for msg in web_socket:
if msg.type == WSMsgType.TEXT:
if msg.data == 'close':
await web_socket.close()
elif msg.type == WSMsgType.ERROR:
print('web socket connection closed with exception %s' %
web_socket.exception())
finally:
self.app['websockets'].remove(web_socket)
return web_socket
def test_close_exc2(self):
req = self.make_request("GET", "/")
ws = WebSocketResponse()
self.loop.run_until_complete(ws.prepare(req))
exc = ValueError()
self.writer.close.side_effect = exc
ws._writer = self.writer
self.loop.run_until_complete(ws.close())
self.assertTrue(ws.closed)
self.assertIs(ws.exception(), exc)
ws._closed = False
self.writer.close.side_effect = asyncio.CancelledError()
self.assertRaises(asyncio.CancelledError, self.loop.run_until_complete, ws.close())
async def _websocket_handler(self, request: web.Request):
"""Handle websocket client."""
ws_client = WebSocketResponse()
ws_client.authenticated = False
await ws_client.prepare(request)
request.app["clients"].append(ws_client)
# handle incoming messages
async for msg in ws_client:
try:
if msg.type == WSMsgType.error:
LOGGER.warning("ws connection closed with exception %s",
ws_client.exception())
if msg.type != WSMsgType.text:
continue
if msg.data == "close":
await ws_client.close()
break
# regular message
json_msg = msg.json(loads=ujson.loads)
if "command" in json_msg and "data" in json_msg:
# handle command
await self._handle_command(
ws_client,
json_msg["command"],
json_msg["data"],
json_msg.get("id"),
)
elif "event" in json_msg:
# handle event
await self._handle_event(ws_client, json_msg["event"],
json_msg.get("data"))
except AuthenticationError as exc: # pylint:disable=broad-except
# disconnect client on auth errors
await self._send_json(ws_client, error=str(exc), **json_msg)
await ws_client.close(message=str(exc).encode())
except Exception as exc: # pylint:disable=broad-except
# log the error only
await self._send_json(ws_client, error=str(exc), **json_msg)
LOGGER.error("Error with WS client", exc_info=exc)
# websocket disconnected
request.app["clients"].remove(ws_client)
LOGGER.debug("websocket connection closed: %s", request.remote)
return ws_client
def test_close_exc2(self):
req = self.make_request('GET', '/')
ws = WebSocketResponse()
ws.start(req)
exc = ValueError()
self.writer.close.side_effect = exc
ws._writer = self.writer
self.loop.run_until_complete(ws.close())
self.assertTrue(ws.closed)
self.assertIs(ws.exception(), exc)
ws._closed = False
self.writer.close.side_effect = asyncio.CancelledError()
self.assertRaises(asyncio.CancelledError,
self.loop.run_until_complete, ws.close())
def function2536(function271, arg68):
var3402 = function271('GET', '/')
var3771 = WebSocketResponse()
yield from var3771.prepare(var3402)
var3771._reader = mock.Mock()
var2011 = ValueError()
var1794 = helpers.create_future(arg68)
var1794.set_exception(var2011)
var3771._reader.read = make_mocked_coro(var1794)
var3771._payload_writer.drain = mock.Mock()
var3771._payload_writer.drain.return_value = helpers.create_future(arg68)
var3771._payload_writer.drain.return_value.set_result(True)
var2571 = yield from var3771.function1900()
assert (var2571.type == WSMsgType.ERROR)
assert (var2571.type is var2571.tp)
assert (var2571.data is var2011)
assert (var3771.exception() is var2011)
async def test_close_exc2(make_request):
req = make_request('GET', '/')
ws = WebSocketResponse()
await ws.prepare(req)
exc = ValueError()
ws._writer = mock.Mock()
ws._writer.close.side_effect = exc
await ws.close()
assert ws.closed
assert ws.exception() is exc
ws._closed = False
ws._writer.close.side_effect = asyncio.CancelledError()
with pytest.raises(asyncio.CancelledError):
await ws.close()
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
async def test_close_exc2(make_request):
req = make_request('GET', '/')
ws = WebSocketResponse()
await ws.prepare(req)
exc = ValueError()
ws._writer = mock.Mock()
ws._writer.close.side_effect = exc
await ws.close()
assert ws.closed
assert ws.exception() is exc
ws._closed = False
ws._writer.close.side_effect = asyncio.CancelledError()
with pytest.raises(asyncio.CancelledError):
await ws.close()
async def test_receive_exc_in_reader(make_request, loop):
req = make_request('GET', '/')
ws = WebSocketResponse()
await ws.prepare(req)
ws._reader = mock.Mock()
exc = ValueError()
res = loop.create_future()
res.set_exception(exc)
ws._reader.read = make_mocked_coro(res)
ws._payload_writer.drain = mock.Mock()
ws._payload_writer.drain.return_value = loop.create_future()
ws._payload_writer.drain.return_value.set_result(True)
msg = await ws.receive()
assert msg.type == WSMsgType.ERROR
assert msg.data is exc
assert ws.exception() is exc
async def test_receive_exc_in_reader(make_request, loop):
req = make_request('GET', '/')
ws = WebSocketResponse()
await ws.prepare(req)
ws._reader = mock.Mock()
exc = ValueError()
res = loop.create_future()
res.set_exception(exc)
ws._reader.read = make_mocked_coro(res)
ws._payload_writer.drain = mock.Mock()
ws._payload_writer.drain.return_value = loop.create_future()
ws._payload_writer.drain.return_value.set_result(True)
msg = await ws.receive()
assert msg.type == WSMsgType.ERROR
assert msg.data is exc
assert ws.exception() is exc
def test_close_exc(make_request, reader, loop):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
exc = ValueError()
reader.read.return_value = helpers.create_future(loop)
reader.read.return_value.set_exception(exc)
yield from ws.close()
assert ws.closed
assert ws.exception() is exc
ws._closed = False
reader.read.return_value = helpers.create_future(loop)
reader.read.return_value.set_exception(asyncio.CancelledError())
with pytest.raises(asyncio.CancelledError):
yield from ws.close()
assert ws.close_code == 1006
def test_close_exc(make_request, reader, loop):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
exc = ValueError()
reader.read.return_value = helpers.create_future(loop)
reader.read.return_value.set_exception(exc)
yield from ws.close()
assert ws.closed
assert ws.exception() is exc
ws._closed = False
reader.read.return_value = helpers.create_future(loop)
reader.read.return_value.set_exception(asyncio.CancelledError())
with pytest.raises(asyncio.CancelledError):
yield from ws.close()
assert ws.close_code == 1006
def test_close_exc(self):
req = self.make_request("GET", "/")
reader = self.reader.set_parser.return_value = mock.Mock()
ws = WebSocketResponse()
self.loop.run_until_complete(ws.prepare(req))
exc = ValueError()
reader.read.return_value = asyncio.Future(loop=self.loop)
reader.read.return_value.set_exception(exc)
self.loop.run_until_complete(ws.close())
self.assertTrue(ws.closed)
self.assertIs(ws.exception(), exc)
ws._closed = False
reader.read.return_value = asyncio.Future(loop=self.loop)
reader.read.return_value.set_exception(asyncio.CancelledError())
self.assertRaises(asyncio.CancelledError, self.loop.run_until_complete, ws.close())
self.assertEqual(ws.close_code, 1006)
def function479(function271, arg926, arg363):
var1796 = function271('GET', '/')
var300 = WebSocketResponse()
yield from var300.prepare(var1796)
var300._reader = mock.Mock()
var4357 = ValueError()
var300._reader.read.return_value = helpers.create_future(arg926)
var300._reader.read.return_value.set_exception(var4357)
var300._payload_writer.drain = mock.Mock()
var300._payload_writer.drain.return_value = helpers.create_future(arg926)
var300._payload_writer.drain.return_value.set_result(True)
yield from var300.close()
assert var300.closed
assert (var300.exception() is var4357)
var300._closed = False
var300._reader.read.return_value = helpers.create_future(arg926)
var300._reader.read.return_value.set_exception(asyncio.CancelledError())
with pytest.raises(asyncio.CancelledError):
yield from var300.close()
assert (var300.close_code == 1006)
def test_close_exc(self):
req = self.make_request('GET', '/')
reader = self.reader.set_parser.return_value = mock.Mock()
ws = WebSocketResponse()
ws.start(req)
exc = ValueError()
reader.read.return_value = asyncio.Future(loop=self.loop)
reader.read.return_value.set_exception(exc)
self.loop.run_until_complete(ws.close())
self.assertTrue(ws.closed)
self.assertIs(ws.exception(), exc)
ws._closed = False
reader.read.return_value = asyncio.Future(loop=self.loop)
reader.read.return_value.set_exception(asyncio.CancelledError())
self.assertRaises(asyncio.CancelledError,
self.loop.run_until_complete, ws.close())
self.assertEqual(ws.close_code, 1006)
async def test_close_exc(make_request, loop, mocker):
req = make_request('GET', '/')
ws = WebSocketResponse()
await ws.prepare(req)
ws._reader = mock.Mock()
exc = ValueError()
ws._reader.read.return_value = loop.create_future()
ws._reader.read.return_value.set_exception(exc)
ws._payload_writer.drain = mock.Mock()
ws._payload_writer.drain.return_value = loop.create_future()
ws._payload_writer.drain.return_value.set_result(True)
await ws.close()
assert ws.closed
assert ws.exception() is exc
ws._closed = False
ws._reader.read.return_value = loop.create_future()
ws._reader.read.return_value.set_exception(asyncio.CancelledError())
with pytest.raises(asyncio.CancelledError):
await ws.close()
assert ws.close_code == 1006
async def ws_handler(request):
resp = WebSocketResponse()
ok, protocol = resp.can_start(request)
logger.debug('ok %s, protocol %s', ok, protocol)
if not ok:
raise Exception('Could not start!')
await resp.prepare(request)
logger.debug('Someone joined.')
app = request.app
app['sockets'].append(resp)
async for msg in resp:
if msg.tp == MsgType.text:
try:
m = json.loads(msg.data)
logger.debug('Got msg %s', m)
if m['type'] in MSG_TYPES:
if hasattr(request, 'session'):
await get_tweets(resp, app, request.session, m, request.conn)
else:
logger.info('Unknown client, closing')
break
except Exception as e:
logger.exception('Got error %s', e)
resp.send_str(json.dumps({'type': 'error', 'desc': 'Server error'}))
break
elif msg.tp == MsgType.error:
logger.exception('ws connection closed with exception %s', resp.exception())
await resp.close()
app['sockets'].remove(resp)
logger.debug('Connection is closed %s', resp)
logger.debug('Return Response')
return resp
async def test_close_exc(make_request, loop, mocker):
req = make_request('GET', '/')
ws = WebSocketResponse()
await ws.prepare(req)
ws._reader = mock.Mock()
exc = ValueError()
ws._reader.read.return_value = loop.create_future()
ws._reader.read.return_value.set_exception(exc)
ws._payload_writer.drain = mock.Mock()
ws._payload_writer.drain.return_value = loop.create_future()
ws._payload_writer.drain.return_value.set_result(True)
await ws.close()
assert ws.closed
assert ws.exception() is exc
ws._closed = False
ws._reader.read.return_value = loop.create_future()
ws._reader.read.return_value.set_exception(asyncio.CancelledError())
with pytest.raises(asyncio.CancelledError):
await ws.close()
assert ws.close_code == 1006
async def lobby_socket_handler(request):
users = request.app["users"]
sockets = request.app["lobbysockets"]
seeks = request.app["seeks"]
ws = WebSocketResponse()
ws_ready = ws.can_prepare(request)
if not ws_ready.ok:
raise web.HTTPFound("/")
await ws.prepare(request)
session = await aiohttp_session.get_session(request)
session_user = session.get("user_name")
user = users[
session_user] if session_user is not None and session_user in users else None
lobby_ping_task = None
ping_counter = [0]
async def lobby_pinger(ping_counter):
""" Prevent Heroku to close inactive ws """
while not ws.closed:
if ping_counter[0] > 2:
await ws.close(code=1009)
if ws in user.lobby_sockets:
user.lobby_sockets.remove(ws)
# online user counter will be updated in quit_lobby also!
if len(user.lobby_sockets) == 0:
# log.info("%s went offline (PINGER)" % user.username)
await user.clear_seeks(sockets, seeks)
await user.quit_lobby(sockets, disconnect=True)
break
if user.bot:
await user.event_queue.put("\n")
# heroku needs something at least in 50 sec not to close BOT connections (stream events) on server side
else:
await ws.send_json({
"type": "ping",
"timestamp": "%s" % time()
})
await asyncio.sleep(3)
ping_counter[0] += 1
log.debug("-------------------------- NEW lobby WEBSOCKET by %s" % user)
async for msg in ws:
if msg.type == aiohttp.WSMsgType.TEXT:
if type(msg.data) == str:
if msg.data == "close":
log.debug("Got 'close' msg.")
break
else:
data = json.loads(msg.data)
if not data["type"] == "pong":
log.debug("Websocket (%s) message: %s" % (id(ws), msg))
if data["type"] == "pong":
ping_counter[0] -= 1
elif data["type"] == "get_seeks":
response = get_seeks(seeks)
await ws.send_json(response)
elif data["type"] == "create_ai_challenge":
no = await is_playing(request, user, ws)
if no:
continue
variant = data["variant"]
engine = users.get("Fairy-Stockfish")
if engine is None or not engine.online():
# TODO: message that engine is offline, but capture BOT will play instead
engine = users.get("Random-Mover")
seek = Seek(user,
variant,
fen=data["fen"],
color=data["color"],
base=data["minutes"],
inc=data["increment"],
byoyomi_period=data["byoyomi_period"],
level=data["level"],
rated=data["rated"],
chess960=data["chess960"],
handicap=data["handicap"])
# print("SEEK", user, variant, data["fen"], data["color"], data["minutes"], data["increment"], data["level"], False, data["chess960"])
seeks[seek.id] = seek
response = await new_game(request.app, engine, seek.id)
await ws.send_json(response)
if response["type"] != "error":
gameId = response["gameId"]
engine.game_queues[gameId] = asyncio.Queue()
await engine.event_queue.put(
challenge(seek, response))
elif data["type"] == "create_seek":
no = await is_playing(request, user, ws)
if no:
continue
print("create_seek", data)
create_seek(seeks, user, data, ws)
await lobby_broadcast(sockets, get_seeks(seeks))
if data.get("target"):
queue = users[data["target"]].notify_queue
if queue is not None:
await queue.put(
json.dumps({"notify": "new_challenge"}))
elif data["type"] == "delete_seek":
del seeks[data["seekID"]]
del user.seeks[data["seekID"]]
await lobby_broadcast(sockets, get_seeks(seeks))
elif data["type"] == "accept_seek":
no = await is_playing(request, user, ws)
if no:
continue
if data["seekID"] not in seeks:
continue
seek = seeks[data["seekID"]]
# print("accept_seek", seek.as_json)
response = await new_game(request.app, user,
data["seekID"])
await ws.send_json(response)
if seek.user.bot:
gameId = response["gameId"]
seek.user.game_queues[gameId] = asyncio.Queue()
await seek.user.event_queue.put(
challenge(seek, response))
else:
await seek.ws.send_json(response)
# Inform others, new_game() deleted accepted seek allready.
await lobby_broadcast(sockets, get_seeks(seeks))
elif data["type"] == "lobby_user_connected":
if session_user is not None:
if data["username"] and data[
"username"] != session_user:
log.info(
"+++ Existing lobby_user %s socket connected as %s."
% (session_user, data["username"]))
session_user = data["username"]
if session_user in users:
user = users[session_user]
else:
user = User(
request.app,
username=data["username"],
anon=data["username"].startswith(
"Anon-"))
users[user.username] = user
response = {
"type": "lobbychat",
"user": "",
"message":
"%s joined the lobby" % session_user
}
else:
if session_user in users:
user = users[session_user]
else:
user = User(
request.app,
username=data["username"],
anon=data["username"].startswith(
"Anon-"))
users[user.username] = user
response = {
"type": "lobbychat",
"user": "",
"message":
"%s joined the lobby" % session_user
}
else:
log.info(
"+++ Existing lobby_user %s socket reconnected."
% data["username"])
session_user = data["username"]
if session_user in users:
user = users[session_user]
else:
user = User(
request.app,
username=data["username"],
anon=data["username"].startswith("Anon-"))
users[user.username] = user
response = {
"type": "lobbychat",
"user": "",
"message":
"%s rejoined the lobby" % session_user
}
ping_counter[0] = 0
await lobby_broadcast(sockets, response)
# update websocket
user.lobby_sockets.add(ws)
sockets[user.username] = user.lobby_sockets
response = {
"type": "lobby_user_connected",
"username": user.username
}
await ws.send_json(response)
response = {
"type": "fullchat",
"lines": list(request.app["chat"])
}
await ws.send_json(response)
loop = asyncio.get_event_loop()
lobby_ping_task = loop.create_task(
lobby_pinger(ping_counter))
# send game count
response = {
"type": "g_cnt",
"cnt": request.app["g_cnt"]
}
await ws.send_json(response)
# send user count
if len(user.game_sockets) == 0:
# not connected to any game socket but connected to lobby socket
if len(user.lobby_sockets) == 1:
request.app["u_cnt"] += 1
response = {
"type": "u_cnt",
"cnt": request.app["u_cnt"]
}
await lobby_broadcast(sockets, response)
else:
response = {
"type": "u_cnt",
"cnt": request.app["u_cnt"]
}
await ws.send_json(response)
elif data["type"] == "lobbychat":
response = {
"type": "lobbychat",
"user": user.username,
"message": data["message"]
}
await lobby_broadcast(sockets, response)
request.app["chat"].append(response)
elif data["type"] == "logout":
await ws.close()
elif data["type"] == "disconnect":
# Used only to test socket disconnection...
await ws.close(code=1009)
else:
log.debug("type(msg.data) != str %s" % msg)
elif msg.type == aiohttp.WSMsgType.ERROR:
log.debug("!!! Lobby ws connection closed with exception %s" %
ws.exception())
else:
log.debug("other msg.type %s %s" % (msg.type, msg))
log.info("--- Lobby Websocket %s closed" % id(ws))
if user is not None:
if ws in user.lobby_sockets:
user.lobby_sockets.remove(ws)
# online user counter will be updated in quit_lobby also!
if len(user.lobby_sockets) == 0:
await user.clear_seeks(sockets, seeks)
await user.quit_lobby(sockets, disconnect=False)
if lobby_ping_task is not None:
lobby_ping_task.cancel()
return ws
async def round_socket_handler(request):
users = request.app["users"]
sockets = request.app["lobbysockets"]
seeks = request.app["seeks"]
games = request.app["games"]
db = request.app["db"]
ws = WebSocketResponse()
ws_ready = ws.can_prepare(request)
if not ws_ready.ok:
raise web.HTTPFound("/")
await ws.prepare(request)
session = await aiohttp_session.get_session(request)
session_user = session.get("user_name")
user = users[
session_user] if session_user is not None and session_user in users else None
game_ping_task = None
game = None
opp_ws = None
async def game_pinger():
""" Prevent Heroku to close inactive ws """
# TODO: use this to detect disconnected games?
while not ws.closed:
await ws.send_json({})
await asyncio.sleep(5)
log.debug("-------------------------- NEW round WEBSOCKET by %s" % user)
async for msg in ws:
if msg.type == aiohttp.WSMsgType.TEXT:
if type(msg.data) == str:
if msg.data == "close":
log.debug("Got 'close' msg.")
break
else:
data = json.loads(msg.data)
# log.debug("Websocket (%s) message: %s" % (id(ws), msg))
if data["type"] == "move":
# log.info("Got USER move %s %s %s" % (user.username, data["gameId"], data["move"]))
game = await load_game(request.app, data["gameId"])
move = data["move"]
await play_move(request.app, user, game, move,
data["clocks"], data["ply"])
elif data["type"] == "ready":
game = await load_game(request.app, data["gameId"])
opp_name = game.wplayer.username if user.username == game.bplayer.username else game.bplayer.username
opp_player = users[opp_name]
if opp_player.bot:
# Janggi game start have to wait for human player setup!
if game.variant != "janggi" or not (game.bsetup or
game.wsetup):
await opp_player.event_queue.put(
game.game_start)
response = {
"type": "gameStart",
"gameId": data["gameId"]
}
await ws.send_json(response)
else:
response = {
"type": "gameStart",
"gameId": data["gameId"]
}
await ws.send_json(response)
response = {
"type": "user_present",
"username": user.username
}
await round_broadcast(game,
users,
game.spectator_list,
full=True)
elif data["type"] == "board":
game = await load_game(request.app, data["gameId"])
if game.variant == "janggi":
if (game.bsetup
or game.wsetup) and game.status <= STARTED:
if game.bsetup:
await ws.send_json({
"type":
"setup",
"color":
"black",
"fen":
game.board.initial_fen
})
elif game.wsetup:
await ws.send_json({
"type":
"setup",
"color":
"white",
"fen":
game.board.initial_fen
})
else:
board_response = game.get_board(full=True)
await ws.send_json(board_response)
else:
board_response = game.get_board(full=True)
await ws.send_json(board_response)
elif data["type"] == "setup":
# Janggi game starts with a prelude phase to set up horses and elephants
# First the second player (Red) choses his setup! Then the first player (Blue)
game = await load_game(request.app, data["gameId"])
game.board.initial_fen = data["fen"]
game.initial_fen = game.board.initial_fen
game.board.fen = game.board.initial_fen
# print("--- Got FEN from %s %s" % (data["color"], data["fen"]))
opp_name = game.wplayer.username if user.username == game.bplayer.username else game.bplayer.username
opp_player = users[opp_name]
game.steps[0]["fen"] = data["fen"]
game.set_dests()
if data["color"] == "black":
game.bsetup = False
response = {
"type": "setup",
"color": "white",
"fen": data["fen"]
}
await ws.send_json(response)
if opp_player.bot:
game.board.janggi_setup("w")
game.steps[0]["fen"] = game.board.initial_fen
game.set_dests()
else:
opp_ws = users[opp_name].game_sockets[
data["gameId"]]
await opp_ws.send_json(response)
else:
game.wsetup = False
response = game.get_board(full=True)
# log.info("User %s asked board. Server sent: %s" % (user.username, board_response["fen"]))
await ws.send_json(response)
if not opp_player.bot:
opp_ws = users[opp_name].game_sockets[
data["gameId"]]
await opp_ws.send_json(response)
if opp_player.bot:
await opp_player.event_queue.put(game.game_start)
elif data["type"] == "analysis":
game = await load_game(request.app, data["gameId"])
# If there is any fishnet client, use it.
if len(request.app["workers"]) > 0:
work_id = "".join(
random.choice(string.ascii_letters +
string.digits) for x in range(6))
work = {
"work": {
"type": "analysis",
"id": work_id,
},
# or:
# "work": {
# "type": "move",
# "id": "work_id",
# "level": 5 // 1 to 8
# },
"username": data["username"],
"game_id": data["gameId"], # optional
"position": game.board.
initial_fen, # start position (X-FEN)
"variant": game.variant,
"chess960": game.chess960,
"moves": " ".join(game.board.move_stack
), # moves of the game (UCI)
"nodes": 500000, # optional limit
# "skipPositions": [1, 4, 5] # 0 is the first position
}
request.app["works"][work_id] = work
request.app["fishnet"].put_nowait(
(ANALYSIS, work_id))
else:
engine = users.get("Fairy-Stockfish")
if (engine is not None) and engine.online():
engine.game_queues[
data["gameId"]] = asyncio.Queue()
await engine.event_queue.put(
game.analysis_start(data["username"]))
response = {
"type": "roundchat",
"user": "",
"room": "spectator",
"message": "Analysis request sent..."
}
await ws.send_json(response)
elif data["type"] == "rematch":
game = await load_game(request.app, data["gameId"])
if game is None:
log.debug("Requested game %s not found!")
response = {
"type": "game_not_found",
"username": user.username,
"gameId": data["gameId"]
}
await ws.send_json(response)
continue
opp_name = game.wplayer.username if user.username == game.bplayer.username else game.bplayer.username
opp_player = users[opp_name]
handicap = data["handicap"]
fen = "" if game.variant == "janggi" else game.initial_fen
if opp_player.bot:
if opp_player.username == "Random-Mover":
engine = users.get("Random-Mover")
else:
engine = users.get("Fairy-Stockfish")
if engine is None or not engine.online():
# TODO: message that engine is offline, but capture BOT will play instead
engine = users.get("Random-Mover")
color = "w" if game.wplayer.username == opp_name else "b"
if handicap:
color = "w" if color == "b" else "b"
seek = Seek(user,
game.variant,
fen=fen,
color=color,
base=game.base,
inc=game.inc,
byoyomi_period=game.byoyomi_period,
level=game.level,
rated=game.rated,
chess960=game.chess960)
seeks[seek.id] = seek
response = await new_game(request.app, engine,
seek.id)
await ws.send_json(response)
await engine.event_queue.put(
challenge(seek, response))
gameId = response["gameId"]
engine.game_queues[gameId] = asyncio.Queue()
else:
opp_ws = users[opp_name].game_sockets[
data["gameId"]]
if opp_name in game.rematch_offers:
color = "w" if game.wplayer.username == opp_name else "b"
if handicap:
color = "w" if color == "b" else "b"
seek = Seek(user,
game.variant,
fen=fen,
color=color,
base=game.base,
inc=game.inc,
byoyomi_period=game.byoyomi_period,
level=game.level,
rated=game.rated,
chess960=game.chess960)
seeks[seek.id] = seek
response = await new_game(
request.app, opp_player, seek.id)
await ws.send_json(response)
await opp_ws.send_json(response)
else:
game.rematch_offers.add(user.username)
response = {
"type": "offer",
"message": "Rematch offer sent",
"room": "player",
"user": ""
}
game.messages.append(response)
await ws.send_json(response)
await opp_ws.send_json(response)
elif data["type"] == "draw":
game = await load_game(request.app, data["gameId"])
opp_name = game.wplayer.username if user.username == game.bplayer.username else game.bplayer.username
opp_player = users[opp_name]
response = await draw(games,
data,
agreement=opp_name
in game.draw_offers)
await ws.send_json(response)
if opp_player.bot:
if game.status > STARTED:
await opp_player.game_queues[
data["gameId"]].put(game.game_end)
else:
opp_ws = users[opp_name].game_sockets[
data["gameId"]]
await opp_ws.send_json(response)
if opp_name not in game.draw_offers:
game.draw_offers.add(user.username)
await round_broadcast(game, users, response)
elif data["type"] == "logout":
await ws.close()
elif data["type"] == "byoyomi":
game = await load_game(request.app, data["gameId"])
game.byo_correction += game.inc * 1000
game.byoyomi_periods[0 if data["color"] ==
"white" else 1] = data["period"]
# print("BYOYOMI:", data)
elif data["type"] in ("abort", "resign", "abandone",
"flag"):
game = await load_game(request.app, data["gameId"])
if data["type"] == "abort" and (
game is not None) and game.board.ply > 2:
continue
response = await game.game_ended(user, data["type"])
await ws.send_json(response)
opp_name = game.wplayer.username if user.username == game.bplayer.username else game.bplayer.username
opp_player = users[opp_name]
if opp_player.bot:
await opp_player.game_queues[data["gameId"]
].put(game.game_end)
else:
if data["gameId"] in users[opp_name].game_sockets:
opp_ws = users[opp_name].game_sockets[
data["gameId"]]
await opp_ws.send_json(response)
await round_broadcast(game, users, response)
elif data["type"] == "game_user_connected":
game = await load_game(request.app, data["gameId"])
if session_user is not None:
if data["username"] and data[
"username"] != session_user:
log.info(
"+++ Existing game_user %s socket connected as %s."
% (session_user, data["username"]))
session_user = data["username"]
if session_user in users:
user = users[session_user]
else:
user = User(
request.app,
username=data["username"],
anon=data["username"].startswith(
"Anon-"))
users[user.username] = user
# Update logged in users as spactators
if user.username != game.wplayer.username and user.username != game.bplayer.username and game is not None:
game.spectators.add(user)
else:
if session_user in users:
user = users[session_user]
else:
user = User(
request.app,
username=data["username"],
anon=data["username"].startswith(
"Anon-"))
users[user.username] = user
else:
log.info(
"+++ Existing game_user %s socket reconnected."
% data["username"])
session_user = data["username"]
if session_user in users:
user = users[session_user]
else:
user = User(
request.app,
username=data["username"],
anon=data["username"].startswith("Anon-"))
users[user.username] = user
user.ping_counter = 0
# update websocket
if data["gameId"] in user.game_sockets:
await user.game_sockets[data["gameId"]].close()
user.game_sockets[data["gameId"]] = ws
# remove user seeks
if len(user.lobby_sockets) == 0 or (
game.status <= STARTED and
(user.username == game.wplayer.username
or user.username == game.bplayer.username)):
await user.clear_seeks(sockets, seeks)
if game is None:
log.debug("Requested game %s not found!")
response = {
"type": "game_not_found",
"username": user.username,
"gameId": data["gameId"]
}
await ws.send_json(response)
continue
else:
games[data["gameId"]] = game
if user.username != game.wplayer.username and user.username != game.bplayer.username:
game.spectators.add(user)
await round_broadcast(game,
users,
game.spectator_list,
full=True)
response = {
"type": "game_user_connected",
"username": user.username,
"gameId": data["gameId"],
"ply": game.board.ply
}
await ws.send_json(response)
response = {
"type": "crosstable",
"ct": game.crosstable
}
await ws.send_json(response)
response = {
"type": "fullchat",
"lines": list(game.messages)
}
await ws.send_json(response)
response = {
"type": "user_present",
"username": user.username
}
await round_broadcast(game, users, response, full=True)
loop = asyncio.get_event_loop()
game_ping_task = loop.create_task(game_pinger())
# not connected to lobby socket but connected to game socket
if len(user.game_sockets
) == 1 and user.username not in sockets:
request.app["u_cnt"] += 1
response = {
"type": "u_cnt",
"cnt": request.app["u_cnt"]
}
await lobby_broadcast(sockets, response)
elif data["type"] == "is_user_present":
player_name = data["username"]
player = users.get(player_name)
await asyncio.sleep(1)
if player is not None and data["gameId"] in (
player.game_queues
if player.bot else player.game_sockets):
response = {
"type": "user_present",
"username": player_name
}
else:
response = {
"type": "user_disconnected",
"username": player_name
}
await ws.send_json(response)
elif data["type"] == "moretime":
# TODO: stop and update game stopwatch time with updated secs
game = await load_game(request.app, data["gameId"])
opp_color = WHITE if user.username == game.bplayer.username else BLACK
if opp_color == game.stopwatch.color:
opp_time = game.stopwatch.stop()
game.stopwatch.restart(opp_time + MORE_TIME)
opp_name = game.wplayer.username if user.username == game.bplayer.username else game.bplayer.username
opp_player = users[opp_name]
if not opp_player.bot:
opp_ws = users[opp_name].game_sockets[
data["gameId"]]
response = {
"type": "moretime",
"username": opp_name
}
await opp_ws.send_json(response)
await round_broadcast(game, users, response)
elif data["type"] == "roundchat":
gameId = data["gameId"]
game = await load_game(request.app, gameId)
if data["message"] == "!analysis" and user.username in request.app[
"fishnet_versions"]:
for step in game.steps:
if "analysis" in step:
del step["analysis"]
await ws.send_json({"type": "request_analysis"})
continue
response = {
"type": "roundchat",
"user": user.username,
"message": data["message"],
"room": data["room"]
}
game.messages.append(response)
for name in (game.wplayer.username,
game.bplayer.username):
player = users[name]
if player.bot:
if gameId in player.game_queues:
await player.game_queues[gameId].put(
'{"type": "chatLine", "username": "******", "room": "spectator", "text": "%s"}\n'
% (user.username, data["message"]))
else:
if gameId in player.game_sockets:
player_ws = player.game_sockets[gameId]
await player_ws.send_json(response)
await round_broadcast(game, users, response)
elif data["type"] == "leave":
response = {
"type": "roundchat",
"user": "",
"message": "%s left the game" % user.username,
"room": "player"
}
gameId = data["gameId"]
game = await load_game(request.app, gameId)
game.messages.append(response)
opp_name = game.wplayer.username if user.username == game.bplayer.username else game.bplayer.username
opp_player = users[opp_name]
if not opp_player.bot and gameId in opp_player.game_sockets:
opp_player_ws = opp_player.game_sockets[gameId]
await opp_player_ws.send_json(response)
response = {
"type": "user_disconnected",
"username": user.username
}
await opp_player_ws.send_json(response)
await round_broadcast(game, users, response)
elif data["type"] == "updateTV":
if "profileId" in data and data["profileId"] != "":
gameId = await tv_game_user(
db, users, data["profileId"])
else:
gameId = await tv_game(db, request.app)
if gameId != data["gameId"] and gameId is not None:
response = {"type": "updateTV", "gameId": gameId}
await ws.send_json(response)
elif data["type"] == "count":
game = await load_game(request.app, data["gameId"])
cur_player = game.bplayer if game.board.color == BLACK else game.wplayer
opp_name = game.wplayer.username if user.username == game.bplayer.username else game.bplayer.username
opp_player = users[opp_name]
opp_ws = users[opp_name].game_sockets[data["gameId"]]
if user.username == cur_player.username:
if data["mode"] == "start":
game.start_manual_count()
response = {
"type": "count",
"message":
"Board's honor counting started",
"room": "player",
"user": ""
}
await ws.send_json(response)
await opp_ws.send_json(response)
await round_broadcast(game, users, response)
elif data["mode"] == "stop":
game.stop_manual_count()
response = {
"type": "count",
"message":
"Board's honor counting stopped",
"room": "player",
"user": ""
}
await ws.send_json(response)
await opp_ws.send_json(response)
await round_broadcast(game, users, response)
else:
response = {
"type": "count",
"message":
"You can only start/stop board's honor counting on your own turn!",
"room": "player",
"user": ""
}
await ws.send_json(response)
else:
log.debug("type(msg.data) != str %s" % msg)
elif msg.type == aiohttp.WSMsgType.ERROR:
log.debug("!!! Round ws connection closed with exception %s" %
ws.exception())
else:
log.debug("other msg.type %s %s" % (msg.type, msg))
log.info("--- Round Websocket %s closed" % id(ws))
if game is not None:
response = {"type": "user_disconnected", "username": user.username}
await round_broadcast(game, users, response, full=True)
if game is not None and not user.bot:
if game.id in user.game_sockets:
del user.game_sockets[game.id]
if user.username != game.wplayer.username and user.username != game.bplayer.username:
game.spectators.discard(user)
await round_broadcast(game, users, game.spectator_list, full=True)
# not connected to lobby socket and not connected to game socket
if len(user.game_sockets) == 0 and user.username not in sockets:
request.app["u_cnt"] -= 1
response = {"type": "u_cnt", "cnt": request.app["u_cnt"]}
await lobby_broadcast(sockets, response)
if game_ping_task is not None:
game_ping_task.cancel()
return ws
