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')
resp.start(request)
print('Someone joined.')
for ws in request.app['sockets']:
ws.send_str('Someone joined')
request.app['sockets'].append(resp)
try:
while True:
msg = yield from resp.receive_str()
print(msg)
for ws in request.app['sockets']:
if ws is not resp:
ws.send_str(msg)
except WSClientDisconnectedError:
if resp not in request.app['sockets']:
return resp
request.app['sockets'].remove(resp)
print('Someone disconnected.')
for ws in request.app['sockets']:
ws.send_str('Someone disconnected.')
raise
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
async 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')
await resp.prepare(request)
try:
print('Someone joined.')
for ws in request.app['sockets']:
ws.send_str('Someone joined')
request.app['sockets'].append(resp)
async for msg in resp:
if msg.tp == MsgType.text:
for ws in request.app['sockets']:
if ws is not resp:
ws.send_str(msg.data)
else:
return resp
return resp
finally:
request.app['sockets'].remove(resp)
print('Someone disconnected.')
for ws in request.app['sockets']:
ws.send_str('Someone disconnected.')
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')
resp.start(request)
print('Someone joined.')
for ws in request.app['sockets']:
ws.send_str('Someone joined')
request.app['sockets'].append(resp)
try:
while True:
msg = yield from resp.receive_str()
print(msg)
for ws in request.app['sockets']:
if ws is not resp:
ws.send_str(msg)
except WSClientDisconnectedError:
if resp not in request.app['sockets']:
return resp
request.app['sockets'].remove(resp)
print('Someone disconnected.')
for ws in request.app['sockets']:
ws.send_str('Someone disconnected.')
raise
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):
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 create_wsgi_environ(self, message, payload):
environ = super().create_wsgi_environ(message, payload)
environ['wsgi.websocket'] = None
self.method = message.method
self.headers = message.headers
self._writer = self.writer
self._reader = self.reader
self.version = message.version
self.path = environ.get('PATH_INFO', '')
ws = WebSocketResponse()
ok, protocol = ws.can_start(self)
if ok:
ws.start(self)
environ['wsgi.websocket'] = ws
return environ
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
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
def test_can_start_ok(self):
req = self.make_request("GET", "/", protocols=True)
ws = WebSocketResponse(protocols=("chat",))
with self.assertWarns(DeprecationWarning):
self.assertEqual((True, "chat"), ws.can_start(req))
def test_can_start_started(self):
req = self.make_request('GET', '/')
ws = WebSocketResponse()
ws.start(req)
with self.assertRaisesRegex(RuntimeError, 'Already started'):
ws.can_start(req)
def test_can_start_without_upgrade(self):
req = self.make_request('GET', '/',
headers=CIMultiDict({}))
ws = WebSocketResponse()
self.assertEqual((False, None), ws.can_start(req))
def test_can_start_invalid_method(self):
req = self.make_request('POST', '/')
ws = WebSocketResponse()
self.assertEqual((False, None), ws.can_start(req))
def test_can_start_unknown_protocol(self):
req = self.make_request('GET', '/')
ws = WebSocketResponse()
self.assertEqual((True, None), ws.can_start(req))
def test_can_start_ok(self):
req = self.make_request('GET', '/')
ws = WebSocketResponse(protocols=('chat',))
self.assertEqual((True, 'chat'), ws.can_start(req))
def test_can_start_ok(make_request):
req = make_request('GET', '/', protocols=True)
ws = WebSocketResponse(protocols=('chat',))
with pytest.warns(DeprecationWarning):
assert (True, 'chat') == ws.can_start(req)
def test_can_start_ok(make_request):
req = make_request('GET', '/', protocols=True)
ws = WebSocketResponse(protocols=('chat',))
with pytest.warns(DeprecationWarning):
assert (True, 'chat') == ws.can_start(req)
async def wshandler(request):
pool = request.app['db_pool']
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')
await 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 = await resp.receive()
try:
data = json.loads(msg.data)
except:
data = ''
def broadcast(message):
message = json.dumps(message)
for ws in request.app['sockets']:
if ws is not resp:
ws.send_str(msg.data)
def reply(message):
message = json.dumps(message)
resp.send_str(message)
if msg.tp == MsgType.text:
if isinstance(data, dict) and data.get('type'):
if data['type'] == 'message':
print(resp.user)
await db.create_message(pool, data, resp.user['id'] )
response = {'type': 'message', 'status': None}
user_to_id = data.get('to')
if user_to_id:
for ws in request.app['sockets']:
user = getattr(ws, 'user')
if user['id'] == user_to_id:
response['status'] = 'online'
reply(response)
data['from'] = resp.user['id']
reply(data)
broadcast(data)
elif data['type'] == 'login':
res = {'type': 'login', 'logined': False}
print(data)
user = await db.check_password(pool, data)
print(user)
if user:
res['logined'] = True
del user['password']
resp.user = user
reply(res)
elif data['type'] == 'register':
user = await db.create_user(pool, data)
res = {'type': 'register', 'logined': False}
if user:
res['logined'] = True
user.update(data)
del user['password']
resp.user = user
reply(res)
else:
reply({'error': 'Message type is incorect'})
else:
reply({'error': 'Cannot parse request message'})
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_can_start_ok(make_request):
req = make_request("GET", "/", protocols=True)
ws = WebSocketResponse(protocols=("chat",))
with pytest.warns(DeprecationWarning):
assert (True, "chat") == ws.can_start(req)
def test_can_start_ok(self):
req = self.make_request('GET', '/')
ws = WebSocketResponse(protocols=('chat',))
with self.assertWarns(DeprecationWarning):
self.assertEqual((True, 'chat'), ws.can_start(req))
def test_can_start_ok(self):
req = self.make_request('GET', '/', protocols=True)
ws = WebSocketResponse(protocols=('chat', ))
with self.assertWarns(DeprecationWarning):
self.assertEqual((True, 'chat'), ws.can_start(req))
