def test_clear_all_members(): data = dds.DynamicData(PRIMITIVES) data["myLong"] = 3 data["myDouble"] = 7.7 assert data["myLong"] == 3 assert data["myDouble"] == 7.7 data.clear_all_members() assert data["myLong"] == 0 assert data["myDouble"] == 0.0 data = dds.DynamicData(COMPLEX) data["myLongSeq"] = list(range(1, 11)) data["myLongArray"] = array.array("i", range(1, 11)) for i in range(0, 10): assert data[f"myLongSeq[{i}]"] == i + 1 assert data[f"myLongArray[{i}]"] == i + 1 member = data.loan_value("myLongSeq") member.data.clear_all_members() member.return_loan() member = data.loan_value("myLongArray") member.data.clear_all_members() member.return_loan() assert len(data["myLongSeq"]) == 0 for i in range(0, 10): assert data[f"myLongArray[{i}]"] == 0
def request_handler(request): global request_serviced request_serviced = True if (request["n"] <= 0 or request["primes_per_reply"] <= 0 or request["primes_per_reply"] > reply_type["primes"].type.bounds): error_reply = dds.DynamicData(reply_type) error_reply["status"] = status_type["REPLY_ERROR"] print("Error, requester asked for too many primes per reply") return error_reply else: print("Calculating prime numbers below {}...".format(request["n"])) n = request["n"] max_count = request["primes_per_reply"] primes = dds.Int32Seq() reply = dds.DynamicData(reply_type) for m in xrange(1, n + 1): if is_prime(m): primes.append(m) if len(primes) > max_count: reply["status"] = status_type["REPLY_ERROR"] print( "Error: too many calculated primes for a single reply" ) return reply reply["primes"] = primes reply["status"] = status_type["REPLY_COMPLETED"] print("DONE") return reply
def test_sample_creation(): s1 = dds.DynamicData(COORD_TYPE) s1["x"] = 1 s1["y"] = 2 my_dict = {"x": 1, "y": 2} s2 = dds.DynamicData(COORD_TYPE, my_dict) assert s1 == s2
def replier_main(domain_id): participant = dds.DomainParticipant(domain_id) qos_provider = dds.QosProvider.default type_provider = dds.QosProvider('Primes.xml') request_type = type_provider.type("PrimeNumberRequest") reply_type = type_provider.type("PrimeNumberReply") status_type = type_provider.type("PrimeNumberCalculationStatus") replier = rti.request.Replier( request_type, reply_type, participant, service_name="PrimeCalculator", datawriter_qos=qos_provider.datawriter_qos_from_profile("RequestReplyExampleProfiles::RequesterExampleProfile"), datareader_qos=qos_provider.datareader_qos_from_profile("RequestReplyExampleProfiles::RequesterExampleProfile")) print("Prime calculation replier started on domain {}...".format(domain_id)) max_wait = dds.Duration.from_seconds(20) requests = replier.receive_requests(max_wait) while len(requests) > 0: for request in (sample for sample in requests if sample.info.valid): if (request.data["n"] <= 0 or request.data["primes_per_reply"] <= 0 or request.data["primes_per_reply"] > reply_type["primes"].type.bounds): error_reply = dds.DynamicData(reply_type) error_reply["status"] = status_type["REPLY_ERROR"] replier.send_reply(error_reply, request.info) else: print("Calculating prime numbers below {}...".format(request.data["n"])) n = request.data["n"] max_count = request.data["primes_per_reply"] primes = dds.Int32Seq() reply = dds.DynamicData(reply_type) for m in xrange(1, n + 1): if is_prime(m): primes.append(m) if len(primes) == max_count: reply["primes"] = primes reply["status"] = status_type["REPLY_IN_PROGRESS"] replier.send_reply(reply, request.info, final=False) primes.clear() reply["primes"] = primes reply["status"] = status_type["REPLY_COMPLETED"] replier.send_reply(reply, request.info) print("DONE") requests = replier.receive_requests(max_wait)
def publisher_main(domain_id, sample_count): participant = dds.DomainParticipant(domain_id) # Participant properties give access to the builtin readers participant.participant_reader.bind_listener( BuiltinParticipantListener(), dds.StatusMask.data_available()) participant.subscription_reader.bind_listener( BuiltinSubscriptionListener(), dds.StatusMask.data_available()) msg_type = dds.QosProvider('msg.xml').type('builtin_topics_lib', 'msg') topic = dds.DynamicData.Topic(participant, 'Example msg', msg_type) writer = dds.DynamicData.DataWriter(dds.Publisher(participant), topic) instance = dds.DynamicData(msg_type) # write samples in a loop, incrementing the 'x' field count = 0 while (sample_count == 0) or (count < sample_count): time.sleep(1) instance['x'] = count writer.write(instance, dds.InstanceHandle()) count += 1 assert count == 5
def publisher_main(domain_id, sample_count): participant = dds.DomainParticipant(domain_id) # Participant properties give access to the builtin readers participant.participant_reader.bind_listener( BuiltinParticipantListener(), dds.StatusMask.DATA_AVAILABLE ) participant.subscription_reader.bind_listener( BuiltinSubscriptionListener(), dds.StatusMask.DATA_AVAILABLE ) participant.enable() msg_type = dds.QosProvider("msg.xml").type("builtin_topics_lib", "msg") topic = dds.DynamicData.Topic(participant, "Example msg", msg_type) writer = dds.DynamicData.DataWriter(dds.Publisher(participant), topic) instance = dds.DynamicData(msg_type) # write samples in a loop, incrementing the 'x' field count = 0 while (sample_count == 0) or (count < sample_count): time.sleep(1) instance["x"] = count writer.write(instance, dds.InstanceHandle()) count += 1
def uvn_info(agent): uvn_info = dds.DynamicData(agent.participant.types["uvn_info"]) uvn_info["id.address"] = agent.registry.address uvn_info["cells"] = agent.summarize_peers() uvn_info["cell_sites"] = agent.summarize_peer_sites() if agent.registry.latest_deployment: uvn_info["deployment_id"] = agent.registry.latest_deployment.id uvn_info["backbone_subnet.address.value"] = ip.ipv4_to_bytes( agent.registry.backbone_subnet.network_address) uvn_info["backbone_subnet.mask"] = ip.ipv4_netmask_to_cidr( agent.registry.backbone_subnet.netmask) else: uvn_info["deployment_id"] = UvnDefaults["registry"][ "deployment_bootstrap"] if agent.registry.router_subnet: uvn_info["router_subnet.address.value"] = ip.ipv4_to_bytes( agent.registry.router_subnet.network_address) # uvn_info["router_subnet.mask"] = ip.ipv4_netmask_to_cidr( # agent.registry.router_subnet.netmask) uvn_info["router_subnet.mask"] = agent.registry.router_subnet.prefixlen if agent.registry.backbone_subnet: uvn_info["backbone_subnet.address.value"] = ip.ipv4_to_bytes( agent.registry.backbone_subnet.network_address) uvn_info["backbone_subnet.mask"] = ip.ipv4_netmask_to_cidr( agent.registry.backbone_subnet.netmask) logger.debug("publishing uvn info:\n{}", uvn_info) agent.participant.writer("uvn_info").write(uvn_info)
def test_sending_dict(): s1 = dds.DynamicData(COORD_TYPE) s1["x"] = 1 s1["y"] = 2 my_dict = {"x": 1, "y": 2} with dds.DomainParticipant(0) as participant: topic = dds.DynamicData.Topic(participant, "dictionary_test", COORD_TYPE) # Create qos for both, add reliable and keep all writer_qos = participant.implicit_publisher.default_datawriter_qos writer_qos << dds.Reliability.reliable() writer_qos << dds.History.keep_all() writer_qos << dds.Durability.transient_local() # Create the reader qos reader_qos = participant.implicit_subscriber.default_datareader_qos reader_qos << dds.Reliability.reliable() reader_qos << dds.History.keep_all() reader_qos << dds.Durability.transient_local() writer = dds.DynamicData.DataWriter(participant.implicit_publisher, topic, writer_qos) reader = dds.DynamicData.DataReader(participant.implicit_subscriber, topic, reader_qos) writer.write(my_dict) while len(reader.read()) < 1: time.sleep(0.001) for s2 in reader.take(): print(s2.data) print(type(s2.data)) # Makes for easy debugging assert type(s2.data) == type(s1) assert s2.data == s1
def test_clear_member(): data = dds.DynamicData(COMPLEX) data["myOptional"] = 3 assert data["myOptional"] == 3 data.clear_optional_member("myOptional") assert not data.member_exists("myOptional") data["myString"] = "aStringValue" assert data["myString"] == "aStringValue" data.clear_member(3) assert data["myString"] == "" data["myStringSeq"] = ["one", "two", "three", "four"] assert data["myStringSeq[1]"] == "two" data.clear_member(4) assert len(data["myStringSeq"]) == 0 data["myLongSeq"] = list(range(1, 11)) assert data.get_values(0) == dds.Int32Seq(list(range(1, 11))) data.clear_member("myLongSeq") assert len(data["myLongSeq"]) == 0 data["myLongSeq"] = list(range(1, 11)) assert data.get_values(0) == dds.Int32Seq(list(range(1, 11))) seq_member = data.loan_value("myLongSeq") seq_member.data.clear_member(3) seq_member.return_loan() values = data.get_values(0) for i in range(0, 10): if i == 3: assert 0 == values[i] else: assert i + 1 == values[i]
def publish_env(id, writer, kvp_type, env): sample = dds.DynamicData(kvp_type) sample["id"] = id for var, value in env.items(): sample["key"] = var sample["value"] = value writer.write(sample)
def _get_peer_backbone_ports(self, cell_name): ports = [] if self.registry.latest_deployment: cell_cfg = self.registry.latest_deployment.cell_config(cell_name) for bbone in cell_cfg.backbone: ipaddr = dds.DynamicData(self.participant.types["ip_address"]) ipaddr["value"] = ip.ipv4_to_bytes(bbone.addr_local) ports.append(ipaddr) return ports
def deployment(agent, deployment_id, cell_name, installer): installer = pathlib.Path(installer) with installer.open("rb") as input: cell_pkg = dds.DynamicData(agent.participant.types["deployment"]) cell_pkg["cell.name"] = cell_name cell_pkg["cell.uvn.address"] = agent.registry.address cell_pkg["id"] = deployment_id cell_pkg["package"] = input.read() logger.info("pushing installer {} to cell {} [size: {} KB]", installer.name, cell_name, len(list(cell_pkg["package"])) / 1024.0) agent.participant.writer("deployment").write(cell_pkg)
def _get_peer_backbone_ports(self, cell_name): ports = [] if self.registry.deployed_cell_config: for bbone in self.registry.deployed_cell_config.backbone: for p in bbone.peers: if p.name != cell_name: continue ipaddr = dds.DynamicData( self.participant.types["ip_address"]) ipaddr["value"] = ip.ipv4_to_bytes(p.addr_remote) ports.append(ipaddr) return ports
def requester_main(domain_id, n, primes_per_reply): participant = dds.DomainParticipant(domain_id) qos_provider = dds.QosProvider.default type_provider = dds.QosProvider('Primes.xml') request_type = type_provider.type("PrimeNumberRequest") reply_type = type_provider.type("PrimeNumberReply") status_type = type_provider.type("PrimeNumberCalculationStatus") requester = request.Requester( request_type, reply_type, participant, service_name="PrimeCalculator", datawriter_qos=qos_provider.datawriter_qos_from_profile( "RequestReplyExampleProfiles::RequesterExampleProfile"), datareader_qos=qos_provider.datareader_qos_from_profile( "RequestReplyExampleProfiles::RequesterExampleProfile")) print("Waiting to discover replier on domain {}...".format(domain_id)) while requester.matched_replier_count == 0: time.sleep(0.1) prime_number_request = dds.DynamicData(request_type) prime_number_request["n"] = n prime_number_request["primes_per_reply"] = primes_per_reply print( "Sending a request to calculate the prime numbers <= {} in sequences of {} or fewer elements" .format(n, primes_per_reply)) request_id = requester.send_request(prime_number_request) max_wait = dds.Duration.from_seconds(20) in_progress = True while in_progress: if not requester.wait_for_replies(max_wait, related_request_id=request_id): raise dds.TimeoutError("Timed out waitinf for replies") for reply in (r.data for r in requester.take_replies(request_id) if r.info.valid): primes = reply["primes"] for prime in primes: print(prime) if reply["status"] != status_type["REPLY_IN_PROGRESS"]: in_progress = False if reply["status"] == status_type["REPLY_ERROR"]: raise RuntimeError("Error in replier") print("DONE")
def summarize_cell_sites(self): sites = [] if self.registry.deployed_cell: for s in self._local_sites: cell_site = dds.DynamicData(self.participant.types["cell_site"]) cell_site["cell"] = self.registry.deployed_cell.id.n cell_site["nic"] = s["nic"] cell_site["subnet.address.value"] = ip.ipv4_to_bytes(s["subnet"].network_address) cell_site["subnet.mask"] = ip.ipv4_netmask_to_cidr(s["subnet"].netmask) cell_site["endpoint.value"] = ip.ipv4_to_bytes(s["address"]) cell_site["gw.value"] = ip.ipv4_to_bytes(self._default_gw) sites.append(cell_site) return sites
def summarize_peer_sites(self): sites = [] for p in self._peers: for s in p._remote_sites: cell_site = dds.DynamicData(self.participant.types["cell_site"]) cell_site["cell"] = p.cell.id.n cell_site["nic"] = s.nic cell_site["subnet.address.value"] = ip.ipv4_to_bytes(s.subnet.network_address) cell_site["subnet.mask"] = ip.ipv4_netmask_to_cidr(s.subnet.netmask) cell_site["endpoint.value"] = ip.ipv4_to_bytes(s.endpoint) cell_site["gw.value"] = ip.ipv4_to_bytes(s.gw) sites.append(cell_site) return sites
def summarize_peers(self): peers = [] for p in self._peers: ports = self._get_peer_backbone_ports(p.cell.id.name) if not ports: continue if len(ports) > 3: raise ValueError(f"too many ports: {ports}") peer = dds.DynamicData(self.participant.types["cell_peer"]) peer["name"] = p.cell.id.name peer["n"] = p.cell.id.n peer["backbone_ports"] = ports peers.append(peer) return peers
def test_union(): test_union = dds.DynamicData(UNION) simple = dds.DynamicData(SIMPLE) simple["key"] = 10 simple["value"] = 20 test_union["red_green"] = simple assert test_union.discriminator_value == ENUM_TYPE["RED"] member_value = test_union.get_value(test_union.discriminator_value) assert member_value.get_value(0) == 10 assert member_value.get_value(1) == 20 with pytest.raises(dds.InvalidArgumentError): test_union.get_value("blue") test_union["blue"] = 123 assert test_union.discriminator_value == ENUM_TYPE["BLUE"] assert 123 == test_union.get_value(test_union.discriminator_value) test_union.clear_member("blue") assert test_union.discriminator_value == ENUM_TYPE["BLUE"] assert 0 == test_union.get_value(test_union.discriminator_value)
def summarize_nameserver_entries(self): entries = [] for e in self._get_published_nameserver_entries(): dns_rec = e["record"] dns_host = dds.DynamicData(self.participant.types["dns_rec"]) dns_host["hostname"] = dns_rec.hostname dns_host["address.value"] = ip.ipv4_to_bytes(dns_rec.address) dns_host["tags"] = list(dns_rec.tags) entries.append(dns_host) logger.activity("publishing dns entry: {}/{} {}", dns_host["hostname"], ".".join(map(str, dns_host["address.value"])), list(dns_host["tags"])) return entries
def test_dynamic_data_buffer_numpy(): np = pytest.importorskip("numpy") data = dds.DynamicData(COMPLEX) my_array_unidim = np.array([1, 2, 3, 4, 5, 6], np.int32) my_array_multidim = np.reshape(np.array([1, 2, 3, 4, 5, 6], np.int32), (2, 3)) my_array_short = np.array([1, 2, 3, 4, 5, 6], np.int16) data["myLongSeq"] = my_array_unidim assert data["myLongSeq[2]"] == 3 with pytest.raises(TypeError): data["myLongSeq"] = my_array_multidim with pytest.raises(TypeError): data["myLongSeq"] = my_array_short
def publish_temperature(writer, sensor_id): # Create temperature sample for writing temperature = dds.DynamicData(TEMPERATURE_TYPE) try: while True: # Modify the data to be written here temperature["sensor_id"] = sensor_id temperature["degrees"] = random.randint( 30, 32) # Random value between 30 and 32 writer.write(temperature) time.sleep(0.1) except KeyboardInterrupt: pass
def test_multidim_array(): data = dds.DynamicData(COMPLEX) for i in range(2): for j in range(2): for k in range(2): data[f"myMultiDimArray[{i}, {j}, {k}]"] = i * j * k assert (data[f"myMultiDimArray[{i},{j},{k}]"] == i * j * k) with pytest.raises(dds.InvalidArgumentError): my_val = data[f"myMultiDimArray[0][0][0]"] info = data.member_info("myMultiDimArray") assert (info.element_count == 8) info = data.member_info("myMultiDimArray[0,0,1]") assert (info.index == 1)
def publisher_main(domain_id, sample_count): participant = dds.DomainParticipant(domain_id) wssc_type = dds.QosProvider("waitset_cond.xml").type("wssc_lib", "Foo") topic = dds.DynamicData.Topic(participant, "Example Foo", wssc_type) writer = dds.DynamicData.DataWriter(dds.Publisher(participant), topic) sample = dds.DynamicData(wssc_type) count = 0 while (sample_count == 0) or (count < sample_count): print("Writing Foo, count = {}".format(count)) sample["x"] = count writer.write(sample) count += 1 time.sleep(1)
def dns_entries(agent): dns_db = dds.DynamicData(agent.participant.types["dns_db"]) dns_db["cell.name"] = (agent.registry.deployed_cell.id.name if agent.registry.deployed_cell else agent.registry.address) dns_db["cell.uvn.address"] = agent.registry.address # This fails 1 out of 9 times for yet to identify reasons # dns_db["entries"] = agent.summarize_nameserver_entries() # This seems to be always working for i, e in enumerate(agent._get_published_nameserver_entries()): dns_rec = e["record"] with dns_db.loan_value("entries") as entries: with entries.data.loan_value(i) as d: d.data[f"hostname"] = dns_rec.hostname d.data[f"address.value"] = ip.ipv4_to_bytes(dns_rec.address) d.data[f"tags"] = dns_rec.tags agent.participant.writer("dns").write(dns_db) logger.info("[dns] pushed {} records", len(dns_db["entries"])) return dns_db
def publisher_main(domain_id, sample_count): participant = dds.DomainParticipant(domain_id) cft_type = dds.QosProvider("cft.xml").type("cft_lib", "cft") topic = dds.DynamicData.Topic(participant, "Example cft", cft_type) writer_qos = dds.QosProvider.default.datawriter_qos writer = dds.DynamicData.DataWriter(dds.Publisher(participant), topic, writer_qos) sample = dds.DynamicData(cft_type) count = 0 while (sample_count == 0) or (count < sample_count): print("Writing cft, count={}".format(count)) sample["count"] = count sample["name"] = "ODD" if count % 2 == 1 else "EVEN" writer.write(sample) time.sleep(1) count += 1
def publisher_main(domain_id, sample_count): participant = dds.DomainParticipant(domain_id) # We can register the custom filter on the writer side participant.register_contentfilter(ccf.CustomFilterType(), "CustomFilter") ccf_type = dds.QosProvider("ccf.xml").type("ccf_lib", "Foo") topic = dds.DynamicData.Topic(participant, "Example ccf", ccf_type) writer = dds.DynamicData.DataWriter(dds.Publisher(participant), topic) instance = dds.DynamicData(ccf_type) count = 0 while (sample_count == 0) or (count < sample_count): print("Writing ccf, count={}".format(count)) instance["x"] = count writer.write(instance) time.sleep(1) count += 1
def cell_info(agent, cell, cell_cfg): cell_info = dds.DynamicData(agent.participant.types["cell_info"]) cell_info["id.name"] = cell.id.name cell_info["id.uvn.address"] = agent.registry.address cell_info["pid"] = os.getpid() cell_info["status"] = agent._status.value() cell_info["peers"] = agent.summarize_peers() sites = agent.summarize_cell_sites() sites.extend(agent.summarize_peer_sites()) cell_info["routed_sites"] = sites if agent.registry.deployment_id is not None: cell_info["deployment_id"] = agent.registry.deployment_id if agent._ts_created: cell_info["ts_created"] = int(agent._ts_created.millis()) if agent._ts_loaded: cell_info["ts_loaded"] = int(agent._ts_loaded.millis()) if agent._ts_started: cell_info["ts_started"] = int(agent._ts_started.millis()) logger.debug("publishing cell info:\n{}", cell_info) agent.participant.writer("cell_info").write(cell_info)
def publisher_main(domain_id, sample_count): participant = dds.DomainParticipant(domain_id) wsqc_type = dds.QosProvider("waitset_query_cond.xml").type( "wsqc_lib", "waitset_query_cond" ) topic = dds.DynamicData.Topic(participant, "Example waitset_query_cond", wsqc_type) writer = dds.DynamicData.DataWriter(dds.Publisher(participant), topic) instance = dds.DynamicData(wsqc_type) count = 0 while (sample_count == 0) or (count < sample_count): print("Writing waitset_query_cond, count = {}".format(count)) instance["x"] = count instance["name"] = "ODD" if count % 2 == 1 else "EVEN" writer.write(instance) count += 1 time.sleep(1)
def publisher_main(domain_id, sample_count): participant = dds.DomainParticipant(domain_id) cft_type = dds.QosProvider("cft.xml").type("cft_lib", "cft") topic = dds.DynamicData.Topic(participant, "Example cft", cft_type) writer_qos = dds.QosProvider.default.datawriter_qos writer = dds.DynamicData.DataWriter(dds.Publisher(participant), topic, writer_qos) instance = dds.DynamicData(cft_type) handle = dds.InstanceHandle.nil() # Output "ones" digit of count as 'x' field count = 0 while (sample_count == 0) or (count < sample_count): instance["count"] = count instance["x"] = count % 10 print("Writing cft, count={}\tx={}".format(instance["count"], instance["x"])) writer.write(instance, handle) time.sleep(1) count += 1
def publisher_main(domain_id, sample_count): participant = dds.DomainParticipant(domain_id) publisher_qos = dds.QosProvider.default.publisher_qos publisher = dds.Publisher(participant, publisher_qos) coherent_type = dds.QosProvider("coherent.xml").type( "coherent_lib", "coherent") topic = dds.DynamicData.Topic(participant, "Example coherent", coherent_type) datawriter_qos = dds.QosProvider.default.datawriter_qos writer = dds.DynamicData.DataWriter(publisher, topic, datawriter_qos) sample = dds.DynamicData(coherent_type) sample["id"] = 0 handle = writer.register_instance(sample) num_samples = 7 count = 0 while (sample_count == 0) or (count < sample_count): # Use a context manager to scope the coherent set writes with dds.CoherentSet(publisher): print("Begin Coherent Changes") for i in xrange(num_samples): time.sleep(1) sample["field"] = chr(ord("a") + i) sample["value"] = random.randint(0, 10) print("Updating instance, {}->{}".format( sample["field"], sample["value"])) writer.write(sample, handle) count += 1 print("End Coherent Changes") writer.unregister_instance(handle)