def test_ProducerConsumerTerminals(self):
tmA = self.terminalsB['pcConsumer']
tmB = self.terminalsA['pcProducer']
msg = bytes([1, 2, 3])
# publish without the terminal being bound
self.assertRaises(yogi.Failure, lambda: tmB.publish(msg))
self.assertEqual(False, tmB.try_publish(msg))
# cancel receive message
with AsyncCall() as wrap:
def fn(res, msg):
self.assertEqual(yogi.Canceled(), res)
self.assertIsNone(msg)
tmA.async_receive_message(wrap(fn))
tmA.cancel_receive_message()
# successfully receive message
self.connect(tmA)
with AsyncCall() as wrap:
def fn(res, msg):
self.assertEqual(yogi.Success(), res)
self.assertEqual(bytes([1, 2, 3]), msg)
tmA.async_receive_message(wrap(fn))
tmB.publish(msg)
self.assertTrue(tmB.try_publish(msg))
def test_async_await_known_terminals_change(self):
tm = None
with AsyncCall() as wrap:
def fn(res, info, change):
self.assertEqual(yogi.Success(), res)
self.assertIs(yogi.ProducerTerminal, info.type)
self.assertEqual(0x0000d007, info.signature.raw)
self.assertEqual('One', info.name)
self.assertEqual(yogi.ChangeType.ADDED, change)
self.node.async_await_known_terminals_change(wrap(fn))
tm = yogi.ProducerTerminal('One',
yogi_0000d007_pb2,
leaf=self.leaf)
with AsyncCall() as wrap:
def fn(res, info, change):
self.assertEqual(yogi.Success(), res)
self.assertIs(yogi.ProducerTerminal, info.type)
self.assertEqual(0x0000d007, info.signature.raw)
self.assertEqual('One', info.name)
self.assertEqual(yogi.ChangeType.REMOVED, change)
self.node.async_await_known_terminals_change(wrap(fn))
tm.destroy()
def test_RawCachedPublishSubscribeTerminal(self):
tmA = self.terminalsA['cps']
tmB = self.terminalsB['cps']
bd = self.bindings['cps']
msg = bytes([1, 2, 3])
# publish without the terminal being bound
self.assertRaises(yogi.Failure, lambda: tmB.publish(msg))
self.assertEqual(False, tmB.try_publish(msg))
# cancel receive message
with AsyncCall() as wrap:
def fn(res, msg, cached):
self.assertEqual(yogi.Canceled(), res)
self.assertIsNone(msg)
tmA.async_receive_message(wrap(fn))
tmA.cancel_receive_message()
# successfully receive cached message
with AsyncCall() as wrap:
def fn(res, msg, cached):
self.assertEqual(yogi.Success(), res)
self.assertEqual(bytes([1, 2, 3]), msg)
self.assertTrue(cached)
tmA.async_receive_message(wrap(fn))
self.connect(bd)
# successfully receive non-cached message
with AsyncCall() as wrap:
def fn(res, msg, cached):
self.assertEqual(yogi.Success(), res)
self.assertEqual(bytes([1, 2, 3]), msg)
self.assertFalse(cached)
tmA.async_receive_message(wrap(fn))
tmB.publish(msg)
self.assertTrue(tmB.try_publish(msg))
# get cached message
msg = tmA.get_cached_message()
self.assertEqual(bytes([1, 2, 3]), msg)
def test_cancel_await_binding_state_changed(self):
with AsyncCall() as wrap:
def fn(res, state):
self.assertEqual(yogi.Canceled(), res)
self.bd.async_await_binding_state_change(wrap(fn))
self.bd.cancel_await_binding_state_change()
def test_async_get_binding_state(self):
with AsyncCall() as wrap:
def fn(res, state):
self.assertEqual(yogi.Success(), res)
self.assertEqual(yogi.BindingState.RELEASED, state)
self.bd.async_get_binding_state(wrap(fn))
self.connect()
with AsyncCall() as wrap:
def fn(res, state):
self.assertEqual(yogi.Success(), res)
self.assertEqual(yogi.BindingState.ESTABLISHED, state)
self.bd.async_get_binding_state(wrap(fn))
def test_async_await_binding_state_changed(self):
with AsyncCall() as wrap:
def fn(res, state):
self.assertEqual(yogi.Success(), res)
self.assertEqual(yogi.BindingState.ESTABLISHED, state)
self.bd.async_await_binding_state_change(wrap(fn))
self.connect()
with AsyncCall() as wrap:
def fn(res, state):
self.assertEqual(yogi.Success(), res)
self.assertEqual(yogi.BindingState.RELEASED, state)
self.bd.async_await_binding_state_change(wrap(fn))
self.connection.destroy()
self.connection = None
def test_cancel_await_subscription_state_changed(self):
with AsyncCall() as wrap:
def fn(res, state):
self.assertEqual(yogi.Canceled(), res)
self.tmB.async_await_subscription_state_change(wrap(fn))
self.tmB.cancel_await_subscription_state_change()
def test_async_get_subscription_state(self):
with AsyncCall() as wrap:
def fn(res, state):
self.assertEqual(yogi.Success(), res)
self.assertEqual(yogi.SubscriptionState.UNSUBSCRIBED, state)
self.tmB.async_get_subscription_state(wrap(fn))
self.connect()
with AsyncCall() as wrap:
def fn(res, state):
self.assertEqual(yogi.Success(), res)
self.assertEqual(yogi.SubscriptionState.SUBSCRIBED, state)
self.tmB.async_get_subscription_state(wrap(fn))
def test_async_await_subscription_state_changed(self):
with AsyncCall() as wrap:
def fn(res, state):
self.assertEqual(yogi.Success(), res)
self.assertEqual(yogi.SubscriptionState.SUBSCRIBED, state)
self.tmB.async_await_subscription_state_change(wrap(fn))
self.connect()
with AsyncCall() as wrap:
def fn(res, state):
self.assertEqual(yogi.Success(), res)
self.assertEqual(yogi.SubscriptionState.UNSUBSCRIBED, state)
self.tmB.async_await_subscription_state_change(wrap(fn))
self.connection.destroy()
self.connection = None
def check(errors, fn):
with AsyncCall() as wrap:
def handler_fn(res, msg, cached):
self.assertEqual(yogi.Success(), res)
self.assertEqual([err.message for err in errors],
msg.value)
self.warnings_terminal.async_receive_message(wrap(handler_fn))
fn()
def check(state, fn):
with AsyncCall() as wrap:
def handler_fn(res, msg, cached):
self.assertEqual(yogi.Success(), res)
self.assertEqual(state, msg.value)
self.operational_terminal.async_receive_message(
wrap(handler_fn))
fn()
def test_cancel_await_known_terminals_change(self):
with AsyncCall() as wrap:
def fn(res, info, change):
self.assertEqual(yogi.Canceled(), res)
self.assertIsNone(info)
self.assertIsNone(change)
self.node.async_await_known_terminals_change(wrap(fn))
self.node.cancel_await_known_terminals_change()
def change_verbosity(self, verbosity_terminal, verbosity):
with AsyncCall() as wrap:
def fn(res, msg, cached):
self.assertEqual(yogi.Success(), res)
self.assertFalse(cached)
self.assertEqual(verbosity.value, msg.value)
verbosity_terminal.async_receive_message(wrap(fn))
verbosity_terminal.publish(
verbosity_terminal.make_message(value=verbosity.value))
def test_ProcessInterface(self):
yogi.Logger.colourised_stdout = False
argv = [
'-j', '''
{
"logging": {
"stdout": {
"colourised": true,
"max-verbosity": "DEBUG",
"component-verbosity": {
"App" : "ERROR",
"Yogi" : "FATAL",
"test" : "TRACE"
}
},
"yogi": {
"max-verbosity": "INFO",
"component-verbosity": {
"App" : "DEBUG",
"Yogi" : "INFO",
"test" : "WARNING"
}
}
}
}'''
]
scheduler = yogi.Scheduler()
leaf = yogi.Leaf(scheduler)
pi = yogi.ProcessInterface(argv)
# check initial configuration
self.assertTrue(yogi.Logger.colourised_stdout)
self.assertIs(yogi.Verbosity.DEBUG, yogi.Logger.max_stdout_verbosity)
self.assertIs(yogi.Verbosity.ERROR, yogi.Logger().stdout_verbosity)
self.assertIs(yogi.Verbosity.ERROR,
yogi.Logger('App').stdout_verbosity)
self.assertIs(yogi.Verbosity.FATAL,
yogi.Logger('Yogi').stdout_verbosity)
self.assertIs(yogi.Verbosity.TRACE,
yogi.Logger('test').stdout_verbosity)
self.assertIs(yogi.Verbosity.INFO, yogi.Logger.max_yogi_verbosity)
self.assertIs(yogi.Verbosity.DEBUG, yogi.Logger().yogi_verbosity)
self.assertIs(yogi.Verbosity.DEBUG, yogi.Logger('App').yogi_verbosity)
self.assertIs(yogi.Verbosity.INFO, yogi.Logger('Yogi').yogi_verbosity)
self.assertIs(yogi.Verbosity.WARNING,
yogi.Logger('test').yogi_verbosity)
# check logging over YOGI
log_terminal = yogi.ConsumerTerminal('/Process/Log',
yogi_000009cd_pb2,
leaf=leaf)
connection = yogi.LocalConnection(leaf, pi.leaf)
while log_terminal.get_binding_state() is yogi.BindingState.RELEASED:
pass
with AsyncCall() as wrap:
def fn(res, msg):
self.assertEqual(yogi.Success(), res)
self.assertEqual('Hello', msg.value.first)
info = json.loads(msg.value.second)
self.assertEqual('App', info['component'])
self.assertEqual('FATAL', info['severity'])
self.assertGreater(info['thread'], 0)
log_terminal.async_receive_message(wrap(fn))
yogi.log_fatal('Hello')
# check changing verbosity levels at runtime
logger = yogi.Logger('My Component')
max_verbosity_terminal = yogi.CachedSlaveTerminal(
'/Process/YOGI Log Verbosity/Max Verbosity',
yogi_00004004_pb2,
leaf=leaf)
while max_verbosity_terminal.get_binding_state(
) is yogi.BindingState.RELEASED:
pass
while max_verbosity_terminal.get_subscription_state(
) is yogi.SubscriptionState.UNSUBSCRIBED:
pass
self.change_verbosity(max_verbosity_terminal, yogi.Verbosity.INFO)
verbosity_terminal = yogi.CachedSlaveTerminal(
'/Process/YOGI Log Verbosity/Components/My Component',
yogi_00004004_pb2,
leaf=leaf)
while verbosity_terminal.get_binding_state(
) is yogi.BindingState.RELEASED:
pass
while verbosity_terminal.get_subscription_state(
) is yogi.SubscriptionState.UNSUBSCRIBED:
pass
self.change_verbosity(verbosity_terminal, yogi.Verbosity.DEBUG)
# check that new verbosity levels are being applied
with AsyncCall() as wrap:
def fn(res, msg):
self.assertEqual(yogi.Success(), res)
self.assertEqual('Go', msg.value.first)
log_terminal.async_receive_message(wrap(fn))
logger.log_info('Go')
self.change_verbosity(verbosity_terminal, yogi.Verbosity.WARNING)
with AsyncCall() as wrap:
def fn(res, msg):
self.assertEqual(yogi.Success(), res)
self.assertEqual('Vegan', msg.value.first)
log_terminal.async_receive_message(wrap(fn))
logger.log_info('Welcome')
logger.log_warning('Vegan')
self.change_verbosity(max_verbosity_terminal, yogi.Verbosity.ERROR)
with AsyncCall() as wrap:
def fn(res, msg):
self.assertEqual(yogi.Success(), res)
self.assertEqual('Mate', msg.value.first)
log_terminal.async_receive_message(wrap(fn))
logger.log_warning('Dude')
logger.log_error('Mate')
# clean up
connection.destroy()
verbosity_terminal.destroy()
max_verbosity_terminal.destroy()
log_terminal.destroy()
leaf.destroy()
scheduler.destroy()
pi.destroy()
def test_ServiceClientTerminals(self):
tmA = self.terminalsA['scService']
tmB = self.terminalsB['scClient']
# cancel receive message
with AsyncCall() as wrap:
def fn(res, request):
self.assertEqual(yogi.Canceled(), res)
self.assertIsNone(request)
tmA.async_receive_request(wrap(fn))
tmA.cancel_receive_request()
# ignore message
self.connect(tmA, tmB)
msg = bytes([1, 2, 3])
with AsyncCall() as wrap:
def fn(res, request):
self.assertEqual(yogi.Success(), res)
self.assertEqual(bytes([1, 2, 3]), request.message)
request.ignore()
tmA.async_receive_request(wrap(fn))
with AsyncCall() as wrap2:
def fn2(res, gathered_msg):
self.assertEqual(yogi.Success(), res)
self.assertTrue(gathered_msg.flags
& yogi.GatherFlags.IGNORED)
return yogi.ControlFlow.STOP
tmB.async_request(msg, wrap2(fn2))
# respond to message
with AsyncCall() as wrap:
def fn(res, request):
self.assertEqual(yogi.Success(), res)
self.assertEqual(bytes([1, 2, 3]), request.message)
response = bytes([4, 5, 6])
request.respond(response)
tmA.async_receive_request(wrap(fn))
with AsyncCall() as wrap2:
def fn2(res, gathered_msg):
self.assertEqual(yogi.Success(), res)
self.assertTrue(gathered_msg.flags
& yogi.GatherFlags.FINISHED)
self.assertEqual(bytes([4, 5, 6]), gathered_msg.message)
return yogi.ControlFlow.STOP
tmB.async_request(msg, wrap2(fn2))
# cancel operation
with AsyncCall() as wrap:
def fn(res, request):
self.assertEqual(yogi.Success(), res)
self.assertEqual(bytes([1, 2, 3]), request.message)
# do not respond
tmA.async_receive_request(wrap(fn))
with AsyncCall() as wrap2:
def fn2(res, gathered_msg):
self.assertEqual(yogi.Canceled(), res)
self.assertIsNone(gathered_msg)
operation = tmB.async_request(msg, wrap2(fn2))
operation.cancel()
def test_CachedMasterSlaveTerminals(self):
tmA = self.terminalsA['cmsMaster']
tmB = self.terminalsB['cmsSlave']
msg = bytes([1, 2, 3])
# publish without the terminals being bound
self.assertRaises(yogi.Failure, lambda: tmA.publish(msg))
self.assertEqual(False, tmA.try_publish(msg))
self.assertRaises(yogi.Failure, lambda: tmB.publish(msg))
self.assertEqual(False, tmB.try_publish(msg))
# cancel receive message
with AsyncCall() as wrap:
def fn(res, msg, cached):
self.assertEqual(yogi.Canceled(), res)
self.assertIsNone(msg)
tmA.async_receive_message(wrap(fn))
tmA.cancel_receive_message()
with AsyncCall() as wrap:
def fn(res, msg, cached):
self.assertEqual(yogi.Canceled(), res)
self.assertIsNone(msg)
tmB.async_receive_message(wrap(fn))
tmB.cancel_receive_message()
# successfully receive cached message
with AsyncCall() as wrap:
def fn(res, msg, cached):
self.assertEqual(yogi.Success(), res)
self.assertEqual(bytes([1, 2, 3]), msg)
self.assertTrue(cached)
tmB.async_receive_message(wrap(fn))
with AsyncCall() as wrap:
def fn(res, msg, cached):
self.assertEqual(yogi.Success(), res)
self.assertEqual(bytes([1, 2, 3]), msg)
self.assertTrue(cached)
tmA.async_receive_message(wrap(fn))
self.connect(tmB, tmA)
while tmA.get_binding_state() == yogi.BindingState.RELEASED:
pass
while tmB.get_subscription_state(
) == yogi.SubscriptionState.UNSUBSCRIBED:
pass
# successfully receive non-cached message
time.sleep(
0.01
) # takes care of tmB receiving the bounced-back cached message it sent to tmA on connection
with AsyncCall() as wrap:
def fn(res, msg, cached):
self.assertEqual(yogi.Success(), res)
self.assertEqual(bytes([1, 2, 3]), msg)
self.assertFalse(cached)
tmB.async_receive_message(wrap(fn))
tmA.publish(msg)
self.assertTrue(tmA.try_publish(msg))
with AsyncCall() as wrap:
def fn(res, msg, cached):
self.assertEqual(yogi.Success(), res)
self.assertEqual(bytes([1, 2, 3]), msg)
self.assertFalse(cached)
tmA.async_receive_message(wrap(fn))
tmB.publish(msg)
self.assertTrue(tmB.try_publish(msg))
# get cached message
msg = tmA.get_cached_message()
self.assertEqual(bytes([1, 2, 3]), msg)
msg = tmB.get_cached_message()
self.assertEqual(bytes([1, 2, 3]), msg)
def test_MasterSlaveTerminals(self):
tmA = self.terminalsB['msMaster']
tmB = self.terminalsA['msSlave']
msg = bytes([1, 2, 3])
# publish without the terminals being bound
self.assertRaises(yogi.Failure, lambda: tmA.publish(msg))
self.assertEqual(False, tmA.try_publish(msg))
self.assertRaises(yogi.Failure, lambda: tmB.publish(msg))
self.assertEqual(False, tmB.try_publish(msg))
# cancel receive message
with AsyncCall() as wrap:
def fn(res, msg):
self.assertEqual(yogi.Canceled(), res)
self.assertIsNone(msg)
tmA.async_receive_message(wrap(fn))
tmA.cancel_receive_message()
with AsyncCall() as wrap:
def fn(res, msg):
self.assertEqual(yogi.Canceled(), res)
self.assertIsNone(msg)
tmB.async_receive_message(wrap(fn))
tmB.cancel_receive_message()
# establish connection
self.connect(tmB, tmA)
while tmA.get_binding_state() == yogi.BindingState.RELEASED:
pass
while tmB.get_subscription_state(
) == yogi.SubscriptionState.UNSUBSCRIBED:
pass
# successfully receive message
with AsyncCall() as wrap:
def fn(res, msg):
self.assertEqual(yogi.Success(), res)
self.assertEqual(bytes([1, 2, 3]), msg)
tmB.async_receive_message(wrap(fn))
tmA.publish(msg)
self.assertTrue(tmA.try_publish(msg))
with AsyncCall() as wrap:
def fn(res, msg):
self.assertEqual(yogi.Success(), res)
self.assertEqual(bytes([1, 2, 3]), msg)
tmA.async_receive_message(wrap(fn))
tmB.publish(msg)
self.assertTrue(tmB.try_publish(msg))
def test_RawScatterGatherTerminal(self):
tmA = self.terminalsA['sg']
tmB = self.terminalsB['sg']
bd = self.bindings['sg']
# cancel receive message
with AsyncCall() as wrap:
def fn(res, scattered_msg):
self.assertEqual(yogi.Canceled(), res)
self.assertIsNone(scattered_msg)
tmA.async_receive_scattered_message(wrap(fn))
tmA.cancel_receive_scattered_message()
# ignore message
self.connect(bd, tmB)
msg = bytes([1, 2, 3])
with AsyncCall() as wrap:
def fn(res, scattered_msg):
self.assertEqual(yogi.Success(), res)
self.assertEqual(bytes([1, 2, 3]), scattered_msg.message)
scattered_msg.ignore()
tmA.async_receive_scattered_message(wrap(fn))
with AsyncCall() as wrap2:
def fn2(res, gathered_msg):
self.assertEqual(yogi.Success(), res)
self.assertTrue(gathered_msg.flags
& yogi.GatherFlags.IGNORED)
return yogi.ControlFlow.STOP
tmB.async_scatter_gather(msg, wrap2(fn2))
# respond to message
with AsyncCall() as wrap:
def fn(res, scattered_msg):
self.assertEqual(yogi.Success(), res)
self.assertEqual(bytes([1, 2, 3]), scattered_msg.message)
response = bytes([4, 5, 6])
scattered_msg.respond(response)
tmA.async_receive_scattered_message(wrap(fn))
with AsyncCall() as wrap2:
def fn2(res, gathered_msg):
self.assertEqual(yogi.Success(), res)
self.assertTrue(gathered_msg.flags
& yogi.GatherFlags.FINISHED)
self.assertEqual(bytes([4, 5, 6]), gathered_msg.message)
return yogi.ControlFlow.STOP
tmB.async_scatter_gather(msg, wrap2(fn2))
# cancel operation
with AsyncCall() as wrap:
def fn(res, scattered_msg):
self.assertEqual(yogi.Success(), res)
self.assertEqual(bytes([1, 2, 3]), scattered_msg.message)
# do not respond
tmA.async_receive_scattered_message(wrap(fn))
with AsyncCall() as wrap2:
def fn2(res, gathered_msg):
self.assertEqual(yogi.Canceled(), res)
self.assertIsNone(gathered_msg)
operation = tmB.async_scatter_gather(msg, wrap2(fn2))
operation.cancel()
