Lines Matching refs:self
323 def __init__(self, radios=None, verbose=_VERBOSE): argument
329 self._index = index
330 self._interface_name = self._INTFC_NAME_PREFIX + str(index)
331 self._verbose = verbose
333 …ncp_socket_path = 'system:{}{} {} --time-speed={}'.format(self._OT_NCP_FTD, '' if radios is None e…
334 index, self._SPEED_UP_FACTOR)
336 cmd = self._WPANTUND + \
338 ' -o Config:TUN:InterfaceName {}'.format(self._interface_name) + \
343 self._tund_log_file = open(self._TUND_LOG_FNAME + str(index) + '.log', 'wb')
345 self._tund_log_file = None
347 if self._verbose:
350 self._wpantund_process = subprocess.Popen(cmd, shell=True, stderr=self._tund_log_file)
352 self._wpanctl_cmd = self._WPANCTL + ' -I ' + self._interface_name + ' '
355 self._recvers = weakref.WeakValueDictionary()
356 Node._all_nodes.add(self)
358 def __del__(self): argument
359 self._wpantund_process.poll()
360 if self._wpantund_process.returncode is None:
361 self._wpantund_process.terminate()
362 self._wpantund_process.wait()
364 def __repr__(self): argument
365 return 'Node (index={}, interface_name={})'.format(self._index, self._interface_name)
368 def index(self): argument
369 return self._index
372 def interface_name(self): argument
373 return self._interface_name
376 def tund_log_file(self): argument
377 return self._tund_log_file
382 def wpanctl(self, cmd): argument
385 if self._verbose:
386 _log('$ Node{}.wpanctl(\'{}\')'.format(self._index, cmd), new_line=False)
388 … result = subprocess.check_output(self._wpanctl_cmd + cmd, shell=True, stderr=subprocess.STDOUT)
393 if self._verbose:
406 def get(self, prop_name, value_only=True): argument
407 return self.wpanctl('get ' + ('-v ' if value_only else '') + prop_name)
409 def set(self, prop_name, value, binary_data=False): argument
410 return self._update_prop('set', prop_name, value, binary_data)
412 def add(self, prop_name, value, binary_data=False): argument
413 return self._update_prop('add', prop_name, value, binary_data)
415 def remove(self, prop_name, value, binary_data=False): argument
416 return self._update_prop('remove', prop_name, value, binary_data)
418 def _update_prop(self, action, prop_name, value, binary_data): argument
419 … return self.wpanctl(action + ' ' + prop_name + ' ' + ('-d ' if binary_data else '') + '-v ' +
422 def reset(self): argument
423 return self.wpanctl('reset')
425 def status(self): argument
426 return self.wpanctl('status')
428 def leave(self): argument
429 return self.wpanctl('leave')
431 def form(self, argument
442 …return self.wpanctl('form \"' + name + '\"' + (' -c {}'.format(channel) if channel is not None els…
452 def join(self, name, channel=None, node_type=None, panid=None, xpanid=None, key=None): argument
453 …return self.wpanctl('join \"' + name + '\"' + (' -c {}'.format(channel) if channel is not None els…
459 def active_scan(self, channel=None): argument
460 return self.wpanctl('scan' + (' -c {}'.format(channel) if channel is not None else ''))
462 def energy_scan(self, channel=None): argument
463 return self.wpanctl('scan -e' + (' -c {}'.format(channel) if channel is not None else ''))
465 …def discover_scan(self, channel=None, joiner_only=False, enable_filtering=False, panid_filter=None… argument
466 return self.wpanctl('scan -d' + (' -c {}'.format(channel) if channel is not None else '') +
470 def permit_join(self, duration_sec=None, port=None, udp=True, tcp=True): argument
481 …return self.wpanctl('permit-join' + (' {}'.format(duration_sec) if duration_sec is not None else '…
484 def config_gateway(self, prefix, default_route=False, priority=None): argument
485 return self.wpanctl('config-gateway ' + prefix + (' -d' if default_route else '') +
488 def add_prefix(self, argument
499 …return self.wpanctl('add-prefix ' + prefix + (' -l {}'.format(prefix_len) if prefix_len is not Non…
505 def remove_prefix(self, prefix, prefix_len=None): argument
506 return self.wpanctl('remove-prefix ' + prefix +
509 def add_route(self, route_prefix, prefix_len=None, priority=None, stable=True): argument
511 return self.wpanctl('add-route ' + route_prefix +
515 def remove_route(self, route_prefix, prefix_len=None, priority=None, stable=True): argument
517 return self.wpanctl('remove-route ' + route_prefix +
521 def commissioner_start(self): argument
522 return self.wpanctl('commissioner start')
524 def commissioner_add_joiner(self, eui64, pskd, timeout='100'): argument
525 return self.wpanctl('commissioner joiner-add {} {} {}'.format(eui64, timeout, pskd))
527 …def commissioner_add_joiner_with_discerner(self, discerner_value, discerner_bit_len, pskd, timeout… argument
528 …return self.wpanctl('commissioner joiner-add-discerner {} {} {} {}'.format(discerner_value, discer…
531 def joiner_join(self, pskd): argument
532 return self.wpanctl('joiner --join {}'.format(pskd))
534 def joiner_attach(self): argument
535 return self.wpanctl('joiner --attach')
540 def is_associated(self): argument
541 return self.get(WPAN_STATE) == STATE_ASSOCIATED
543 def join_node(self, node, node_type=JOIN_TYPE_ROUTER, should_set_key=True): argument
549 return self.join(node.get(WPAN_NAME)[1:-1],
556 def allowlist_node(self, node): argument
559 self.add(WPAN_MAC_ALLOWLIST_ENTRIES, node.get(WPAN_EXT_ADDRESS)[1:-1])
560 self.set(WPAN_MAC_ALLOWLIST_ENABLED, '1')
562 def un_allowlist_node(self, node): argument
564 self.remove(WPAN_MAC_ALLOWLIST_ENTRIES, node.get(WPAN_EXT_ADDRESS)[1:-1])
566 def is_in_scan_result(self, scan_result): argument
570 panid = self.get(WPAN_PANID)
571 xpanid = self.get(WPAN_XPANID)[2:]
572 name = self.get(WPAN_NAME)[1:-1]
573 channel = self.get(WPAN_CHANNEL)
574 ext_address = self.get(WPAN_EXT_ADDRESS)[1:-1]
587 def find_ip6_address_with_prefix(self, prefix): argument
594 all_addrs = parse_list(self.get(WPAN_IP6_ALL_ADDRESSES))
598 def add_ip6_address_on_interface(self, address, prefix_len=64): argument
605 '/{} dev '.format(prefix_len) + self.interface_name
606 if self._verbose:
607 _log('$ Node{} \'{}\')'.format(self._index, cmd))
612 def remove_ip6_address_on_interface(self, address, prefix_len=64): argument
619 '/{} dev '.format(prefix_len) + self.interface_name
620 if self._verbose:
621 _log('$ Node{} \'{}\')'.format(self._index, cmd))
677 def prepare_tx(self, src, dst, data=40, count=1, mcast_hops=None): argument
711 return AsyncSender(self, src_addr, src_port, dst_addr, dst_port, msg, count, mcast_hops)
713 def _get_receiver(self, local_port): argument
716 if local_port in self._recvers:
717 receiver = self._recvers[local_port]
719 receiver = AsyncReceiver(self, local_port)
720 self._recvers[local_port] = receiver
723 def _remove_recver(self, recvr): argument
727 if local_port in self._recvers:
728 del self._recvers[local_port]
730 def prepare_rx(self, sender): argument
732 receiver = self._get_receiver(sender.dst_port)
736 def prepare_listener(self, local_port, timeout=1): argument
738 receiver = self._get_receiver(local_port)
780 def __init__(self, node, src_addr, src_port, dst_addr, dst_port, msg, count, mcast_hops=None): argument
781 self._node = node
782 self._src_addr = src_addr
783 self._src_port = src_port
784 self._dst_addr = dst_addr
785 self._dst_port = dst_port
786 self._msg = msg
787 self._count = count
788 self._dst_sock_addr = _create_socket_address(dst_addr, dst_port)
789 self._tx_buffer = self._msg
790 self._tx_counter = 0
810 asyncore.dispatcher.__init__(self, sock)
815 def node(self): argument
816 return self._node
819 def src_addr(self): argument
820 return self._src_addr
823 def src_port(self): argument
824 return self._src_port
827 def dst_addr(self): argument
828 return self._dst_addr
831 def dst_port(self): argument
832 return self._dst_port
835 def msg(self): argument
836 return self._msg
839 def count(self): argument
840 return self._count
843 def was_successful(self): argument
845 return self._tx_counter == self._count
849 def readable(self): argument
852 def writable(self): argument
855 def handle_write(self): argument
856 sent_len = self.sendto(self._tx_buffer, self._dst_sock_addr)
858 if self._node._verbose:
860 info_text = '{} bytes ("{}")'.format(sent_len, self._tx_buffer[:sent_len])
863 …_log('- Node{} sent {} to [{}]:{} from [{}]:{}'.format(self._node._index, info_text, self._dst_add…
864 … self._dst_port, self._src_addr, self._src_port))
866 self._tx_buffer = self._tx_buffer[sent_len:]
868 if len(self._tx_buffer) == 0:
869 self._tx_counter += 1
870 if self._tx_counter < self._count:
871 self._tx_buffer = self._msg
873 self.handle_close()
875 def handle_close(self): argument
876 self.close()
889 def __init__(self, sender_addr, sender_port, msg, count): argument
890 self._sender_addr = sender_addr
891 self._sender_port = sender_port
892 self._msg = msg
893 self._count = count
894 self._rx_counter = 0
896 def _check_received(self, msg, sender_addr, sender_port): argument
897 … if self._msg == msg and self._sender_addr == sender_addr and self._sender_port == sender_port:
898 self._rx_counter += 1
899 return self._did_recv_all()
901 def _did_recv_all(self): argument
902 return self._rx_counter >= self._count
904 def __init__(self, node, local_port): argument
905 self._node = node
906 self._local_port = local_port
907 self._senders = [] # list of `_SenderInfo` objects
910 self._all_rx = []
911 self._timeout = 0 # listen timeout (zero means forever)
912 self._started = False
913 self._start_time = 0
924 asyncore.dispatcher.__init__(self, sock)
926 def _add_sender(self, sender_addr, sender_port, msg, count): argument
927 self._senders.append(AsyncReceiver._SenderInfo(sender_addr, sender_port, msg, count))
929 def _set_listen_timeout(self, timeout): argument
930 self._timeout = timeout
935 def node(self): argument
936 return self._node
939 def local_port(self): argument
940 return self._local_port
943 def all_rx_msg(self): argument
945 return self._all_rx
948 def was_successful(self): argument
950 return len(self._senders) == 0 or all([sender._did_recv_all() for sender in self._senders])
954 def readable(self): argument
955 if not self._started:
956 self._start_time = time.time()
957 self._started = True
958 if self._timeout != 0 and time.time() - self._start_time >= self._timeout:
959 self.handle_close()
960 if self._node._verbose:
962 self._node._index, self._local_port, self._timeout, len(self._all_rx)))
966 def writable(self): argument
969 def handle_read(self): argument
970 (msg, src_sock_addr) = self.recvfrom(AsyncReceiver._MAX_RECV_SIZE)
979 if self._node._verbose:
984 …_log('- Node{} received {} on port {} from [{}]:{}'.format(self._node._index, info_text, self._loc…
987 self._all_rx.append((msg, (src_addr, src_port)))
989 if all([sender._check_received(msg, src_addr, src_port) for sender in self._senders]):
990 self.handle_close()
992 def handle_close(self): argument
993 self.close()
995 self._node._remove_recver(self)
1059 def __init__(self, result_text): argument
1064 self._type = ScanResult.TYPE_ENERGY_SCAN
1065 self._channel = items[0]
1066 self._rssi = items[1]
1068 self._type = ScanResult.TYPE_ACTIVE_SCAN
1069 self._index = items[0]
1070 self._panid = items[2]
1071 self._channel = items[3]
1072 self._ext_address = items[5]
1073 self._rssi = items[6]
1075 self._type = ScanResult.TYPE_DISCOVERY_SCAN
1076 self._index = items[0]
1077 self._network_name = items[1][1:-1]
1078 self._panid = items[2]
1079 self._channel = items[3]
1080 self._xpanid = items[4]
1081 self._ext_address = items[5]
1082 self._rssi = items[6]
1087 def type(self): argument
1088 return self._type
1091 def joinable(self): argument
1092 return self._joinable
1095 def network_name(self): argument
1096 return self._network_name
1099 def panid(self): argument
1100 return self._panid
1103 def channel(self): argument
1104 return self._channel
1107 def xpanid(self): argument
1108 return self._xpanid
1111 def ext_address(self): argument
1112 return self._ext_address
1115 def rssi(self): argument
1116 return self._rssi
1118 def __repr__(self): argument
1119 return 'ScanResult({})'.format(self.__dict__)
1153 def __init__(self, text): argument
1167 self._prefix = data[0]
1168 self._prefix_len = data[1]
1169 self._origin = data[2]
1170 self._stable = (data[3] == 'yes')
1171 self._on_mesh = (data[4] == '1')
1172 self._def_route = (data[5] == '1')
1173 self._config = (data[6] == '1')
1174 self._dhcp = (data[7] == '1')
1175 self._slaac = (data[8] == '1')
1176 self._preferred = (data[9] == '1')
1177 self._priority = (data[10])
1178 self._rloc16 = (data[11])
1181 def prefix(self): argument
1182 return self._prefix
1185 def prefix_len(self): argument
1186 return self._prefix_len
1189 def origin(self): argument
1190 return self._origin
1193 def priority(self): argument
1194 return self._priority
1196 def is_stable(self): argument
1197 return self._stable
1199 def is_on_mesh(self): argument
1200 return self._on_mesh
1202 def is_def_route(self): argument
1203 return self._def_route
1205 def is_config(self): argument
1206 return self._config
1208 def is_dhcp(self): argument
1209 return self._dhcp
1211 def is_slaac(self): argument
1212 return self._slaac
1214 def is_preferred(self): argument
1215 return self._preferred
1217 def rloc16(self): argument
1218 return self._rloc16
1220 def __repr__(self): argument
1221 return 'OnMeshPrefix({})'.format(self.__dict__)
1235 def __init__(self, text): argument
1248 self._ext_address = items[0]
1254 self._rloc16 = dict['RLOC16']
1255 self._timeout = dict['Timeout']
1256 self._rx_on_idle = (dict['RxOnIdle'] == 'yes')
1257 self._ftd = (dict['FTD'] == 'yes')
1258 self._sec_data_req = (dict['SecDataReq'] == 'yes')
1259 self._full_net_data = (dict['FullNetData'] == 'yes')
1262 def ext_address(self): argument
1263 return self._ext_address
1266 def rloc16(self): argument
1267 return self._rloc16
1270 def timeout(self): argument
1271 return self._timeout
1273 def is_rx_on_when_idle(self): argument
1274 return self._rx_on_idle
1276 def is_ftd(self): argument
1277 return self._ftd
1279 def is_sec_data_req(self): argument
1280 return self._sec_data_req
1282 def is_full_net_data(self): argument
1283 return self._full_net_data
1285 def __repr__(self): argument
1286 return 'ChildEntry({})'.format(self.__dict__)
1300 def __init__(self, text): argument
1313 self._ext_address = items[0]
1319 self._rloc16 = dict['RLOC16']
1320 self._is_child = (dict['IsChild'] == 'yes')
1321 self._rx_on_idle = (dict['RxOnIdle'] == 'yes')
1322 self._ftd = (dict['FTD'] == 'yes')
1325 def ext_address(self): argument
1326 return self._ext_address
1329 def rloc16(self): argument
1330 return self._rloc16
1332 def is_rx_on_when_idle(self): argument
1333 return self._rx_on_idle
1335 def is_ftd(self): argument
1336 return self._ftd
1338 def is_child(self): argument
1339 return self._is_child
1341 def __repr__(self): argument
1342 return 'NeighborEntry({})'.format(self.__dict__)
1356 def __init__(self, text): argument
1368 self._ext_address = items[0]
1374 self._rloc16 = int(dict['RLOC16'], 16)
1375 self._router_id = int(dict['RouterId'], 0)
1376 self._next_hop = int(dict['NextHop'], 0)
1377 self._path_cost = int(dict['PathCost'], 0)
1378 self._age = int(dict['Age'], 0)
1379 self._le = (dict['LinkEst'] == 'yes')
1382 def ext_address(self): argument
1383 return self._ext_address
1386 def rloc16(self): argument
1387 return self._rloc16
1390 def router_id(self): argument
1391 return self._router_id
1394 def next_hop(self): argument
1395 return self._next_hop
1398 def path_cost(self): argument
1399 return self._path_cost
1401 def is_link_established(self): argument
1402 return self._le
1404 def __repr__(self): argument
1405 return 'RouterTableEntry({})'.format(self.__dict__)
1419 def __init__(self, text): argument
1431 self._address = items[0]
1432 self._rloc16 = int(items[2], 16)
1438 self._age = int(dict['Age'], 0)
1440 self._state = dict['State']
1442 if self._state == ADDRESS_CACHE_ENTRY_STATE_CACHED:
1443 self._last_trans = int(dict.get("LastTrans", "-1"), 0)
1445 self._can_evict = (dict['CanEvict'] == 'yes')
1446 self._timeout = int(dict['Timeout'])
1447 self._retry_delay = int(dict['RetryDelay'])
1450 def address(self): argument
1451 return self._address
1454 def rloc16(self): argument
1455 return self._rloc16
1458 def age(self): argument
1459 return self._age
1462 def state(self): argument
1463 return self._state
1465 def can_evict(self): argument
1466 return self._can_evict
1469 def timeout(self): argument
1470 return self._timeout
1473 def retry_delay(self): argument
1474 return self._retry_delay
1477 def last_trans(self): argument
1478 return self._last_trans
1480 def __repr__(self): argument
1481 return 'AddressCacheEntry({})'.format(self.__dict__)
1495 def __init__(self, text): argument
1507 self._route_prefix = items[0].split('/')[0]
1508 self._prefix_len = int(items[0].split('/')[1], 0)
1509 self._metric = int(items[1].split(':')[1], 0)
1512 def route_prefix(self): argument
1513 return self._route_prefix
1516 def prefix_len(self): argument
1517 return self._prefix_len
1520 def metric(self): argument
1521 return self._metric
1523 def __repr__(self): argument
1524 return 'InterfaceRoute({})'.format(self.__dict__)
1538 def __init__(self, text): argument
1550 self._ext_address = items[0]
1553 self._rloc16 = items[1].split(':')[1]
1561 …self._radios = {radio.split("(")[0]: radio.split("(")[1][:-1] for radio in radios[1:-1].split(' ')}
1563 self._radios = {}
1566 def ext_address(self): argument
1567 return self._ext_address
1570 def rloc16(self): argument
1571 return self._rloc16
1574 def radios(self): argument
1575 return self._radios
1577 def supports(self, radio_type): argument
1578 return radio_type in self._radios
1580 def preference(self, radio_type): argument
1581 return int(self._radios[radio_type], 0) if self.supports(radio_type) else None
1583 def __repr__(self): argument
1584 return 'MultiRadioEntry({})'.format(self.__dict__)