def test_reader_readnext_takenext():
dp = DomainParticipant(0)
tp = Topic(dp, "Message__DONOTPUBLISH", Message)
sub = Subscriber(dp)
pub = Publisher(dp)
dr = DataReader(sub, tp)
dw = DataWriter(pub, tp)
msg = Message("Hello")
dw.write(msg)
assert dr.read_next() == msg
assert dr.read_next() is None
dw.write(msg)
assert dr.take_next() == msg
assert dr.take_next() is None
def test_suspension():
dp = DomainParticipant(0)
pub = Publisher(dp)
with pytest.raises(DDSException) as exc:
pub.suspend()
assert exc.value.code == DDSException.DDS_RETCODE_UNSUPPORTED
with pytest.raises(DDSException) as exc:
pub.resume()
assert exc.value.code == DDSException.DDS_RETCODE_UNSUPPORTED
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 __init__(self, args, dp, eqos, waitset):
self.dp = dp
if args.topic:
self.topic_name = args.topic
self.dynamic = False
else:
self.topic_name = args.dynamic
self.dynamic = True
self.seq = -1 # Sequence number counter
self.eqos = eqos # Entity qos
self.entities = {} # Store writers and readers
self.file = args.filename # Write to file or not
self.track_samples = {} # Track read samples if needs to write to file
try:
self.listener = QosListener()
self.pub = Publisher(dp, qos=self.eqos.publisher_qos)
self.sub = Subscriber(dp,
qos=self.eqos.subscriber_qos,
listener=self.listener)
if self.dynamic:
ds, tmap = discover_datatype(self.dp, self.topic_name)
self.entity = self.create_entities(ds, self.topic_name)
self.type_map = tmap
print(f"Discovered datatype dynamically:{ds}")
else:
for type in datatypes:
self.entities[type] = self.create_entities(
type, self.topic_name + type.postfix())
except DDSException:
raise Exception(
"The arguments inputted are considered invalid for cyclonedds."
)
self.read_cond = ReadCondition(
(self.entities[Integer]
if not self.dynamic else self.entity).reader,
ViewState.Any | InstanceState.Alive | SampleState.NotRead)
waitset.attach(self.read_cond)
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)
def pub(self, qos=None, listener=None):
self._pub = Publisher(self.dp, qos=qos, listener=listener)
return self._pub
def test_initialize_publisher():
dp = DomainParticipant(0)
pub = Publisher(dp)
assert isgoodentity(pub)
def test_pub_matched_cross_participant(hitpoint_factory):
hpf = hitpoint_factory
class MyListener(Listener):
def __init__(self):
super().__init__()
self.hitpoint_data_available = hpf()
self.hitpoint_pub_matched = hpf()
self.hitpoint_sub_matched = hpf()
def on_data_available(self, reader):
self.hitpoint_data_available.hit()
def on_publication_matched(self, writer,status):
self.hitpoint_pub_matched.hit()
def on_subscription_matched(self, reader, status):
self.hitpoint_sub_matched.hit()
domain1_participant_listener = MyListener()
domain2_participant_listener = MyListener()
dp1 = DomainParticipant(listener=domain1_participant_listener)
dp2 = DomainParticipant(listener=domain2_participant_listener)
tp1 = Topic(dp1, "Message", Message)
tp2 = Topic(dp2, "Message", Message)
publisher_listener = MyListener()
pub = Publisher(dp1, listener=publisher_listener)
subscriber_listener = MyListener()
sub = Subscriber(dp2, listener=subscriber_listener)
datawriter_listener = MyListener()
datawriter = DataWriter(pub, tp1, listener=datawriter_listener)
datareader_listener = MyListener()
datareader = DataReader(sub, tp2, listener=datareader_listener)
datawriter.write(Message("hi!"))
# Assertions, _only_ datawriter should publication match,
# _only_ datareader should subscriber match and receive data
assert datawriter_listener.hitpoint_pub_matched.was_hit()
assert datareader_listener.hitpoint_sub_matched.was_hit()
assert datareader_listener.hitpoint_data_available.was_hit()
assert domain1_participant_listener.hitpoint_pub_matched.was_not_hit()
assert domain1_participant_listener.hitpoint_sub_matched.was_not_hit()
assert domain1_participant_listener.hitpoint_data_available.was_not_hit()
assert domain2_participant_listener.hitpoint_pub_matched.was_not_hit()
assert domain2_participant_listener.hitpoint_sub_matched.was_not_hit()
assert domain2_participant_listener.hitpoint_data_available.was_not_hit()
assert publisher_listener.hitpoint_pub_matched.was_not_hit()
assert publisher_listener.hitpoint_sub_matched.was_not_hit()
assert publisher_listener.hitpoint_data_available.was_not_hit()
assert subscriber_listener.hitpoint_pub_matched.was_not_hit()
assert subscriber_listener.hitpoint_sub_matched.was_not_hit()
assert subscriber_listener.hitpoint_data_available.was_not_hit()
assert datawriter_listener.hitpoint_sub_matched.was_not_hit()
assert datawriter_listener.hitpoint_data_available.was_not_hit()
assert datareader_listener.hitpoint_pub_matched.was_not_hit()
* v. 1.0 which is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
"""
from cyclonedds.domain import DomainParticipant
from cyclonedds.pub import Publisher, DataWriter
from cyclonedds.sub import Subscriber, DataReader
from cyclonedds.topic import Topic
from pycdr import cdr
@cdr
class HelloWorld:
data: str
dp = DomainParticipant()
tp = Topic(dp, "Hello", HelloWorld)
pub = Publisher(dp)
dw = DataWriter(pub, tp)
sub = Subscriber(dp)
dr = DataReader(sub, tp)
dw.write(HelloWorld(data='Hello, World!'))
sample = dr.read()[0]
print(sample.data)
