def test_liveliness_changed_status(self):
dp = dds.DomainParticipant()
topic_name = 'ST_liveliness_changed_status'
gci = ddsutil.get_dds_classes_from_idl(self.idl_path,
self.shape_type_name)
t = gci.register_topic(dp, topic_name)
rd = dp.create_datareader(t)
status = rd.liveliness_changed_status()
Info = namedtuple('Info', ['name', 'type'])
attrs = [
Info('alive_count', int),
Info('not_alive_count', int),
Info('alive_count_change', int),
Info('not_alive_count_change', int),
Info('last_publication_handle', int)
]
self.assertIsNotNone(status, 'status is None')
self.assertIsInstance(status, dds.LivelinessChangedStatus)
for a in attrs:
self.assertTrue(hasattr(status, a.name))
self.assertIsInstance(getattr(status, a.name), a.type,
'{} is not a {}'.format(a.name, a.type))
def test_read_cond(self):
dp = dds.DomainParticipant()
gci = ddsutil.get_dds_classes_from_idl(self.idl_path,
self.shape_type_name)
ShapeType = gci.get_class('ShapeType')
Inner = gci.get_class('Inner')
t = gci.register_topic(dp, 'ST_test_take_cond')
rd = dp.create_datareader(t)
wr = dp.create_datawriter(t)
qc = rd.create_querycondition(expression='x = 1')
dataR = ShapeType(color='RED', x=1, y=1, z=1, t=Inner(foo=1))
dataG = ShapeType(color='GREEN', x=1, y=1, z=1, t=Inner(foo=1))
dataB = ShapeType(color='BLUE', x=2, y=1, z=1, t=Inner(foo=1))
wr.write(dataR)
wr.write(dataG)
wr.write(dataB)
samples = rd.read_cond(qc, 3)
self.assertEqual(2, len(samples))
found = [s.data.color for s in samples]
self.assertIn('RED', found)
self.assertIn('GREEN', found)
def testTopic_bytesData(self):
myData = b'Topic Bytes Topic Data'
builtinTopicName = 'DCPSTopic'
sawMyData = Event()
class L(dds.Listener):
def on_data_available(self, reader):
nonlocal sawMyData
while True:
r = reader.take(n = 1)
if len(r) == 0:
break
elif r[0].status.valid_data:
try:
v = bytes(r[0].data.topic_data.value)
if v == myData:
sawMyData.set()
break
except UnicodeError:
pass
builtin_sub = self.dp.create_subscriber(qos=dds.Qos([dds.PartitionQosPolicy(['__BUILT-IN PARTITION__'])]))
builtin_topic_info = ddsutil.find_and_register_topic(self.dp, builtinTopicName)
builtin_reader = builtin_sub.create_datareader(builtin_topic_info.topic, qos=builtin_topic_info.topic.qos, listener=L())
# Register a topic with a TopicdataQosPolicy
t_qos = dds.Qos(policies=[dds.TopicdataQosPolicy(myData)])
info = ddsutil.get_dds_classes_from_idl('idl/Shapes.idl', "ShapeType")
t = info.register_topic(self.dp, "T_testTopic_bytesData", t_qos)
self.assertIsNotNone(t, "Topic registration failed")
self.assertTrue(sawMyData.wait(10), 'Did not see expected data')
builtin_reader.close()
def testSimplifiedFindAPI(self):
idl_path = 'idl/' + 'Thales' + '.idl'
type_info = 'test::C_TopicStruct'
gen_info = ddsutil.get_dds_classes_from_idl(idl_path, type_info)
dp1 = DomainParticipant()
tq1 = Qos([DurabilityQosPolicy(DDSDurabilityKind.PERSISTENT)])
topic_dp1 = gen_info.register_topic(dp1, 'DP1_C_TopicStruct_2',tq1)
self.assertEqual('DP1_C_TopicStruct_2', topic_dp1.name, 'Topic name not as expected')
self.assertEqual(type_info, topic_dp1.type_name, 'Type name not as expected')
self.assertEqual('A_ID.A_ID,A_ID.A_subID', topic_dp1.keylist, 'Key list not as expected')
self.assertEqual('<MetaData version="1.0.0"><Module name="test"><Struct name="T_ID"><Member name="A_ID"><Long/></Member><Member name="A_subID"><Long/></Member></Struct><TypeDef name="T_IDList"><Sequence><Type name="T_ID"/></Sequence></TypeDef><Struct name="C_TopicStruct"><Member name="A_ID"><Type name="T_ID"/></Member><Member name="A_ForeignIDList"><Type name="T_IDList"/></Member><Member name="value"><Long/></Member></Struct></Module></MetaData>',
topic_dp1.metadescriptor, 'Meta descriptor not as expected')
dp2 = DomainParticipant()
topic_dp2, gen_info2 = ddsutil.find_and_register_topic(dp2, 'DP1_C_TopicStruct_2')
self.assertIsNotNone(topic_dp2, 'Found topic is not None')
self.assertEqual('DP1_C_TopicStruct_2', topic_dp2.name, 'Found topic name not as expected')
self.assertEqual(type_info, topic_dp2.type_name, 'Found type name not as expected')
self.assertEqual('A_ID.A_ID,A_ID.A_subID', topic_dp2.keylist, 'Found key list not as expected')
self.assertEqual('<MetaData version="1.0.0"><Module name="test"><Struct name="T_ID"><Member name="A_ID"><Long/></Member><Member name="A_subID"><Long/></Member></Struct><TypeDef name="T_IDList"><Sequence><Type name="T_ID"/></Sequence></TypeDef><Struct name="C_TopicStruct"><Member name="A_ID"><Type name="T_ID"/></Member><Member name="A_ForeignIDList"><Type name="T_IDList"/></Member><Member name="value"><Long/></Member></Struct></Module></MetaData>',
topic_dp2.metadescriptor, 'Found meta descriptor not as expected')
sub2 = dp2.create_subscriber()
# now register the found topic locally, and test reading and writing between the participants
self.assertIsNotNone(gen_info2, 'Returned gen_info2 is None')
tq2 = topic_dp2.qos
self.assertIsNotNone(tq2)
# TODO: need get copy topic qos
#local_topic_dp2 = register_topic_locally(topic_dp2)
# local_topic_dp2 = gen_info2.register_topic(dp2, topic_dp2.get_name(), tq2)
# Reader for dp2
result_holder = ResultHolder()
event = Event()
rd2 = sub2.create_datareader(topic_dp2, tq2, DataAvailableListener(result_holder, event))
# Writer for dp1
pub1 = dp1.create_publisher()
wr1 = pub1.create_datawriter(topic_dp1, tq1)
# create the data
Outer = gen_info.get_class('test::C_TopicStruct')
Inner = gen_info.get_class('test::T_ID')
data1 = Outer()
data1.A_ID = Inner(A_ID=21,A_subID=212)
data1.A_ForeignIDList = [Inner(A_ID=22,A_subID=223),Inner(A_ID=23,A_subID=234)]
data1.value = 242
wr1.write(data1)
# let the listener catch up...
self.assertTrue(event.wait(10.0), 'wait timed out')
self.assertEqual(str(data1), result_holder.result, 'read and write results do not match')
def test_on_inconsistent_topic(self):
'''
from: osplo/testsuite/dbt/api/dcps/c99/utest/listener/code/listener_utests.c
It's not that easy for OpenSplice to generate inconsistent_topic
events. However, it is build on top of SAC and it works on that
language binding. We can assume that this test succeeds when
the other listener test pass as well...
So, we will just check that the listener's actually got installed
'''
topic_name = 'ST_on_inconsistent_topic'
event = threading.Event()
gci = ddsutil.get_dds_classes_from_idl(self.idl_path,
self.shape_type_name)
# gci2 = ddsutil.get_dds_classes_from_idl(self.idl_path, self.shape_type_name + '2')
class L(Listener):
def on_inconsistent_topic(self, topic, status):
print(
'on_inconsistent_topic triggered: topic name = {}, total_count = {}, total_change_count = {}'
.format(topic.get_name(), status.total_coutn,
status.total_change_count))
event.set()
dp1 = DomainParticipant(listener=L())
self.assertIsNotNone(dp1.listener,
"DomainParticipant Listener was not set")
t1 = gci.register_topic(dp1, topic_name, listener=L())
self.assertIsNotNone(t1.listener, "Topic Listener was not set")
def test_take_cond(self):
dp = dds.DomainParticipant()
gci = ddsutil.get_dds_classes_from_idl(self.idl_path,
self.shape_type_name)
ShapeType = gci.get_class('ShapeType')
Inner = gci.get_class('Inner')
t = gci.register_topic(dp, 'ST_test_take_cond')
rd = dp.create_datareader(t)
wr = dp.create_datawriter(t)
qc = rd.create_querycondition(expression='color = %0',
parameters=['RED'])
dataR = ShapeType(color='RED', x=1, y=1, z=1, t=Inner(foo=1))
dataG = ShapeType(color='GREEN', x=1, y=1, z=1, t=Inner(foo=1))
wr.write(dataR)
wr.write(dataG)
data = rd.take_cond(qc, 2)
self.assertEqual(1, len(data))
found = [d.color for d, _ in data]
self.assertIn('RED', found)
def test_publication_matched_status(self):
dp = dds.DomainParticipant()
topic_name = 'ST_publication_matched_status'
gci = ddsutil.get_dds_classes_from_idl(self.idl_path,
self.shape_type_name)
t = gci.register_topic(dp, topic_name)
wr = dp.create_datawriter(t)
status = wr.publication_matched_status()
Info = namedtuple('Info', ['name', 'type'])
attrs = [
Info('total_count', int),
Info('total_count_change', int),
Info('current_count', int),
Info('current_count_change', int),
Info('last_subscription_handle', int)
]
self.assertIsNotNone(status, 'status is None')
self.assertIsInstance(status, dds.PublicationMatchedStatus)
for a in attrs:
self.assertTrue(hasattr(status, a.name))
self.assertIsInstance(getattr(status, a.name), a.type,
'{} is not a {}'.format(a.name, a.type))
def test_on_data_available(self):
topic_name = 'ST_on_data_available'
event = threading.Event()
dp1 = DomainParticipant()
gci = ddsutil.get_dds_classes_from_idl(self.idl_path,
self.shape_type_name)
ShapeType = gci.get_class('ShapeType')
Inner = gci.get_class('Inner')
t1 = gci.register_topic(dp1, topic_name)
wr1 = dp1.create_datawriter(t1)
class L(Listener):
def on_data_available(self, _):
event.set()
dp2 = DomainParticipant()
t2 = gci.register_topic(dp2, topic_name)
rd2 = dp2.create_datareader(t2, listener=L())
data = ShapeType(color='RED', x=1, y=2, z=3, t=Inner(foo=4))
wr1.write(data)
self.assertTrue(event.wait(self.time_out),
'Did not receive on_data_available')
def test_on_data_available(self):
topic_name = 'ST_on_data_available'
event = threading.Event()
dp1 = DomainParticipant()
gci = ddsutil.get_dds_classes_from_idl(self.idl_path, self.shape_type_name)
ShapeType = gci.get_class('ShapeType')
Inner = gci.get_class('Inner')
t1 = gci.register_topic(dp1, topic_name)
wr1 = dp1.create_datawriter(t1)
class L(Listener):
def on_data_available(self,_):
event.set()
dp2 = DomainParticipant()
t2 = gci.register_topic(dp2, topic_name)
rd2 = dp2.create_datareader(t2,listener=L())
data = ShapeType(color='RED',x=1,y=2,z=3,t=Inner(foo=4))
wr1.write(data)
self.assertTrue(event.wait(self.time_out),'Did not receive on_data_available')
def test_on_inconsistent_topic(self):
'''
from: osplo/testsuite/dbt/api/dcps/c99/utest/listener/code/listener_utests.c
It's not that easy for OpenSplice to generate inconsistent_topic
events. However, it is build on top of SAC and it works on that
language binding. We can assume that this test succeeds when
the other listener test pass as well...
So, we will just check that the listener's actually got installed
'''
topic_name = 'ST_on_inconsistent_topic'
event = threading.Event()
gci = ddsutil.get_dds_classes_from_idl(self.idl_path, self.shape_type_name)
# gci2 = ddsutil.get_dds_classes_from_idl(self.idl_path, self.shape_type_name + '2')
class L(Listener):
def on_inconsistent_topic(self, topic, status):
print('on_inconsistent_topic triggered: topic name = {}, total_count = {}, total_change_count = {}'
.format(topic.get_name(), status.total_coutn, status.total_change_count))
event.set()
dp1 = DomainParticipant(listener=L())
self.assertIsNotNone(dp1.listener, "DomainParticipant Listener was not set")
t1 = gci.register_topic(dp1, topic_name, listener=L())
self.assertIsNotNone(t1.listener, "Topic Listener was not set")
def test_on_data_available(self):
topic_name = 'ST_on_data_available'
event = self.event
gci = ddsutil.get_dds_classes_from_idl(self.idl_path, self.shape_type_name)
ShapeType = gci.get_class('ShapeType')
Inner = gci.get_class('Inner')
print('createing writer')
t1 = gci.register_topic(self.dp2, topic_name)
wr1 = self.dp2.create_datawriter(t1)
class L(Listener):
# def on_requested_deadline_missed(self, _, __):
# Listener.on_requested_deadline_missed(self)
def on_data_available(self,_):
print('triggering event')
event.set()
print('creating reader with listener')
t2 = gci.register_topic(self.dp2, topic_name)
rd2 = self.dp2.create_datareader(t2,listener=L())
print('writing')
data = ShapeType(color='RED',x=1,y=2,z=3,t=Inner(foo=4))
wr1.write(data)
try:
print('waiting for listener to trigger')
self.assertTrue(self.event.wait(2.0),'Did not receive on_data_available')
print('done waiting')
finally:
print('closing rd2')
# rd2.close()
print('all done')
def test_read_cond(self):
dp = dds.DomainParticipant()
gci = ddsutil.get_dds_classes_from_idl(self.idl_path, self.shape_type_name)
ShapeType = gci.get_class('ShapeType')
Inner = gci.get_class('Inner')
t = gci.register_topic(dp, 'ST_test_take_cond')
rd = dp.create_datareader(t)
wr = dp.create_datawriter(t)
qc = rd.create_querycondition(expression='x = 1')
dataR = ShapeType(color='RED',x=1,y=1,z=1,t=Inner(foo=1))
dataG = ShapeType(color='GREEN',x=1,y=1,z=1,t=Inner(foo=1))
dataB = ShapeType(color='BLUE',x=2,y=1,z=1,t=Inner(foo=1))
wr.write(dataR)
wr.write(dataG)
wr.write(dataB)
samples = rd.read_cond(qc,3)
self.assertEqual(2, len(samples))
found = [s.data.color for s in samples]
self.assertIn('RED',found)
self.assertIn('GREEN',found)
def run(self):
qp = QosProvider('file://DDS_DefaultQoS_All.xml',
'DDS DefaultQosProfile')
dp = DomainParticipant(qos=qp.get_participant_qos())
pub = dp.create_publisher(qos=qp.get_publisher_qos())
gen_info = ddsutil.get_dds_classes_from_idl(
'example1.idl', 'Sample::DataTypesList::DataTypes')
topic = gen_info.register_topic(dp, "Example", qp.get_topic_qos())
writer = pub.create_datawriter(topic, qp.get_writer_qos())
Inner = gen_info.get_class("Sample::DataTypesList::Inner")
Color = gen_info.get_class("Sample::DataTypesList::Color")
inner1 = Inner(short1=self.sn, double1=222)
inner2 = Inner(short1=777, double1=333)
time.sleep(0.5)
data = gen_info.topic_data_class(longValue=self.sn,
booleanValue=True,
charValue='a',
stringValue='Fire!',
seq1=[inner1, inner2],
color1=Color.Red)
writer.write(data)
print(data)
def suscriptor_statix():
sus_status = threading.current_thread()
while getattr(sus_status, "do_run", True):
qp = QosProvider('file://DDS_DefaultQoS_All.xml',
'DDS DefaultQosProfile')
# Create participant
dp = DomainParticipant(qos=qp.get_participant_qos())
# Create Subscriber
sub = dp.create_subscriber(qos=Qos([
DurabilityQosPolicy(DDSDurabilityKind.TRANSIENT),
ReliabilityQosPolicy(DDSReliabilityKind.RELIABLE),
PartitionQosPolicy([Partition])
]))
# Generate python classes from IDL file
gen_info = ddsutil.get_dds_classes_from_idl(
'status.idl', 'com::ulma::supervisor::dds::status::Status')
# Type support class
topic = gen_info.register_topic(dp, "Status", qp.get_topic_qos())
# Create a reader
readerQos = qp.get_reader_qos()
reader = sub.create_datareader(topic, readerQos)
AgentType = gen_info.get_class(
"com::ulma::supervisor::dds::status::AgentReferenceType")
time.sleep(1)
# Create waitset
waitset = WaitSet()
condition = ReadCondition(reader, DDSMaskUtil.all_samples())
waitset.attach(condition)
# Wait for data
conditions = waitset.wait()
# Print data
while sus_status.do_run == True:
listaSamples = reader.take(10)
for (sampleData, sampleInformation) in listaSamples:
if sampleInformation.valid_data:
ldDestinatario = sampleData.src_id.ld
lnDestinatario = sampleData.src_id.ln
print("Status recibido: [LD: {}; LN: {}]".format(
ldDestinatario, lnDestinatario))
if (ldDestinatario == AgenteLD) and (lnDestinatario
== AgenteLN):
print("Es para mi")
else:
print(
"Este status no es para mi. Es para : [LD: {}; LN: {}]"
.format(ldDestinatario, lnDestinatario))
sus_status.do_run = False
def __init__(self, component, name, volatile):
self.name = name
self.volatile = volatile
self.type = ddsutil.get_dds_classes_from_idl(component.idl_path, name)
self.DataType = self.type.topic_data_class
topic_name = name.replace("::", "_")
topic_qos = component.domain.volatile_topic_qos if volatile else component.domain.topic_qos
self.topic = self.type.register_topic(component.domain.participant,
topic_name, topic_qos)
def WaitForThrottleInputRoutine(threadName, idlFile):
global isFinished;
print('Thread {}: starting'.format(threadName))
print('{} => Initializing DDS and idl files ...'.format(threadName))
vehicleSignalTopicName = 'VehicleSignalTopic'
tVehicleSignal = 'basic::module_vehicleSignal::vehicleSignalStruct'
vehicleSignalIdlClass = ddsutil.get_dds_classes_from_idl(idlFile, tVehicleSignal);
vehicleSignalTopic = vehicleSignalIdlClass.register_topic(dp, vehicleSignalTopicName)
pub = dp.create_publisher()
qos = Qos([ReliabilityQosPolicy(DDSReliabilityKind.RELIABLE)])
vehicleSignalWriter = pub.create_datawriter(vehicleSignalTopic, qos)
print('Press w to increase throttle, s to decrease throttle, q to quit')
throttle = 0
messageId = 1;
vehicleSpeed = 0.0;
while True:
print('Throttle = {}'.format(throttle))
keyboardInput = readchar.readkey()
print("keyboardInput: {}".format(keyboardInput))
if keyboardInput == 'w':
print("increasing throttle")
if throttle < 100:
throttle += 1
vehicleSpeed += (throttle * 0.6)
elif keyboardInput == 'q':
# setting isFinished = true will signal WaitForVehicleSignalStructTask
# to return
print('{} => Exiting'.format(threadName))
isFinished = True
return
else:
if throttle > 0:
throttle -= 1
if vehicleSpeed - 2 < 0:
vehicleSpeed = 0
elif vehicleSpeed > 0:
vehicleSpeed -= 2
# sends dds message vehicleSignalStruct (vehicle_speed)
vehicleSignalMessage = vehicleSignalIdlClass.topic_data_class(
id=messageId, vehicle_speed=vehicleSpeed)
vehicleSignalMessage.id = messageId
vehicleSignalMessage.throttle = throttle
vehicleSignalMessage.vehicle_speed = vehicleSpeed
vehicleSignalMessage.simulation_time = str(int(time.monotonic() * 1e9))
vehicleSignalWriter.write(vehicleSignalMessage)
messageId += 1
def test_unregistration(self):
dp = dds.DomainParticipant()
gci = ddsutil.get_dds_classes_from_idl(self.idl_path, self.shape_type_name)
ShapeType = gci.get_class('ShapeType')
Inner = gci.get_class('Inner')
t = gci.register_topic(dp, 'ST_test_unregistration')
wr = dp.create_datawriter(t)
#data = ShapeType(color='RED')
data = ShapeType(color='RED',x=0,y=0,z=0,t=Inner(foo=0))
data2 = ShapeType(color='BLUE',x=0,y=0,z=0,t=Inner(foo=0))
data3 = ShapeType(color='YELLOW',x=0,y=0,z=0,t=Inner(foo=0))
data4 = ShapeType(color='PINK',x=0,y=0,z=0,t=Inner(foo=0))
dataNever = ShapeType(color='NEVER',x=0,y=0,z=0,t=Inner(foo=0))
h = wr.register_instance(data)
h2 = wr.register_instance(data2)
h3 = wr.register_instance(data3)
h4 = wr.register_instance(data4)
self.assertIsNotNone(h, 'handle is None')
self.assertIsInstance(h, int, 'handle is not int')
# test expected success paths
wr.unregister_instance(handle=h)
wr.unregister_instance(data=data2)
# test failure paths
try:
wr.unregister_instance()
self.fail('should not succeed; unregistering inconsistent data')
except dds.DDSException:
pass
# unregister something that's already unregistered
try:
wr.unregister_instance(handle=h)
self.fail('should not succeed; duplicate unregistration')
except dds.DDSException:
pass
# unregister something that was never registered
try:
wr.unregister_instance(data=dataNever)
self.fail('should not succeed; instance never registered')
except dds.DDSException:
pass
# The following are not failures, but will produce oslp-error.log entries
# unregister something where data does not match
wr.unregister_instance(dataNever, h4)
def AddTopic(self, sTopicName, sDataClassName):
if (sTopicName == None or sTopicName == ''):
return
if (self.__oTopics == None):
self.__oTopics = []
gen_info = ddsutil.get_dds_classes_from_idl(self.__sDataStructureFile,
sDataClassName)
oTopic = gen_info.register_topic(self.__oDP, sTopicName,
self.__oQP.get_topic_qos())
self.__oTopics.append(oTopic)
def genInfo(self, datatype):
global mutex
guard = OpenRTM_aist.ScopedLock(mutex)
if datatype in self._info:
return self._info[datatype]
datainfo = OpenSpliceMessageInfo.OpenSpliceMessageInfoList.instance().getInfo(datatype)
if datainfo:
datatype = datainfo.datatype()
idlfile = datainfo.idlFile()
self._info[datatype] = ddsutil.get_dds_classes_from_idl(idlfile,
datatype)
return self._info[datatype]
return None
def get_idl(self, name, *args):
dds_name = "basic::module_" + name + "::" + name + "_struct"
gci = ddsutil.get_dds_classes_from_idl(
os.path.join('idl', name + '.idl'), dds_name)
names = [name]
names.extend(args)
dict = {}
for n in names:
dds_name = "basic::module_" + name + "::" + n
if n == name:
dds_name += '_struct'
dict[n] = gci.get_class(dds_name)
return dict
def conexxion_Status():
publi_status = threading.current_thread()
while getattr(publi_status, "do_run", True):
qosprovider = QosProvider('file://DDS_DefaultQoS_All.xml',
'DDS DefaultQosProfile')
# Create participant
domainparticipant = DomainParticipant(
qos=qosprovider.get_participant_qos())
# Create publisher
pub = domainparticipant.create_publisher(qos=Qos([
DurabilityQosPolicy(DDSDurabilityKind.TRANSIENT),
ReliabilityQosPolicy(DDSReliabilityKind.RELIABLE),
PartitionQosPolicy([Partition])
]))
# Generate python classes from IDL file
gen_info = ddsutil.get_dds_classes_from_idl(
'status.idl', 'com::ulma::supervisor::dds::status::Status')
# Type support class
topic = gen_info.register_topic(domainparticipant, "Status",
qosprovider.get_topic_qos())
AgentType = gen_info.get_class(
"com::ulma::supervisor::dds::status::AgentReferenceType")
# Create a writer
writer = pub.create_datawriter(topic)
writer = pub.create_datawriter(topic, qosprovider.get_writer_qos())
# ES UNA CONDICION PARA QUE NO PUBLIQUE NADA SI EL KILL ESTA ACTIVADO
#if suscrip_kill.do_run == False:
#publi_status.do_run = False
while suscrip_kill.do_run == True:
id = AgentType(ld=AgenteLD, ln=AgenteLN)
sample1 = gen_info.topic_data_class(src_id=id,
status=StatusAgente,
error_description=sys.argv[1],
masterSlave=sys.argv[2])
writer.write(sample1)
time.sleep(6.0)
print("status")
print(sample1)
def genInfo(self, datatype):
global mutex
guard = OpenRTM_aist.ScopedLock(mutex)
if datatype in self._info:
return self._info[datatype]
factory = OpenSpliceMessageInfo.OpenSpliceMessageInfoFactory.instance()
datainfo = factory.createObject(datatype)
if datainfo:
datatype = datainfo.datatype()
idlfile = datainfo.idlFile()
factory.deleteObject(datainfo)
self._info[datatype] = ddsutil.get_dds_classes_from_idl(
idlfile, datatype)
return self._info[datatype]
return None
def conexxion_LlamadaRequest():
publi_request = multiprocessing.current_process()
while getattr(publi_request, "do_run", True):
qosprovider = QosProvider('file://DDS_DefaultQoS_All.xml',
'DDS DefaultQosProfile')
# Create participant
domainparticipant = DomainParticipant(
qos=qosprovider.get_participant_qos())
# Create publisher
pub = domainparticipant.create_publisher(qos=Qos([
DurabilityQosPolicy(DDSDurabilityKind.TRANSIENT),
ReliabilityQosPolicy(DDSReliabilityKind.RELIABLE),
PartitionQosPolicy(['the_partition'])
]))
# Generate python classes from IDL file
gen_info = ddsutil.get_dds_classes_from_idl(
'LauncherReq.idl',
'com::ulma::supervisor::dds::launcherReq::LauncherReq')
# Type support class
topic = gen_info.register_topic(domainparticipant, "LauncherReq",
qosprovider.get_topic_qos())
AgentType = gen_info.get_class(
"com::ulma::supervisor::dds::launcherReq::AgentReferenceType")
# Create a writer
writer = pub.create_datawriter(topic)
writer = pub.create_datawriter(topic, qosprovider.get_writer_qos())
while publi_request.do_run == True:
s_id = AgentType(ld="Mod", ln="bus")
d_id = AgentType(ld="Modbus", ln="MShuttle")
sample = gen_info.topic_data_class(
src_id=s_id,
dst_id=d_id,
command=1,
request_id=0,
)
writer.write(sample)
time.sleep(3.0)
print("LlamadaReq")
print(sample)
def testGroup_textData(self):
myData = 'Pub Text Group Data'
builtinTopicName = 'DCPSPublication'
sawMyData = Event()
class L(dds.Listener):
def on_data_available(self, reader):
nonlocal sawMyData
while True:
r = reader.take(n=1)
if len(r) == 0:
break
elif r[0].status.valid_data:
try:
v = bytes(r[0].data.group_data.value).decode(
'ISO-8859-1')
if v == myData:
sawMyData.set()
break
except UnicodeError:
pass
builtin_sub = self.dp.create_subscriber(
qos=dds.Qos([dds.PartitionQosPolicy(['__BUILT-IN PARTITION__'])]))
builtin_topic_info = ddsutil.find_and_register_topic(
self.dp, builtinTopicName)
builtin_reader = builtin_sub.create_datareader(
builtin_topic_info.topic,
qos=builtin_topic_info.topic.qos,
listener=L())
# Register a topic with a TopicdataQosPolicy
p_qos = dds.Qos(policies=[dds.GroupdataQosPolicy(myData)])
pub = self.dp.create_publisher(p_qos)
info = ddsutil.get_dds_classes_from_idl('idl/Shapes.idl', "ShapeType")
t = info.register_topic(self.dp, "T_testGroup_textData")
self.assertIsNotNone(t, "Topic registration failed")
dw = pub.create_datawriter(t)
self.assertTrue(sawMyData.wait(10), 'Did not see expected data')
builtin_reader.close()
dw.close()
pub.close()
def serialize(self, data):
factory = OpenSpliceMessageInfo.OpenSpliceMessageInfoFactory.instance()
info = factory.createObject(data._NP_RepositoryId)
if info:
datatype = info.datatype()
idlFile = info.idlFile()
factory.deleteObject(info)
try:
gen_info = ddsutil.get_dds_classes_from_idl(idlFile, datatype)
osdata = gen_info.topic_data_class(**OmniDataToDDSData(data, gen_info))
if osdata:
return OpenRTM_aist.ByteDataStreamBase.SERIALIZE_OK, osdata
else:
return OpenRTM_aist.ByteDataStreamBase.SERIALIZE_ERROR, osdata
except:
return OpenRTM_aist.ByteDataStreamBase.SERIALIZE_ERROR, None
else:
return OpenRTM_aist.ByteDataStreamBase.SERIALIZE_NOTFOUND, None
def test_registration(self):
dp = dds.DomainParticipant()
gci = ddsutil.get_dds_classes_from_idl(self.idl_path, self.shape_type_name)
ShapeType = gci.get_class('ShapeType')
Inner = gci.get_class('Inner')
t = gci.register_topic(dp, 'ST_test_registration')
wr = dp.create_datawriter(t)
#data = ShapeType(color='RED')
data = ShapeType(color='RED',x=0,y=0,z=0,t=Inner(foo=0))
h = wr.register_instance(data)
self.assertIsNotNone(h, 'handle is None')
self.assertIsInstance(h, int, 'handle is not int')
wr.unregister_instance(data, h)
def test_on_sample_lost(self):
handlerTriggered = threading.Event()
saved_status = None
class L(Listener):
def on_sample_lost(self, reader, status):
nonlocal saved_status
saved_status = status
handlerTriggered.set()
qos = Qos(policies=[
DestinationOrderQosPolicy(
DDSDestinationOrderKind.BY_SOURCE_TIMESTAMP)
])
dp = DomainParticipant()
topic_name = 'ST_on_sample_lost'
gci = ddsutil.get_dds_classes_from_idl(self.idl_path,
self.shape_type_name)
t = gci.register_topic(dp, topic_name)
wr = dp.create_datawriter(t, qos)
rd = dp.create_datareader(t, qos, L())
ShapeType = gci.get_class('ShapeType')
Inner = gci.get_class('Inner')
data1 = ShapeType(color='GREEN', x=22, y=33, z=44, t=Inner(foo=55))
t1 = DDSTime(1000, 0)
t2 = DDSTime(1001, 0)
# write out-of-order samples
wr.write_ts(data1, t2)
rd.take()
wr.write_ts(data1, t1)
self.assertTrue(handlerTriggered.wait(self.time_out),
'Event not triggered')
self._check_status(saved_status, SampleLostStatus, [
Info('total_count', int),
Info('total_count_change', int),
])
def test_liveliness_lost_status(self):
dp = dds.DomainParticipant()
topic_name = 'ST_liveliness_lost_status'
gci = ddsutil.get_dds_classes_from_idl(self.idl_path, self.shape_type_name)
t = gci.register_topic(dp, topic_name)
wr = dp.create_datawriter(t)
status = wr.liveliness_lost_status()
Info = namedtuple('Info', ['name','type'])
attrs = [Info('total_count', int),
Info('total_count_change', int),
]
self.assertIsNotNone(status, 'status is None')
self.assertIsInstance(status, dds.LivelinessLostStatus)
for a in attrs:
self.assertTrue(hasattr(status, a.name))
self.assertIsInstance(getattr(status, a.name), a.type, '{} is not a {}'.format(a.name, a.type))
def test_on_requested_deadline_missed(self):
handlerTriggered = threading.Event()
write_time = 0.0
delay = 0.0
saved_status = None
class L(Listener):
def on_requested_deadline_missed(self, reader, status):
nonlocal delay
nonlocal saved_status
saved_status = status
handlerTriggered.set()
delay = time.time() - write_time
dp = DomainParticipant()
topic_name = 'ST_on_requested_deadline_missed'
gci = ddsutil.get_dds_classes_from_idl(self.idl_path,
self.shape_type_name)
t = gci.register_topic(dp, topic_name)
qos = Qos(policies=[DeadlineQosPolicy(DDSDuration(1, 0))])
wr = dp.create_datawriter(t, qos)
rd = dp.create_datareader(t, qos, L())
ShapeType = gci.get_class('ShapeType')
Inner = gci.get_class('Inner')
data = ShapeType(color='GREEN', x=22, y=33, z=44, t=Inner(foo=55))
wr.write(data)
write_time = time.time()
self.assertTrue(handlerTriggered.wait(self.time_out),
'Event not triggered')
self.assertGreaterEqual(delay, 1.0 - 0.05, 'Delay not >= 1.0s')
self._check_status(saved_status, RequestedDeadlineMissedStatus, [
Info('total_count', int),
Info('total_count_change', int),
Info('last_instance_handle', int),
])
def test_requested_incompatible_qos_status(self):
dp = dds.DomainParticipant()
topic_name = 'ST_requested_incompatible_qos_status'
gci = ddsutil.get_dds_classes_from_idl(self.idl_path, self.shape_type_name)
t = gci.register_topic(dp, topic_name)
rd = dp.create_datareader(t)
status = rd.requested_incompatible_qos_status()
Info = namedtuple('Info', ['name','type'])
attrs = [Info('total_count', int),
Info('total_count_change', int),
Info('last_policy_id', dds.QosPolicyId),
]
self.assertIsNotNone(status, 'status is None')
self.assertIsInstance(status, dds.RequestedIncompatibleQosStatus)
for a in attrs:
self.assertTrue(hasattr(status, a.name))
self.assertIsInstance(getattr(status, a.name), a.type, '{} is not a {}'.format(a.name, a.type))
def conexxion_sendInfo():
publi_sendinfo = multiprocessing.current_process()
while getattr(publi_sendinfo, "do_run", True):
qosprovider = QosProvider('file://DDS_DefaultQoS_All.xml',
'DDS DefaultQosProfile')
# Create participant
domainparticipant = DomainParticipant(
qos=qosprovider.get_participant_qos())
# Create publisher with type suport class(dentro del parentersis)
pub = domainparticipant.create_publisher(qos=Qos([
DurabilityQosPolicy(DDSDurabilityKind.TRANSIENT),
ReliabilityQosPolicy(DDSReliabilityKind.RELIABLE),
PartitionQosPolicy(['the_partition'])
]))
# Generate python classes from IDL file
gen_info = ddsutil.get_dds_classes_from_idl(
'sendInfo.idl', 'com::ulma::supervisor::dds::sendInfo::SendInfo')
# Type support class
topic = gen_info.register_topic(domainparticipant, "SendInfo",
qosprovider.get_topic_qos())
AgentType = gen_info.get_class(
"com::ulma::supervisor::dds::sendInfo::AgentReferenceType")
# Create a writer
writer = pub.create_datawriter(topic)
writer = pub.create_datawriter(topic, qosprovider.get_writer_qos())
while publi_sendinfo.do_run == True:
s_id = AgentType(ld="modbus", ln="Mshuttle")
d_id = AgentType(ld="Modbus", ln="MShuttle")
sample = gen_info.topic_data_class(src_id=s_id, dst_agent_id=d_id)
writer.write(sample)
time.sleep(3.0)
print("SendInfo")
print(sample)
def test_on_requested_deadline_missed(self):
handlerTriggered = threading.Event()
write_time = 0.0
delay = 0.0
saved_status = None
class L(Listener):
def on_requested_deadline_missed(self, reader, status):
nonlocal delay
nonlocal saved_status
saved_status = status
handlerTriggered.set()
delay = time.time() - write_time
dp = DomainParticipant()
topic_name = 'ST_on_requested_deadline_missed'
gci = ddsutil.get_dds_classes_from_idl(self.idl_path, self.shape_type_name)
t = gci.register_topic(dp, topic_name)
qos = Qos(policies=[
DeadlineQosPolicy(DDSDuration(1,0))
])
wr = dp.create_datawriter(t, qos)
rd = dp.create_datareader(t, qos, L())
ShapeType = gci.get_class('ShapeType')
Inner = gci.get_class('Inner')
data = ShapeType(color='GREEN', x=22, y=33, z=44, t=Inner(foo=55))
wr.write(data)
write_time = time.time()
self.assertTrue(handlerTriggered.wait(self.time_out), 'Event not triggered')
self.assertGreaterEqual(delay, 1.0 - 0.05, 'Delay not >= 1.0s')
self._check_status(saved_status, RequestedDeadlineMissedStatus, [
Info('total_count', int),
Info('total_count_change', int),
Info('last_instance_handle', int),
])
def test_on_sample_lost(self):
handlerTriggered = threading.Event()
saved_status = None
class L(Listener):
def on_sample_lost(self, reader, status):
nonlocal saved_status
saved_status = status
handlerTriggered.set()
qos = Qos(policies=[
DestinationOrderQosPolicy(DDSDestinationOrderKind.BY_SOURCE_TIMESTAMP)
])
dp = DomainParticipant()
topic_name = 'ST_on_sample_lost'
gci = ddsutil.get_dds_classes_from_idl(self.idl_path, self.shape_type_name)
t = gci.register_topic(dp, topic_name)
wr = dp.create_datawriter(t, qos)
rd = dp.create_datareader(t, qos, L())
ShapeType = gci.get_class('ShapeType')
Inner = gci.get_class('Inner')
data1 = ShapeType(color='GREEN', x=22, y=33, z=44, t=Inner(foo=55))
t1 = DDSTime(1000,0)
t2 = DDSTime(1001,0)
# write out-of-order samples
wr.write_ts(data1, t2)
rd.take()
wr.write_ts(data1, t1)
self.assertTrue(handlerTriggered.wait(self.time_out), 'Event not triggered')
self._check_status(saved_status, SampleLostStatus, [
Info('total_count', int),
Info('total_count_change', int),
])
def test_on_sample_rejected(self):
handlerTriggered = threading.Event()
saved_status = None
class L(Listener):
def on_sample_rejected(self, reader, status):
nonlocal saved_status
saved_status = status
handlerTriggered.set()
dp = DomainParticipant()
topic_name = 'ST_on_sample_rejected'
gci = ddsutil.get_dds_classes_from_idl(self.idl_path,
self.shape_type_name)
t = gci.register_topic(dp, topic_name)
qos = Qos(policies=[ResourceLimitsQosPolicy(max_samples=1)])
wr = dp.create_datawriter(t)
rd = dp.create_datareader(t, qos, L())
ShapeType = gci.get_class('ShapeType')
Inner = gci.get_class('Inner')
data1 = ShapeType(color='GREEN', x=22, y=33, z=44, t=Inner(foo=55))
data2 = ShapeType(color='BLUE', x=222, y=233, z=244, t=Inner(foo=255))
wr.write(data1)
self.assertFalse(handlerTriggered.is_set(), 'Event already triggered')
wr.write(data2)
self.assertTrue(handlerTriggered.wait(self.time_out),
'Event not triggered')
self._check_status(saved_status, SampleRejectedStatus, [
Info('total_count', int),
Info('total_count_change', int),
Info('last_reason', DDSSampleRejectedStatusKind),
Info('last_instance_handle', int),
])
def test_liveliness_changed_status(self):
dp = dds.DomainParticipant()
topic_name = 'ST_liveliness_changed_status'
gci = ddsutil.get_dds_classes_from_idl(self.idl_path, self.shape_type_name)
t = gci.register_topic(dp, topic_name)
rd = dp.create_datareader(t)
status = rd.liveliness_changed_status()
Info = namedtuple('Info', ['name','type'])
attrs = [Info('alive_count', int),
Info('not_alive_count', int),
Info('alive_count_change', int),
Info('not_alive_count_change', int),
Info('last_publication_handle', int)]
self.assertIsNotNone(status, 'status is None')
self.assertIsInstance(status, dds.LivelinessChangedStatus)
for a in attrs:
self.assertTrue(hasattr(status, a.name))
self.assertIsInstance(getattr(status, a.name), a.type, '{} is not a {}'.format(a.name, a.type))
def test_publication_matched_status(self):
dp = dds.DomainParticipant()
topic_name = 'ST_publication_matched_status'
gci = ddsutil.get_dds_classes_from_idl(self.idl_path, self.shape_type_name)
t = gci.register_topic(dp, topic_name)
wr = dp.create_datawriter(t)
status = wr.publication_matched_status()
Info = namedtuple('Info', ['name','type'])
attrs = [Info('total_count', int),
Info('total_count_change', int),
Info('current_count', int),
Info('current_count_change', int),
Info('last_subscription_handle', int)]
self.assertIsNotNone(status, 'status is None')
self.assertIsInstance(status, dds.PublicationMatchedStatus)
for a in attrs:
self.assertTrue(hasattr(status, a.name))
self.assertIsInstance(getattr(status, a.name), a.type, '{} is not a {}'.format(a.name, a.type))
def test_wr_instance_lookup(self):
dp = dds.DomainParticipant()
gci = ddsutil.get_dds_classes_from_idl(self.idl_path, self.shape_type_name)
ShapeType = gci.get_class('ShapeType')
Inner = gci.get_class('Inner')
t = gci.register_topic(dp, 'ST_test_wr_instance_lookup')
wr = dp.create_datawriter(t)
#data = ShapeType(color='RED')
data = ShapeType(color='RED',x=0,y=0,z=0,t=Inner(foo=0))
dataUnreg = ShapeType(color='GREEN',x=0,y=0,z=0,t=Inner(foo=0))
h = wr.register_instance(data)
hlookup = wr.lookup_instance(data)
self.assertEqual(hlookup, h)
hUnreg = wr.lookup_instance(dataUnreg)
self.assertIsNone(hUnreg)
def test_sample_rejected_status(self):
dp = dds.DomainParticipant()
topic_name = 'ST_sample_rejected_status'
gci = ddsutil.get_dds_classes_from_idl(self.idl_path, self.shape_type_name)
t = gci.register_topic(dp, topic_name)
rd = dp.create_datareader(t)
status = rd.sample_rejected_status()
Info = namedtuple('Info', ['name','type'])
attrs = [Info('total_count', int),
Info('total_count_change', int),
Info('last_reason', dds.DDSSampleRejectedStatusKind),
Info('last_instance_handle', int),
]
self.assertIsNotNone(status, 'status is None')
self.assertIsInstance(status, dds.SampleRejectedStatus)
for a in attrs:
self.assertTrue(hasattr(status, a.name))
self.assertIsInstance(getattr(status, a.name), a.type, '{} is not a {}'.format(a.name, a.type))
def test_on_sample_rejected(self):
handlerTriggered = threading.Event()
saved_status = None
class L(Listener):
def on_sample_rejected(self, reader, status):
nonlocal saved_status
saved_status = status
handlerTriggered.set()
dp = DomainParticipant()
topic_name = 'ST_on_sample_rejected'
gci = ddsutil.get_dds_classes_from_idl(self.idl_path, self.shape_type_name)
t = gci.register_topic(dp, topic_name)
qos = Qos(policies=[
ResourceLimitsQosPolicy(max_samples=1)
])
wr = dp.create_datawriter(t)
rd = dp.create_datareader(t, qos, L())
ShapeType = gci.get_class('ShapeType')
Inner = gci.get_class('Inner')
data1 = ShapeType(color='GREEN', x=22, y=33, z=44, t=Inner(foo=55))
data2 = ShapeType(color='BLUE', x=222, y=233, z=244, t=Inner(foo=255))
wr.write(data1)
self.assertFalse(handlerTriggered.is_set(), 'Event already triggered')
wr.write(data2)
self.assertTrue(handlerTriggered.wait(self.time_out), 'Event not triggered')
self._check_status(saved_status, SampleRejectedStatus, [
Info('total_count', int),
Info('total_count_change', int),
Info('last_reason', DDSSampleRejectedStatusKind),
Info('last_instance_handle', int),
])
def test_liveliness_lost_status(self):
dp = dds.DomainParticipant()
topic_name = 'ST_liveliness_lost_status'
gci = ddsutil.get_dds_classes_from_idl(self.idl_path,
self.shape_type_name)
t = gci.register_topic(dp, topic_name)
wr = dp.create_datawriter(t)
status = wr.liveliness_lost_status()
Info = namedtuple('Info', ['name', 'type'])
attrs = [
Info('total_count', int),
Info('total_count_change', int),
]
self.assertIsNotNone(status, 'status is None')
self.assertIsInstance(status, dds.LivelinessLostStatus)
for a in attrs:
self.assertTrue(hasattr(status, a.name))
self.assertIsInstance(getattr(status, a.name), a.type,
'{} is not a {}'.format(a.name, a.type))
def test_on_requested_incompatible_qos(self):
handlerTriggered = threading.Event()
saved_status = None
class L(Listener):
def on_requested_incompatible_qos(self, reader, status):
nonlocal saved_status
saved_status = status
handlerTriggered.set()
dp = DomainParticipant()
topic_name = 'ST_test_on_requested_incompatible_qos'
gci = ddsutil.get_dds_classes_from_idl(self.idl_path, self.shape_type_name)
t = gci.register_topic(dp, topic_name)
wqos = Qos(policies=[
DurabilityQosPolicy(DDSDurabilityKind.VOLATILE)
])
rqos = Qos(policies=[
DurabilityQosPolicy(DDSDurabilityKind.TRANSIENT)
])
wr = dp.create_datawriter(t, wqos)
rd = dp.create_datareader(t,rqos, L())
ShapeType = gci.get_class('ShapeType')
Inner = gci.get_class('Inner')
data = ShapeType(color='GREEN', x=22, y=33, z=44, t=Inner(foo=55))
wr.write(data)
self.assertTrue(handlerTriggered.wait(self.time_out), 'Event not triggered')
self._check_status(saved_status, RequestedIncompatibleQosStatus, [
Info('total_count', int),
Info('total_count_change', int),
Info('last_policy_id', QosPolicyId),
])
def test_requested_incompatible_qos_status(self):
dp = dds.DomainParticipant()
topic_name = 'ST_requested_incompatible_qos_status'
gci = ddsutil.get_dds_classes_from_idl(self.idl_path,
self.shape_type_name)
t = gci.register_topic(dp, topic_name)
rd = dp.create_datareader(t)
status = rd.requested_incompatible_qos_status()
Info = namedtuple('Info', ['name', 'type'])
attrs = [
Info('total_count', int),
Info('total_count_change', int),
Info('last_policy_id', dds.QosPolicyId),
]
self.assertIsNotNone(status, 'status is None')
self.assertIsInstance(status, dds.RequestedIncompatibleQosStatus)
for a in attrs:
self.assertTrue(hasattr(status, a.name))
self.assertIsInstance(getattr(status, a.name), a.type,
'{} is not a {}'.format(a.name, a.type))
def test_on_requested_incompatible_qos(self):
handlerTriggered = threading.Event()
saved_status = None
class L(Listener):
def on_requested_incompatible_qos(self, reader, status):
nonlocal saved_status
saved_status = status
handlerTriggered.set()
dp = DomainParticipant()
topic_name = 'ST_test_on_requested_incompatible_qos'
gci = ddsutil.get_dds_classes_from_idl(self.idl_path,
self.shape_type_name)
t = gci.register_topic(dp, topic_name)
wqos = Qos(policies=[DurabilityQosPolicy(DDSDurabilityKind.VOLATILE)])
rqos = Qos(policies=[DurabilityQosPolicy(DDSDurabilityKind.TRANSIENT)])
wr = dp.create_datawriter(t, wqos)
rd = dp.create_datareader(t, rqos, L())
ShapeType = gci.get_class('ShapeType')
Inner = gci.get_class('Inner')
data = ShapeType(color='GREEN', x=22, y=33, z=44, t=Inner(foo=55))
wr.write(data)
self.assertTrue(handlerTriggered.wait(self.time_out),
'Event not triggered')
self._check_status(saved_status, RequestedIncompatibleQosStatus, [
Info('total_count', int),
Info('total_count_change', int),
Info('last_policy_id', QosPolicyId),
])
def test_take_cond(self):
dp = dds.DomainParticipant()
gci = ddsutil.get_dds_classes_from_idl(self.idl_path, self.shape_type_name)
ShapeType = gci.get_class('ShapeType')
Inner = gci.get_class('Inner')
t = gci.register_topic(dp, 'ST_test_take_cond')
rd = dp.create_datareader(t)
wr = dp.create_datawriter(t)
qc = rd.create_querycondition(expression='color = %0', parameters=['RED'])
dataR = ShapeType(color='RED',x=1,y=1,z=1,t=Inner(foo=1))
dataG = ShapeType(color='GREEN',x=1,y=1,z=1,t=Inner(foo=1))
wr.write(dataR)
wr.write(dataG)
data = rd.take_cond(qc,2)
self.assertEqual(1, len(data))
found = [d.color for d, _ in data]
self.assertIn('RED',found)
def test_read_instance(self):
dp = dds.DomainParticipant()
gci = ddsutil.get_dds_classes_from_idl(self.idl_path, self.shape_type_name)
ShapeType = gci.get_class('ShapeType')
Inner = gci.get_class('Inner')
t = gci.register_topic(dp, 'ST_test_read_instance')
rd = dp.create_datareader(t)
wr = dp.create_datawriter(t)
dataR = ShapeType(color='RED',x=1,y=1,z=1,t=Inner(foo=1))
dataG = ShapeType(color='GREEN',x=1,y=1,z=1,t=Inner(foo=1))
keyR = ShapeType(color='RED',x=0,y=0,z=0,t=Inner(foo=0))
hR = rd.lookup_instance(keyR)
self.assertIsNone(hR)
wr.write(dataR)
wr.write(dataG)
hR = rd.lookup_instance(keyR)
self.assertIsInstance(hR, int)
data = rd.read_instance(hR,n=2)
self.assertEqual(1, len(data))
found = [d.color for d, _ in data]
self.assertIn('RED',found)
#do it again
data = rd.read_instance(hR,n=2)
self.assertEqual(1, len(data))
found = [d.color for d, _ in data]
self.assertIn('RED',found)
if __name__ == "__main__":
qp = QosProfile('file://DDS_VolatileQoS_All.xml', 'DDS VolatileQosProfile')
# Create participant
dp = DomainParticipant(qos=qp.get_participant_qos())
# Create publisher
pub = dp.create_publisher(qos=qp.get_publisher_qos())
# Create Subscriber
sub = dp.create_subscriber(qos=qp.get_subscriber_qos())
# Generate python classes from IDL file
gen_info = ddsutil.get_dds_classes_from_idl('example2.idl', 'basic::module_Enum2::Enum2_struct')
# Register topic
topic = gen_info.register_topic(dp, "Example2", qp.get_topic_qos())
# Create a writer
writer = pub.create_datawriter(topic, qp.get_writer_qos())
readerQos = qp.get_reader_qos()
reader = sub.create_datareader(topic, readerQos, DataAvailableListener())
reader2 = sub.create_datareader(topic, readerQos)
# Topic data class
ColorA = gen_info.get_class("basic::module_Enum2::Color")
ColorZ = gen_info.get_class("basic::enumZ::Color")
s = gen_info.topic_data_class(long1 = 4, color1 = ColorA.Green, color2=ColorZ.Blue, array=[ColorZ.Red, ColorZ.Blue])
qp = QosProfile('file://DDS_DefaultQoS_All.xml', 'DDS DefaultQosProfile')
# Create participant
dp = DomainParticipant(qos = qp.get_participant_qos())
# Create publisher
pub = dp.create_publisher(qos = qp.get_publisher_qos())
# Create Subscriber
sub = dp.create_subscriber(qos = qp.get_subscriber_qos())
# Generate python classes from IDL file
gen_info = ddsutil.get_dds_classes_from_idl('example1.idl',
'basic::module_SequenceOfStruct::SequenceOfStruct_struct')
# Type support class
topic = gen_info.register_topic(dp, "Example1", qp.get_topic_qos())
# Create a writer
writer = pub.create_datawriter(topic, qp.get_writer_qos())
readerQos = qp.get_reader_qos()
reader = sub.create_datareader(topic, readerQos)
Inner = gen_info.get_class("basic::module_SequenceOfStruct::Inner")
inner1 = Inner(short1 = 999, double1=222)
inner2 = Inner(short1 = 777, double1=333)
# Topic data class
s = gen_info.topic_data_class(long1=2, seq1 = [inner1, inner2])
def test_liveliness(self):
handlerTriggered = threading.Event()
aliveTriggered = threading.Event()
notaliveTriggered = threading.Event()
write_time = 0.0
delay = 0.0
saved_lost_status = None
saved_changed_status = None
class L(Listener):
def on_liveliness_lost(self, writer, status):
nonlocal delay
nonlocal saved_lost_status
saved_lost_status = status
handlerTriggered.set()
delay = time.time() - write_time
class RL(Listener):
def on_liveliness_changed(self, reader, status):
nonlocal saved_changed_status
saved_changed_status = status
if status.alive_count == 1:
aliveTriggered.set()
else:
notaliveTriggered.set()
qos = Qos(policies=[
LivelinessQosPolicy(DDSLivelinessKind.MANUAL_BY_TOPIC,
DDSDuration(1,0)),
OwnershipQosPolicy(DDSOwnershipKind.EXCLUSIVE)
])
dp = DomainParticipant()
topic_name = 'ST_liveliness'
gci = ddsutil.get_dds_classes_from_idl(self.idl_path, self.shape_type_name)
t = gci.register_topic(dp, topic_name, qos)
wr = dp.create_datawriter(t, qos=qos, listener=L())
rd = dp.create_datareader(t, qos=qos, listener=RL())
ShapeType = gci.get_class('ShapeType')
Inner = gci.get_class('Inner')
data = ShapeType(color='GREEN', x=22, y=33, z=44, t=Inner(foo=55))
wr.write(data)
write_time = time.time()
self.assertTrue(handlerTriggered.wait(self.time_out), 'Event not triggered')
self.assertGreaterEqual(delay, 1.0 - 0.05, 'Delay not >= 1.0s')
self.assertTrue(aliveTriggered.wait(self.time_out), 'Alive not signaled to reader')
self.assertTrue(notaliveTriggered.wait(self.time_out), 'Not Alive not signaled to reader')
self._check_status(saved_lost_status, LivelinessLostStatus, [
Info('total_count', int),
Info('total_count_change', int),
])
self._check_status(saved_changed_status, LivelinessChangedStatus, [
Info('alive_count', int),
Info('not_alive_count', int),
Info('alive_count_change', int),
Info('not_alive_count_change', int),
Info('last_publication_handle', int),
])
def test_data_available_listeners(self):
dp_on_data_available_event = threading.Event()
dp_on_publication_matched_event = threading.Event()
dp_on_subscription_matched_event = threading.Event()
p_on_publication_matched_event = threading.Event()
s_on_data_available_event = threading.Event()
s_on_subscription_matched_event = threading.Event()
wr_on_publication_matched_event = threading.Event()
rd_on_data_available_event = threading.Event()
rd_on_subscription_matched_event = threading.Event()
opm_event = threading.Event()
osm_event = threading.Event()
oda_event = threading.Event()
pub_match_status = None
sub_match_status = None
class DPL(Listener):
def on_data_available(self,reader):
dp_on_data_available_event.set()
oda_event.set()
def on_publication_matched(self,writer,status):
dp_on_publication_matched_event.set()
opm_event.set()
def on_subscription_matched(self,reader,status):
dp_on_subscription_matched_event.set()
osm_event.set()
class PL(Listener):
def on_publication_matched(self,writer, status):
p_on_publication_matched_event.set()
class SL(Listener):
def on_data_available(self,reader):
s_on_data_available_event.set()
oda_event.set()
def on_subscription_matched(self,reader, status):
s_on_subscription_matched_event.set()
osm_event.set()
class WL(Listener):
def on_publication_matched(self,writer, status):
nonlocal pub_match_status
pub_match_status = status
wr_on_publication_matched_event.set()
opm_event.set()
class RL(Listener):
def on_data_available(self,reader):
rd_on_data_available_event.set()
oda_event.set()
def on_subscription_matched(self,reader, status):
nonlocal sub_match_status
sub_match_status = status
rd_on_subscription_matched_event.set()
osm_event.set()
dp = DomainParticipant(listener=DPL())
self.assertIsInstance(dp.listener, DPL, 'listener is not a DPL')
topic_name = 'ST_data_available_listeners'
gci = ddsutil.get_dds_classes_from_idl(self.idl_path, self.shape_type_name)
t = gci.register_topic(dp, topic_name)
pub = dp.create_publisher(listener=PL())
self.assertIsInstance(pub.listener, PL, 'listener is not a PL')
sub = dp.create_subscriber(listener=SL())
self.assertIsInstance(sub.listener, SL, 'listener is not a SL')
wr = pub.create_datawriter(t, listener=WL())
self.assertIsInstance(wr.listener, WL, 'listener is not a WL')
rd = sub.create_datareader(t, listener=RL())
self.assertIsInstance(rd.listener, RL, 'listener is not a RL')
ShapeType = gci.get_class('ShapeType')
Inner = gci.get_class('Inner')
data = ShapeType(color='GREEN', x=22, y=33, z=44, t=Inner(foo=55))
# time.sleep(1.0)
wr.write(data)
TriggerState = collections.namedtuple('TriggerState',[
'opm',
'osm',
'oda',
])
actual_trigger_state = TriggerState(
opm_event.wait(self.time_out),
osm_event.wait(self.time_out),
oda_event.wait(self.time_out))
print(actual_trigger_state)
self.assertEqual(
actual_trigger_state,
TriggerState(True, True, True)
, 'Not all events triggered')
EventState = collections.namedtuple('EventState',[
'dp_opm',
'p_opm',
'wr_opm',
'dp_osm',
's_osm',
'rd_osm',
'dp_oda',
's_oda',
'rd_oda',
])
actual_event_state = EventState(
dp_on_publication_matched_event.is_set(),
p_on_publication_matched_event.is_set(),
wr_on_publication_matched_event.is_set(),
dp_on_subscription_matched_event.is_set(),
s_on_subscription_matched_event.is_set(),
rd_on_subscription_matched_event.is_set(),
dp_on_data_available_event.is_set(),
s_on_data_available_event.is_set(),
rd_on_data_available_event.is_set(),
)
expected_event_state = EventState(
False, False, True,
False, False, True,
False, False, True,
)
print(actual_event_state)
self.assertEqual(actual_event_state, expected_event_state, 'Incorrect listeners triggered')
# time.sleep(1.0)
# self.assertTrue(wr_on_publication_matched_event.wait(self.time_out), 'wr_on_publication_matched_event')
# self.assertTrue(rd_on_subscription_matched_event.wait(self.time_out), 'rd_on_subscription_matched_event')
self._check_status(pub_match_status, PublicationMatchedStatus, [
Info('total_count', int),
Info('total_count_change', int),
Info('current_count', int),
Info('current_count_change', int),
Info('last_subscription_handle', int),
])
self._check_status(sub_match_status, SubscriptionMatchedStatus, [
Info('total_count', int),
Info('total_count_change', int),
Info('current_count', int),
Info('current_count_change', int),
Info('last_publication_handle', int),
])
