async def unpack(wallet_handle, message_bytes): try: unpacked = json.loads(await crypto.unpack_message(wallet_handle, message_bytes)) from_key = None from_did = None if 'sender_verkey' in unpacked: from_key = unpacked['sender_verkey'] from_did = await did_for_key(wallet_handle, unpacked['sender_verkey']) to_key = unpacked['recipient_verkey'] to_did = await did_for_key(wallet_handle, unpacked['recipient_verkey']) msg = Message.deserialize(unpacked['message']) msg.context = { 'from_did': from_did, 'to_did': to_did, 'from_key': from_key, 'to_key': to_key } return msg except error.IndyError as indy_error: if indy_error.error_code is error.ErrorCode.CommonInvalidStructure: msg = Message.deserialize(message_bytes) msg.context = None return msg raise indy_error
async def test_http_return_route_no_endpoint(connected_client_server_agents): (alice, alice_did, alice_vk, bob, bob_did, bob_vk) = connected_client_server_agents alice.ponged = asyncio.Event() @bob.route('ping') async def respond(agent, msg): print('got ping, sending pong should queue message') pong = Message({'@type': 'pong'}) await agent.conductor.send(pong, msg.context['from_key'], to_did=msg.context['from_did'], from_key=msg.context['to_key']) print('sent pong to queue, probably') print('queue up a noop') await agent.conductor.send(Message({'@type': 'noop'}), msg.context['from_key'], to_did=msg.context['from_did'], from_key=msg.context['to_key']) assert agent.conductor.queues[msg.context['from_key']].qsize() == 2 @alice.route('noop') @bob.route('noop') async def noop(agent, msg): print('noop') pass @alice.route('pong') async def got_pong(agent, msg): print('got pong') agent.ponged.set() gathered_agent_tasks = asyncio.gather(alice.start(), bob.start()) # No return route, can't respond directly ping = Message({'@type': 'ping'}) await alice.conductor.send(ping, bob_vk, to_did=bob_did, from_key=alice_vk) print('sending noop to pump bob\'s queue') noop = Message({'@type': 'noop', '~transport': {'return_route': 'all'}}) await alice.conductor.send(noop, bob_vk, to_did=bob_did, from_key=alice_vk) await asyncio.wait_for(alice.ponged.wait(), 5) await alice.shutdown() await bob.shutdown() gathered_agent_tasks.cancel() with suppress(asyncio.CancelledError): await gathered_agent_tasks assert alice.ponged.is_set()
def load_level(self, level: str): player : Entity = Player(self.message_bus, Vector2(5, 5)) self.message_bus.post_message(Message("ADD_ENTITY", player)) self.message_bus.post_message(Message("ADD_CAMERA", player.get_component(MainCamera))) level_name = level + ".json" to_load_level = Path.cwd() / "levels" / "level_information" / level_name try: level_contents_text = open(to_load_level).read() except: log.error(f'Could not load level: {to_load_level}')
async def test_module_routing_many(): """ Test that routing to a module works. """ agent = Agent() agent.called_module = None routed_event = asyncio.Event() @module class TestModule1(): DOC_URI = '' PROTOCOL = 'test_protocol' VERSION = '1.0' async def testing_type(self, agent, msg, *args, **kwargs): agent.called_module = 1 kwargs['event'].set() @module class TestModule2(): DOC_URI = '' PROTOCOL = 'test_protocol' VERSION = '2.0' async def testing_type(self, agent, msg, *args, **kwargs): agent.called_module = 2 kwargs['event'].set() agent.route_module(TestModule1()) agent.route_module(TestModule2()) test_msg = Message({ '@type': 'test_protocol/1.0/testing_type', 'test': 'test' }) await agent.handle(test_msg, event=routed_event) await routed_event.wait() assert routed_event.is_set() assert agent.called_module == 1 routed_event.clear() test_msg = Message({ '@type': 'test_protocol/2.0/testing_type', 'test': 'test' }) await agent.handle(test_msg, event=routed_event) await routed_event.wait() assert routed_event.is_set() assert agent.called_module == 2
async def respond(agent, msg): print('got ping, sending pong should queue message') pong = Message({'@type': 'pong'}) await agent.conductor.send(pong, msg.context['from_key'], to_did=msg.context['from_did'], from_key=msg.context['to_key']) print('sent pong to queue, probably') print('queue up a noop') await agent.conductor.send(Message({'@type': 'noop'}), msg.context['from_key'], to_did=msg.context['from_did'], from_key=msg.context['to_key']) assert agent.conductor.queues[msg.context['from_key']].qsize() == 2
async def respond(agent, msg): logger.info('got ping, sending pong should queue message') pong = Message({'@type': pong_type}) await agent.send(pong, msg.context['from_key'], to_did=msg.context['from_did'], from_key=msg.context['to_key']) logger.info('sent pong to queue, probably') logger.info('queue up a noop') await agent.send(Message({'@type': Noop.TYPE}), msg.context['from_key'], to_did=msg.context['from_did'], from_key=msg.context['to_key']) assert agent.conductor.pending_queues[ msg.context['from_key']].qsize() == 2
async def respond(agent, msg): logger.info('got ping') pong = Message({'@type': pong_type}) await agent.send(pong, msg.context['from_key'], to_did=msg.context['from_did'], from_key=msg.context['to_key'])
def receive_file(self, filename: str, rng: Tuple[int, int], owner: tuple): # telling the nodes we NEED a file, therefore idx=-1 and data=None. msg = FileCommunication(self.name, owner[0], filename, rng) temp_s = create_socket(give_port()) self.send_datagram(temp_s, msg, owner[1]) print(f"Node {self.name} has sent the start-of-transfer message to " f"{owner[0]}.") while True: data, addr = temp_s.recvfrom(BUFFER_SIZE) dg: UDPDatagram = crypto_unit.decrypt(data) msg = Message.decode(dg.data) # msg now contains the actual bytes of the data for that file. # TODO some validation if msg["filename"] != filename: print(f"Wanted {filename} but received {msg['range']} range " f"of {msg['filename']}") return if msg["idx"] == -1: print(f"Node {self.name} received the end-of-transfer message " f"from {owner[0]}.") free_socket(temp_s) return self.received_files[filename].append(msg)
async def test_http_return_route(ping_pong_agents, message): (alice, alice_did, alice_vk, bob, bob_did, bob_vk) = ping_pong_agents ping = Message(message) await alice.conductor.send(ping, bob_vk, to_did=bob_did, from_key=alice_vk) await asyncio.wait_for(alice.ponged.wait(), 20) assert alice.ponged.is_set()
async def respond(agent, msg): print('got ping') pong = Message({'@type': 'pong'}) await agent.conductor.send(pong, msg.context['from_key'], to_did=msg.context['from_did'], from_key=msg.context['to_key'])
async def test_module_routing_explicit_def(): """ Test that routing to a module works. """ from module import route_def agent = Agent() called_event = asyncio.Event() @module class TestModule(): DOC_URI = '' PROTOCOL = 'test_protocol' VERSION = '1.0' routes = {} @route_def(routes, 'test_protocol/1.0/testing_type') async def route_gets_called(self, agent, msg, **kwargs): kwargs['event'].set() mod = TestModule() agent.route_module(mod) test_msg = Message({ '@type': 'test_protocol/1.0/testing_type', 'test': 'test' }) await agent.handle(test_msg, event=called_event) assert called_event.is_set()
def handle_node(self, data, addr): dg = crypto_unit.decrypt(data) message = Message.decode(dg.data) message_mode = message['mode'] if message_mode == modes.HAVE: self.add_uploader(message, addr) elif message_mode == modes.NEED: self.search_file(message, addr) elif message_mode == modes.EXIT: self.exit_uploader(message, addr)
async def test_http_return_route_no_endpoint(connected_client_server_agents): (alice, alice_did, alice_vk, bob, bob_did, bob_vk) = connected_client_server_agents alice.ponged = asyncio.Event() @bob.route(ping_type) async def respond(agent, msg): logger.info('got ping, sending pong should queue message') pong = Message({'@type': pong_type}) await agent.send(pong, msg.context['from_key'], to_did=msg.context['from_did'], from_key=msg.context['to_key']) logger.info('sent pong to queue, probably') logger.info('queue up a noop') await agent.send(Message({'@type': Noop.TYPE}), msg.context['from_key'], to_did=msg.context['from_did'], from_key=msg.context['to_key']) assert agent.conductor.pending_queues[ msg.context['from_key']].qsize() == 2 @alice.route(Noop.TYPE) @bob.route(Noop.TYPE) async def noop(agent, msg): logger.info(Noop.TYPE) pass @alice.route(pong_type) async def got_pong(agent, msg): logger.info('got pong') agent.ponged.set() gathered_agent_tasks = asyncio.gather(alice.start(), bob.start()) # No return route, can't respond directly ping = Message({'@type': ping_type}) await alice.send(ping, bob_vk, to_did=bob_did, from_key=alice_vk) logger.info('sending noop to pump bob\'s queue') noop = Noop(return_route=True) await alice.send(noop, bob_vk, to_did=bob_did, from_key=alice_vk) await asyncio.wait_for(alice.ponged.wait(), 5) logger.info('alice shutdown') await alice.shutdown() logger.info('bob shutdown') await bob.shutdown() gathered_agent_tasks.cancel() with suppress(asyncio.CancelledError): await gathered_agent_tasks assert alice.ponged.is_set()
def save_message(self, message_body: dict, result: EventResult, started: datetime, finished: datetime): try: message = Message( msg_id=message_body.get('message_id'), env=self.env_name, source=self.SOURCE_SYSTEM, object_id=result.related_object, display_context=result.display_context, level=message_body.get('priority'), msg=message_body, ts=message_body.get('timestamp'), received_ts=started, finished_ts=finished ) self.inv.collections['messages'].insert_one(message.get()) return True except Exception as e: self.inv.log.error("Failed to save message") self.inv.log.exception(e) return False
def search(self, filename: str) -> dict: message = NodeToTracker(self.name, modes.NEED, filename) temp_s = create_socket(give_port()) self.send_datagram(temp_s, message, TRACKER_ADDR) while True: data, addr = temp_s.recvfrom(BUFFER_SIZE) dg: UDPDatagram = crypto_unit.decrypt(data) if dg.src_port != TRACKER_ADDR[1]: raise ValueError(f"Someone other than the tracker with " f"port:{dg.src_port} sent {self.name} " f"the search datagram.") return Message.decode(dg.data)
def start_listening(self): while True: data, addr = self.rec_s.recvfrom(BUFFER_SIZE) dg: UDPDatagram = crypto_unit.decrypt(data) msg = Message.decode(dg.data) if "size" in msg.keys() and msg["size"] == -1: # meaning someone needs the file size self.tell_file_size(dg, msg) elif "range" in msg.keys() and msg["data"] is None: print(f"Node {self.name} received the start-of-transfer " f"message from Node {msg['src_name']}.") self.send_file(msg["filename"], msg["range"], msg["src_name"], dg.src_port)
def ask_file_size(self, filename: str, owner: tuple) -> int: # size == -1 means asking the size message = SizeInformation(self.name, owner[0], filename) temp_s = create_socket(give_port()) self.send_datagram(temp_s, message, owner[1]) while True: data, addr = temp_s.recvfrom(BUFFER_SIZE) dg: UDPDatagram = crypto_unit.decrypt(data) # TODO some validation free_socket(temp_s) return Message.decode(dg.data)["size"]
def keep_message(self, doc, check_result, error_level=None): is_link = 'link_type' in doc msg_id = check_result['id'] obj_id = 'link_{}_{}'.format(doc['source_id'], doc['target_id']) \ if is_link \ else doc['id'] obj_type = 'link_{}'.format( doc['link_type']) if is_link else doc['type'] display_context = obj_id if is_link \ else doc['network_id'] if doc['type'] == 'port' else doc['id'] level = error_level if error_level\ else ERROR_LEVEL[check_result['status']] dt = datetime.datetime.utcfromtimestamp(check_result['executed']) message = Message(msg_id=msg_id, env=self.env, source=SOURCE_SYSTEM, object_id=obj_id, object_type=obj_type, display_context=display_context, level=level, msg=check_result, ts=dt) collection = self.inv.collections['messages'] collection.insert_one(message.get())
def start(self): pygame.init() self.level_manager = LevelManager(self.message_bus) self.event_manager = EventManager(self.message_bus) self.entity_manager = EntityManager(self.message_bus) self.screen_manager = ScreenManager(self.message_bus) self.debug_manager = DebugManager(self.message_bus) self.message_bus.subscribe(self) self.message_bus.subscribe(self.level_manager) self.message_bus.subscribe(self.event_manager) self.message_bus.subscribe(self.entity_manager) self.message_bus.subscribe(self.screen_manager) self.message_bus.subscribe(self.debug_manager) self.message_bus.post_message(Message("LOAD_LEVEL", "level_one")) self.clock = pygame.time.Clock() self.fps = 60 self.running = True self.update()
async def test_module_routing_no_matching_version(): """ Test that routing to a module works. """ agent = Agent() called_event = asyncio.Event() @module class TestModule(): DOC_URI = '' PROTOCOL = 'test_protocol' VERSION = '1.0' async def testing_type(self, agent, msg, *args, **kwargs): kwargs['event'].set() mod = TestModule() agent.route_module(mod) test_msg = Message({ '@type': 'test_protocol/3.0/testing_type', 'test': 'test' }) with pytest.raises(NoRegisteredRouteException): await agent.handle(test_msg, event=called_event)
async def test_module_routing_simple(): """ Test that routing to a module works. """ agent = Agent() called_event = asyncio.Event() @module class TestModule(): DOC_URI = '' PROTOCOL = 'test_protocol' VERSION = '1.0' async def testing_type(self, agent, msg, *args, **kwargs): kwargs['event'].set() mod = TestModule() agent.route_module(mod) test_msg = Message({ '@type': 'test_protocol/1.0/testing_type', 'test': 'test' }) await agent.handle(test_msg, event=called_event) assert called_event.is_set()
def emit(self, record): # Try to invoke InventoryMgr for logging if not self.inv: try: self.inv = InventoryMgr() except: return # make sure we do not try to log to DB when DB is not ready if not (self.inv.is_db_ready() and 'messages' in self.inv.collections): return # make ID from current timestamp now = datetime.datetime.utcnow() d = now - datetime.datetime(1970, 1, 1) timestamp_id = '{}.{}.{}'.format(d.days, d.seconds, d.microseconds) source = self.SOURCE_SYSTEM message = Message(msg_id=timestamp_id, env=self.env, source=source, msg=Logger.formatter.format(record), ts=now, level=record.levelname) if self.origin: message.extra['origin_id'] = ( str(self.origin.origin_id) if self.origin.origin_id else None ) message.extra['origin_type'] = ( self.origin.origin_type.value if self.origin.origin_type else None ) for extra_field in self.origin.extra: message.extra[extra_field] = getattr(self.origin, extra_field) self.inv.collections['messages'].insert_one(message.get())
def update(self, dt: float): self.rect.x = self.entity_transform.x self.rect.y = self.entity_transform.y self.message_bus.post_message(Message("DRAW_ENTITY", self))
""" @Author: Eduardo Rodríguez Sánchez GLaDOS Voice """ from tts import voice from status import gen_info from messages.message import Message message1 = Message("NONE", gen_info.moods) print(message1.answers) # text = voice.listen() # voice.talk(text)
def build_message(self, text='', action=None, parameters=None): message = Message(text) message.action = action or self.action message.parameters = parameters return message
def update(self, dt: float, time: float): self.message_bus.post_message(Message("DRAW_TEXT", self.draw_fps(time)))
def update(self, dt: float): for event in pygame.event.get(): if event.type == KEYDOWN: if event.key == K_ESCAPE: self.message_bus.post_message(Message("KB_PRESS_ESC")) if event.key == K_UP: self.message_bus.post_message(Message("KB_PRESS_UP")) if event.key == K_DOWN: self.message_bus.post_message(Message("KB_PRESS_DOWN")) if event.key == K_LEFT: self.message_bus.post_message(Message("KB_PRESS_LEFT")) if event.key == K_RIGHT: self.message_bus.post_message(Message("KB_PRESS_RIGHT")) if event.type == KEYUP: if event.key == K_ESCAPE: self.message_bus.post_message(Message("KB_RELEASE_ESC")) if event.key == K_UP: self.message_bus.post_message(Message("KB_RELEASE_UP")) if event.key == K_DOWN: self.message_bus.post_message(Message("KB_RELEASE_DOWN")) if event.key == K_LEFT: self.message_bus.post_message(Message("KB_RELEASE_LEFT")) if event.key == K_RIGHT: self.message_bus.post_message(Message("KB_RELEASE_RIGHT")) elif event.type == QUIT: self.message_bus.post_message(Message("QuitGame"))
def __init__(self, text, original): Message.__init__(self, text, channel=TWITTER) self.original = original self.username = self.original.user.screen_name self.reply_id = self.original.id
async def pump_remote_queue(self, to_key, to_did, from_key): #TODO define noop somewhere else noop = Message({'@type': 'noop', '~transport': {'return_route': 'all'}}) await self.send(noop, to_key, to_did=to_did, from_key=from_key)
def write_message(self, sender, receiver, message, subject, creation_date, receiver_user): message = Message(sender, receiver, message, subject, creation_date) receiver_user.get_messages().add_message(message)