def test_destroy(self):
obj = yogi.Object(ctypes.c_void_p())
self.assertRaises(yogi.Failure, lambda: obj.destroy())
scheduler = yogi.Scheduler()
scheduler.destroy()
self.assertRaises(yogi.Failure, lambda: scheduler.destroy())
def setUp(self):
self.scheduler = yogi.Scheduler()
self.leafA = yogi.Leaf(self.scheduler)
self.leafB = yogi.Leaf(self.scheduler)
self.connection = None
def makeTerminals(leaf):
terminals = {}
terminals['dm'] = yogi.RawDeafMuteTerminal(
'DM Terminal', yogi.Signature(0x12345678), leaf=leaf)
terminals['ps'] = yogi.RawPublishSubscribeTerminal('PS Terminal',
0x12345678,
leaf=leaf)
terminals['cps'] = yogi.RawCachedPublishSubscribeTerminal(
'CPS Terminal', 0x12345678, leaf=leaf)
terminals['sg'] = yogi.RawScatterGatherTerminal('SG Terminal',
0x12345678,
leaf=leaf)
terminals['pcProducer'] = yogi.RawProducerTerminal('PC Terminal',
0x12345678,
leaf=leaf)
terminals['pcConsumer'] = yogi.RawConsumerTerminal('PC Terminal',
0x12345678,
leaf=leaf)
terminals['cpcProducer'] = yogi.RawCachedProducerTerminal(
'CPC Terminal', 0x12345678, leaf=leaf)
terminals['cpcConsumer'] = yogi.RawCachedConsumerTerminal(
'CPC Terminal', 0x12345678, leaf=leaf)
terminals['msMaster'] = yogi.RawMasterTerminal('MS Terminal',
0x12345678,
leaf=leaf)
terminals['msSlave'] = yogi.RawSlaveTerminal('MS Terminal',
0x12345678,
leaf=leaf)
terminals['cmsMaster'] = yogi.RawCachedMasterTerminal(
'CMS Terminal', 0x12345678, leaf=leaf)
terminals['cmsSlave'] = yogi.RawCachedSlaveTerminal('CMS Terminal',
0x12345678,
leaf=leaf)
terminals['scService'] = yogi.RawServiceTerminal('SC Terminal',
0x12345678,
leaf=leaf)
terminals['scClient'] = yogi.RawClientTerminal('SC Terminal',
0x12345678,
leaf=leaf)
return terminals
self.terminalsA = makeTerminals(self.leafA)
self.terminalsB = makeTerminals(self.leafB)
self.bindings = {
'dm':
yogi.Binding(self.terminalsA['dm'], self.terminalsA['dm'].name),
'ps':
yogi.Binding(self.terminalsA['ps'], self.terminalsA['ps'].name),
'cps':
yogi.Binding(self.terminalsA['cps'], self.terminalsA['cps'].name),
'sg':
yogi.Binding(self.terminalsA['sg'], self.terminalsA['sg'].name)
}
def setUp(self):
self.pi = yogi.ProcessInterface(yogi.Configuration())
self.scheduler = yogi.Scheduler()
self.leaf = yogi.Leaf(self.scheduler)
self.connection = yogi.LocalConnection(self.pi.leaf, self.leaf)
self.operational_terminal = yogi.CachedConsumerTerminal(
'/Process/Operational', yogi_00000001_pb2, leaf=self.leaf)
self.errors_terminal = yogi.CachedConsumerTerminal('/Process/Errors',
yogi_0000040d_pb2,
leaf=self.leaf)
self.warnings_terminal = yogi.CachedConsumerTerminal(
'/Process/Warnings', yogi_0000040d_pb2, leaf=self.leaf)
for tm in [
self.operational_terminal, self.errors_terminal,
self.warnings_terminal
]:
while tm.get_binding_state() is yogi.BindingState.RELEASED:
pass
while True:
try:
tm.get_cached_message()
break
except yogi.Failure:
pass
def setUp(self):
self.scheduler = yogi.Scheduler()
self.leafA = yogi.Leaf(self.scheduler)
self.leafB = yogi.Leaf(self.scheduler)
self.connection = None
self.producer = yogi.ProducerTerminal('T',
yogi_0000d007_pb2,
leaf=self.leafA)
self.consumer = yogi.ConsumerTerminal('T',
yogi_0000d007_pb2,
leaf=self.leafB)
self.cachedProducer = yogi.CachedProducerTerminal('T',
yogi_0000d007_pb2,
leaf=self.leafA)
self.cachedConsumer = yogi.CachedConsumerTerminal('T',
yogi_0000d007_pb2,
leaf=self.leafB)
self.scatterGatherA = yogi.ScatterGatherTerminal('T',
yogi_0000d007_pb2,
leaf=self.leafA)
self.scatterGatherB = yogi.ScatterGatherTerminal('T',
yogi_0000d007_pb2,
leaf=self.leafB)
self.scatterGatherBinding = yogi.Binding(self.scatterGatherA, 'T')
self.service = yogi.ServiceTerminal('T',
yogi_0000d007_pb2,
leaf=self.leafA)
self.client = yogi.ClientTerminal('T',
yogi_0000d007_pb2,
leaf=self.leafB)
def setUp(self):
self.scheduler = yogi.Scheduler()
self.leafA = yogi.Leaf(self.scheduler)
self.leafB = yogi.Leaf(self.scheduler)
self.connection = None
self.tmA = yogi.DeafMuteTerminal('T', yogi_0000d007_pb2, leaf=self.leafA)
self.tmB = yogi.DeafMuteTerminal('T', yogi_0000d007_pb2, leaf=self.leafB)
self.bd = yogi.Binding(self.tmA, self.tmB.name)
def setUp(self):
self.scheduler = yogi.Scheduler()
self.endpointA = yogi.Leaf(self.scheduler)
self.endpointB = yogi.Leaf(self.scheduler)
self.server = None
self.server_connection = None
self.client = None
self.client_connection = None
self.connect_handler_res = None
self.accept_handler_res = None
self.death_handler_res = None
def setUp(self):
self.scheduler = yogi.Scheduler()
self.endpointA = yogi.Leaf(self.scheduler)
self.endpointB = yogi.Leaf(self.scheduler)
self.timeout = 5.0
self.identification = 'hello'
self.client = yogi.AutoConnectingTcpClient(self.endpointA,
self.ADDRESS, self.PORT,
self.timeout,
self.identification)
self.server = None
self.server_connection = None
self.connect_handler_res = None
self.connect_handler_connection = None
self.disconnect_handler_res = None
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 setUp(self):
self.scheduler = yogi.Scheduler()
self.node = yogi.Node(self.scheduler)
self.leaf = yogi.Leaf(self.scheduler)
self.connection = yogi.LocalConnection(self.node, self.leaf)
def setUp(self):
self.scheduler = yogi.Scheduler()
self.leaf = yogi.Leaf(self.scheduler)
def setUp(self):
self.scheduler = yogi.Scheduler()
self.endpointA = yogi.Leaf(self.scheduler)
self.endpointB = yogi.Leaf(self.scheduler)
self.connection = yogi.LocalConnection(self.endpointA, self.endpointB)
def test_str(self):
obj = yogi.Object(ctypes.c_void_p())
self.assertRegexpMatches(str(obj), r'.*Object.*INVALID.*')
scheduler = yogi.Scheduler()
self.assertRegexpMatches(str(scheduler),
r'.*Scheduler.*0x[0-9a-f]{8}.*')
def test_init(self):
obj = yogi.Object(ctypes.c_void_p())
scheduler = yogi.Scheduler()
def setUp(self):
self.scheduler = yogi.Scheduler()
