def transmit(*args, **kwargs): element = kwargs.get('element') print str(element) e2 = parse_message(element.build_string()) print [element.build_string()] print str(e2) root.dispatch_message(data=element.build_string())
def send(self, msg_type, data: dict): message_type = message_type_table[msg_type] message = message_type(data) res = message.pack() # for name, type_ in definition.items(): # res.extend(pack_field(data.get(name, None), type_)) length = len(res) if length % 16 != 8: pad_length = (8 - length % 16) if pad_length < 0: pad_length += 16 res += b"\x00" * pad_length res = pack("<II", length, msg_type) + res data = self.encryptor.encrypt(res) logging.debug("SEND >>> %s" % res) parse_message(res, None, 1) self.s.sendall(data)
def recv_message(self): length = self._connection_sock.recv(MESSAGE_LENGTH_SIZE) length = struct.unpack("!I", length)[0] received_buff = b"" while len(received_buff) < length: temp_buff = self._connection_sock.recv(RECV_SIZE) received_buff += temp_buff return parse_message(received_buff)
async def handle_conn(self, reader, writer): while True: data = await reader.readline() data = data.decode() msg = messages.parse_message(data) if msg: if msg._type == 'event': await self.send_event(msg) elif msg._type in ['dispatch', 'request', 'reply']: await self.send_message(msg)
def worker(self): data = bytearray() while True: data.extend(self.s.recv(65535)) if len(data) % 16 == 0: msg = self.decryptor.decrypt(bytes(data)) else: continue data = bytearray() self.stream.write(msg) if len(msg) == 0: break logging.debug("RECV <<< %s" % msg) while self.stream.count(): size = unpack("<I", self.stream.peek(4))[0] expect = size + 8 + (16 - (size + 8) % 16) % 16 logging.debug("expect %s have %s" % (expect, self.stream.count())) if expect <= self.stream.count(): parse_message(self.stream.read(expect), self, 2) else: break
def dispatch_message(self, **kwargs): if self.receive_interrupt_enabled: return if not self.is_root_node: self.get_root_node().dispatch_message(**kwargs) return element = kwargs.get('element') data = kwargs.get('data') client = kwargs.get('client') timestamp = kwargs.get('timestamp') if data: element = parse_message(data, client=client, timestamp=timestamp) if self.debug: self.LOG.info('osc recv: ' + str(element)) self.dispatch_thread.add_element(element)
async def run(self): while(True): try: print(f"trying to connect to external context {self.name}") self.reader, self.writer = await asyncio.open_connection(self.host, self.port) while(True): data = await self.reader.readline() data = data.decode() msg = messages.parse_message(data) if msg: print('received ', str(msg)) if msg._type == 'reply': for ctx in pyqak.contexts: if msg._to in ctx.actors: await ctx.send_message(msg) self.writer.close() await self.writer.wait_closed() except Exception as e: print(f"connection attempt failed to {self.name}. retrying in 1 second...") await asyncio.sleep(1)
def parse_message(self, **kwargs): data = kwargs.get('data') client = kwargs.get('client') msg = messages.parse_message(data) if not msg: return #print msg.__class__.__name__, [[f.id, f.value] for f in msg.Fields.indexed_items.values()] if msg.msg_type == 'ArtPoll': self.artnet_io.send(self.artpoll_reply.build_string()) elif msg.msg_type == 'ArtPollReply':# and msg.Fields['MAC'].value != self.mac_addr: self.add_node(artpoll_reply=msg) elif msg.msg_type == 'ArtDmx': #print 'ArtDmx from :', client u = msg.Fields['Universe'].value subuniv = (u / 0x10, u % 0x10) u = self.Universes.get(subuniv) if u is None: return u.merge_dmx_msg(msg=msg, client=client) #print 'artnet gc: ', gc.collect(0) self.collect_garbage()
else: raise ConnectionError( "Could not connect to the Slack API! Check your connection and/or tokens." ) apicall = client.api_call("channels.list") channels = [] if apicall.get("ok"): all_channels = apicall.get('channels') for chan in all_channels: if 'id' in chan.keys(): channels.append(chan['id']) else: raise ConnectionError( "Could not connect to the Slack API! Check your connection and/or tokens." ) # Useful constants AT_BOT = "<@" + BOT_ID + ">" READ_WEBSOCKET_DELAY = 1 if client.rtm_connect(): while True: message, channel = parse_message(client, channels, AT_BOT) if message is not None and channel is not None: respond(client, channel, status(message)) time.sleep(READ_WEBSOCKET_DELAY) else: raise ConnectionError( "Could not connect to the Slakc API! Check your connection and/or tokens." )
def test_parse_message_command_data(): raw_message = struct.pack("B", 4) + "asdfasdf".encode() parsed = parse_message(raw_message) assert isinstance(parsed, CommandDataMessage)
def test_parse_message_start_command(): raw_message = struct.pack("!BBBBBB", 3, 1, 2, 3, 4, 5) parsed = parse_message(raw_message) assert isinstance(parsed, StartCommandMessage)
def test_parse_message_error(): with pytest.raises(ErrorMessageReceived): raw_message = struct.pack("B", 2) + "asdfasdf".encode() parse_message(raw_message)
def test_parse_message_session_start(): raw_message = struct.pack("B", 1) + "asdfasdf".encode() parsed = parse_message(raw_message) assert isinstance(parsed, SessionStartMessage)