def serialize(topic, engine_data, datatypes):
"""Builds a message by serializing passed data object using
serialization routine defined in one of the data types objects
Args:
topic (xMsgTopic): the topic where data will be published
engine_data (EngineData): the data to be serialized
datatypes (set(<EngineDataType>)): the set of registered dataTypes
Returns:
xMsgMessage: Message with serialized data
"""
assert isinstance(engine_data, EngineData)
for dt in datatypes:
if dt.mimetype == engine_data.mimetype:
msg = xMsgMessage()
msg.topic = str(topic)
msg.metadata = engine_data.metadata
msg.data = dt.serializer.write(engine_data.get_data())
return msg
if engine_data.mimetype == Mimetype.STRING:
msg = xMsgMessage()
msg.topic = str(topic)
msg.metadata = engine_data.metadata
msg.data = EngineDataType.STRING().serializer.write(
engine_data.get_data())
return msg
def _create_request(topic, data, metadata=None):
msg = xMsgMessage(topic=topic)
msg.data = data
if metadata:
msg.metadata = metadata
else:
msg.mimetype = Mimetype.STRING
return msg
def exit_dpe(self, dpe_name):
"""Sends message to DPE and requesting to stop
Args:
dpe_name (String): name of the dpe to stop
"""
if not ClaraUtils.is_dpe_name(dpe_name):
raise MalformedCanonicalName("Malformed DPE name: %s" % dpe_name)
topic = ClaraUtils.build_topic(CConstants.DPE, dpe_name)
self.base.send(xMsgMessage(topic, CConstants.DPE_EXIT))
def runner(bind_to, message_size, message_count):
pub_node_addr = xMsgAddress(bind_to)
publisher = Publisher(bind_to, message_size, message_count)
pub_connection = publisher.get_new_connection(pub_node_addr)
topic = xMsgTopic.wrap("thr_topic")
try:
data = bytes(b'\x00' * message_size)
for _ in range(message_count):
t_msg = xMsgMessage()
t_msg.set_topic(topic)
t_msg.set_data(bytes(data), "data/binary")
publisher.publish(pub_connection, t_msg)
publisher.destroy()
except Exception as e:
print "Removing publisher..."
publisher.destroy()
return
return
def test_set_serialize_data(self):
msg = xMsgMessage(self.topic, bytes([1, 2, 3]))
self.assertEqual("a:b:c", self.message.topic)
self.assertEqual(msg.data, bytes([1, 2, 3]))
self.assertIsInstance(msg, xMsgMessage)
def setUp(self):
self.topic = xMsgTopic.wrap("a:b:c")
self.message = xMsgMessage(self.topic, bytes([1, 2, 3]))
def __create_message(topic, data):
try:
return xMsgMessage(topic, str(data))
except Exception as e:
raise ClaraException("Cannot create message: " + e)