async def process_msg_outbound(self, msg_raw, ws_id):
# preliminary validation
msg = MessageProtoHandler.validate_raw_input(msg_raw)
self.state.aquire_lock(ws_id)
pub_topic = random.choice(settings.WORKER_TOPIC)
dikt = self.state[ws_id]
data_out = MessageProtoHandler.pack_input(msg, ws_id, **dikt)
self.logger.debug(
"[%s] publish message [%s] to topic [%s]", ws_id, data_out, pub_topic
)
await self.redis_pub.publish_json(pub_topic, data_out)
async def close_connection(
self, ws_id, code=WSCloseCode.POLICY_VIOLATION, message="replacing_conn"
):
if ws_id in self.websockets:
info = self.websockets.pop(ws_id)
stored_ws = info["ws"]
nym_freed = info["identity_nym"]
room_left = info["room"]
if room_left is not None:
self.rooms[room_left].remove(ws_id)
if len(self.rooms[room_left]) == 0:
self.rooms.pop(room_left)
else:
content = f"[{nym_freed}] has left {room_left}"
announce, _ = MessageProtoHandler.send_message_layout(
content, room_left, from_nym="hendrix"
)
await self.redis_pub.publish_json(
settings.ROUNDTRIP_CHANNEL, announce
)
if nym_freed is not None:
self.logger.info("[%s] freeing a nym", nym_freed)
await self.redis_pub.sadd(
settings.NYMS_KEY, nym_freed.encode(encoding="utf-8")
)
await stored_ws.close(code=code, message=message)
self.logger.info(
"[%s] websocket was removed from websocket store and closed", ws_id
)
else:
self.logger.warn("an attempt to close an already closed conn: [%s]", ws_id)
async def test_handle_history_retrieve():
proto = MessageProtoHandler()
test_room = 'illegally_set_on_client'
test_range = MessageProtoHandler.PAGE
for i in range(test_range):
msg = {
'content': f'control {i} relinquish',
'room': test_room,
'from_nym': 'a unique nym'
}
rslt = await proto.handle_send_message(msg, Mock())
logger.debug(rslt)
last_msg = Room.objects.get(title=test_room).messages_of.count() - 1
hist = {'last_message': last_msg, 'room': test_room}
rslt = await proto.handle_history_retrieve(hist, Mock())
logger.debug(rslt)
resp = rslt[0]
act_msg, _ = resp
results = act_msg['msg']['result']
assert len(results) == test_range
for i in range(test_range):
exp = {
'content': f'control {i} relinquish',
'from_nym': 'a unique nym',
'date_created': ANY,
'seq': (last_msg - (test_range - 1) + i)
}
assert results[i] == exp
def test_seq_mapper():
mapper = MessageProtoHandler().map_sequence
assert mapper([]) == ''
assert mapper(
['authenticate', 'select_room', 'history_retrieve',
'send_message']) == 'ASHM'
assert mapper([
'authenticate', 'select_room', 'select_room', 'send_message',
'history_retrieve'
]) == 'ASSMH'
async def test_handle_send_message():
proto = MessageProtoHandler()
test_room = 'illegally_set_on_client'
start_count = Room.objects.get(title=test_room).messages_of.count()
for i in range(10):
msg = {
'content': f'control {i} relinquish',
'room': test_room,
'from_nym': 'a unique nym'
}
rslt = await proto.handle_send_message(msg, Mock())
logger.debug(rslt)
end_count = Room.objects.get(title=test_room).messages_of.count()
assert (end_count - start_count) == 10
def cock_message(message):
logger.debug('debug [%s]: [%s]', HENDRIX_CHANNEL, message)
if message.from_user.id == tlgrm_secrets.chat_id:
logger.info('[%s]: [%s]', HENDRIX_CHANNEL, message.text)
try:
ws_id = message.text[len('rose') + 1:]
ws_id = ws_id.strip()
text = 'PPP: ' + '<img width=450 height=300 src="https://p0.piqsels.com/preview/57/568/973/animal-avian-beak-bird.jpg">'
except Exception as e:
print(f'excpetion {e} happened')
return
msg, chan = MessageProtoHandler.send_message_layout(
content=text,
room=None,
from_nym=None,
ws_id=ws_id,
channel=HENDRIX_CHANNEL)
msg_json = json.dumps(msg)
r.publish(chan, msg_json)
def rose_message(message):
logger.debug('debug [%s]: [%s]', HENDRIX_CHANNEL, message)
if message.from_user.id == tlgrm_secrets.chat_id:
logger.info('[%s]: [%s]', HENDRIX_CHANNEL, message.text)
try:
ws_id = message.text[len('rose') + 1:]
ws_id = ws_id.strip()
text = 'PPP: ' + '<img width=350 height=300 src="https://upload.wikimedia.org/wikipedia/commons/d/d7/Red_rose_with_black_background.jpg">'
except Exception as e:
print(f'excpetion {e} happened')
return
msg, chan = MessageProtoHandler.send_message_layout(
content=text,
room=None,
from_nym=None,
ws_id=ws_id,
channel=HENDRIX_CHANNEL)
msg_json = json.dumps(msg)
r.publish(chan, msg_json)
async def process_msg_admin(self, chann_name, raw_msg):
self.logger.debug("receieved message on [%s]: [%s]", chann_name, raw_msg)
msg = json.loads(raw_msg)
ws_id = msg.pop("ws_id")
message_content = msg["msg"]["content"]
if message_content.startswith("PPP:"):
message_content = message_content[4:]
if ws_id in self.state:
found_room = self.state.websockets[ws_id]["room"]
payload, _ = MessageProtoHandler.send_message_layout(
message_content,
found_room,
"hendrix",
ws_id=None,
token=msg["msg"]["token"],
)
await self.state.send_message(ws_id, payload)
else:
self.logger.warn("connection [%s] already not present", ws_id)
def forward_messages(message):
logger.debug('debug [%s]: [%s]', HENDRIX_CHANNEL, message)
if message.from_user.id == tlgrm_secrets.chat_id:
logger.info('[%s]: [%s]', HENDRIX_CHANNEL, message.text)
try:
suffix = message.text[len(command) + 1:]
ws_id, text = suffix.split('|')[:2]
ws_id = ws_id.strip()
text = 'PPP: ' + text.strip()
except Exception as e:
print(f'excpetion {e} happened')
return
msg, chan = MessageProtoHandler.send_message_layout(
content=text,
room=None,
from_nym=None,
ws_id=ws_id,
channel=HENDRIX_CHANNEL)
msg_json = json.dumps(msg)
r.publish(chan, msg_json)
async def test_handle_select_room():
proto = MessageProtoHandler()
msg = {
'destination_room': 'illegally_set_on_client',
'from_nym': 'a nym',
'room': 'previous_room'
}
rslt = await proto.handle_select_room(msg, Mock())
logger.debug(rslt)
assert len(rslt) == 3
status, _ = rslt[0]
exp_mes = {
"destination_room": "illegally_set_on_client",
"from_nym": "a nym",
"room": "illegally_set_on_client",
"last_message": ANY,
"prev_room": "previous_room",
"page": MessageProtoHandler.PAGE
}
assert status['msg'] == exp_mes
def test_validate_raw_input_error_keys():
arg = '{"toxicity": 45454}'
with pytest.raises(ValueError, match='not all keys'):
MessageProtoHandler.validate_raw_input(arg)
def test_validate_raw_input_error_not_mapping():
arg = '[5435, 345345 ,345345 ,34535 ,34535]'
with pytest.raises(ValueError, match='has to be a mapping'):
MessageProtoHandler.validate_raw_input(arg)
def test_validate_raw_input_error():
arg = 'invalid_input: failure'
with pytest.raises(ValueError, match='invalid json encoding'):
MessageProtoHandler.validate_raw_input(arg)
def test_seq_mapper_error():
mapper = MessageProtoHandler().map_sequence
with pytest.raises(KeyError, match='invalid_action'):
mapper(['authenticate', 'invalid_action', 'send_message'])