def handle_skill_emit(self, message):
if isinstance(message, str):
message = Message.deserialize(message)
message.context["skill_id"] = self.skill_id
if not message.context.get("source"):
message.context["source"] = self.skill_id
msg = HiveMessage(HiveMessageType.BUS, payload=message)
LOG.debug(f"<<: {message.msg_type}")
self.hive.emit(msg)
def test_serialize_deserialize(self):
"""Assert that a serized message is recreated when deserialized."""
source = Message('test_type',
data={
'robot': 'marvin',
'android': 'data'
},
context={'origin': 'earth'})
msg_string = source.serialize()
reassembled = Message.deserialize(msg_string)
self.assertEqual(source.msg_type, reassembled.msg_type)
self.assertEqual(source.data, reassembled.data)
self.assertEqual(source.context, reassembled.context)
def handle_intent_service_message(self, message):
if isinstance(message, str):
message = Message.deserialize(message)
skill_id = message.context.get("skill_id")
peers = message.context.get("destination") or []
# converse method handling
if message.msg_type in ["skill.converse.request"]:
skill_id = message.data.get("skill_id")
message.context["skill_id"] = skill_id
skill_peer = self.skill2peer(skill_id)
LOG.info(f"Converse: {message.msg_type} "
f"Skill: {skill_id} "
f"Peer: {skill_peer}")
message.context['source'] = "IntentService"
message.context['destination'] = peers
self.send2peer(message, skill_peer)
elif message.msg_type in ["skill.converse.response"]:
# just logging that it was received, converse method handled by
# skill
skill_id = message.data.get("skill_id")
response = message.data.get("result")
message.context["skill_id"] = skill_id
skill_peer = self.skill2peer(skill_id)
LOG.info(f"Converse Response: {response} "
f"Skill: {skill_id} "
f"Peer: {skill_peer}")
message.context['source'] = skill_id
message.context['destination'] = peers
# intent found
elif message.msg_type in self.intent2skill:
skill_id = self.intent2skill[message.msg_type]
skill_peer = self.skill2peer(skill_id)
message.context["skill_id"] = skill_id
LOG.info(f"Intent: {message.msg_type} "
f"Skill: {skill_id} "
f"Source: {peers} "
f"Target: {skill_peer}")
# trigger the skill
message.context['source'] = "IntentService"
LOG.debug(f"Triggering intent: {skill_peer}")
self.send2peer(message, skill_peer)
# skill registering intent
elif message.msg_type in ["register_intent",
"padatious:register_intent"]:
LOG.info(f"Register Intent: {message.data['name']} "
f"Skill: {message.context['skill_id']}")
self.intent2skill[message.data["name"]] = skill_id
def handle_skill_message(self, message):
""" message sent by local/system skill"""
if isinstance(message, str):
message = Message.deserialize(message)
skill_id = message.context.get("skill_id")
intent_skill = self.intent2skill.get(message.msg_type)
permitted = False
# skill intents
if intent_skill:
permitted = True
# skill_id permission override
elif skill_id and skill_id in self.permission_overrides:
if message.msg_type in self.permission_overrides[skill_id]:
permitted = True
# default permissions
elif message.msg_type in self.default_permissions:
permitted = True
if permitted:
peers = message.context.get('destination') or []
if isinstance(peers, str):
peers = [peers]
# check if it should be forwarded to some peer (skill/terminal)
for peer in peers:
if peer in self.clients:
LOG.debug(f"destination: {message.context['destination']} "
f"skill:{skill_id} "
f"type:{message.msg_type}")
self.send2peer(message, peer)
# check if this message should be forwarded to intent service
if message.msg_type in self.intent_messages or \
"IntentService" in peers:
self.intent_service.bus.emit(message)
else:
self.handle_ignored_message(message)
