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)
