Lines Matching refs:self
67 def __init__(self, nodeid: int, backbone_network: str, **kwargs): argument
68 self.verbose = int(float(os.getenv('VERBOSE', 0)))
71 self.backbone_network = backbone_network
73 self._docker_name = config.OTBR_DOCKER_NAME_PREFIX + str(nodeid)
74 self._prepare_ot_rcp_sim(nodeid)
75 self._launch_docker()
78 self.destroy()
81 def _prepare_ot_rcp_sim(self, nodeid: int): argument
82 … self._socat_proc = subprocess.Popen(['socat', '-d', '-d', 'pty,raw,echo=0', 'pty,raw,echo=0'],
87 line = self._socat_proc.stderr.readline().decode('ascii').strip()
88 self._rcp_device_pty = rcp_device_pty = line[line.index('PTY is /dev') + 7:]
89 line = self._socat_proc.stderr.readline().decode('ascii').strip()
90 self._rcp_device = rcp_device = line[line.index('PTY is /dev') + 7:]
93 ot_rcp_path = self._get_ot_rcp_path()
94 …self._ot_rcp_proc = subprocess.Popen(f"{ot_rcp_path} {nodeid} > {rcp_device_pty} < {rcp_device_pty…
101 self._ot_rcp_proc.wait(1)
108 def _get_ot_rcp_path(self) -> str: argument
114 def _launch_docker(self): argument
125 self._docker_name,
127 self.backbone_network,
145 self._docker_proc = subprocess.Popen(cmd,
147 … stdout=sys.stdout if self.verbose else subprocess.DEVNULL,
148 … stderr=sys.stderr if self.verbose else subprocess.DEVNULL)
157 … logging.info("OTBR Docker %s on %s Is Ready!", self._docker_name, self.backbone_network)
165 self.start_ot_ctl()
167 def __repr__(self): argument
170 def start_otbr_service(self): argument
171 self.bash('service otbr-agent start')
172 self.simulator.go(3)
173 self.start_ot_ctl()
175 def stop_otbr_service(self): argument
176 self.stop_ot_ctl()
177 self.bash('service otbr-agent stop')
179 def stop_mdns_service(self): argument
180 … self.bash('service avahi-daemon stop; service mdns stop; !(cat /proc/net/udp | grep -i :14E9)')
182 def start_mdns_service(self): argument
183 … self.bash('service avahi-daemon start; service mdns start; cat /proc/net/udp | grep -i :14E9')
185 def start_ot_ctl(self): argument
187 self.pexpect = pexpect.popen_spawn.PopenSpawn(cmd, timeout=30)
188 if self.verbose:
189 self.pexpect.logfile_read = sys.stdout.buffer
194 self.pexpect.send('\r\n')
196 self.pexpect.expect('> ', timeout=0.1)
201 def stop_ot_ctl(self): argument
202 self.pexpect.sendeof()
203 self.pexpect.wait()
204 self.pexpect.proc.kill()
206 def reserve_udp_port(self, port): argument
207 self.bash(f'socat -u UDP6-LISTEN:{port},bindtodevice=wpan0 - &')
209 def destroy(self): argument
210 logging.info("Destroying %s", self)
211 self._shutdown_docker()
212 self._shutdown_ot_rcp()
213 self._shutdown_socat()
215 def _shutdown_docker(self): argument
216 if self._docker_proc is None:
226 self.bash('service otbr-agent stop')
236 self.bash(codecov_cmd)
245 self._docker_proc.wait()
246 del self._docker_proc
248 def _shutdown_ot_rcp(self): argument
249 if self._ot_rcp_proc is not None:
250 self._ot_rcp_proc.kill()
251 self._ot_rcp_proc.wait()
252 del self._ot_rcp_proc
254 def _shutdown_socat(self): argument
255 if self._socat_proc is not None:
256 self._socat_proc.stderr.close()
257 self._socat_proc.kill()
258 self._socat_proc.wait()
259 del self._socat_proc
261 def bash(self, cmd: str, encoding='ascii') -> List[str]: argument
262 logging.info("%s $ %s", self, cmd)
263 proc = subprocess.Popen(['docker', 'exec', '-i', self._docker_name, 'bash', '-c', cmd],
280 logging.info("%s $ %r", self, line.rstrip('\r\n'))
289 def dns_dig(self, server: str, name: str, qtype: str): argument
317 output = self.bash(f'dig -6 @{server} \'{name}\' {qtype}', encoding='raw_unicode_escape')
360 record[0] = self.__unescape_dns_instance_name(record[0])
364 record[0] = self.__unescape_dns_instance_name(record[0])
367 record[0] = self.__unescape_dns_instance_name(record[0])
368 record[4:] = [self.__parse_dns_dig_txt(line)]
370 record[4] = self.__unescape_dns_instance_name(record[4])
376 def call_dbus_method(self, *args): argument
379 …self.bash(f'python3 /app/third_party/openthread/repo/tests/scripts/thread-cert/call_dbus_method.py…
382 def get_dbus_property(self, property_name): argument
383 …return self.call_dbus_method('org.freedesktop.DBus.Properties', 'Get', 'io.openthread.BorderRouter…
386 def set_dbus_property(self, property_name, property_value): argument
387 …return self.call_dbus_method('org.freedesktop.DBus.Properties', 'Set', 'io.openthread.BorderRouter…
390 def get_border_routing_counters(self): argument
391 counters = self.get_dbus_property('BorderRoutingCounters')
407 def _process_traffic_counters(self, counter): argument
419 def _process_packet_counters(self, counter): argument
422 def nat64_set_enabled(self, enable): argument
423 return self.call_dbus_method('io.openthread.BorderRouter', 'SetNat64Enabled', enable)
425 def activate_ephemeral_key_mode(self, lifetime): argument
426 … return self.call_dbus_method('io.openthread.BorderRouter', 'ActivateEphemeralKeyMode', lifetime)
428 def deactivate_ephemeral_key_mode(self): argument
429 return self.call_dbus_method('io.openthread.BorderRouter', 'DeactivateEphemeralKeyMode')
432 def nat64_cidr(self): argument
433 self.send_command('nat64 cidr')
434 cidr = self._expect_command_output()[0].strip()
438 def nat64_cidr(self, cidr: ipaddress.IPv4Network): argument
441 self.send_command(f'nat64 cidr {cidr}')
442 self._expect_done()
445 def nat64_state(self): argument
446 state = self.get_dbus_property('Nat64State')
450 def nat64_mappings(self): argument
457 'total': self._process_traffic_counters(row[4][0]),
458 'ICMP': self._process_traffic_counters(row[4][1]),
459 'UDP': self._process_traffic_counters(row[4][2]),
460 'TCP': self._process_traffic_counters(row[4][3]),
462 } for row in self.get_dbus_property('Nat64Mappings')]
465 def nat64_counters(self): argument
466 res_error = self.get_dbus_property('Nat64ErrorCounters')
467 res_proto = self.get_dbus_property('Nat64ProtocolCounters')
470 'Total': self._process_traffic_counters(res_proto[0]),
471 'ICMP': self._process_traffic_counters(res_proto[1]),
472 'UDP': self._process_traffic_counters(res_proto[2]),
473 'TCP': self._process_traffic_counters(res_proto[3]),
476 'Unknown': self._process_packet_counters(res_error[0]),
477 'Illegal Pkt': self._process_packet_counters(res_error[1]),
478 'Unsup Proto': self._process_packet_counters(res_error[2]),
479 'No Mapping': self._process_packet_counters(res_error[3]),
484 def nat64_traffic_counters(self): argument
485 res = self.get_dbus_property('Nat64TrafficCounters')
487 'Total': self._process_traffic_counters(res[0]),
488 'ICMP': self._process_traffic_counters(res[1]),
489 'UDP': self._process_traffic_counters(res[2]),
490 'TCP': self._process_traffic_counters(res[3]),
494 def dns_upstream_query_state(self): argument
495 return bool(self.get_dbus_property('DnsUpstreamQueryState'))
498 def dns_upstream_query_state(self, value): argument
501 return self.set_dbus_property('DnsUpstreamQueryState', value)
504 def ephemeral_key_enabled(self): argument
505 return bool(self.get_dbus_property('EphemeralKeyEnabled'))
508 def ephemeral_key_enabled(self, value): argument
511 return self.set_dbus_property('EphemeralKeyEnabled', value)
513 def read_border_routing_counters_delta(self): argument
514 old_counters = self._border_routing_counters
515 new_counters = self.get_border_routing_counters()
516 self._border_routing_counters = new_counters
557 def __parse_dns_dig_txt(self, line: str): argument
570 def _setup_sysctl(self): argument
571 self.bash(f'sysctl net.ipv6.conf.{self.ETH_DEV}.accept_ra=2')
572 self.bash(f'sysctl net.ipv6.conf.{self.ETH_DEV}.accept_ra_rt_info_max_plen=64')
578 def __init__(self, nodeid, is_mtd=False, version=None, is_bbr=False, **kwargs): argument
579 self.verbose = int(float(os.getenv('VERBOSE', 0)))
580 self.node_type = os.getenv('NODE_TYPE', 'sim')
581 self.env_version = os.getenv('THREAD_VERSION', '1.1')
582 self.is_bbr = is_bbr
583 self._initialized = False
585 self._cmd_prefix = '/usr/bin/env GCOV_PREFIX=%s/ot-run/%s/ot-gcda.%d ' % (os.getenv(
588 self._cmd_prefix = ''
591 self.version = version
593 self.version = self.env_version
597 if self.node_type == 'soc':
598 self.__init_soc(nodeid)
599 elif self.node_type == 'ncp-sim':
601 self.__init_ncp_sim(nodeid, 'ftd')
603 self.__init_sim(nodeid, mode)
605 if self.verbose:
606 self.pexpect.logfile_read = sys.stdout.buffer
608 self._initialized = True
610 def __init_sim(self, nodeid, mode): argument
617 if self.version != '1.1' and mode == 'mtd' and 'top_builddir' in os.environ:
622 elif self.version == self.env_version:
625 if self.version != '1.1' and self.is_bbr:
643 self.is_posix = True
648 elif self.version == '1.1':
659 self.is_posix = True
665 self.pexpect = pexpect.popen_spawn.PopenSpawn(self._cmd_prefix + cmd, timeout=10)
670 self.pexpect.send('\r\n')
672 self.pexpect.expect('> ', timeout=0.1)
677 def __init_ncp_sim(self, nodeid, mode): argument
684 if self.version == self.env_version:
688 self.is_posix = True
694 if self.version != '1.1' and self.is_bbr:
724 elif self.version == '1.1':
728 self.is_posix = True
748 self.pexpect = pexpect.spawn(self._cmd_prefix + cmd, timeout=10)
752 self._expect('spinel-cli >')
753 self.debug(int(os.getenv('DEBUG', '0')))
755 def __init_soc(self, nodeid): argument
760 … self.pexpect = fdpexpect.fdspawn(os.open(serialPort, os.O_RDWR | os.O_NONBLOCK | os.O_NOCTTY))
762 def destroy(self): argument
763 if not self._initialized:
766 if (hasattr(self.pexpect, 'proc') and self.pexpect.proc.poll() is None or
767 not hasattr(self.pexpect, 'proc') and self.pexpect.isalive()):
768 print("%d: exit" % self.nodeid)
769 self.pexpect.send('exit\n')
770 self.pexpect.expect(pexpect.EOF)
771 self.pexpect.wait()
772 self._initialized = False
779 def __init__(self, nodeid, name=None, simulator=None, **kwargs): argument
780 self.nodeid = nodeid
781 self.name = name or ('Node%d' % nodeid)
782 self.is_posix = False
784 self.simulator = simulator
785 if self.simulator:
786 self.simulator.add_node(self)
790 self.set_addr64('%016x' % (thread_cert.EXTENDED_ADDRESS_BASE + nodeid))
792 def _expect(self, pattern, timeout=-1, *args, **kwargs): argument
795 timeout = self.pexpect.timeout
801 return self.pexpect.expect(pattern, 0.1, *args, **kwargs)
804 self.simulator.go(0)
808 def _expect_done(self, timeout=-1): argument
809 self._expect('Done', timeout)
811 def _expect_result(self, pattern, *args, **kwargs): argument
819 results = self._expect_results(pattern, *args, **kwargs)
823 def _expect_results(self, pattern, *args, **kwargs): argument
831 output = self._expect_command_output()
832 results = [line for line in output if self._match_pattern(line, pattern)]
835 def _expect_key_value_pairs(self, pattern, separator=': '): argument
842 for line in self._expect_results(pattern):
857 def _expect_command_output(self, ignore_logs=True): argument
861 line = self.__readline(ignore_logs=ignore_logs)
873 def __is_logging_line(self, line: str) -> bool: argument
876 def read_cert_messages_in_commissioning_log(self, timeout=-1): argument
891 self._expect(pattern, timeout=timeout)
892 log = self.pexpect.match.group(0)
893 messages.append(self._extract_cert_message(log))
898 def _extract_cert_message(self, log): argument
925 def send_command(self, cmd, go=True, expect_command_echo=True): argument
926 print("%d: %s" % (self.nodeid, cmd))
927 self.pexpect.send(cmd + '\n')
929 self.simulator.go(0, nodeid=self.nodeid)
933 self._expect_command_echo(cmd)
935 def _expect_command_echo(self, cmd): argument
938 line = self.__readline()
944 def __readline(self, ignore_logs=True): argument
945 PROMPT = 'spinel-cli > ' if self.node_type == 'ncp-sim' else '> '
947 self._expect(r"[^\n]+\n")
948 line = self.pexpect.match.group(0).decode('utf8').strip()
955 if ignore_logs and self.__is_logging_line(line):
960 def get_commands(self): argument
961 self.send_command('?')
962 self._expect('Commands:')
963 return self._expect_results(r'\S+')
965 def set_mode(self, mode): argument
967 self.send_command(cmd)
968 self._expect_done()
970 def debug(self, level): argument
972 self.send_command('debug %d' % level, go=False)
974 def start(self): argument
975 self.interface_up()
976 self.thread_start()
978 def stop(self): argument
979 self.thread_stop()
980 self.interface_down()
982 def set_log_level(self, level: int): argument
983 self.send_command(f'log level {level}')
984 self._expect_done()
986 def interface_up(self): argument
987 self.send_command('ifconfig up')
988 self._expect_done()
990 def interface_down(self): argument
991 self.send_command('ifconfig down')
992 self._expect_done()
994 def thread_start(self): argument
995 self.send_command('thread start')
996 self._expect_done()
998 def thread_stop(self): argument
999 self.send_command('thread stop')
1000 self._expect_done()
1002 def detach(self, is_async=False): argument
1007 self.send_command(cmd)
1010 self._expect_done()
1013 end = self.simulator.now() + 4
1015 self.simulator.go(1)
1017 self._expect_done(timeout=0.1)
1020 if self.simulator.now() > end:
1023 def expect_finished_detaching(self): argument
1024 self._expect('Finished detaching')
1026 def commissioner_start(self): argument
1028 self.send_command(cmd)
1029 self._expect_done()
1031 def commissioner_stop(self): argument
1033 self.send_command(cmd)
1034 self._expect_done()
1036 def commissioner_state(self): argument
1038 self.send_command('commissioner state')
1039 return self._expect_result(states)
1041 def commissioner_add_joiner(self, addr, psk): argument
1043 self.send_command(cmd)
1044 self._expect_done()
1046 def commissioner_set_provisioning_url(self, provisioning_url=''): argument
1048 self.send_command(cmd)
1049 self._expect_done()
1051 def joiner_start(self, pskd='', provisioning_url=''): argument
1053 self.send_command(cmd)
1054 self._expect_done()
1056 def clear_allowlist(self): argument
1058 self.send_command(cmd)
1059 self._expect_done()
1061 def enable_allowlist(self): argument
1063 self.send_command(cmd)
1064 self._expect_done()
1066 def disable_allowlist(self): argument
1068 self.send_command(cmd)
1069 self._expect_done()
1071 def add_allowlist(self, addr, rssi=None): argument
1077 self.send_command(cmd)
1078 self._expect_done()
1080 def radiofilter_is_enabled(self) -> bool: argument
1082 self.send_command('radiofilter')
1083 return self._expect_result(states) == 'Enabled'
1085 def radiofilter_enable(self): argument
1087 self.send_command(cmd)
1088 self._expect_done()
1090 def radiofilter_disable(self): argument
1092 self.send_command(cmd)
1093 self._expect_done()
1095 def get_bbr_registration_jitter(self): argument
1096 self.send_command('bbr jitter')
1097 return int(self._expect_result(r'\d+'))
1099 def set_bbr_registration_jitter(self, jitter): argument
1101 self.send_command(cmd)
1102 self._expect_done()
1104 def get_rcp_version(self) -> str: argument
1105 self.send_command('rcp version')
1106 rcp_version = self._expect_command_output()[0].strip()
1109 def srp_server_get_state(self): argument
1111 self.send_command('srp server state')
1112 return self._expect_result(states)
1114 def srp_server_get_addr_mode(self): argument
1116 self.send_command(f'srp server addrmode')
1117 return self._expect_result(modes)
1119 def srp_server_set_addr_mode(self, mode): argument
1120 self.send_command(f'srp server addrmode {mode}')
1121 self._expect_done()
1123 def srp_server_get_anycast_seq_num(self): argument
1124 self.send_command(f'srp server seqnum')
1125 return int(self._expect_result(r'\d+'))
1127 def srp_server_set_anycast_seq_num(self, seqnum): argument
1128 self.send_command(f'srp server seqnum {seqnum}')
1129 self._expect_done()
1131 def srp_server_set_enabled(self, enable): argument
1133 self.send_command(cmd)
1134 self._expect_done()
1136 def srp_server_set_lease_range(self, min_lease, max_lease, min_key_lease, max_key_lease): argument
1137 … self.send_command(f'srp server lease {min_lease} {max_lease} {min_key_lease} {max_key_lease}')
1138 self._expect_done()
1140 def srp_server_set_ttl_range(self, min_ttl, max_ttl): argument
1141 self.send_command(f'srp server ttl {min_ttl} {max_ttl}')
1142 self._expect_done()
1144 def srp_server_get_hosts(self): argument
1158 self.send_command(cmd)
1159 lines = self._expect_command_output()
1180 def srp_server_get_host(self, host_name): argument
1187 for host in self.srp_server_get_hosts():
1191 def srp_server_get_services(self): argument
1217 self.send_command(cmd)
1218 lines = self._expect_command_output()
1254 def srp_server_get_service(self, instance_name, service_name): argument
1262 for service in self.srp_server_get_services():
1266 def get_srp_server_port(self): argument
1271 for service in self.get_services():
1279 def srp_client_start(self, server_address, server_port): argument
1280 self.send_command(f'srp client start {server_address} {server_port}')
1281 self._expect_done()
1283 def srp_client_stop(self): argument
1284 self.send_command(f'srp client stop')
1285 self._expect_done()
1287 def srp_client_get_state(self): argument
1289 self.send_command(cmd)
1290 return self._expect_command_output()[0]
1292 def srp_client_get_auto_start_mode(self): argument
1294 self.send_command(cmd)
1295 return self._expect_command_output()[0]
1297 def srp_client_enable_auto_start_mode(self): argument
1298 self.send_command(f'srp client autostart enable')
1299 self._expect_done()
1301 def srp_client_disable_auto_start_mode(self): argument
1302 self.send_command(f'srp client autostart disable')
1303 self._expect_done()
1305 def srp_client_get_server_address(self): argument
1307 self.send_command(cmd)
1308 return self._expect_command_output()[0]
1310 def srp_client_get_server_port(self): argument
1312 self.send_command(cmd)
1313 return int(self._expect_command_output()[0])
1315 def srp_client_get_host_state(self): argument
1317 self.send_command(cmd)
1318 return self._expect_command_output()[0]
1320 def srp_client_set_host_name(self, name): argument
1321 self.send_command(f'srp client host name {name}')
1322 self._expect_done()
1324 def srp_client_get_host_name(self): argument
1325 self.send_command(f'srp client host name')
1326 self._expect_done()
1328 def srp_client_remove_host(self, remove_key=False, send_unreg_to_server=False): argument
1329 self.send_command(f'srp client host remove {int(remove_key)} {int(send_unreg_to_server)}')
1330 self._expect_done()
1332 def srp_client_clear_host(self): argument
1333 self.send_command(f'srp client host clear')
1334 self._expect_done()
1336 def srp_client_enable_auto_host_address(self): argument
1337 self.send_command(f'srp client host address auto')
1338 self._expect_done()
1340 def srp_client_set_host_address(self, *addrs: str): argument
1341 self.send_command(f'srp client host address {" ".join(addrs)}')
1342 self._expect_done()
1344 def srp_client_get_host_address(self): argument
1345 self.send_command(f'srp client host address')
1346 self._expect_done()
1348 def srp_client_add_service(self, argument
1357 txt_record = "".join(self._encode_txt_entry(entry) for entry in txt_entries)
1360 instance_name = self._escape_escapable(instance_name)
1361 self.send_command(
1364 self._expect_done()
1366 def srp_client_remove_service(self, instance_name, service_name): argument
1367 self.send_command(f'srp client service remove {instance_name} {service_name}')
1368 self._expect_done()
1370 def srp_client_clear_service(self, instance_name, service_name): argument
1371 self.send_command(f'srp client service clear {instance_name} {service_name}')
1372 self._expect_done()
1374 def srp_client_get_services(self): argument
1376 self.send_command(cmd)
1377 service_lines = self._expect_command_output()
1378 return [self._parse_srp_client_service(line) for line in service_lines]
1380 def srp_client_set_lease_interval(self, leaseinterval: int): argument
1382 self.send_command(cmd)
1383 self._expect_done()
1385 def srp_client_get_lease_interval(self) -> int: argument
1387 self.send_command(cmd)
1388 return int(self._expect_result('\d+'))
1390 def srp_client_set_key_lease_interval(self, leaseinterval: int): argument
1392 self.send_command(cmd)
1393 self._expect_done()
1395 def srp_client_get_key_lease_interval(self) -> int: argument
1397 self.send_command(cmd)
1398 return int(self._expect_result('\d+'))
1400 def srp_client_set_ttl(self, ttl: int): argument
1402 self.send_command(cmd)
1403 self._expect_done()
1405 def srp_client_get_ttl(self) -> int: argument
1407 self.send_command(cmd)
1408 return int(self._expect_result('\d+'))
1414 def enable_trel(self): argument
1416 self.send_command(cmd)
1417 self._expect_done()
1419 def is_trel_enabled(self) -> Union[None, bool]: argument
1421 self.send_command('trel')
1423 return self._expect_result(states) == 'Enabled'
1430 def get_trel_counters(self): argument
1432 self.send_command(cmd)
1433 result = self._expect_command_output()
1449 def reset_trel_counters(self): argument
1451 self.send_command(cmd)
1452 self._expect_done()
1454 def set_epskc(self, keystring: str, timeout=120000, port=0): argument
1456 self.send_command(cmd)
1457 self._expect(r"(Done|Error .*)")
1459 def clear_epskc(self): argument
1461 self.send_command(cmd)
1462 self._expect_done()
1464 def get_border_agent_counters(self): argument
1466 self.send_command(cmd)
1467 result = self._expect_command_output()
1479 def _encode_txt_entry(self, entry): argument
1489 def _parse_srp_client_service(self, line: str): argument
1512 def locate(self, anycast_addr): argument
1514 self.send_command(cmd)
1515 self.simulator.go(5)
1516 return self._parse_locate_result(self._expect_command_output()[0])
1518 def _parse_locate_result(self, line: str): argument
1528 def enable_backbone_router(self): argument
1530 self.send_command(cmd)
1531 self._expect_done()
1533 def disable_backbone_router(self): argument
1535 self.send_command(cmd)
1536 self._expect_done()
1538 def register_backbone_router(self): argument
1540 self.send_command(cmd)
1541 self._expect_done()
1543 def get_backbone_router_state(self): argument
1545 self.send_command('bbr state')
1546 return self._expect_result(states)
1549 def is_primary_backbone_router(self) -> bool: argument
1550 return self.get_backbone_router_state() == 'Primary'
1552 def get_backbone_router(self): argument
1554 self.send_command(cmd)
1555 self._expect(r'(.*)Done')
1556 g = self.pexpect.match.groups()
1576 def set_backbone_router(self, seqno=None, reg_delay=None, mlr_timeout=None): argument
1588 self.send_command(cmd)
1589 self._expect_done()
1591 def set_domain_prefix(self, prefix, flags='prosD'): argument
1592 self.add_prefix(prefix, flags)
1593 self.register_netdata()
1595 def remove_domain_prefix(self, prefix): argument
1596 self.remove_prefix(prefix)
1597 self.register_netdata()
1599 def set_next_dua_response(self, status: Union[str, int], iid=None): argument
1609 self.send_command(cmd)
1610 self._expect_done()
1612 def set_dua_iid(self, iid: str): argument
1617 self.send_command(cmd)
1618 self._expect_done()
1620 def clear_dua_iid(self): argument
1622 self.send_command(cmd)
1623 self._expect_done()
1625 def multicast_listener_list(self) -> Dict[IPv6Address, int]: argument
1627 self.send_command(cmd)
1630 for line in self._expect_results("\S+ \d+"):
1641 def multicast_listener_clear(self): argument
1643 self.send_command(cmd)
1644 self._expect_done()
1646 def multicast_listener_add(self, ip: Union[IPv6Address, str], timeout: int = 0): argument
1651 self.send_command(cmd)
1652 self._expect(r"(Done|Error .*)")
1654 def set_next_mlr_response(self, status: int): argument
1656 self.send_command(cmd)
1657 self._expect_done()
1659 def register_multicast_listener(self, *ipaddrs: Union[IPv6Address, str], timeout=None): argument
1666 self.send_command(cmd)
1667 self.simulator.go(3)
1668 lines = self._expect_command_output()
1678 def set_link_quality(self, addr, lqi): argument
1680 self.send_command(cmd)
1681 self._expect_done()
1683 def set_outbound_link_quality(self, lqi): argument
1685 self.send_command(cmd)
1686 self._expect_done()
1688 def remove_allowlist(self, addr): argument
1690 self.send_command(cmd)
1691 self._expect_done()
1693 def get_addr16(self): argument
1694 self.send_command('rloc16')
1695 rloc16 = self._expect_result(r'[0-9a-fA-F]{4}')
1698 def get_router_id(self): argument
1699 rloc16 = self.get_addr16()
1702 def get_addr64(self): argument
1703 self.send_command('extaddr')
1704 return self._expect_result('[0-9a-fA-F]{16}')
1706 def set_addr64(self, addr64: str): argument
1710 self.send_command('extaddr %s' % addr64)
1711 self._expect_done()
1713 def get_eui64(self): argument
1714 self.send_command('eui64')
1715 return self._expect_result('[0-9a-fA-F]{16}')
1717 def set_extpanid(self, extpanid): argument
1718 self.send_command('extpanid %s' % extpanid)
1719 self._expect_done()
1721 def get_extpanid(self): argument
1722 self.send_command('extpanid')
1723 return self._expect_result('[0-9a-fA-F]{16}')
1725 def get_mesh_local_prefix(self): argument
1726 self.send_command('prefix meshlocal')
1727 return self._expect_command_output()[0]
1729 def set_mesh_local_prefix(self, mesh_local_prefix): argument
1730 self.send_command('prefix meshlocal %s' % mesh_local_prefix)
1731 self._expect_done()
1733 def get_joiner_id(self): argument
1734 self.send_command('joiner id')
1735 return self._expect_result('[0-9a-fA-F]{16}')
1737 def get_channel(self): argument
1738 self.send_command('channel')
1739 return int(self._expect_result(r'\d+'))
1741 def set_channel(self, channel): argument
1743 self.send_command(cmd)
1744 self._expect_done()
1746 def get_networkkey(self): argument
1747 self.send_command('networkkey')
1748 return self._expect_result('[0-9a-fA-F]{32}')
1750 def set_networkkey(self, networkkey): argument
1752 self.send_command(cmd)
1753 self._expect_done()
1755 def get_key_sequence_counter(self): argument
1756 self.send_command('keysequence counter')
1757 result = self._expect_result(r'\d+')
1760 def set_key_sequence_counter(self, key_sequence_counter): argument
1762 self.send_command(cmd)
1763 self._expect_done()
1765 def get_key_switch_guardtime(self): argument
1766 self.send_command('keysequence guardtime')
1767 return int(self._expect_result(r'\d+'))
1769 def set_key_switch_guardtime(self, key_switch_guardtime): argument
1771 self.send_command(cmd)
1772 self._expect_done()
1774 def set_network_id_timeout(self, network_id_timeout): argument
1776 self.send_command(cmd)
1777 self._expect_done()
1779 def _escape_escapable(self, string): argument
1793 def get_network_name(self): argument
1794 self.send_command('networkname')
1795 return self._expect_result([r'\S+'])
1797 def set_network_name(self, network_name): argument
1798 cmd = 'networkname %s' % self._escape_escapable(network_name)
1799 self.send_command(cmd)
1800 self._expect_done()
1802 def get_panid(self): argument
1803 self.send_command('panid')
1804 result = self._expect_result('0x[0-9a-fA-F]{4}')
1807 def set_panid(self, panid=config.PANID): argument
1809 self.send_command(cmd)
1810 self._expect_done()
1812 def set_parent_priority(self, priority): argument
1814 self.send_command(cmd)
1815 self._expect_done()
1817 def get_partition_id(self): argument
1818 self.send_command('partitionid')
1819 return self._expect_result(r'\d+')
1821 def get_preferred_partition_id(self): argument
1822 self.send_command('partitionid preferred')
1823 return self._expect_result(r'\d+')
1825 def set_preferred_partition_id(self, partition_id): argument
1827 self.send_command(cmd)
1828 self._expect_done()
1830 def get_pollperiod(self): argument
1831 self.send_command('pollperiod')
1832 return self._expect_result(r'\d+')
1834 def set_pollperiod(self, pollperiod): argument
1835 self.send_command('pollperiod %d' % pollperiod)
1836 self._expect_done()
1838 def get_child_supervision_interval(self): argument
1839 self.send_command('childsupervision interval')
1840 return self._expect_result(r'\d+')
1842 def set_child_supervision_interval(self, interval): argument
1843 self.send_command('childsupervision interval %d' % interval)
1844 self._expect_done()
1846 def get_child_supervision_check_timeout(self): argument
1847 self.send_command('childsupervision checktimeout')
1848 return self._expect_result(r'\d+')
1850 def set_child_supervision_check_timeout(self, timeout): argument
1851 self.send_command('childsupervision checktimeout %d' % timeout)
1852 self._expect_done()
1854 def get_child_supervision_check_failure_counter(self): argument
1855 self.send_command('childsupervision failcounter')
1856 return self._expect_result(r'\d+')
1858 def reset_child_supervision_check_failure_counter(self): argument
1859 self.send_command('childsupervision failcounter reset')
1860 self._expect_done()
1862 def get_csl_info(self): argument
1863 self.send_command('csl')
1864 return self._expect_key_value_pairs(r'\S+')
1866 def set_csl_channel(self, csl_channel): argument
1867 self.send_command('csl channel %d' % csl_channel)
1868 self._expect_done()
1870 def set_csl_period(self, csl_period): argument
1871 self.send_command('csl period %d' % csl_period)
1872 self._expect_done()
1874 def set_csl_timeout(self, csl_timeout): argument
1875 self.send_command('csl timeout %d' % csl_timeout)
1876 self._expect_done()
1878 def send_mac_emptydata(self): argument
1879 self.send_command('mac send emptydata')
1880 self._expect_done()
1882 def send_mac_datarequest(self): argument
1883 self.send_command('mac send datarequest')
1884 self._expect_done()
1886 def set_router_upgrade_threshold(self, threshold): argument
1888 self.send_command(cmd)
1889 self._expect_done()
1891 def set_router_downgrade_threshold(self, threshold): argument
1893 self.send_command(cmd)
1894 self._expect_done()
1896 def get_router_downgrade_threshold(self) -> int: argument
1897 self.send_command('routerdowngradethreshold')
1898 return int(self._expect_result(r'\d+'))
1900 def set_router_eligible(self, enable: bool): argument
1902 self.send_command(cmd)
1903 self._expect_done()
1905 def get_router_eligible(self) -> bool: argument
1907 self.send_command('routereligible')
1908 return self._expect_result(states) == 'Enabled'
1910 def prefer_router_id(self, router_id): argument
1912 self.send_command(cmd)
1913 self._expect_done()
1915 def release_router_id(self, router_id): argument
1917 self.send_command(cmd)
1918 self._expect_done()
1920 def get_state(self): argument
1922 self.send_command('state')
1923 return self._expect_result(states)
1925 def set_state(self, state): argument
1927 self.send_command(cmd)
1928 self._expect_done()
1930 def get_ephemeral_key_state(self): argument
1933 self.send_command(cmd)
1934 return self._expect_result(states)
1936 def get_timeout(self): argument
1937 self.send_command('childtimeout')
1938 return self._expect_result(r'\d+')
1940 def set_timeout(self, timeout): argument
1942 self.send_command(cmd)
1943 self._expect_done()
1945 def set_max_children(self, number): argument
1947 self.send_command(cmd)
1948 self._expect_done()
1950 def get_weight(self): argument
1951 self.send_command('leaderweight')
1952 return self._expect_result(r'\d+')
1954 def set_weight(self, weight): argument
1956 self.send_command(cmd)
1957 self._expect_done()
1959 def add_ipaddr(self, ipaddr): argument
1961 self.send_command(cmd)
1962 self._expect_done()
1964 def del_ipaddr(self, ipaddr): argument
1966 self.send_command(cmd)
1967 self._expect_done()
1969 def add_ipmaddr(self, ipmaddr): argument
1971 self.send_command(cmd)
1972 self._expect_done()
1974 def del_ipmaddr(self, ipmaddr): argument
1976 self.send_command(cmd)
1977 self._expect_done()
1979 def get_addrs(self, verbose=False): argument
1980 self.send_command('ipaddr' + (' -v' if verbose else ''))
1982 return self._expect_results(r'\S+(:\S*)+')
1984 def get_mleid(self): argument
1985 self.send_command('ipaddr mleid')
1986 return self._expect_result(r'\S+(:\S*)+')
1988 def get_linklocal(self): argument
1989 self.send_command('ipaddr linklocal')
1990 return self._expect_result(r'\S+(:\S*)+')
1992 def get_rloc(self): argument
1993 self.send_command('ipaddr rloc')
1994 return self._expect_result(r'\S+(:\S*)+')
1996 def get_addr(self, prefix): argument
1998 addrs = self.get_addrs()
2009 def has_ipaddr(self, address): argument
2011 ipaddrs = self.get_addrs()
2019 def get_ipmaddrs(self): argument
2020 self.send_command('ipmaddr')
2021 return self._expect_results(r'\S+(:\S*)+')
2023 def has_ipmaddr(self, address): argument
2025 ipmaddrs = self.get_ipmaddrs()
2033 def get_addr_leader_aloc(self): argument
2034 addrs = self.get_addrs()
2041 def get_mleid_iid(self): argument
2042 ml_eid = IPv6Address(self.get_mleid())
2045 def get_eidcaches(self): argument
2047 self.send_command('eidcache')
2048 for line in self._expect_results(r'([a-fA-F0-9\:]+) ([a-fA-F0-9]+)'):
2053 def add_service(self, enterpriseNumber, serviceData, serverData): argument
2059 self.send_command(cmd)
2060 self._expect_done()
2062 def remove_service(self, enterpriseNumber, serviceData): argument
2064 self.send_command(cmd)
2065 self._expect_done()
2067 def get_child_table(self) -> Dict[int, Dict[str, Any]]: argument
2070 self.send_command(cmd)
2071 output = self._expect_command_output()
2082 headers = self.__split_table_row(output[0])
2090 fields = self.__split_table_row(line)
2091 col = lambda colname: self.__get_table_col(colname, headers, fields)
2114 def __split_table_row(self, row: str) -> List[str]: argument
2122 def __get_table_col(self, colname: str, headers: List[str], fields: List[str]) -> str: argument
2125 def __getOmrAddress(self): argument
2126 prefixes = [prefix.split('::')[0] for prefix in self.get_prefixes()]
2128 for addr in self.get_addrs():
2130 if (addr.startswith(prefix)) and (addr != self.__getDua()):
2136 def __getLinkLocalAddress(self): argument
2137 for ip6Addr in self.get_addrs():
2143 def __getGlobalAddress(self): argument
2145 for ip6Addr in self.get_addrs():
2153 def __getRloc(self): argument
2154 for ip6Addr in self.get_addrs():
2161 def __getAloc(self): argument
2163 for ip6Addr in self.get_addrs():
2171 def __getMleid(self): argument
2172 for ip6Addr in self.get_addrs():
2179 def __getDua(self) -> Optional[str]: argument
2180 for ip6Addr in self.get_addrs():
2186 def get_ip6_address_by_prefix(self, prefix: Union[str, IPv6Network]) -> List[IPv6Address]: argument
2198 addrs = map(IPv6Address, self.get_addrs())
2202 def get_ip6_address(self, address_type): argument
2212 return self.__getLinkLocalAddress()
2214 return self.__getGlobalAddress()
2216 return self.__getRloc()
2218 return self.__getAloc()
2220 return self.__getMleid()
2222 return self.__getDua()
2224 return self._getBackboneGua()
2226 return self.__getOmrAddress()
2230 def get_context_reuse_delay(self): argument
2231 self.send_command('contextreusedelay')
2232 return self._expect_result(r'\d+')
2234 def set_context_reuse_delay(self, delay): argument
2236 self.send_command(cmd)
2237 self._expect_done()
2239 def add_prefix(self, prefix, flags='paosr', prf='med'): argument
2241 self.send_command(cmd)
2242 self._expect_done()
2244 def remove_prefix(self, prefix): argument
2246 self.send_command(cmd)
2247 self._expect_done()
2252 def enable_br(self): argument
2253 self.send_command('br enable')
2254 self._expect_done()
2256 def disable_br(self): argument
2257 self.send_command('br disable')
2258 self._expect_done()
2260 def get_br_omr_prefix(self): argument
2262 self.send_command(cmd)
2263 return self._expect_command_output()[0]
2265 def get_br_peers(self) -> List[str]: argument
2270 self.send_command('br peers')
2271 return self._expect_command_output()
2273 def get_br_peers_rloc16s(self) -> List[int]: argument
2277 for line in self.get_br_peers()
2282 def get_br_routers(self) -> List[str]: argument
2287 self.send_command('br routers')
2288 return self._expect_command_output()
2290 def get_br_routers_ip_addresses(self) -> List[IPv6Address]: argument
2292 return [IPv6Address(line.split()[0]) for line in self.get_br_routers()]
2294 def get_netdata_omr_prefixes(self): argument
2296 for prefix in self.get_prefixes():
2303 def get_br_on_link_prefix(self): argument
2305 self.send_command(cmd)
2306 return self._expect_command_output()[0]
2308 def get_netdata_non_nat64_routes(self): argument
2310 routes = self.get_routes()
2316 def get_netdata_nat64_routes(self): argument
2318 routes = self.get_routes()
2324 def get_br_nat64_prefix(self): argument
2326 self.send_command(cmd)
2327 return self._expect_command_output()[0]
2329 def get_br_favored_nat64_prefix(self): argument
2331 self.send_command(cmd)
2332 return self._expect_command_output()[0].split(' ')[0]
2334 def enable_nat64(self): argument
2335 self.send_command(f'nat64 enable')
2336 self._expect_done()
2338 def disable_nat64(self): argument
2339 self.send_command(f'nat64 disable')
2340 self._expect_done()
2342 def get_nat64_state(self): argument
2343 self.send_command('nat64 state')
2345 for line in self._expect_command_output():
2350 def get_nat64_mappings(self): argument
2352 self.send_command(cmd)
2353 result = self._expect_command_output()
2405 def get_nat64_counters(self): argument
2407 self.send_command(cmd)
2408 result = self._expect_command_output()
2441 def get_prefixes(self): argument
2442 return self.get_netdata()['Prefixes']
2444 def get_routes(self): argument
2445 return self.get_netdata()['Routes']
2447 def get_services(self): argument
2448 netdata = self.netdata_show()
2461 def netdata_show(self): argument
2462 self.send_command('netdata show')
2463 return self._expect_command_output()
2465 def get_netdata(self): argument
2466 raw_netdata = self.netdata_show()
2480 def add_route(self, prefix, stable=False, nat64=False, prf='med'): argument
2487 self.send_command(cmd)
2488 self._expect_done()
2490 def remove_route(self, prefix): argument
2492 self.send_command(cmd)
2493 self._expect_done()
2495 def register_netdata(self): argument
2496 self.send_command('netdata register')
2497 self._expect_done()
2499 def netdata_publish_dnssrp_anycast(self, seqnum): argument
2500 self.send_command(f'netdata publish dnssrp anycast {seqnum}')
2501 self._expect_done()
2503 def netdata_publish_dnssrp_unicast(self, address, port): argument
2504 self.send_command(f'netdata publish dnssrp unicast {address} {port}')
2505 self._expect_done()
2507 def netdata_publish_dnssrp_unicast_mleid(self, port): argument
2508 self.send_command(f'netdata publish dnssrp unicast {port}')
2509 self._expect_done()
2511 def netdata_unpublish_dnssrp(self): argument
2512 self.send_command('netdata unpublish dnssrp')
2513 self._expect_done()
2515 def netdata_publish_prefix(self, prefix, flags='paosr', prf='med'): argument
2516 self.send_command(f'netdata publish prefix {prefix} {flags} {prf}')
2517 self._expect_done()
2519 def netdata_publish_route(self, prefix, flags='s', prf='med'): argument
2520 self.send_command(f'netdata publish route {prefix} {flags} {prf}')
2521 self._expect_done()
2523 def netdata_publish_replace(self, old_prefix, prefix, flags='s', prf='med'): argument
2524 self.send_command(f'netdata publish replace {old_prefix} {prefix} {flags} {prf}')
2525 self._expect_done()
2527 def netdata_unpublish_prefix(self, prefix): argument
2528 self.send_command(f'netdata unpublish {prefix}')
2529 self._expect_done()
2531 def send_network_diag_get(self, addr, tlv_types): argument
2532 …self.send_command('networkdiagnostic get %s %s' % (addr, ' '.join([str(t.value) for t in tlv_types…
2534 if isinstance(self.simulator, simulator.VirtualTime):
2535 self.simulator.go(8)
2540 self._expect_done(timeout=timeout)
2542 def send_network_diag_reset(self, addr, tlv_types): argument
2543 …self.send_command('networkdiagnostic reset %s %s' % (addr, ' '.join([str(t.value) for t in tlv_typ…
2545 if isinstance(self.simulator, simulator.VirtualTime):
2546 self.simulator.go(8)
2551 self._expect_done(timeout=timeout)
2553 def energy_scan(self, mask, count, period, scan_duration, ipaddr): argument
2561 self.send_command(cmd)
2563 if isinstance(self.simulator, simulator.VirtualTime):
2564 self.simulator.go(8)
2569 self._expect('Energy:', timeout=timeout)
2571 def panid_query(self, panid, mask, ipaddr): argument
2573 self.send_command(cmd)
2575 if isinstance(self.simulator, simulator.VirtualTime):
2576 self.simulator.go(8)
2581 self._expect('Conflict:', timeout=timeout)
2583 def scan(self, result=1, timeout=10): argument
2584 self.send_command('scan')
2586 self.simulator.go(timeout)
2590 for line in self._expect_command_output()[2:]:
2604 def scan_energy(self, timeout=10): argument
2605 self.send_command('scan energy')
2606 self.simulator.go(timeout)
2608 for line in self._expect_command_output()[2:]:
2616 …def ping(self, ipaddr, num_responses=1, size=8, timeout=5, count=1, interval=1, hoplimit=64, inter… argument
2622 self.send_command(cmd)
2625 end = self.simulator.now() + timeout + wait_allowance
2631 done = (self.node_type == 'ncp-sim')
2633 self.simulator.go(1)
2635 i = self._expect([r'from (\S+):', r'Done'], timeout=0.1)
2637 if self.simulator.now() < end:
2640 if isinstance(self.simulator, simulator.VirtualTime):
2641 self.simulator.sync_devices()
2645 responders[self.pexpect.match.groups()[0]] = 1
2650 def reset(self): argument
2651 self._reset('reset')
2653 def factory_reset(self): argument
2654 self._reset('factoryreset')
2656 def _reset(self, cmd): argument
2657 self.send_command(cmd, expect_command_echo=False)
2658 time.sleep(self.RESET_DELAY)
2660 self.send_command('version', expect_command_echo=False)
2663 self._expect(r"[^\n]+\n", timeout=0.1)
2668 if self.is_otbr:
2669 self.set_log_level(5)
2671 def set_router_selection_jitter(self, jitter): argument
2673 self.send_command(cmd)
2674 self._expect_done()
2677 self, argument
2692 self.send_command('dataset init active', go=False)
2694 self.send_command('dataset clear', go=False)
2695 self._expect_done()
2699 self.send_command(cmd, go=False)
2700 self._expect_done()
2704 self.send_command(cmd, go=False)
2705 self._expect_done()
2709 self.send_command(cmd, go=False)
2710 self._expect_done()
2714 self.send_command(cmd, go=False)
2715 self._expect_done()
2719 self.send_command(cmd, go=False)
2720 self._expect_done()
2724 self.send_command(cmd, go=False)
2725 self._expect_done()
2729 self.send_command(cmd, go=False)
2730 self._expect_done()
2734 self.send_command(cmd, go=False)
2735 self._expect_done()
2739 self.send_command(cmd, go=False)
2740 self._expect_done()
2750 self.send_command(cmd, go=False)
2751 self._expect_done()
2753 self.send_command('dataset commit active', go=False)
2754 self._expect_done()
2756 …def set_pending_dataset(self, pendingtimestamp, activetimestamp, panid=None, channel=None, delay=N… argument
2757 self.send_command('dataset clear')
2758 self._expect_done()
2761 self.send_command(cmd)
2762 self._expect_done()
2765 self.send_command(cmd)
2766 self._expect_done()
2770 self.send_command(cmd)
2771 self._expect_done()
2775 self.send_command(cmd)
2776 self._expect_done()
2780 self.send_command(cmd)
2781 self._expect_done()
2784 self.send_command('dataset meshlocalprefix %s' % config.MESH_LOCAL_PREFIX.split('/')[0])
2785 self._expect_done()
2787 self.send_command('dataset commit pending')
2788 self._expect_done()
2790 def start_dataset_updater(self, panid=None, channel=None, security_policy=None, delay=None): argument
2791 self.send_command('dataset clear')
2792 self._expect_done()
2796 self.send_command(cmd)
2797 self._expect_done()
2801 self.send_command(cmd)
2802 self._expect_done()
2808 self.send_command(cmd)
2809 self._expect_done()
2813 self.send_command(cmd)
2814 self._expect_done()
2816 self.send_command('dataset updater start')
2817 self._expect_done()
2819 def announce_begin(self, mask, count, period, ipaddr): argument
2826 self.send_command(cmd)
2827 self._expect_done()
2830 self, argument
2866 cmd += 'networkname %s ' % self._escape_escapable(network_name)
2876 self.send_command(cmd)
2877 self._expect_done()
2879 def send_mgmt_active_get(self, addr='', tlvs=[]): argument
2891 self.send_command(cmd)
2892 self._expect_done()
2894 def send_mgmt_pending_get(self, addr='', tlvs=[]): argument
2906 self.send_command(cmd)
2907 self._expect_done()
2910 self, argument
2943 cmd += 'networkname %s ' % self._escape_escapable(network_name)
2945 self.send_command(cmd)
2946 self._expect_done()
2948 def coap_cancel(self): argument
2953 self.send_command(cmd)
2954 self._expect_done()
2956 def coap_delete(self, ipaddr, uri, con=False, payload=None): argument
2960 return self._coap_rq('delete', ipaddr, uri, con, payload)
2962 def coap_get(self, ipaddr, uri, con=False, payload=None): argument
2966 return self._coap_rq('get', ipaddr, uri, con, payload)
2968 def coap_get_block(self, ipaddr, uri, size=16, count=0): argument
2972 return self._coap_rq_block('get', ipaddr, uri, size, count)
2974 def coap_observe(self, ipaddr, uri, con=False, payload=None): argument
2978 return self._coap_rq('observe', ipaddr, uri, con, payload)
2980 def coap_post(self, ipaddr, uri, con=False, payload=None): argument
2984 return self._coap_rq('post', ipaddr, uri, con, payload)
2986 def coap_post_block(self, ipaddr, uri, size=16, count=0): argument
2990 return self._coap_rq_block('post', ipaddr, uri, size, count)
2992 def coap_put(self, ipaddr, uri, con=False, payload=None): argument
2996 return self._coap_rq('put', ipaddr, uri, con, payload)
2998 def coap_put_block(self, ipaddr, uri, size=16, count=0): argument
3002 return self._coap_rq_block('put', ipaddr, uri, size, count)
3004 def _coap_rq(self, method, ipaddr, uri, con=False, payload=None): argument
3017 self.send_command(cmd)
3018 return self.coap_wait_response()
3020 def _coap_rq_block(self, method, ipaddr, uri, size=16, count=0): argument
3031 self.send_command(cmd)
3032 return self.coap_wait_response()
3034 def coap_wait_response(self): argument
3038 if isinstance(self.simulator, simulator.VirtualTime):
3039 self.simulator.go(5)
3044 self._expect(r'coap response from ([\da-f:]+)(?: OBS=(\d+))?'
3047 (source, observe, payload) = self.pexpect.match.groups()
3062 def coap_wait_request(self): argument
3066 if isinstance(self.simulator, simulator.VirtualTime):
3067 self.simulator.go(5)
3072 self._expect(r'coap request from ([\da-f:]+)(?: OBS=(\d+))?'
3075 (source, observe, payload) = self.pexpect.match.groups()
3087 def coap_wait_subscribe(self): argument
3091 if isinstance(self.simulator, simulator.VirtualTime):
3092 self.simulator.go(5)
3097 self._expect(r'Subscribing client\b', timeout=timeout)
3099 def coap_wait_ack(self): argument
3103 if isinstance(self.simulator, simulator.VirtualTime):
3104 self.simulator.go(5)
3109 self._expect(r'Received ACK in reply to notification from ([\da-f:]+)\b', timeout=timeout)
3110 (source,) = self.pexpect.match.groups()
3115 def coap_set_resource_path(self, path): argument
3120 self.send_command(cmd)
3121 self._expect_done()
3123 def coap_set_resource_path_block(self, path, count=0): argument
3128 self.send_command(cmd)
3129 self._expect('Done')
3131 def coap_set_content(self, content): argument
3136 self.send_command(cmd)
3137 self._expect_done()
3139 def coap_start(self): argument
3144 self.send_command(cmd)
3145 self._expect_done()
3147 def coap_stop(self): argument
3152 self.send_command(cmd)
3154 if isinstance(self.simulator, simulator.VirtualTime):
3155 self.simulator.go(5)
3160 self._expect_done(timeout=timeout)
3162 def coaps_start_psk(self, psk, pskIdentity): argument
3164 self.send_command(cmd)
3165 self._expect_done()
3168 self.send_command(cmd)
3169 self._expect_done()
3171 def coaps_start_x509(self): argument
3173 self.send_command(cmd)
3174 self._expect_done()
3177 self.send_command(cmd)
3178 self._expect_done()
3180 def coaps_set_resource_path(self, path): argument
3182 self.send_command(cmd)
3183 self._expect_done()
3185 def coaps_stop(self): argument
3187 self.send_command(cmd)
3189 if isinstance(self.simulator, simulator.VirtualTime):
3190 self.simulator.go(5)
3195 self._expect_done(timeout=timeout)
3197 def coaps_connect(self, ipaddr): argument
3199 self.send_command(cmd)
3201 if isinstance(self.simulator, simulator.VirtualTime):
3202 self.simulator.go(5)
3207 self._expect('coaps connected', timeout=timeout)
3209 def coaps_disconnect(self): argument
3211 self.send_command(cmd)
3212 self._expect_done()
3213 self.simulator.go(5)
3215 def coaps_get(self): argument
3217 self.send_command(cmd)
3219 if isinstance(self.simulator, simulator.VirtualTime):
3220 self.simulator.go(5)
3225 self._expect('coaps response', timeout=timeout)
3227 def commissioner_mgmtget(self, tlvs_binary=None): argument
3231 self.send_command(cmd)
3232 self._expect_done()
3234 def commissioner_mgmtset(self, tlvs_binary): argument
3236 self.send_command(cmd)
3237 self._expect_done()
3239 def bytes_to_hex_str(self, src): argument
3242 def commissioner_mgmtset_with_tlvs(self, tlvs): argument
3246 self.commissioner_mgmtset(self.bytes_to_hex_str(payload))
3248 def udp_start(self, local_ipaddr, local_port, bind_unspecified=False): argument
3250 self.send_command(cmd)
3251 self._expect_done()
3254 self.send_command(cmd)
3255 self._expect_done()
3257 def udp_stop(self): argument
3259 self.send_command(cmd)
3260 self._expect_done()
3262 def udp_send(self, bytes, ipaddr, port, success=True): argument
3264 self.send_command(cmd)
3266 self._expect_done()
3268 self._expect('Error')
3270 def udp_check_rx(self, bytes_should_rx): argument
3271 self._expect('%d bytes' % bytes_should_rx)
3273 def set_routereligible(self, enable: bool): argument
3275 self.send_command(cmd)
3276 self._expect_done()
3278 def router_list(self): argument
3280 self.send_command(cmd)
3281 self._expect([r'(\d+)((\s\d+)*)'])
3283 g = self.pexpect.match.groups()
3286 self._expect_done()
3289 def router_table(self): argument
3291 self.send_command(cmd)
3293 self._expect(r'(.*)Done')
3294 g = self.pexpect.match.groups()
3343 …def link_metrics_request_single_probe(self, dst_addr: str, linkmetrics_flags: str, mode: str = ''): argument
3345 self.send_command(cmd)
3346 self.simulator.go(5)
3347 return self._parse_linkmetrics_query_result(self._expect_command_output())
3349 …def link_metrics_request_forward_tracking_series(self, dst_addr: str, series_id: int, mode: str = … argument
3351 self.send_command(cmd)
3352 self.simulator.go(5)
3353 return self._parse_linkmetrics_query_result(self._expect_command_output())
3355 def _parse_linkmetrics_query_result(self, lines): argument
3376 def link_metrics_config_req_enhanced_ack_based_probing(self, argument
3387 self.send_command(cmd)
3388 self._expect_done()
3390 def link_metrics_config_req_forward_tracking_series(self, argument
3397 self.send_command(cmd)
3398 self._expect_done()
3400 def link_metrics_send_link_probe(self, dst_addr: str, series_id: int, length: int): argument
3402 self.send_command(cmd)
3403 self._expect_done()
3405 def link_metrics_mgr_set_enabled(self, enable: bool): argument
3408 self.send_command(cmd)
3409 self._expect_done()
3411 def send_address_notification(self, dst: str, target: str, mliid: str): argument
3413 self.send_command(cmd)
3414 self._expect_done()
3416 def send_proactive_backbone_notification(self, target: str, mliid: str, ltt: int): argument
3418 self.send_command(cmd)
3419 self._expect_done()
3421 def dns_get_config(self): argument
3434 self.send_command(cmd)
3435 output = self._expect_command_output()
3442 def dns_set_config(self, config): argument
3444 self.send_command(cmd)
3445 self._expect_done()
3447 def dns_resolve(self, hostname, server=None, port=53): argument
3452 self.send_command(cmd)
3453 self.simulator.go(10)
3454 output = self._expect_command_output()
3464 def _parse_dns_service_info(self, output): argument
3489 def dns_resolve_service(self, instance, service, server=None, port=53): argument
3506 instance = self._escape_escapable(instance)
3511 self.send_command(cmd)
3512 self.simulator.go(10)
3513 output = self._expect_command_output()
3514 info = self._parse_dns_service_info(output)
3524 def dns_browse(self, service_name, server=None, port=53): argument
3558 self.send_command(cmd)
3559 self.simulator.go(10)
3560 output = self._expect_command_output()
3580 result[ins] = self._parse_dns_service_info(output[index + 1:index + 6])
3584 def set_mliid(self, mliid: str): argument
3586 self.send_command(cmd)
3587 self._expect_command_output()
3589 def history_netinfo(self, num_entries=0): argument
3613 self.send_command(cmd)
3614 output = self._expect_command_output()
3626 def history_rx(self, num_entries=0): argument
3648 self.send_command(cmd)
3649 return self._parse_history_rx_tx_ouput(self._expect_command_output())
3651 def history_tx(self, num_entries=0): argument
3674 self.send_command(cmd)
3675 return self._parse_history_rx_tx_ouput(self._expect_command_output())
3677 def _parse_history_rx_tx_ouput(self, lines): argument
3695 def set_router_id_range(self, min_router_id: int, max_router_id: int): argument
3697 self.send_command(cmd)
3698 self._expect_command_output()
3700 def get_router_id_range(self): argument
3702 self.send_command(cmd)
3703 line = self._expect_command_output()[0]
3706 def get_channel_monitor_info(self) -> Dict: argument
3736 self.send_command('channel monitor')
3738 for line in self._expect_results(r'\S+'):
3753 def set_channel_manager_auto_enable(self, enable: bool): argument
3754 self.send_command(f'channel manager auto {int(enable)}')
3755 self._expect_done()
3757 def set_channel_manager_autocsl_enable(self, enable: bool): argument
3758 self.send_command(f'channel manager autocsl {int(enable)}')
3759 self._expect_done()
3761 def set_channel_manager_supported(self, channel_mask: int): argument
3762 self.send_command(f'channel manager supported {int(channel_mask)}')
3763 self._expect_done()
3765 def set_channel_manager_favored(self, channel_mask: int): argument
3766 self.send_command(f'channel manager favored {int(channel_mask)}')
3767 self._expect_done()
3769 def set_channel_manager_interval(self, interval: int): argument
3770 self.send_command(f'channel manager interval {interval}')
3771 self._expect_done()
3773 def set_channel_manager_cca_threshold(self, hex_value: str): argument
3774 self.send_command(f'channel manager threshold {hex_value}')
3775 self._expect_done()
3777 def get_channel_manager_config(self): argument
3778 self.send_command('channel manager')
3779 return self._expect_key_value_pairs(r'\S+')
3790 def enable_ether(self): argument
3794 self.bash(f'ip link set {self.ETH_DEV} up')
3796 def disable_ether(self): argument
3800 self.bash(f'ip link set {self.ETH_DEV} down')
3802 def get_ether_addrs(self): argument
3803 output = self.bash(f'ip -6 addr list dev {self.ETH_DEV}')
3816 logging.debug('%s: get_ether_addrs: %r', self, addrs)
3819 def get_ether_mac(self): argument
3820 output = self.bash(f'ip addr list dev {self.ETH_DEV}')
3829 def add_ipmaddr_ether(self, ip: str): argument
3831 self.bash(cmd)
3833 …def ping_ether(self, ipaddr, num_responses=1, size=None, timeout=5, ttl=None, interface='eth0') ->… argument
3845 for line in self.bash(cmd):
3846 if self.PING_RESPONSE_PATTERN.match(line):
3853 def get_ip6_address(self, address_type: config.ADDRESS_TYPE): argument
3863 return self._getBackboneGua()
3865 return self._getInfraLinkLocalAddress()
3867 return self._getInfraUla()
3869 return self._getInfraGua()
3873 def _getBackboneGua(self) -> Optional[str]: argument
3874 for addr in self.get_ether_addrs():
3880 def _getInfraUla(self) -> Optional[str]: argument
3884 for addr in self.get_ether_addrs():
3890 def _getInfraGua(self) -> Optional[str]: argument
3895 return [addr for addr in self.get_ether_addrs() if addr.startswith(gua_prefix)]
3897 def _getInfraLinkLocalAddress(self) -> Optional[str]: argument
3900 for addr in self.get_ether_addrs():
3906 def ping(self, *args, **kwargs): argument
3909 return self.ping_ether(*args, **kwargs)
3913 def udp_send_host(self, ipaddr, port, data, hop_limit=None): argument
3920 self.bash(cmd)
3922 def add_ipmaddr(self, *args, **kwargs): argument
3925 return self.add_ipmaddr_ether(*args, **kwargs)
3929 def ip_neighbors_flush(self): argument
3931 self.bash(f'ip -6 neigh list dev {self.ETH_DEV}')
3932 self.bash(f'ip -6 neigh flush nud all nud failed nud noarp dev {self.ETH_DEV}')
3933 …self.bash('ip -6 neigh list nud all dev %s | cut -d " " -f1 | sudo xargs -I{} ip -6 neigh delete {…
3934 (self.ETH_DEV, self.ETH_DEV))
3935 self.bash(f'ip -6 neigh list dev {self.ETH_DEV}')
3937 def publish_mdns_service(self, instance_name, service_type, port, host_name, txt): argument
3948 …self.bash(f'avahi-publish -s {instance_name} {service_type} {port} -H {host_name}.local {txt_stri…
3950 def publish_mdns_host(self, hostname, addresses): argument
3959 self.bash(f'avahi-publish -a {hostname}.local {address} &')
3961 def browse_mdns_services(self, name, timeout=2): argument
3969 self.bash(f'dns-sd -Z {name} local. > /tmp/{name} 2>&1 &')
3971 self.bash('pkill dns-sd')
3974 for line in self.bash(f'cat /tmp/{name}', encoding='raw_unicode_escape'):
3980 def discover_mdns_service(self, instance, name, host_name, timeout=2): argument
3993 host_name_file = self.bash('mktemp')[0].strip()
3994 service_data_file = self.bash('mktemp')[0].strip()
3996 self.bash(f'dns-sd -Z {name} local. > {service_data_file} 2>&1 &')
4002 for line in self.bash(f'cat {service_data_file}', encoding='raw_unicode_escape'):
4009 self.bash(f'dns-sd -G v6 {host_name}.local. > {host_name_file} 2>&1 &')
4012 self.bash('pkill dns-sd')
4016 logging.debug(self.bash(f'cat {host_name_file}', encoding='raw_unicode_escape'))
4017 logging.debug(self.bash(f'cat {service_data_file}', encoding='raw_unicode_escape'))
4023 for line in self.bash(f'cat {host_name_file}', encoding='raw_unicode_escape'):
4041 for line in self.bash(f'cat {service_data_file}', encoding='raw_unicode_escape'):
4049 txt_dict = self.__parse_dns_sd_txt(txt)
4068 def start_radvd_service(self, prefix, slaac): argument
4069 self.bash("""cat >/etc/radvd.conf <<EOF
4092 self.bash('service radvd start')
4093 self.bash('service radvd status') # Make sure radvd service is running
4095 def stop_radvd_service(self): argument
4096 self.bash('service radvd stop')
4098 def kill_radvd_service(self): argument
4099 self.bash('pkill radvd')
4101 def __parse_dns_sd_txt(self, line: str): argument
4121 def __repr__(self): argument
4124 def start(self): argument
4125 self._setup_sysctl()
4126 self.set_log_level(5)
4129 def add_ipaddr(self, addr): argument
4131 self.bash(cmd)
4133 def add_ipmaddr_tun(self, ip: str): argument
4135 self.bash(cmd)
4137 def get_ip6_address(self, address_type: config.ADDRESS_TYPE): argument
4139 return super(OtbrNode, self).get_ip6_address(address_type)
4141 return super(LinuxHost, self).get_ip6_address(address_type)
4147 def __init__(self, nodeid, name=None, **kwargs): argument
4148 self.nodeid = nodeid
4149 self.name = name or ('Host%d' % nodeid)
4151 self.bash('service otbr-agent stop')
4153 def start(self, start_radvd=True, prefix=config.DOMAIN_PREFIX, slaac=False): argument
4154 self._setup_sysctl()
4156 self.start_radvd_service(prefix, slaac)
4158 self.stop_radvd_service()
4160 def stop(self): argument
4161 self.stop_radvd_service()
4163 def get_addrs(self) -> List[str]: argument
4164 return self.get_ether_addrs()
4166 def __repr__(self): argument
4169 def get_matched_ula_addresses(self, prefix): argument
4174 for addr in self.get_ip6_address(config.ADDRESS_TYPE.ONLINK_ULA):