def test_liveliness(manual_setup, hitpoint_factory):
handler = hitpoint_factory()
alive = hitpoint_factory()
notalive = hitpoint_factory()
class MyListenerWriter(Listener):
def on_liveliness_lost(self, writer, status):
handler.hit(data=timestamp.now())
class MyListenerReader(Listener):
def on_liveliness_changed(self, reader, status):
if status.alive_count == 1:
alive.hit(data=status.alive_count_change)
else:
notalive.hit(data=status.alive_count_change)
qos = Qos(Policy.Liveliness.ManualByTopic(duration(seconds=0.2)),
Policy.Ownership.Exclusive)
manual_setup.tp(qos=qos)
manual_setup.dr(listener=MyListenerReader())
datawriter = manual_setup.dw(listener=MyListenerWriter())
write_time = timestamp.now()
datawriter.write(manual_setup.msg)
assert handler.was_hit()
assert handler.data - write_time >= duration(seconds=0.2)
assert alive.was_hit() and alive.data == 1
assert notalive.was_hit() and notalive.data == -1
def test_builtin_dcps_participant():
dp = DomainParticipant(0)
sub = Subscriber(dp)
dr1 = BuiltinDataReader(sub, BuiltinTopicDcpsParticipant)
dr2 = BuiltinDataReader(sub, BuiltinTopicDcpsSubscription)
assert isgoodentity(dr1)
assert isgoodentity(dr2)
for msg in dr1.read_iter(timeout=duration(milliseconds=10)):
assert msg.key == dp.guid
for msg in dr2.take_iter(timeout=duration(milliseconds=10)):
msg.key in [dr1.guid, dr2.guid]
def test_on_requested_deadline_missed(manual_setup, hitpoint):
class MyListener(Listener):
def on_requested_deadline_missed(self, reader, status):
hitpoint.hit(data=timestamp.now())
qos = Qos(Policy.Deadline(duration(seconds=0.2)))
datawriter = manual_setup.dw(qos=qos)
manual_setup.dr(qos=qos, listener=MyListener())
write_time = timestamp.now()
datawriter.write(manual_setup.msg)
assert hitpoint.was_hit()
assert hitpoint.data - write_time >= duration(seconds=0.2)
def work_fn(worker):
time_start = datetime.datetime.now()
v = True
while v and not worker.is_stopped():
txt = worker.get_input()
if txt:
try: # Integer or list
text = eval(txt)
manager.write(text)
except NameError: # String
manager.write(txt.rstrip("\n"))
except SyntaxError:
raise Exception("Input unrecognizable, please check your input.")
manager.read()
waitset.wait(duration(microseconds=20))
if args.runtime:
v = datetime.datetime.now() < time_start + datetime.timedelta(seconds=args.runtime)
# Write to file
if args.filename:
try:
with open(args.filename, 'w') as f:
json.dump(manager.track_samples, f, indent=4)
print(f"\nResults have been written to file {args.filename}\n")
except OSError:
raise Exception(f"Could not open file {args.filename}")
if not v:
os._exit(0)
def test_reader_waitforhistoricaldata():
dp = DomainParticipant(0)
tp = Topic(dp, "Message__DONOTPUBLISH", Message)
sub = Subscriber(dp)
dr = DataReader(sub, tp)
assert dr.wait_for_historical_data(duration(milliseconds=5))
def main():
managers = []
args = create_parser()
dp = DomainParticipant(args.id)
topics = parse_args(args)
waitset = WaitSet(dp)
for topic_type, topic in topics:
managers.append(TopicManager(BuiltinDataReader(dp, topic), topic_type, args))
managers[-1].add_to_waitset(waitset)
if args.watch:
try:
while True:
for manager in managers:
waitset.wait(duration(milliseconds=20))
manager.poll()
except KeyboardInterrupt:
pass
else:
for manager in managers:
manager.poll()
if args.filename:
try:
with open(args.filename, 'w') as f:
Output.to_file(manager, managers, f)
print("\nResults have been written to file", args.filename, "\n")
except OSError:
print("could not open file")
return 1
return 0
def main():
qos_manager = Qosmanager()
qos = None
args = create_parser()
if args.qos:
args.qos = ' '.join(args.qos)
myqos = qos_manager.construct_policy(args.qos)
qos = Qos(myqos)
dp = DomainParticipant(0)
waitset = WaitSet(dp)
manager = Topicmanger(args, dp, qos, waitset)
if args.topic:
try:
while True:
input = select.select([sys.stdin], [], [], 0)[0]
if input:
for text in sys.stdin.readline().split():
try:
text = int(text)
manager.write(text)
except ValueError:
manager.write(text.rstrip("\n"))
manager.read()
waitset.wait(duration(microseconds=20))
except KeyboardInterrupt:
sys.exit(0)
def main(sys_args):
JsonWriter.reset()
managers = []
args = create_parser(sys_args)
dp = DomainParticipant(args.id)
topics = parse_args(args)
waitset = WaitSet(dp)
for topic_type, topic in topics:
# Create TopicManager for each topic
managers.append(
TopicManager(BuiltinDataReader(dp, topic), topic_type, args))
managers[-1].add_to_waitset(waitset)
if not args.filename and args.json:
print("[")
# Watchmode
if args.watch:
try:
time_start = datetime.datetime.now()
v = True
while v:
for manager in managers:
waitset.wait(duration(milliseconds=20))
manager.poll()
if args.runtime:
v = datetime.datetime.now(
) < time_start + datetime.timedelta(seconds=args.runtime)
except KeyboardInterrupt:
pass
# Non-watchmode
else:
time_start = datetime.datetime.now()
runtime = args.runtime or 1
while datetime.datetime.now() < time_start + datetime.timedelta(
seconds=runtime):
for manager in managers:
manager.poll()
if not args.filename and args.json:
print("]")
# Write to file
if args.filename:
try:
with open(args.filename, 'w') as f:
data = {
manager.topic_type: manager.as_dict()
for manager in managers
}
json.dump(data, f, indent=4)
print(f"\nResults have been written to file {args.filename}\n")
except OSError:
raise Exception(f"Could not open file {args.filename}")
return 0
def test_waitset_wait(common_setup):
ws = WaitSet(common_setup.dp)
rc1 = ReadCondition(common_setup.dr,
ViewState.Any | InstanceState.Any | SampleState.Any)
ws.attach(rc1)
assert ws.wait(duration(milliseconds=5)) == 0
common_setup.dw.write(Message(message="Hi!"))
assert ws.wait(duration(seconds=1)) == 1
rc2 = ReadCondition(
common_setup.dr,
ViewState.Any | InstanceState.Any | SampleState.NotRead)
ws.attach(rc2)
assert ws.wait(duration(seconds=1)) == 2
def test_writeto_writer():
dp = DomainParticipant(0)
tp = Topic(dp, "Message", Message)
pub = Publisher(dp)
dw = DataWriter(pub, tp)
msg = Message(message="TestMessage")
dw.write(msg)
assert dw.wait_for_acks(duration(seconds=1))
def check_enforced_non_communication(log: Stream, ctx: FullContext,
typename: str) -> bool:
datatype_regular = ctx.get_datatype(typename)
if datatype_regular.__idl__.keyless:
return True
narrow_ctx = ctx.narrow_context_of(typename)
new_scope = deepcopy(narrow_ctx.scope)
non_valid_mutation(new_scope, typename)
mutated_ctx = FullContext(new_scope)
mutated_datatype = mutated_ctx.get_datatype(typename)
normal_without_header_idl = "\n".join(narrow_ctx.idl_file.splitlines()[1:])
mutated_without_header_idl = "\n".join(
mutated_ctx.idl_file.splitlines()[1:])
if normal_without_header_idl == mutated_without_header_idl:
# No mutation took place (only unions) just assume it is good
return True
dp = DomainParticipant()
try:
tp = Topic(dp, typename, mutated_datatype)
except DDSException:
# Sometimes the type gets so mangled (like empty structs/unions)
# that it is not a valid topic type anymore. We'll consider this a
# successful test.
return True
dw = DataWriter(
dp,
tp,
qos=Qos(Policy.DataRepresentation(use_xcdrv2_representation=True),
Policy.Reliability.Reliable(duration(seconds=2)),
Policy.DestinationOrder.BySourceTimestamp))
dw.set_status_mask(DDSStatus.PublicationMatched)
dw.take_status()
ctx.c_app.run(typename, 1)
now = time.time()
while (dw.take_status() & DDSStatus.PublicationMatched) == 0:
if time.time() - now > 0.5:
ctx.c_app.process.kill()
return True
time.sleep(0.001)
ctx.c_app.process.kill()
log << f"C-app agreed to communicate with non-valid mutation" << log.endl << log.indent
log << log.dedent << "[Mutated IDL]:" << log.indent << log.endl
log << mutated_ctx.idl_file << log.endl
log << log.dedent
return False
def __init__(self, domain_id=0):
self.qos = Qos(Policy.Reliability.Reliable(duration(seconds=2)), Policy.History.KeepLast(10))
self.dp = DomainParticipant(domain_id)
self._tp = None
self._pub = None
self._sub = None
self._dw = None
self._dr = None
self.msg = Message(message="hi")
self.msg2 = Message(message="hi2")
def __init__(self, domain_id=0):
self.qos = Qos(Policy.Reliability.Reliable(duration(seconds=2)), Policy.History.KeepLast(10))
self.dp = DomainParticipant(domain_id)
self.tp = Topic(self.dp, 'Message', Message)
self.pub = Publisher(self.dp)
self.sub = Subscriber(self.dp)
self.dw = DataWriter(self.pub, self.tp, qos=self.qos)
self.dr = DataReader(self.sub, self.tp, qos=self.qos)
self.msg = Message(message="hi")
self.msg2 = Message(message="hi2")
def discover_datatype(participant, topic_name: str):
drp = BuiltinDataReader(participant, BuiltinTopicDcpsPublication)
drpc = ReadCondition(drp, InstanceState.Alive)
drs = BuiltinDataReader(participant, BuiltinTopicDcpsSubscription)
drsc = ReadCondition(drs, InstanceState.Alive)
ws = WaitSet(participant)
ws.attach(drp)
ws.attach(drs)
while True:
for s in drp.take_iter(condition=drpc,
timeout=duration(milliseconds=1)):
if s.topic_name == topic_name and s.type_id is not None:
return get_types_for_typeid(participant, s.type_id,
duration(seconds=5))
for s in drs.take_iter(condition=drsc,
timeout=duration(milliseconds=1)):
if s.topic_name == topic_name and s.type_id is not None:
return get_types_for_typeid(participant, s.type_id,
duration(seconds=5))
ws.wait(duration(milliseconds=4))
def test_dynamic_subscribe(common_setup):
type_id = common_setup.tp.data_type.__idl__.get_type_id()
dp = DomainParticipant(common_setup.dp.domain_id)
datatype, _ = get_types_for_typeid(dp, type_id, duration(seconds=1))
assert datatype
tp = Topic(dp, common_setup.tp.name, datatype)
dr = DataReader(dp, tp)
common_setup.dw.write(common_setup.msg)
assert dr.read()[0].message == common_setup.msg.message
def test_dynamic_publish_complex():
dp = DomainParticipant()
tp = Topic(dp, 'DynTest', XStruct)
rd = DataReader(dp, tp)
type_id = XStruct.__idl__.get_type_id()
datatype, tmap = get_types_for_typeid(dp, type_id, duration(seconds=1))
assert datatype
assert datatype.__idl__.get_type_id() == XStruct.__idl__.get_type_id()
tp = Topic(dp, 'DynTest', datatype)
wr = DataWriter(dp, tp)
wr.write(datatype(A=tmap['XUnion'](A=tmap['XEnum'].V1), k=1))
assert rd.read()[0].k == 1
def test_dynamic_subscribe_complex():
dp = DomainParticipant()
tp = Topic(dp, 'DynTest', XStruct)
wr = DataWriter(dp, tp)
type_id = XStruct.__idl__.get_type_id()
datatype, tmap = get_types_for_typeid(dp, type_id, duration(seconds=1))
assert datatype
assert datatype.__idl__.get_type_id() == XStruct.__idl__.get_type_id()
tp = Topic(dp, 'DynTest', datatype)
dr = DataReader(dp, tp)
wr.write(XStruct(A=XUnion(A=XEnum.V1), k=1))
assert dr.read()[0].k == 1
def manage_dcps_object(dp, topic_type, topic):
dr = BuiltinDataReader(dp, topic)
samples = dr.take_iter(timeout=duration(milliseconds=10))
for sample in samples:
if topic_type == 'PARTICIPANT':
sample = {topic_type: [{"key": str(sample.key)}]}
else:
sample = {
topic_type: [{
"key": str(sample.key),
"participant_key": str(sample.participant_key),
"topic_name": sample.topic_name,
"qos": sample.qos.asdict()
}]
}
return sample
def test_reader_readiter():
dp = DomainParticipant(0)
tp = Topic(dp, "Message", Message)
sub = Subscriber(dp)
pub = Publisher(dp)
dr = DataReader(sub, tp)
dw = DataWriter(pub, tp)
msg = Message("Hello")
dw.write(msg)
read = False
for msgr in dr.read_iter(timeout=duration(milliseconds=10)):
assert not read
assert msg == msgr
read = True
def test_on_sample_lost(manual_setup, hitpoint):
class MyListener(Listener):
def on_sample_lost(self, reader, status):
hitpoint.hit()
qos = Qos(Policy.DestinationOrder.BySourceTimestamp)
datawriter = manual_setup.dw(qos=qos)
datareader = manual_setup.dr(qos=qos, listener=MyListener())
t1 = timestamp.now()
t2 = t1 + duration(seconds=1)
datawriter.write(manual_setup.msg, timestamp=t2)
datareader.take()
datawriter.write(manual_setup.msg, timestamp=t1)
assert hitpoint.was_hit()
def integer(self):
# Integers can represent: a duration or an amount
data = self.pop().lower()
if '=' in data:
# Allow writing durations like "seconds=10;minutes=12"
duration_expression = {
k: float(v)
for k, v in dict(
value.split("=") for value in data.split(';')).items()
}
data = duration(**duration_expression)
elif data in ["infinity", "inf"]:
data = dds_infinity
else:
data = int(data)
return data
import time
import random
from cyclonedds.core import Qos, Policy
from cyclonedds.domain import DomainParticipant
from cyclonedds.pub import Publisher, DataWriter
from cyclonedds.topic import Topic
from cyclonedds.util import duration
from vehicles import Vehicle
qos = Qos(Policy.Reliability.BestEffort(duration(seconds=1)),
Policy.Deadline(duration(microseconds=10)),
Policy.Durability.Transient, Policy.History.KeepLast(10))
domain_participant = DomainParticipant(0)
topic = Topic(domain_participant, 'Vehicle', Vehicle, qos=qos)
publisher = Publisher(domain_participant)
writer = DataWriter(publisher, topic)
cart = Vehicle(name="Dallara IL-15", x=200, y=200)
while True:
cart.x += random.choice([-1, 0, 1])
cart.y += random.choice([-1, 0, 1])
writer.write(cart)
print(">> Wrote vehicle")
time.sleep(random.random() * 0.9 + 0.1)
import time
import random
from cyclonedds.core import Qos, Policy
from cyclonedds.domain import DomainParticipant
from cyclonedds.pub import Publisher, DataWriter
from cyclonedds.topic import Topic
from cyclonedds.util import duration
from vehicles import Vehicle
qos = Qos(Policy.Reliability.BestEffort,
Policy.Deadline(duration(microseconds=10)),
Policy.Durability.Transient, Policy.History.KeepLast(10))
domain_participant = DomainParticipant(0)
topic = Topic(domain_participant, 'Vehicle', Vehicle, qos=qos)
publisher = Publisher(domain_participant)
writer = DataWriter(publisher, topic)
cart = Vehicle(name="Dallara IL-15", x=200, y=200)
while True:
cart.x += random.choice([-1, 0, 1])
cart.y += random.choice([-1, 0, 1])
writer.write(cart)
print(">> Wrote vehicle")
time.sleep(random.random() * 0.9 + 0.1)
async def task1(reader):
async for sample in reader.take_aiter(timeout=duration(seconds=2)):
print(sample)
*
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
"""
from cyclonedds.core import Listener, WaitSet, ReadCondition, ViewState, SampleState, InstanceState, Qos, Policy
from cyclonedds.domain import DomainParticipant
from cyclonedds.topic import Topic
from cyclonedds.sub import Subscriber, DataReader
from cyclonedds.util import duration
from vehicles import Vehicle
class MyListener(Listener):
def on_liveliness_changed(self, reader, status):
print(">> Liveliness event")
listener = MyListener()
qos = Qos(Policy.Reliability.BestEffort(duration(seconds=1)),
Policy.Deadline(duration(microseconds=10)),
Policy.Durability.Transient, Policy.History.KeepLast(10))
domain_participant = DomainParticipant(0)
topic = Topic(domain_participant, 'Vehicle', Vehicle, qos=qos)
subscriber = Subscriber(domain_participant)
reader = DataReader(domain_participant, topic, listener=listener)
for sample in reader.take_iter(timeout=duration(seconds=2)):
print(sample)
*
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
"""
from cyclonedds.core import Listener, WaitSet, ReadCondition, ViewState, SampleState, InstanceState, Qos, Policy
from cyclonedds.domain import DomainParticipant
from cyclonedds.topic import Topic
from cyclonedds.sub import Subscriber, DataReader
from cyclonedds.util import duration
from vehicles import Vehicle
class MyListener(Listener):
def on_liveliness_changed(self, reader, status):
print(">> Liveliness event")
listener = MyListener()
qos = Qos(Policy.Reliability.BestEffort,
Policy.Deadline(duration(microseconds=10)),
Policy.Durability.Transient, Policy.History.KeepLast(10))
domain_participant = DomainParticipant(0)
topic = Topic(domain_participant, 'Vehicle', Vehicle, qos=qos)
subscriber = Subscriber(domain_participant)
reader = DataReader(domain_participant, topic, listener=listener)
for sample in reader.take_iter(timeout=duration(seconds=2)):
print(sample)
from cyclonedds.domain import DomainParticipant
from cyclonedds.builtin import BuiltinDataReader, BuiltinTopicDcpsParticipant
from cyclonedds.util import duration
dp = DomainParticipant()
dr = BuiltinDataReader(dp, BuiltinTopicDcpsParticipant)
for sample in dr.take_iter(timeout=duration(milliseconds=10)):
print(sample)
def check_py_c_key_equivalence(log: Stream, ctx: FullContext, typename: str,
num_samples: int) -> bool:
datatype = ctx.get_datatype(typename)
if datatype.__idl__.keyless:
return True
samples = [
generate_random_instance(datatype, seed=i) for i in range(num_samples)
]
# We need to make sure the samples all have unique keys to make sure that we agree
# on sample ordering with C
keysamples = {}
for s in samples:
keysamples[datatype.__idl__.key(s)] = s
samples = list(keysamples.values())
dp = DomainParticipant()
tp = Topic(dp, typename, datatype)
dw = DataWriter(
dp,
tp,
qos=Qos(Policy.DataRepresentation(use_xcdrv2_representation=True),
Policy.History.KeepLast(len(samples)),
Policy.Reliability.Reliable(duration(seconds=2)),
Policy.DestinationOrder.BySourceTimestamp))
dw.set_status_mask(DDSStatus.PublicationMatched)
dw.take_status()
ctx.c_app.run(typename, len(samples))
now = time.time()
while (dw.take_status() & DDSStatus.PublicationMatched) == 0:
if time.time() - now > 4:
# timeout if C app did not start up within 4 seconds
ctx.c_app.result()
log << f"C-app did not communicate with Python:" << log.endl << log.indent
log << ctx.c_app.last_error << log.endl
log << log.dedent
return False
time.sleep(0.001)
time.sleep(0.5)
for sample in samples:
dw.write(sample)
time.sleep(0.002)
hashes = ctx.c_app.result()
success = True
if not hashes:
log << f"C-app did not return output, stderr:" << log.endl << log.indent
log << ctx.c_app.last_error << log.endl
log << f"stdout:" << log.endl
log << ctx.c_app.last_out << log.endl
log << log.dedent << "Example sample sent:" << log.endl << log.indent
log << samples[0] << log.endl << samples[0].serialize()
log << log.dedent
return False
if len(hashes) != len(samples):
log << f"C-app did not return as many samples as were sent, stderr:" << log.endl << log.indent
log << ctx.c_app.last_error << log.endl
log << f"stdout:" << log.endl
log << ctx.c_app.last_out << log.endl << log.dedent
log << log.dedent << "Example sample sent:" << log.endl << log.indent
log << samples[0] << log.endl << samples[0].serialize()
success = False
for i in range(min(len(hashes), len(samples))):
c_key = hashes[i]
py_key = datatype.__idl__.key(samples[i], use_version_2=True)
if not py_key == c_key:
log << "PY-C Keys do not match!" << log.endl << log.indent
log << "Instance: " << samples[i] << log.endl
log << "Serialized Instance:" << log.endl << samples[i].serialize()
log << "Python key:" << log.endl << py_key
log << "C key:" << log.endl << c_key
log << log.dedent
return False
return success
