def testRoundtrip(self):
goodScope = Scope("/good")
inconnector = self._getInPushConnector(goodScope)
outconnector = self._getOutConnector(goodScope)
receiver = SettingReceiver(goodScope)
inconnector.setObserverAction(receiver)
# first an event that we do not want
event = Event(EventId(uuid.uuid4(), 0))
event.scope = Scope("/notGood")
event.data = "dummy data"
event.type = str
event.metaData.senderId = uuid.uuid4()
outconnector.handle(event)
# and then a desired event
event.scope = goodScope
outconnector.handle(event)
with receiver.resultCondition:
while receiver.resultEvent is None:
receiver.resultCondition.wait(10)
self.assertTrue(receiver.resultEvent)
# ignore meta data here
event.setMetaData(None)
receiver.resultEvent.setMetaData(None)
self.assertEqual(receiver.resultEvent, event)
inconnector.deactivate()
outconnector.deactivate()
def testPullRoundtrip(self):
goodScope = Scope("/good")
try:
inconnector = self._getInPullConnector(goodScope)
except NotImplementedError:
return
outconnector = self._getOutConnector(goodScope)
# first an event that we do not want
event = Event(EventId(uuid.uuid4(), 0))
event.scope = Scope("/notGood")
event.data = "dummy data"
event.type = str
event.metaData.senderId = uuid.uuid4()
outconnector.handle(event)
# and then a desired event
event.scope = goodScope
outconnector.handle(event)
received = inconnector.raiseEvent(True)
# ignore meta data here
event.setMetaData(None)
received.setMetaData(None)
self.assertEqual(received, event)
inconnector.deactivate()
outconnector.deactivate()
def publish_cache(self):
self.__logger.debug("[{}] Publishing cache... ({} total)".format(
self.__authority,
len(self.__send_cache_dynamic.keys()) +
len(self.__send_cache_static.keys())))
for _, v in self.__send_cache_dynamic.iteritems():
event = Event()
event.setData(v[0])
event.setType(type(v[0]))
event.setScope(self.__rsb_informer_transform.getScope().concat(
Scope(self.__scope_suffix_dynamic)))
event.setMetaData(v[1])
self.__rsb_informer_transform.publishEvent(event)
for _, v in self.__send_cache_static.iteritems():
event = Event()
event.setData(v[0])
event.setType(type(v[0]))
event.setScope(self.__rsb_informer_transform.getScope().concat(
Scope(self.__scope_suffix_static)))
event.setMetaData(v[1])
self.__rsb_informer_transform.publishEvent(event)
def send_transform(self, transform, transform_type):
'''
Add transform information to the rct data structure.
:param transform:
:param transform_type:
:return: True unless an error occured
'''
if not self.__rsb_informer_transform:
self.__logger.error(
"[{}] RSB communicator was not initialized!".format(
self.__authority))
# some small type checks for usability
assert isinstance(
transform, Transform
), "Input transformation has to be of type rct.Transform! (Input was: {})".format(
type(transform))
assert hasattr(
TransformType, transform_type
), "Input transformation type has to be of type rct.TransformType! (Input was: {})".format(
type(transform_type))
cache_key = transform.get_frame_parent() + transform.get_frame_child()
meta_data = MetaData()
if transform.get_authority() is "":
meta_data.setUserInfo(self.__user_key_authority, self.__authority)
else:
meta_data.setUserInfo(self.__user_key_authority,
transform.get_authority())
self.__logger.info("[{}] Publishing transform from {}".format(
self.__authority, self.__rsb_informer_transform.getId()))
# TODO: threaded?
event = Event()
event.setData(transform)
event.setType(type(transform))
event.setMetaData(meta_data)
if transform_type is TransformType.STATIC:
self.__send_cache_static[cache_key] = (transform, meta_data)
event.setScope(self.__rsb_informer_transform.getScope().concat(
Scope(self.__scope_suffix_static)))
elif transform_type is TransformType.DYNAMIC:
self.__send_cache_dynamic[cache_key] = (transform, meta_data)
event.setScope(self.__rsb_informer_transform.getScope().concat(
Scope(self.__scope_suffix_dynamic)))
else:
self.__logger.error(
"[{}] Cannot send transform. Reason: Unknown TransformType: {}"
.format(self.__authority, str(transform_type)))
return False
self.__logger.info("[{}] Sending {} to scope {}".format(
self.__authority, transform.__str__(), event.getScope()))
self.__rsb_informer_transform.publishEvent(event)
self.__logger.debug("[{}] Sending successful!".format(
self.__authority))
return True
