def create_date_path(self, p_dut, pub_session, s_dut, sub_session, sec_type): """Create NDP based on the security type(open, PMK, PASSPHRASE), run socket connect Args: p_dut: Publish device p_disc_id: Publisher discovery id peer_id_on_pub: peer id on publisher s_dut: Subscribe device s_disc_id: Subscriber discovery id peer_id_on_sub: peer id on subscriber sec_type: NDP security type(open, PMK or PASSPHRASE) @:return: dict with NDP info """ passphrase = None pmk = None if sec_type == self.ENCR_TYPE_PASSPHRASE: passphrase = self.PASSPHRASE if sec_type == self.ENCR_TYPE_PMK: pmk = self.PMK p_req_key = autils.request_network( p_dut, p_dut.droid.wifiAwareCreateNetworkSpecifier(pub_session["discId"], None, passphrase, pmk)) s_req_key = autils.request_network( s_dut, s_dut.droid.wifiAwareCreateNetworkSpecifier(sub_session["discId"], sub_session["peerId"], passphrase, pmk)) p_net_event_nc = autils.wait_for_event_with_keys( p_dut, cconsts.EVENT_NETWORK_CALLBACK, autils.EVENT_NDP_TIMEOUT, (cconsts.NETWORK_CB_KEY_EVENT, cconsts.NETWORK_CB_CAPABILITIES_CHANGED), (cconsts.NETWORK_CB_KEY_ID, p_req_key)) s_net_event_nc = autils.wait_for_event_with_keys( s_dut, cconsts.EVENT_NETWORK_CALLBACK, autils.EVENT_NDP_TIMEOUT, (cconsts.NETWORK_CB_KEY_EVENT, cconsts.NETWORK_CB_CAPABILITIES_CHANGED), (cconsts.NETWORK_CB_KEY_ID, s_req_key)) p_net_event_lp = autils.wait_for_event_with_keys( p_dut, cconsts.EVENT_NETWORK_CALLBACK, autils.EVENT_NDP_TIMEOUT, (cconsts.NETWORK_CB_KEY_EVENT, cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED), (cconsts.NETWORK_CB_KEY_ID, p_req_key)) s_net_event_lp = autils.wait_for_event_with_keys( s_dut, cconsts.EVENT_NETWORK_CALLBACK, autils.EVENT_NDP_TIMEOUT, (cconsts.NETWORK_CB_KEY_EVENT, cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED), (cconsts.NETWORK_CB_KEY_ID, s_req_key)) p_aware_if = p_net_event_lp["data"][cconsts.NETWORK_CB_KEY_INTERFACE_NAME] s_aware_if = s_net_event_lp["data"][cconsts.NETWORK_CB_KEY_INTERFACE_NAME] p_if_mac = self.transfer_mac_format(autils.get_mac_addr(p_dut, p_aware_if)) p_dut.log.info("NDI %s=%s", p_aware_if, p_if_mac) s_if_mac = self.transfer_mac_format(autils.get_mac_addr(s_dut, s_aware_if)) s_dut.log.info("NDI %s=%s", s_aware_if, s_if_mac) s_ipv6 = p_net_event_nc["data"][aconsts.NET_CAP_IPV6] p_ipv6 = s_net_event_nc["data"][aconsts.NET_CAP_IPV6] asserts.assert_true( autils.verify_socket_connect(p_dut, s_dut, p_ipv6, s_ipv6, 0), "Failed socket link with Pub as Server") asserts.assert_true( autils.verify_socket_connect(s_dut, p_dut, s_ipv6, p_ipv6, 0), "Failed socket link with Sub as Server") ndp_info = {"pubReqKey": p_req_key, "pubIfMac": p_if_mac, "subReqKey": s_req_key, "subIfMac": s_if_mac} return ndp_info
def test_oob_ndp_stress(self): """Run NDP (NAN data-path) stress test creating and destroying Aware attach sessions, discovery sessions, and NDPs.""" init_dut = self.android_devices[0] init_dut.pretty_name = 'Initiator' resp_dut = self.android_devices[1] resp_dut.pretty_name = 'Responder' ndp_init_setup_success = 0 ndp_init_setup_failures = 0 ndp_resp_setup_success = 0 ndp_resp_setup_failures = 0 for attach_iter in range(self.ATTACH_ITERATIONS): init_id = init_dut.droid.wifiAwareAttach(True) autils.wait_for_event(init_dut, aconsts.EVENT_CB_ON_ATTACHED) init_ident_event = autils.wait_for_event( init_dut, aconsts.EVENT_CB_ON_IDENTITY_CHANGED) init_mac = init_ident_event['data']['mac'] time.sleep(self.device_startup_offset) resp_id = resp_dut.droid.wifiAwareAttach(True) autils.wait_for_event(resp_dut, aconsts.EVENT_CB_ON_ATTACHED) resp_ident_event = autils.wait_for_event( resp_dut, aconsts.EVENT_CB_ON_IDENTITY_CHANGED) resp_mac = resp_ident_event['data']['mac'] # wait for for devices to synchronize with each other - there are no other # mechanisms to make sure this happens for OOB discovery (except retrying # to execute the data-path request) time.sleep(autils.WAIT_FOR_CLUSTER) for ndp_iteration in range(self.NDP_ITERATIONS): # Responder: request network resp_req_key = autils.request_network( resp_dut, resp_dut.droid.wifiAwareCreateNetworkSpecifierOob( resp_id, aconsts.DATA_PATH_RESPONDER, init_mac, None)) # Initiator: request network init_req_key = autils.request_network( init_dut, init_dut.droid.wifiAwareCreateNetworkSpecifierOob( init_id, aconsts.DATA_PATH_INITIATOR, resp_mac, None)) # Initiator: wait for network formation got_on_available = False got_on_link_props = False while not got_on_available or not got_on_link_props: try: nc_event = init_dut.ed.pop_event( cconsts.EVENT_NETWORK_CALLBACK, autils.EVENT_NDP_TIMEOUT) if nc_event['data'][ cconsts. NETWORK_CB_KEY_EVENT] == cconsts.NETWORK_CB_AVAILABLE: got_on_available = True elif (nc_event['data'][cconsts.NETWORK_CB_KEY_EVENT] == cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED): got_on_link_props = True except queue.Empty: ndp_init_setup_failures = ndp_init_setup_failures + 1 init_dut.log.info( '[Initiator] Timed out while waiting for ' 'EVENT_NETWORK_CALLBACK') break if got_on_available and got_on_link_props: ndp_init_setup_success = ndp_init_setup_success + 1 # Responder: wait for network formation got_on_available = False got_on_link_props = False while not got_on_available or not got_on_link_props: try: nc_event = resp_dut.ed.pop_event( cconsts.EVENT_NETWORK_CALLBACK, autils.EVENT_NDP_TIMEOUT) if nc_event['data'][ cconsts. NETWORK_CB_KEY_EVENT] == cconsts.NETWORK_CB_AVAILABLE: got_on_available = True elif (nc_event['data'][cconsts.NETWORK_CB_KEY_EVENT] == cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED): got_on_link_props = True except queue.Empty: ndp_resp_setup_failures = ndp_resp_setup_failures + 1 init_dut.log.info( '[Responder] Timed out while waiting for ' 'EVENT_NETWORK_CALLBACK') break if got_on_available and got_on_link_props: ndp_resp_setup_success = ndp_resp_setup_success + 1 # clean-up init_dut.droid.connectivityUnregisterNetworkCallback( init_req_key) resp_dut.droid.connectivityUnregisterNetworkCallback( resp_req_key) # wait before trying another iteration (need to let CM clean-up) time.sleep(10) # clean-up at end of iteration init_dut.droid.wifiAwareDestroy(init_id) resp_dut.droid.wifiAwareDestroy(resp_id) results = {} results['ndp_init_setup_success'] = ndp_init_setup_success results['ndp_init_setup_failures'] = ndp_init_setup_failures results['ndp_resp_setup_success'] = ndp_resp_setup_success results['ndp_resp_setup_failures'] = ndp_resp_setup_failures asserts.assert_equal(ndp_init_setup_failures + ndp_resp_setup_failures, 0, 'test_oob_ndp_stress finished', extras=results) asserts.explicit_pass("test_oob_ndp_stress done", extras=results)
def test_max_ndp(self): """Validate that the device can create as many NDPs as are specified by its capabilities. Mechanics: - Publisher on DUT (first device) - Subscribers on all other devices - On discovery set up NDP Note: the test requires MAX_NDP + 2 devices to be validated. If these are not available the test will fail. """ dut = self.android_devices[0] # get max NDP: using first available device (assumes all devices are the # same) max_ndp = dut.aware_capabilities[aconsts.CAP_MAX_NDP_SESSIONS] # get number of attached devices: needs to be max_ndp+2 to allow for max_ndp # NDPs + an additional one expected to fail. # However, will run the test with max_ndp+1 devices to verify that at least # that many NDPs can be created. Will still fail at the end to indicate that # full test was not run. num_peer_devices = min(len(self.android_devices) - 1, max_ndp + 1) asserts.assert_true( num_peer_devices >= max_ndp, 'A minimum of %d devices is needed to run the test, have %d' % (max_ndp + 1, len(self.android_devices))) # attach session_id = dut.droid.wifiAwareAttach() autils.wait_for_event(dut, aconsts.EVENT_CB_ON_ATTACHED) # start publisher p_disc_id = self.start_discovery_session( dut, session_id, is_publish=True, dtype=aconsts.PUBLISH_TYPE_UNSOLICITED, service_name=self.SERVICE_NAME, expect_success=True) # loop over other DUTs for i in range(num_peer_devices): other_dut = self.android_devices[i + 1] # attach other_session_id = other_dut.droid.wifiAwareAttach() autils.wait_for_event(other_dut, aconsts.EVENT_CB_ON_ATTACHED) # start subscriber s_disc_id = self.start_discovery_session( other_dut, other_session_id, is_publish=False, dtype=aconsts.SUBSCRIBE_TYPE_PASSIVE, service_name=self.SERVICE_NAME, expect_success=True) discovery_event = autils.wait_for_event( other_dut, aconsts.SESSION_CB_ON_SERVICE_DISCOVERED) peer_id_on_sub = discovery_event['data'][ aconsts.SESSION_CB_KEY_PEER_ID] # Subscriber: send message to peer (Publisher - so it knows our address) other_dut.droid.wifiAwareSendMessage(s_disc_id, peer_id_on_sub, self.get_next_msg_id(), "ping", aconsts.MAX_TX_RETRIES) autils.wait_for_event(other_dut, aconsts.SESSION_CB_ON_MESSAGE_SENT) # Publisher: wait for received message pub_rx_msg_event = autils.wait_for_event( dut, aconsts.SESSION_CB_ON_MESSAGE_RECEIVED) peer_id_on_pub = pub_rx_msg_event['data'][ aconsts.SESSION_CB_KEY_PEER_ID] # publisher (responder): request network p_req_key = autils.request_network( dut, dut.droid.wifiAwareCreateNetworkSpecifier( p_disc_id, peer_id_on_pub)) # subscriber (initiator): request network s_req_key = autils.request_network( other_dut, other_dut.droid.wifiAwareCreateNetworkSpecifier( s_disc_id, peer_id_on_sub)) # wait for network (or not - on the last iteration) if i != max_ndp: p_net_event = autils.wait_for_event_with_keys( dut, cconsts.EVENT_NETWORK_CALLBACK, autils.EVENT_NDP_TIMEOUT, (cconsts.NETWORK_CB_KEY_EVENT, cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED), (cconsts.NETWORK_CB_KEY_ID, p_req_key)) s_net_event = autils.wait_for_event_with_keys( other_dut, cconsts.EVENT_NETWORK_CALLBACK, autils.EVENT_NDP_TIMEOUT, (cconsts.NETWORK_CB_KEY_EVENT, cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED), (cconsts.NETWORK_CB_KEY_ID, s_req_key)) p_aware_if = p_net_event['data'][ cconsts.NETWORK_CB_KEY_INTERFACE_NAME] s_aware_if = s_net_event['data'][ cconsts.NETWORK_CB_KEY_INTERFACE_NAME] self.log.info('Interface names: p=%s, s=%s', p_aware_if, s_aware_if) p_ipv6 = dut.droid.connectivityGetLinkLocalIpv6Address( p_aware_if).split('%')[0] s_ipv6 = other_dut.droid.connectivityGetLinkLocalIpv6Address( s_aware_if).split('%')[0] self.log.info('Interface addresses (IPv6): p=%s, s=%s', p_ipv6, s_ipv6) else: autils.fail_on_event_with_keys( dut, cconsts.EVENT_NETWORK_CALLBACK, autils.EVENT_NDP_TIMEOUT, (cconsts.NETWORK_CB_KEY_EVENT, cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED), (cconsts.NETWORK_CB_KEY_ID, p_req_key)) autils.fail_on_event_with_keys( other_dut, cconsts.EVENT_NETWORK_CALLBACK, autils.EVENT_NDP_TIMEOUT, (cconsts.NETWORK_CB_KEY_EVENT, cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED), (cconsts.NETWORK_CB_KEY_ID, s_req_key)) asserts.assert_true( num_peer_devices > max_ndp, 'Needed %d devices to run the test, have %d' % (max_ndp + 2, len(self.android_devices)))
def run_end_to_end_latency(self, results, dw_24ghz, dw_5ghz, num_iterations, startup_offset, include_setup): """Measure the latency for end-to-end communication link setup: - Start Aware - Discovery - Message from Sub -> Pub - Message from Pub -> Sub - NDP setup Args: results: Result array to be populated - will add results (not erase it) dw_24ghz: DW interval in the 2.4GHz band. dw_5ghz: DW interval in the 5GHz band. startup_offset: The start-up gap (in seconds) between the two devices include_setup: True to include the cluster setup in the latency measurements. """ key = "dw24_%d_dw5_%d" % (dw_24ghz, dw_5ghz) results[key] = {} results[key]["num_iterations"] = num_iterations p_dut = self.android_devices[0] p_dut.pretty_name = "Publisher" s_dut = self.android_devices[1] s_dut.pretty_name = "Subscriber" # override the default DW configuration autils.config_power_settings(p_dut, dw_24ghz, dw_5ghz) autils.config_power_settings(s_dut, dw_24ghz, dw_5ghz) latencies = [] # allow for failures here since running lots of samples and would like to # get the partial data even in the presence of errors failures = 0 if not include_setup: # Publisher+Subscriber: attach and wait for confirmation p_id = p_dut.droid.wifiAwareAttach(False) autils.wait_for_event(p_dut, aconsts.EVENT_CB_ON_ATTACHED) time.sleep(startup_offset) s_id = s_dut.droid.wifiAwareAttach(False) autils.wait_for_event(s_dut, aconsts.EVENT_CB_ON_ATTACHED) for i in range(num_iterations): while (True): # for pseudo-goto/finalize timestamp_start = time.perf_counter() if include_setup: # Publisher+Subscriber: attach and wait for confirmation p_id = p_dut.droid.wifiAwareAttach(False) autils.wait_for_event(p_dut, aconsts.EVENT_CB_ON_ATTACHED) time.sleep(startup_offset) s_id = s_dut.droid.wifiAwareAttach(False) autils.wait_for_event(s_dut, aconsts.EVENT_CB_ON_ATTACHED) # start publish p_disc_id, p_disc_event = self.start_discovery_session( p_dut, p_id, True, aconsts.PUBLISH_TYPE_UNSOLICITED) # start subscribe s_disc_id, s_session_event = self.start_discovery_session( s_dut, s_id, False, aconsts.SUBSCRIBE_TYPE_PASSIVE) # wait for discovery (allow for failures here since running lots of # samples and would like to get the partial data even in the presence of # errors) try: event = s_dut.ed.pop_event( aconsts.SESSION_CB_ON_SERVICE_DISCOVERED, autils.EVENT_TIMEOUT) s_dut.log.info( "[Subscriber] SESSION_CB_ON_SERVICE_DISCOVERED: %s", event["data"]) peer_id_on_sub = event['data'][ aconsts.SESSION_CB_KEY_PEER_ID] except queue.Empty: s_dut.log.info("[Subscriber] Timed out while waiting for " "SESSION_CB_ON_SERVICE_DISCOVERED") failures = failures + 1 break # message from Sub -> Pub msg_s2p = "Message Subscriber -> Publisher #%d" % i next_msg_id = self.get_next_msg_id() s_dut.droid.wifiAwareSendMessage(s_disc_id, peer_id_on_sub, next_msg_id, msg_s2p, 0) # wait for Tx confirmation try: s_dut.ed.pop_event(aconsts.SESSION_CB_ON_MESSAGE_SENT, autils.EVENT_TIMEOUT) except queue.Empty: s_dut.log.info("[Subscriber] Timed out while waiting for " "SESSION_CB_ON_MESSAGE_SENT") failures = failures + 1 break # wait for Rx confirmation (and validate contents) try: event = p_dut.ed.pop_event( aconsts.SESSION_CB_ON_MESSAGE_RECEIVED, autils.EVENT_TIMEOUT) peer_id_on_pub = event['data'][ aconsts.SESSION_CB_KEY_PEER_ID] if (event["data"][aconsts.SESSION_CB_KEY_MESSAGE_AS_STRING] != msg_s2p): p_dut.log.info( "[Publisher] Corrupted input message - %s", event) failures = failures + 1 break except queue.Empty: p_dut.log.info("[Publisher] Timed out while waiting for " "SESSION_CB_ON_MESSAGE_RECEIVED") failures = failures + 1 break # message from Pub -> Sub msg_p2s = "Message Publisher -> Subscriber #%d" % i next_msg_id = self.get_next_msg_id() p_dut.droid.wifiAwareSendMessage(p_disc_id, peer_id_on_pub, next_msg_id, msg_p2s, 0) # wait for Tx confirmation try: p_dut.ed.pop_event(aconsts.SESSION_CB_ON_MESSAGE_SENT, autils.EVENT_TIMEOUT) except queue.Empty: p_dut.log.info("[Publisher] Timed out while waiting for " "SESSION_CB_ON_MESSAGE_SENT") failures = failures + 1 break # wait for Rx confirmation (and validate contents) try: event = s_dut.ed.pop_event( aconsts.SESSION_CB_ON_MESSAGE_RECEIVED, autils.EVENT_TIMEOUT) if (event["data"][aconsts.SESSION_CB_KEY_MESSAGE_AS_STRING] != msg_p2s): s_dut.log.info( "[Subscriber] Corrupted input message - %s", event) failures = failures + 1 break except queue.Empty: s_dut.log.info("[Subscriber] Timed out while waiting for " "SESSION_CB_ON_MESSAGE_RECEIVED") failures = failures + 1 break # create NDP # Publisher: request network p_req_key = autils.request_network( p_dut, p_dut.droid.wifiAwareCreateNetworkSpecifier( p_disc_id, peer_id_on_pub, None)) # Subscriber: request network s_req_key = autils.request_network( s_dut, s_dut.droid.wifiAwareCreateNetworkSpecifier( s_disc_id, peer_id_on_sub, None)) # Publisher & Subscriber: wait for network formation try: p_net_event = autils.wait_for_event_with_keys( p_dut, cconsts.EVENT_NETWORK_CALLBACK, autils.EVENT_TIMEOUT, (cconsts.NETWORK_CB_KEY_EVENT, cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED), (cconsts.NETWORK_CB_KEY_ID, p_req_key)) s_net_event = autils.wait_for_event_with_keys( s_dut, cconsts.EVENT_NETWORK_CALLBACK, autils.EVENT_TIMEOUT, (cconsts.NETWORK_CB_KEY_EVENT, cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED), (cconsts.NETWORK_CB_KEY_ID, s_req_key)) except: failures = failures + 1 break p_aware_if = p_net_event["data"][ cconsts.NETWORK_CB_KEY_INTERFACE_NAME] s_aware_if = s_net_event["data"][ cconsts.NETWORK_CB_KEY_INTERFACE_NAME] p_ipv6 = \ p_dut.droid.connectivityGetLinkLocalIpv6Address(p_aware_if).split("%")[ 0] s_ipv6 = \ s_dut.droid.connectivityGetLinkLocalIpv6Address(s_aware_if).split("%")[ 0] p_dut.log.info("[Publisher] IF=%s, IPv6=%s", p_aware_if, p_ipv6) s_dut.log.info("[Subscriber] IF=%s, IPv6=%s", s_aware_if, s_ipv6) latencies.append(time.perf_counter() - timestamp_start) break # destroy sessions p_dut.droid.wifiAwareDestroyDiscoverySession(p_disc_id) s_dut.droid.wifiAwareDestroyDiscoverySession(s_disc_id) if include_setup: p_dut.droid.wifiAwareDestroy(p_id) s_dut.droid.wifiAwareDestroy(s_id) autils.extract_stats(p_dut, data=latencies, results=results[key], key_prefix="", log_prefix="End-to-End(dw24=%d, dw5=%d)" % (dw_24ghz, dw_5ghz)) results[key]["failures"] = failures
def run_ndp_oob_latency(self, results, dw_24ghz, dw_5ghz, num_iterations): """Runs the NDP setup with OOB (out-of-band) discovery latency test. Args: results: Result array to be populated - will add results (not erase it) dw_24ghz: DW interval in the 2.4GHz band. dw_5ghz: DW interval in the 5GHz band. """ key_avail = "on_avail_dw24_%d_dw5_%d" % (dw_24ghz, dw_5ghz) key_link_props = "link_props_dw24_%d_dw5_%d" % (dw_24ghz, dw_5ghz) results[key_avail] = {} results[key_link_props] = {} results[key_avail]["num_iterations"] = num_iterations init_dut = self.android_devices[0] init_dut.pretty_name = 'Initiator' resp_dut = self.android_devices[1] resp_dut.pretty_name = 'Responder' # override the default DW configuration autils.config_power_settings(init_dut, dw_24ghz, dw_5ghz) autils.config_power_settings(resp_dut, dw_24ghz, dw_5ghz) # Initiator+Responder: attach and wait for confirmation & identity init_id = init_dut.droid.wifiAwareAttach(True) autils.wait_for_event(init_dut, aconsts.EVENT_CB_ON_ATTACHED) init_ident_event = autils.wait_for_event( init_dut, aconsts.EVENT_CB_ON_IDENTITY_CHANGED) init_mac = init_ident_event['data']['mac'] time.sleep(self.device_startup_offset) resp_id = resp_dut.droid.wifiAwareAttach(True) autils.wait_for_event(resp_dut, aconsts.EVENT_CB_ON_ATTACHED) resp_ident_event = autils.wait_for_event( resp_dut, aconsts.EVENT_CB_ON_IDENTITY_CHANGED) resp_mac = resp_ident_event['data']['mac'] # wait for for devices to synchronize with each other - there are no other # mechanisms to make sure this happens for OOB discovery (except retrying # to execute the data-path request) time.sleep(autils.WAIT_FOR_CLUSTER) on_available_latencies = [] link_props_latencies = [] ndp_setup_failures = 0 for i in range(num_iterations): # Responder: request network resp_req_key = autils.request_network( resp_dut, resp_dut.droid.wifiAwareCreateNetworkSpecifierOob( resp_id, aconsts.DATA_PATH_RESPONDER, init_mac, None)) # Initiator: request network init_req_key = autils.request_network( init_dut, init_dut.droid.wifiAwareCreateNetworkSpecifierOob( init_id, aconsts.DATA_PATH_INITIATOR, resp_mac, None)) # Initiator & Responder: wait for network formation got_on_available = False got_on_link_props = False while not got_on_available or not got_on_link_props: try: nc_event = init_dut.ed.pop_event( cconsts.EVENT_NETWORK_CALLBACK, autils.EVENT_NDP_TIMEOUT) if nc_event["data"][ cconsts. NETWORK_CB_KEY_EVENT] == cconsts.NETWORK_CB_AVAILABLE: got_on_available = True on_available_latencies.append( nc_event["data"][ cconsts.NETWORK_CB_KEY_CURRENT_TS] - nc_event["data"][cconsts.NETWORK_CB_KEY_CREATE_TS]) elif (nc_event["data"][cconsts.NETWORK_CB_KEY_EVENT] == cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED): got_on_link_props = True link_props_latencies.append( nc_event["data"][ cconsts.NETWORK_CB_KEY_CURRENT_TS] - nc_event["data"][cconsts.NETWORK_CB_KEY_CREATE_TS]) except queue.Empty: ndp_setup_failures = ndp_setup_failures + 1 init_dut.log.info( "[Initiator] Timed out while waiting for " "EVENT_NETWORK_CALLBACK") break # clean-up init_dut.droid.connectivityUnregisterNetworkCallback(init_req_key) resp_dut.droid.connectivityUnregisterNetworkCallback(resp_req_key) # wait to make sure previous NDP terminated, otherwise its termination # time will be counted in the setup latency! time.sleep(2) autils.extract_stats( init_dut, data=on_available_latencies, results=results[key_avail], key_prefix="", log_prefix="NDP setup OnAvailable(dw24=%d, dw5=%d)" % (dw_24ghz, dw_5ghz)) autils.extract_stats( init_dut, data=link_props_latencies, results=results[key_link_props], key_prefix="", log_prefix="NDP setup OnLinkProperties (dw24=%d, dw5=%d)" % (dw_24ghz, dw_5ghz)) results[key_avail]["ndp_setup_failures"] = ndp_setup_failures
def run_iperf_max_ndi_aware_only(self, sec_configs, results): """Measure iperf performance on multiple NDPs between 2 devices using different security configurations (and hence different NDIs). Test with Aware enabled and no infrastructure connection - i.e. device is not associated to an AP. The security configuration can be: - None: open - String: passphrase - otherwise: PMK (byte array) Args: sec_configs: list of security configurations results: Dictionary into which to place test results. """ init_dut = self.android_devices[0] init_dut.pretty_name = "Initiator" resp_dut = self.android_devices[1] resp_dut.pretty_name = "Responder" asserts.skip_if( init_dut.aware_capabilities[aconsts.CAP_MAX_NDI_INTERFACES] < len(sec_configs) or resp_dut.aware_capabilities[aconsts.CAP_MAX_NDI_INTERFACES] < len(sec_configs), "Initiator or Responder do not support multiple NDIs") init_id, init_mac = autils.attach_with_identity(init_dut) resp_id, resp_mac = autils.attach_with_identity(resp_dut) # wait for for devices to synchronize with each other - there are no other # mechanisms to make sure this happens for OOB discovery (except retrying # to execute the data-path request) time.sleep(autils.WAIT_FOR_CLUSTER) resp_req_keys = [] init_req_keys = [] resp_aware_ifs = [] init_aware_ifs = [] resp_aware_ipv6s = [] init_aware_ipv6s = [] for sec in sec_configs: # Responder: request network resp_req_key = autils.request_network( resp_dut, autils.get_network_specifier(resp_dut, resp_id, aconsts.DATA_PATH_RESPONDER, init_mac, sec)) resp_req_keys.append(resp_req_key) # Initiator: request network init_req_key = autils.request_network( init_dut, autils.get_network_specifier(init_dut, init_id, aconsts.DATA_PATH_INITIATOR, resp_mac, sec)) init_req_keys.append(init_req_key) # Wait for network init_net_event_nc = autils.wait_for_event_with_keys( init_dut, cconsts.EVENT_NETWORK_CALLBACK, autils.EVENT_NDP_TIMEOUT, (cconsts.NETWORK_CB_KEY_EVENT, cconsts.NETWORK_CB_CAPABILITIES_CHANGED), (cconsts.NETWORK_CB_KEY_ID, init_req_key)) resp_net_event_nc = autils.wait_for_event_with_keys( resp_dut, cconsts.EVENT_NETWORK_CALLBACK, autils.EVENT_NDP_TIMEOUT, (cconsts.NETWORK_CB_KEY_EVENT, cconsts.NETWORK_CB_CAPABILITIES_CHANGED), (cconsts.NETWORK_CB_KEY_ID, resp_req_key)) # validate no leak of information asserts.assert_false( cconsts.NETWORK_CB_KEY_NETWORK_SPECIFIER in init_net_event_nc["data"], "Network specifier leak!") asserts.assert_false( cconsts.NETWORK_CB_KEY_NETWORK_SPECIFIER in resp_net_event_nc["data"], "Network specifier leak!") # note that Init <-> Resp since IPv6 are of peer's! resp_ipv6 = init_net_event_nc["data"][aconsts.NET_CAP_IPV6] init_ipv6 = resp_net_event_nc["data"][aconsts.NET_CAP_IPV6] init_net_event_lp = autils.wait_for_event_with_keys( init_dut, cconsts.EVENT_NETWORK_CALLBACK, autils.EVENT_NDP_TIMEOUT, (cconsts.NETWORK_CB_KEY_EVENT, cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED), (cconsts.NETWORK_CB_KEY_ID, init_req_key)) resp_net_event_lp = autils.wait_for_event_with_keys( resp_dut, cconsts.EVENT_NETWORK_CALLBACK, autils.EVENT_NDP_TIMEOUT, (cconsts.NETWORK_CB_KEY_EVENT, cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED), (cconsts.NETWORK_CB_KEY_ID, resp_req_key)) resp_aware_ifs.append(resp_net_event_lp["data"][ cconsts.NETWORK_CB_KEY_INTERFACE_NAME]) init_aware_ifs.append(init_net_event_lp["data"][ cconsts.NETWORK_CB_KEY_INTERFACE_NAME]) resp_aware_ipv6s.append(resp_ipv6) init_aware_ipv6s.append(init_ipv6) self.log.info("Initiator interfaces/ipv6: %s / %s", init_aware_ifs, init_aware_ipv6s) self.log.info("Responder interfaces/ipv6: %s / %s", resp_aware_ifs, resp_aware_ipv6s) # create threads, start them, and wait for all to finish base_port = 5000 q = queue.Queue() threads = [] for i in range(len(sec_configs)): threads.append( threading.Thread(target=self.run_iperf, args=(q, init_dut, resp_dut, resp_aware_ifs[i], init_aware_ipv6s[i], base_port + i))) for thread in threads: thread.start() for thread in threads: thread.join() # release requests for resp_req_key in resp_req_keys: resp_dut.droid.connectivityUnregisterNetworkCallback(resp_req_key) for init_req_key in init_req_keys: init_dut.droid.connectivityUnregisterNetworkCallback(init_req_key) # collect data for i in range(len(sec_configs)): results[i] = {} result, data = q.get() asserts.assert_true( result, "Failure starting/running iperf3 in client mode") self.log.debug(pprint.pformat(data)) data_json = json.loads("".join(data)) if "error" in data_json: asserts.fail("iperf run failed: %s" % data_json["error"], extras=data_json) results[i]["tx_rate"] = data_json["end"]["sum_sent"][ "bits_per_second"] results[i]["rx_rate"] = data_json["end"]["sum_received"][ "bits_per_second"] self.log.info("iPerf3: Sent = %d bps Received = %d bps", results[i]["tx_rate"], results[i]["rx_rate"])
def run_oob_ndp_stress(self, attach_iterations, ndp_iterations, trigger_failure_on_index=None): """Run NDP (NAN data-path) stress test creating and destroying Aware attach sessions, discovery sessions, and NDPs. Args: attach_iterations: Number of attach sessions. ndp_iterations: Number of NDP to be attempted per attach session. trigger_failure_on_index: Trigger a failure on this NDP iteration (the mechanism is to request NDP on Initiator before issuing the requeest on the Responder). If None then no artificial failure triggered. """ init_dut = self.android_devices[0] init_dut.pretty_name = 'Initiator' resp_dut = self.android_devices[1] resp_dut.pretty_name = 'Responder' ndp_init_setup_success = 0 ndp_init_setup_failures = 0 ndp_resp_setup_success = 0 ndp_resp_setup_failures = 0 ndp_full_socket_success = 0 for attach_iter in range(attach_iterations): init_id = init_dut.droid.wifiAwareAttach(True) autils.wait_for_event(init_dut, aconsts.EVENT_CB_ON_ATTACHED) init_ident_event = autils.wait_for_event( init_dut, aconsts.EVENT_CB_ON_IDENTITY_CHANGED) init_mac = init_ident_event['data']['mac'] time.sleep(self.device_startup_offset) resp_id = resp_dut.droid.wifiAwareAttach(True) autils.wait_for_event(resp_dut, aconsts.EVENT_CB_ON_ATTACHED) resp_ident_event = autils.wait_for_event( resp_dut, aconsts.EVENT_CB_ON_IDENTITY_CHANGED) resp_mac = resp_ident_event['data']['mac'] # wait for for devices to synchronize with each other - there are no other # mechanisms to make sure this happens for OOB discovery (except retrying # to execute the data-path request) time.sleep(autils.WAIT_FOR_CLUSTER) for ndp_iteration in range(ndp_iterations): if trigger_failure_on_index != ndp_iteration: # Responder: request network resp_req_key = autils.request_network( resp_dut, resp_dut.droid.wifiAwareCreateNetworkSpecifierOob( resp_id, aconsts.DATA_PATH_RESPONDER, init_mac, None)) # Wait a minimal amount of time to let the Responder configure itself # and be ready for the request. While calling it first may be # sufficient there are no guarantees that a glitch may slow the # Responder slightly enough to invert the setup order. time.sleep(1) # Initiator: request network init_req_key = autils.request_network( init_dut, init_dut.droid.wifiAwareCreateNetworkSpecifierOob( init_id, aconsts.DATA_PATH_INITIATOR, resp_mac, None)) else: # Initiator: request network init_req_key = autils.request_network( init_dut, init_dut.droid.wifiAwareCreateNetworkSpecifierOob( init_id, aconsts.DATA_PATH_INITIATOR, resp_mac, None)) # Wait a minimal amount of time to let the Initiator configure itself # to guarantee failure! time.sleep(2) # Responder: request network resp_req_key = autils.request_network( resp_dut, resp_dut.droid.wifiAwareCreateNetworkSpecifierOob( resp_id, aconsts.DATA_PATH_RESPONDER, init_mac, None)) init_ipv6 = None resp_ipv6 = None # Initiator: wait for network formation got_on_available = False got_on_link_props = False got_on_net_cap = False while not got_on_available or not got_on_link_props or not got_on_net_cap: try: nc_event = init_dut.ed.pop_event( cconsts.EVENT_NETWORK_CALLBACK, autils.EVENT_NDP_TIMEOUT) if nc_event['data'][ cconsts. NETWORK_CB_KEY_EVENT] == cconsts.NETWORK_CB_AVAILABLE: got_on_available = True elif (nc_event['data'][cconsts.NETWORK_CB_KEY_EVENT] == cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED): got_on_link_props = True elif (nc_event['data'][cconsts.NETWORK_CB_KEY_EVENT] == cconsts.NETWORK_CB_CAPABILITIES_CHANGED): got_on_net_cap = True if aconsts.NET_CAP_IPV6 in nc_event["data"]: resp_ipv6 = nc_event["data"][ aconsts.NET_CAP_IPV6] except queue.Empty: ndp_init_setup_failures = ndp_init_setup_failures + 1 init_dut.log.info( '[Initiator] Timed out while waiting for ' 'EVENT_NETWORK_CALLBACK') break if got_on_available and got_on_link_props and got_on_net_cap: ndp_init_setup_success = ndp_init_setup_success + 1 # Responder: wait for network formation got_on_available = False got_on_link_props = False got_on_net_cap = False while not got_on_available or not got_on_link_props or not got_on_net_cap: try: nc_event = resp_dut.ed.pop_event( cconsts.EVENT_NETWORK_CALLBACK, autils.EVENT_NDP_TIMEOUT) if nc_event['data'][ cconsts. NETWORK_CB_KEY_EVENT] == cconsts.NETWORK_CB_AVAILABLE: got_on_available = True elif (nc_event['data'][cconsts.NETWORK_CB_KEY_EVENT] == cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED): got_on_link_props = True elif (nc_event['data'][cconsts.NETWORK_CB_KEY_EVENT] == cconsts.NETWORK_CB_CAPABILITIES_CHANGED): got_on_net_cap = True if aconsts.NET_CAP_IPV6 in nc_event["data"]: init_ipv6 = nc_event["data"][ aconsts.NET_CAP_IPV6] except queue.Empty: ndp_resp_setup_failures = ndp_resp_setup_failures + 1 init_dut.log.info( '[Responder] Timed out while waiting for ' 'EVENT_NETWORK_CALLBACK') break if got_on_available and got_on_link_props and got_on_net_cap: ndp_resp_setup_success = ndp_resp_setup_success + 1 # open sockets to test connection if autils.verify_socket_connect(init_dut, resp_dut, init_ipv6, resp_ipv6, 0): if autils.verify_socket_connect(resp_dut, init_dut, resp_ipv6, init_ipv6, 0): ndp_full_socket_success = ndp_full_socket_success + 1 # clean-up init_dut.droid.connectivityUnregisterNetworkCallback( init_req_key) resp_dut.droid.connectivityUnregisterNetworkCallback( resp_req_key) # clean-up at end of iteration init_dut.droid.wifiAwareDestroy(init_id) resp_dut.droid.wifiAwareDestroy(resp_id) results = {} results['ndp_init_setup_success'] = ndp_init_setup_success results['ndp_init_setup_failures'] = ndp_init_setup_failures results['ndp_resp_setup_success'] = ndp_resp_setup_success results['ndp_resp_setup_failures'] = ndp_resp_setup_failures results['ndp_full_socket_success'] = ndp_full_socket_success max_failures = (self.MAX_FAILURE_PERCENTAGE * attach_iterations * ndp_iterations / 100) if max_failures == 0: max_failures = 1 if trigger_failure_on_index is not None: max_failures = max_failures + 1 # for the triggered failure asserts.assert_true( (ndp_init_setup_failures + ndp_resp_setup_failures) < (2 * max_failures), 'NDP setup failure rate exceeds threshold', extras=results) asserts.explicit_pass("test_oob_ndp_stress* done", extras=results)