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