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 test_roundtrip(self):
good_scope = Scope("/good")
inconnector = self._get_in_connector(good_scope)
outconnector = self._get_out_connector(good_scope)
receiver = SettingReceiver(good_scope)
inconnector.set_observer_action(receiver)
# first an event that we do not want
event = Event(EventId(uuid.uuid4(), 0))
event.scope = Scope("/notGood")
event.data = "x" * 600000
event.data_type = str
event.meta_data.sender_id = uuid.uuid4()
outconnector.handle(event)
# and then a desired event
event.scope = good_scope
outconnector.handle(event)
with receiver.result_condition:
while receiver.result_event is None:
receiver.result_condition.wait(10)
assert receiver.result_event
# ignore meta data here
event.meta_data = None
receiver.result_event.meta_data = None
assert receiver.result_event == event
outconnector.deactivate()
inconnector.deactivate()
def test_sequencing(self):
good_scope = Scope("/good")
in_connector = get_connector(good_scope,
clazz=spread_transport.InConnector)
out_connector = get_connector(good_scope,
clazz=spread_transport.OutConnector)
try:
receiver = SettingReceiver(good_scope)
in_connector.set_observer_action(receiver)
# first an event that we do not want
event = Event(EventId(uuid.uuid4(), 0))
event.scope = Scope("/notGood")
event.data = ''.join(
random.choice(string.ascii_uppercase + string.ascii_lowercase +
string.digits) for i in range(300502))
event.data_type = str
event.meta_data.sender_id = uuid.uuid4()
out_connector.handle(event)
# and then a desired event
event.scope = good_scope
out_connector.handle(event)
with receiver.result_condition:
receiver.result_condition.wait(10)
assert receiver.result_event is not None
# self.assertEqual(receiver.result_event, event)
finally:
in_connector.deactivate()
out_connector.deactivate()
def testParsing(self):
root = rsb.Scope("/")
self.assertEqual(0, len(root.getComponents()))
onePart = rsb.Scope("/test/")
self.assertEqual(1, len(onePart.getComponents()))
self.assertEqual("test", onePart.getComponents()[0])
manyParts = rsb.Scope("/this/is/a/dumb3/test/")
self.assertEqual(5, len(manyParts.getComponents()))
self.assertEqual("this", manyParts.getComponents()[0])
self.assertEqual("is", manyParts.getComponents()[1])
self.assertEqual("a", manyParts.getComponents()[2])
self.assertEqual("dumb3", manyParts.getComponents()[3])
self.assertEqual("test", manyParts.getComponents()[4])
# also ensure that the shortcut syntax works
shortcut = rsb.Scope("/this/is")
self.assertEqual(2, len(shortcut.getComponents()))
self.assertEqual("this", shortcut.getComponents()[0])
self.assertEqual("is", shortcut.getComponents()[1])
# Non-ASCII characters are not allowed. However, unicode
# object consisting of acceptable characters are OK.
Scope(u'/')
Scope(u'/test')
self.assertRaises(ValueError, Scope, u'/br\xc3\xb6tchen')
def testSequencing(self):
goodScope = Scope("/good")
inConnector = getConnector(goodScope, clazz=rsbspread.InPushConnector)
outConnector = getConnector(goodScope, clazz=rsbspread.OutConnector)
try:
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 = "".join(
random.choice(string.ascii_uppercase + string.ascii_lowercase +
string.digits) for i in range(300502))
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:
receiver.resultCondition.wait(10)
if receiver.resultEvent is None:
self.fail("Did not receive an event")
# self.assertEqual(receiver.resultEvent, event)
finally:
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 test_round_trip(self):
converter = ScopeConverter()
root = Scope('/foo/bar')
assert converter.deserialize(*converter.serialize(root)) == root
some_scope = Scope('/foo/bar')
assert converter.deserialize(
*converter.serialize(some_scope)) == some_scope
def set_up(self):
self.default_scope = Scope("/a/test")
self.informer = Informer(self.default_scope,
rsb.get_default_participant_config(),
data_type=str)
yield
self.informer.deactivate()
def testRoundTrip(self):
converter = ScopeConverter()
root = Scope('/foo/bar')
self.assertEqual(root,
converter.deserialize(*converter.serialize(root)))
someScope = Scope('/foo/bar')
self.assertEqual(
someScope, converter.deserialize(*converter.serialize(someScope)))
def testSendEventWrongScope(self):
# Error: unrelated scope
e = Event(scope=Scope("/blubb"), data='foo', type=self.informer.type)
self.assertRaises(ValueError, self.informer.publishEvent, e)
# OK: identical scope
e = Event(scope=self.defaultScope, data='foo', type=self.informer.type)
self.informer.publishEvent(e)
# OK: sub-scope
e = Event(scope=self.defaultScope.concat(Scope('/sub')),
data='foo',
type=self.informer.type)
self.informer.publishEvent(e)
def testMatch(self):
scope = Scope("/bla")
f = rsb.filter.ScopeFilter(scope)
self.assertEqual(scope, f.getScope())
e = rsb.Event()
e.scope = scope
self.assertTrue(f.match(e))
e.scope = scope.concat(Scope("/sub/scope"))
self.assertTrue(f.match(e))
e.scope = Scope("/blubbbbbb")
self.assertFalse(f.match(e))
def test_match(self):
scope = Scope("/bla")
f = rsb.filter.ScopeFilter(scope)
assert scope == f.scope
e = rsb.Event()
e.scope = scope
assert f.match(e)
e.scope = scope.concat(Scope("/sub/scope"))
assert f.match(e)
e.scope = Scope("/blubbbbbb")
assert not f.match(e)
def testSpreadSubscription(self):
s1 = Scope("/xxx")
dummySpread = SpreadConnectorTest.DummySpread()
connector = getConnector(s1,
clazz=rsbspread.InPushConnector,
module=dummySpread)
self.assertEqual(1, len(dummySpread.returnedConnections))
connection = dummySpread.returnedConnections[0]
hasher = hashlib.md5()
hasher.update(s1.toString())
hashed = hasher.hexdigest()[:-1]
self.assertTrue(hashed in connection.joinCalls)
connector.deactivate()
def test_spread_subscription(self):
s1 = Scope("/xxx")
dummy_spread = self.DummySpread()
connector = get_connector(s1,
clazz=spread_transport.InConnector,
module=dummy_spread)
assert len(dummy_spread.returned_connections) == 1
connection = dummy_spread.returned_connections[0]
hasher = hashlib.md5()
hasher.update(s1.to_string().encode('ascii'))
hashed = hasher.hexdigest()[:-1].encode('ascii')
assert hashed in connection.join_calls
connector.deactivate()
class InformerTest(unittest.TestCase):
def setUp(self):
self.defaultScope = Scope("/a/test")
self.informer = Informer(self.defaultScope,
rsb.getDefaultParticipantConfig(),
dataType=str)
def tearDown(self):
self.informer.deactivate()
def testSendEventWrongScope(self):
# Error: unrelated scope
e = Event(scope=Scope("/blubb"), data='foo', type=self.informer.type)
self.assertRaises(ValueError, self.informer.publishEvent, e)
# OK: identical scope
e = Event(scope=self.defaultScope, data='foo', type=self.informer.type)
self.informer.publishEvent(e)
# OK: sub-scope
e = Event(scope=self.defaultScope.concat(Scope('/sub')),
data='foo',
type=self.informer.type)
self.informer.publishEvent(e)
def testSendEventWrongType(self):
# Wrong type
e = Event(scope=self.defaultScope, data=5)
self.assertRaises(ValueError, self.informer.publishEvent, e)
# Wrong type
self.assertRaises(ValueError, self.informer.publishData, 5.0)
# OK
self.informer.publishData('bla')
def test_parsing(self, str_repr, components):
scope = rsb.Scope(str_repr)
assert scope.components == components
# Non-ASCII characters are not allowed. However, unicode
# object consisting of acceptable characters are OK.
with pytest.raises(ValueError):
Scope('/br\xc3\xb6tchen')
def testDeactivate(self):
dummySpread = SpreadConnectorTest.DummySpread()
connector = getConnector(Scope("/foo"), module=dummySpread)
self.assertEqual(1, len(dummySpread.returnedConnections))
connection = dummySpread.returnedConnections[0]
connector.deactivate()
self.assertEqual(1, connection.disconnectCalls)
def test_deactivate(self):
dummy_spread = self.DummySpread()
connector = get_connector(Scope("/foo"), module=dummy_spread)
assert len(dummy_spread.returned_connections) == 1
connection = dummy_spread.returned_connections[0]
connector.deactivate()
assert connection.disconnect_calls == 1
def test_hierarchy_sending(self):
send_scope = Scope("/this/is/a/test")
super_scopes = send_scope.super_scopes(True)
out_connector = self._get_out_connector(send_scope, activate=False)
out_configurator = rsb.eventprocessing.OutRouteConfigurator(
connectors=[out_connector])
informer = create_informer(send_scope,
data_type=str,
configurator=out_configurator)
# set up listeners on the complete hierarchy
listeners = []
receivers = []
for scope in super_scopes:
in_connector = self._get_in_connector(scope, activate=False)
in_configurator = rsb.eventprocessing.InRouteConfigurator(
connectors=[in_connector])
listener = create_listener(scope, configurator=in_configurator)
listeners.append(listener)
receiver = SettingReceiver(scope)
listener.add_handler(receiver)
receivers.append(receiver)
data = "a string to test"
informer.publish_data(data)
for receiver in receivers:
with receiver.result_condition:
while receiver.result_event is None:
receiver.result_condition.wait(10)
if receiver.result_event is None:
pytest.fail(
"Listener on scope {} did not receive an event".format(
receiver.scope))
assert receiver.result_event.data == data
for listener in listeners:
listener.deactivate()
informer.deactivate()
def testHierarchySending(self):
sendScope = Scope("/this/is/a/test")
superScopes = sendScope.superScopes(True)
outConnector = self._getOutConnector(sendScope, activate=False)
outConfigurator = rsb.eventprocessing.OutRouteConfigurator(
connectors=[outConnector])
informer = createInformer(sendScope,
dataType=str,
configurator=outConfigurator)
# set up listeners on the complete hierarchy
listeners = []
receivers = []
for scope in superScopes:
inConnector = self._getInPushConnector(scope, activate=False)
inConfigurator = rsb.eventprocessing.InPushRouteConfigurator(
connectors=[inConnector])
listener = createListener(scope, configurator=inConfigurator)
listeners.append(listener)
receiver = SettingReceiver(scope)
listener.addHandler(receiver)
receivers.append(receiver)
data = "a string to test"
informer.publishData(data)
for receiver in receivers:
with receiver.resultCondition:
while receiver.resultEvent is None:
receiver.resultCondition.wait(10)
if receiver.resultEvent is None:
self.fail("Listener on scope %s did not receive an event" %
receiver.scope)
self.assertEqual(receiver.resultEvent.data, data)
for listener in listeners:
listener.deactivate()
informer.deactivate()
def test_user_roundtrip(self):
scope = Scope("/test/it")
in_connector = self._get_in_connector(scope, activate=False)
out_connector = self._get_out_connector(scope, activate=False)
in_configurator = rsb.eventprocessing.InRouteConfigurator(
connectors=[in_connector])
out_configurator = rsb.eventprocessing.OutRouteConfigurator(
connectors=[out_connector])
listener = create_listener(scope, configurator=in_configurator)
publisher = create_informer(scope,
data_type=str,
configurator=out_configurator)
receiver = SettingReceiver(scope)
listener.add_handler(receiver)
data1 = "a string to test"
sent_event = Event(EventId(uuid.uuid4(), 0))
sent_event.data = data1
sent_event.data_type = str
sent_event.scope = scope
sent_event.meta_data.set_user_info("test", "it")
sent_event.meta_data.set_user_info("test again", "it works?")
sent_event.meta_data.set_user_time("blubb", 234234.0)
sent_event.meta_data.set_user_time("bla", 3434343.45)
sent_event.add_cause(EventId(uuid.uuid4(), 1323))
sent_event.add_cause(EventId(uuid.uuid4(), 42))
publisher.publish_event(sent_event)
with receiver.result_condition:
while receiver.result_event is None:
receiver.result_condition.wait(10)
if receiver.result_event is None:
self.fail("Listener did not receive an event")
assert receiver.result_event.meta_data.create_time <= \
receiver.result_event.meta_data.send_time
assert receiver.result_event.meta_data.send_time <= \
receiver.result_event.meta_data.receive_time
assert receiver.result_event.meta_data.receive_time <= \
receiver.result_event.meta_data.deliver_time
sent_event.meta_data.receive_time = \
receiver.result_event.meta_data.receive_time
sent_event.meta_data.deliver_time = \
receiver.result_event.meta_data.deliver_time
# HACK: floating point precision leads to an imprecision here,
# avoid this.
sent_event.meta_data.send_time = \
receiver.result_event.meta_data.send_time
sent_event.meta_data.create_time = \
receiver.result_event.meta_data.create_time
assert sent_event == receiver.result_event
publisher.deactivate()
listener.deactivate()
def test_send_event_wrong_scope(self):
# Error: unrelated scope
e = Event(scope=Scope("/blubb"),
data='foo',
data_type=self.informer.data_type)
with pytest.raises(ValueError):
self.informer.publish_event(e)
# OK: identical scope
e = Event(scope=self.default_scope,
data='foo',
data_type=self.informer.data_type)
self.informer.publish_event(e)
# OK: sub-scope
e = Event(scope=self.default_scope.concat(Scope('/sub')),
data='foo',
data_type=self.informer.data_type)
self.informer.publish_event(e)
def testPullNonBlocking(self):
try:
inconnector = self._getInPullConnector(Scope("/somewhere"))
except NotImplementedError:
return
received = inconnector.raiseEvent(False)
self.assertIsNone(received)
inconnector.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 testUserRoundtrip(self):
scope = Scope("/test/it")
inConnector = self._getInPushConnector(scope, activate=False)
outConnector = self._getOutConnector(scope, activate=False)
outConfigurator = rsb.eventprocessing.OutRouteConfigurator(
connectors=[outConnector])
inConfigurator = rsb.eventprocessing.InPushRouteConfigurator(
connectors=[inConnector])
publisher = createInformer(scope,
dataType=str,
configurator=outConfigurator)
listener = createListener(scope, configurator=inConfigurator)
receiver = SettingReceiver(scope)
listener.addHandler(receiver)
data1 = "a string to test"
sentEvent = Event(EventId(uuid.uuid4(), 0))
sentEvent.setData(data1)
sentEvent.setType(str)
sentEvent.setScope(scope)
sentEvent.getMetaData().setUserInfo("test", "it")
sentEvent.getMetaData().setUserInfo("test again", "it works?")
sentEvent.getMetaData().setUserTime("blubb", 234234)
sentEvent.getMetaData().setUserTime("bla", 3434343.45)
sentEvent.addCause(EventId(uuid.uuid4(), 1323))
sentEvent.addCause(EventId(uuid.uuid4(), 42))
publisher.publishEvent(sentEvent)
with receiver.resultCondition:
while receiver.resultEvent is None:
receiver.resultCondition.wait(10)
if receiver.resultEvent is None:
self.fail("Listener did not receive an event")
self.assertTrue(
receiver.resultEvent.metaData.createTime <= receiver.
resultEvent.metaData.sendTime <= receiver.resultEvent.metaData.
receiveTime <= receiver.resultEvent.metaData.deliverTime)
sentEvent.metaData.receiveTime = \
receiver.resultEvent.metaData.receiveTime
sentEvent.metaData.deliverTime = \
receiver.resultEvent.metaData.deliverTime
self.assertEqual(sentEvent, receiver.resultEvent)
listener.deactivate()
publisher.deactivate()
def testPassToAction(self):
scope = Scope("/lets/go")
bus = Bus()
connector = InPushConnector(bus=bus)
connector.setScope(scope)
connector.activate()
action = StubSink(scope)
connector.setObserverAction(action)
e = Event()
e.scope = scope
bus.handle(e)
self.assertEqual(1, len(action.events))
self.assertTrue(e in action.events)
def transform_handler(self, event):
'''
Handles incoming transformation updates.
The C++ counterpart is "transformCallback"
:param event:Incoming event
'''
if event.getSenderId() == self.__rsb_informer_transform.getId():
self.__logger.debug(
"[{}] Received transform update from myself. Ignore. (id: {})".
format(self.__authority, str(event.getSenderId())))
return
# data is of type rct.core.Transform
data = event.getData()
if not isinstance(data, Transform):
self.__logger.warning(
"[{}] Incoming data is of type {} (expected {}). Ignore.".
format(self.__authority, type(data), Transform))
return
try:
received_authority = event.getMetaData().userInfos[
self.__user_key_authority]
static_scope = self.__rsb_informer_transform.getScope().concat(
Scope(self.__scope_suffix_static))
is_static = event.scope == static_scope
data.__authority = received_authority
self.__logger.debug("[%s] Received transform from '%s: %s",
self.__authority, received_authority, data)
# TODO: threaded?
for a_listener in self.__listeners:
a_listener.new_transform_available(data, is_static)
except KeyError as ke:
self.__logger.warning(
"[{}] ERROR during data handling: Cannot find neccessary key '{}' in meta data user info field of event! Actual content: {}"
.format(self.__authority, ke, event.metaData))
except Exception as e:
self.__logger.exception(
"[{}] ERROR during data handling: {}".format(
self.__authority, str(e)))
def test_pass_to_action(self):
scope = Scope("/lets/go")
bus = Bus()
connector = InConnector(bus=bus)
connector.scope = scope
connector.activate()
action = StubSink(scope)
connector.set_observer_action(action)
e = Event()
e.scope = scope
bus.handle(e)
assert len(action.events) == 1
assert e in action.events
class TestInformer:
@pytest.fixture(autouse=True)
def set_up(self):
self.default_scope = Scope("/a/test")
self.informer = Informer(self.default_scope,
rsb.get_default_participant_config(),
data_type=str)
yield
self.informer.deactivate()
def test_send_event_wrong_scope(self):
# Error: unrelated scope
e = Event(scope=Scope("/blubb"),
data='foo',
data_type=self.informer.data_type)
with pytest.raises(ValueError):
self.informer.publish_event(e)
# OK: identical scope
e = Event(scope=self.default_scope,
data='foo',
data_type=self.informer.data_type)
self.informer.publish_event(e)
# OK: sub-scope
e = Event(scope=self.default_scope.concat(Scope('/sub')),
data='foo',
data_type=self.informer.data_type)
self.informer.publish_event(e)
def test_send_event_wrong_type(self):
# Wrong type
e = Event(scope=self.default_scope, data=5)
with pytest.raises(ValueError):
self.informer.publish_event(e)
# Wrong type
with pytest.raises(ValueError):
self.informer.publish_data(5.0)
# OK
self.informer.publish_data('bla')
def test_handle(self):
bus = Bus()
connector = OutConnector(bus=bus)
scope = Scope("/a/test")
sink = StubSink(scope)
bus.add_sink(sink)
e = Event()
e.scope = scope
before = time.time()
connector.handle(e)
after = time.time()
assert len(sink.events) == 1
assert e in sink.events
assert e.meta_data.send_time >= before
assert e.meta_data.send_time <= after