def test_modify_config_for_non_sanity(self): """Modify configurations for Non-Sanity Test Cases Some non-sanity test cases need changes in default configuration. This test script modifies the configuration files with required values so that all the test cases of non-sanity test suite can be verified """ magmad_client = MagmadServiceGrpc() self._magmad_util = MagmadUtil(magmad_client) ret_codes = [] print("Modifying configuration for all non-sanity test cases to pass") print("Enabling Ha service") ret_codes.append( self._magmad_util.config_ha_service( MagmadUtil.ha_service_cmds.ENABLE, ), ) print( "Modifying MME configuration for non-sanity test cases to pass", ) self._magmad_util.update_mme_config_for_non_sanity( MagmadUtil.config_update_cmds.MODIFY, ) print("Restarting services to apply configuration change") self._magmad_util.restart_all_services()
def test_modify_config_for_non_sanity(self): """Modify configurations for Non-Sanity Test Cases Some non-sanity test cases need changes in default configuration. This test script modifies the configuration files with required values so that all the test cases of non-sanity test suite can be verified """ magmad_client = MagmadServiceGrpc() self._magmad_util = MagmadUtil(magmad_client) ret_codes = [] print("Modifying configuration for all non-sanity test cases to pass") print("Enabling Ha service") ret_codes.append( self._magmad_util.config_ha_service( MagmadUtil.ha_service_cmds.ENABLE, ), ) # It is assumed that oai-gtp_4.9-9_amd64.deb pkg is already installed print("Enabling IPv6 solicitation service") ret_codes.append( self._magmad_util.config_ipv6_solicitation( MagmadUtil.ipv6_config_cmds.ENABLE, ), ) if 1 in ret_codes: print("Restarting services to apply configuration change") self._magmad_util.restart_all_services() else: print("No need to restart the services")
def test_restore_config_after_non_sanity(self): """Restore configurations after Non-Sanity Test Cases Execution This test script restores the configuration to default values after non-sanity test case execution, if the config files have been modified using the test script s1aptests/test_modify_config_for_non_sanity.py """ magmad_client = MagmadServiceGrpc() self._magmad_util = MagmadUtil(magmad_client) ret_codes = [] print("Restoring configuration to default values") print("Disabling Ha service") ret_codes.append( self._magmad_util.config_ha_service( MagmadUtil.ha_service_cmds.DISABLE, ), ) print("Disabling IPv6 solicitation service") ret_codes.append( self._magmad_util.config_ipv6_solicitation( MagmadUtil.ipv6_config_cmds.DISABLE, ), ) if 1 in ret_codes: print("Restarting services to apply configuration change") self._magmad_util.restart_all_services() else: print("No need to restart the services")
def test_restore_config_after_non_sanity(self): """Restore configurations after Non-Sanity Test Cases Execution This test script restores the configuration to default values after non-sanity test case execution, if the config files have been modified using the test script s1aptests/test_modify_config_for_non_sanity.py """ magmad_client = MagmadServiceGrpc() self._magmad_util = MagmadUtil(magmad_client) ret_codes = [] print("Restoring configuration to default values") print("Disabling Ha service") ret_codes.append( self._magmad_util.config_ha_service( MagmadUtil.ha_service_cmds.DISABLE, ), ) print( "Restoring MME configuration to default values using backup " "configuration file", ) self._magmad_util.update_mme_config_for_non_sanity( MagmadUtil.config_update_cmds.RESTORE, ) print("Restarting services to apply configuration change") self._magmad_util.restart_all_services()
def __init__(self, stateless_mode=MagmadUtil.stateless_cmds.DISABLE): """ Initialize the various classes required by the tests and setup. """ self._s1_util = S1ApUtil() self._enBConfig() if self._test_oai_upstream: subscriber_client = SubscriberDbCassandra() self.wait_gateway_healthy = False else: subscriber_client = SubscriberDbGrpc() self.wait_gateway_healthy = True mobility_client = MobilityServiceGrpc() magmad_client = MagmadServiceGrpc() self._sub_util = SubscriberUtil(subscriber_client) # Remove existing subscribers to start self._sub_util.cleanup() self._mobility_util = MobilityUtil(mobility_client) self._mobility_util.cleanup() self._magmad_util = MagmadUtil(magmad_client) self._magmad_util.config_stateless(stateless_mode) # gateway tests don't require restart, just wait for healthy now self._gateway_services = GatewayServicesUtil() if not self.wait_gateway_healthy: self.init_s1ap_tester() self._configuredUes = [] self._ue_idx = 0 # Index of UEs already used in test self._trf_util = TrafficUtil()
def __init__( self, stateless_mode=MagmadUtil.stateless_cmds.ENABLE, apn_correction=MagmadUtil.apn_correction_cmds.DISABLE, health_service=MagmadUtil.health_service_cmds.DISABLE, federated_mode=False, ip_version=4, ): """ Initialize the various classes required by the tests and setup. """ t = time.localtime() current_time = time.strftime("%H:%M:%S", t) if TestWrapper.TEST_CASE_EXECUTION_COUNT != 0: print("\n**Running the test case again to identify flaky behavior") TestWrapper.TEST_CASE_EXECUTION_COUNT += 1 print( "\nTest Case Execution Count:", TestWrapper.TEST_CASE_EXECUTION_COUNT, "[Start time: " + str(current_time) + "]", ) self._s1_util = S1ApUtil() self._enBConfig(ip_version) federated_mode = (os.environ.get("FEDERATED_MODE") == "True") print( f"\n *** Running the test in {'Non-' if not federated_mode else ''}" "Federated Mode\n", ) if self._test_oai_upstream: subscriber_client = SubscriberDbCassandra() self.wait_gateway_healthy = False elif federated_mode: subscriber_client = HSSGrpc() self.wait_gateway_healthy = True else: subscriber_client = SubscriberDbGrpc() self.wait_gateway_healthy = True mobility_client = MobilityServiceGrpc() magmad_client = MagmadServiceGrpc() self._sub_util = SubscriberUtil(subscriber_client) # Remove existing subscribers to start self._sub_util.cleanup() self._mobility_util = MobilityUtil(mobility_client) self._mobility_util.cleanup() self._magmad_util = MagmadUtil(magmad_client) self._magmad_util.config_stateless(stateless_mode) self._magmad_util.config_apn_correction(apn_correction) self._magmad_util.config_health_service(health_service) # gateway tests don't require restart, just wait for healthy now self._gateway_services = GatewayServicesUtil() if not self.wait_gateway_healthy: self.init_s1ap_tester() self._configuredUes = [] self._ue_idx = 0 # Index of UEs already used in test self._trf_util = TrafficUtil()
def test_modify_mme_config_for_sanity(self): """ Some test cases need changes in default mme configuration. This test script modifies MME configuration with generic values so that all the test cases of sanity suite can be verified """ magmad_client = MagmadServiceGrpc() self._magmad_util = MagmadUtil(magmad_client) print("Modifying MME configuration for all sanity test cases to pass") self._magmad_util.update_mme_config_for_sanity( MagmadUtil.config_update_cmds.MODIFY) print("Restarting services to apply configuration change") self._magmad_util.restart_all_services()
def test_restore_mme_config_after_sanity(self): """ This test script restores the MME configuration to default values, if the config file mme.conf.template has been modified using the test script s1aptests/test_modify_mme_config_for_sanity.py """ magmad_client = MagmadServiceGrpc() self._magmad_util = MagmadUtil(magmad_client) # Replace mme.conf.template with backup of this config file. Backup of # this config file with default values is created when running the # test script s1aptests/test_modify_mme_config_for_sanity.py print("Restoring MME configuration to default values using backup " "configuration file") self._magmad_util.update_mme_config_for_sanity( MagmadUtil.config_update_cmds.RESTORE)
def __init__( self, stateless_mode=MagmadUtil.stateless_cmds.ENABLE, apn_correction=MagmadUtil.apn_correction_cmds.DISABLE, health_service=MagmadUtil.health_service_cmds.DISABLE, ): """ Initialize the various classes required by the tests and setup. """ if not TestWrapper.IS_TEST_RUNNING_FIRST_TIME: print("\n**Running the test case again to identify flaky behavior") TestWrapper.IS_TEST_RUNNING_FIRST_TIME = False t = time.localtime() current_time = time.strftime("%H:%M:%S", t) print("Start time", current_time) self._s1_util = S1ApUtil() self._enBConfig() if self._test_oai_upstream: subscriber_client = SubscriberDbCassandra() self.wait_gateway_healthy = False else: subscriber_client = SubscriberDbGrpc() self.wait_gateway_healthy = True mobility_client = MobilityServiceGrpc() magmad_client = MagmadServiceGrpc() self._sub_util = SubscriberUtil(subscriber_client) # Remove existing subscribers to start self._sub_util.cleanup() self._mobility_util = MobilityUtil(mobility_client) self._mobility_util.cleanup() self._magmad_util = MagmadUtil(magmad_client) self._magmad_util.config_stateless(stateless_mode) self._magmad_util.config_apn_correction(apn_correction) self._magmad_util.config_health_service(health_service) # gateway tests don't require restart, just wait for healthy now self._gateway_services = GatewayServicesUtil() if not self.wait_gateway_healthy: self.init_s1ap_tester() self._configuredUes = [] self._ue_idx = 0 # Index of UEs already used in test self._trf_util = TrafficUtil()
def tearDown(self): """Cleanup after test case execution""" is_test_successful = s1ap_wrapper.TestWrapper.is_test_successful(self) print("************************* Sending SCTP SHUTDOWN") self._s1_util.issue_cmd(s1ap_types.tfwCmd.SCTP_SHUTDOWN_REQ, None) if not is_test_successful: print("************************* Cleaning up TFW") self._s1_util.issue_cmd(s1ap_types.tfwCmd.TFW_CLEANUP, None) self._s1_util.delete_ovs_flow_rules() self._s1_util.cleanup() if not is_test_successful: print("The test has failed. Restarting Sctpd for cleanup") magmad_client = MagmadServiceGrpc() magmad_util = MagmadUtil(magmad_client) magmad_util.restart_sctpd() magmad_util.print_redis_state()
class TestWrapper(object): """ Module wrapping boiler plate code for all test setups and cleanups. """ # With the current mask value of 24 in TEST_IP_BLOCK, we can allocate a # maximum of 255 UE IP addresses only. Moreover, magma has reserved 12 IP # addresses for testing purpose, hence maximum allowed free IP addresses # are 243. We need to change this mask value in order to allocate more than # 243 UE IP addresses. Therefore, with the mask value of n, the maximum # number of UE IP addresses allowed will be ((2^(32-n)) - 13). # Example: # mask value 24, max allowed UE IP addresses = ((2^(32-24)) - 13) = 243 # mask value 20, max allowed UE IP addresses = ((2^(32-20)) - 13) = 4083 # mask value 17, max allowed UE IP addresses = ((2^(32-17)) - 13) = 32755 # Decreasing the mask value will provide more UE IP addresses in the free # IP address pool TEST_IP_BLOCK = "192.168.128.0/24" MSX_S1_RETRY = 2 def __init__( self, stateless_mode=MagmadUtil.stateless_cmds.DISABLE, apn_correction=MagmadUtil.apn_correction_cmds.DISABLE, ): """ Initialize the various classes required by the tests and setup. """ self._s1_util = S1ApUtil() self._enBConfig() if self._test_oai_upstream: subscriber_client = SubscriberDbCassandra() self.wait_gateway_healthy = False else: subscriber_client = SubscriberDbGrpc() self.wait_gateway_healthy = True mobility_client = MobilityServiceGrpc() magmad_client = MagmadServiceGrpc() self._sub_util = SubscriberUtil(subscriber_client) # Remove existing subscribers to start self._sub_util.cleanup() self._mobility_util = MobilityUtil(mobility_client) self._mobility_util.cleanup() self._magmad_util = MagmadUtil(magmad_client) self._magmad_util.config_stateless(stateless_mode) self._magmad_util.config_apn_correction(apn_correction) # gateway tests don't require restart, just wait for healthy now self._gateway_services = GatewayServicesUtil() if not self.wait_gateway_healthy: self.init_s1ap_tester() self._configuredUes = [] self._ue_idx = 0 # Index of UEs already used in test self._trf_util = TrafficUtil() def init_s1ap_tester(self): """ Initialize the s1ap tester and the UEApp. Doing this separately allows initialization to occur during tests rather than during setup stage. """ # config ip first, because cloud tests will restart gateway self.configIpBlock() self._s1setup() self._configUEApp() @property def _test_cloud(self): test_cloud = os.getenv("MAGMA_S1APTEST_USE_CLOUD") is not None return test_cloud @property def _test_oai_upstream(self): return os.getenv("TEST_OAI_UPSTREAM") is not None def _enBConfig(self): """Helper to configure the eNB""" # Using exaggerated prints makes the stdout easier to read. print("************************* Enb tester config") req = s1ap_types.FwNbConfigReq_t() req.cellId_pr.pres = True req.cellId_pr.cell_id = 10 assert self._s1_util.issue_cmd(s1ap_types.tfwCmd.ENB_CONFIG, req) == 0 response = self._s1_util.get_response() assert response.msg_type == s1ap_types.tfwCmd.ENB_CONFIG_CONFIRM.value res = response.cast(s1ap_types.FwNbConfigCfm_t) assert res.status == s1ap_types.CfgStatus.CFG_DONE.value def _issue_s1setup_req(self): """ Issue the actual setup request and get the response""" req = None assert (self._s1_util.issue_cmd(s1ap_types.tfwCmd.ENB_S1_SETUP_REQ, req) == 0) response = self._s1_util.get_response() assert response.msg_type == s1ap_types.tfwCmd.ENB_S1_SETUP_RESP.value return response.cast(s1ap_types.FwNbS1setupRsp_t) def _s1setup(self): """Helper to setup s1 to the EPC""" print("************************* S1 setup") res = self._issue_s1setup_req() retry = 0 while retry < TestWrapper.MSX_S1_RETRY: if (res.res == s1ap_types.S1_setp_Result.S1_SETUP_FAILED.value and res.waitIe.pres == 1): print( "Received time to wait in S1-Setup-Failure" " message is", res.waitIe.val, ) time.sleep(res.waitIe.val) res = self._issue_s1setup_req() retry += 1 else: # Not a failure in setup. break assert res.res == s1ap_types.S1_setp_Result.S1_SETUP_SUCCESS.value def _configUEApp(self): """ Update the internal configuration of the UEApp""" print("************************* UE App config") req = s1ap_types.ueAppConfig_t() req.nasProcGuardTimer_pr.pres = True req.nasProcGuardTimer_pr.nas_proc_guard_timer = 5 assert (self._s1_util.issue_cmd(s1ap_types.tfwCmd.UE_APPL_CONFIG, req) == 0) response = self._s1_util.get_response() assert (s1ap_types.tfwCmd.UE_APP_CONFIG_COMPLETE_IND.value == response.msg_type) def _getAddresses(self, *ues): """ Retrieve IP addresses for the given UEs Will put None for IPs in the cases where a UE has been included that doesn't have a cached IP (e.g. the UE has not yet been attached) Args: ues (list(s1ap_types.ueAppConfig_t)): the UEs whose IPs we want Returns a list of ipaddress.ip_address objects, corresponding in order with the input UE parameters """ return [self._s1_util.get_ip(ue.ue_id) for ue in ues] def configIpBlock(self): """ Removes any existing allocated blocks, then adds the ones used for testing """ print("************************* Configuring IP block") self._mobility_util.remove_all_ip_blocks() self._mobility_util.add_ip_block(self.TEST_IP_BLOCK) print("************************* Waiting for IP changes to propagate") self._mobility_util.wait_for_changes() def configUEDevice(self, num_ues, reqData=[]): """ Configure the device on the UE side """ reqs = self._sub_util.add_sub(num_ues=num_ues) for i in range(num_ues): print( "************************* UE device config for ue_id ", reqs[i].ue_id, ) if reqData and bool(reqData[i]): if reqData[i].ueNwCap_pr.pres: reqs[i].ueNwCap_pr.pres = reqData[i].ueNwCap_pr.pres reqs[i].ueNwCap_pr.eea2_128 = reqData[ i].ueNwCap_pr.eea2_128 reqs[i].ueNwCap_pr.eea1_128 = reqData[ i].ueNwCap_pr.eea1_128 reqs[i].ueNwCap_pr.eea0 = reqData[i].ueNwCap_pr.eea0 reqs[i].ueNwCap_pr.eia2_128 = reqData[ i].ueNwCap_pr.eia2_128 reqs[i].ueNwCap_pr.eia1_128 = reqData[ i].ueNwCap_pr.eia1_128 reqs[i].ueNwCap_pr.eia0 = reqData[i].ueNwCap_pr.eia0 assert (self._s1_util.issue_cmd(s1ap_types.tfwCmd.UE_CONFIG, reqs[i]) == 0) response = self._s1_util.get_response() assert (s1ap_types.tfwCmd.UE_CONFIG_COMPLETE_IND.value == response.msg_type) # APN configuration below can be overwritten in the test case # after configuring UE device. self.configAPN("IMSI" + "".join([str(j) for j in reqs[i].imsi]), None) self._configuredUes.append(reqs[i]) self.check_gw_health_after_ue_load() def configUEDevice_ues_same_imsi(self, num_ues): """ Configure the device on the UE side with same IMSI and having different ue-id""" reqs = self._sub_util.add_sub(num_ues=num_ues) for i in range(num_ues): print( "************************* UE device config for ue_id ", reqs[i].ue_id, ) assert (self._s1_util.issue_cmd(s1ap_types.tfwCmd.UE_CONFIG, reqs[i]) == 0) response = self._s1_util.get_response() assert (s1ap_types.tfwCmd.UE_CONFIG_COMPLETE_IND.value == response.msg_type) # APN configuration below can be overwritten in the test case # after configuring UE device. self.configAPN("IMSI" + "".join([str(j) for j in reqs[i].imsi]), None) self._configuredUes.append(reqs[i]) for i in range(num_ues): reqs[i].ue_id = 2 print( "************************* UE device config for ue_id ", reqs[i].ue_id, ) assert (self._s1_util.issue_cmd(s1ap_types.tfwCmd.UE_CONFIG, reqs[i]) == 0) response = self._s1_util.get_response() assert (s1ap_types.tfwCmd.UE_CONFIG_COMPLETE_IND.value == response.msg_type) self._configuredUes.append(reqs[i]) self.check_gw_health_after_ue_load() def configUEDevice_without_checking_gw_health(self, num_ues): """ Configure the device on the UE side """ reqs = self._sub_util.add_sub(num_ues=num_ues) for i in range(num_ues): print( "************************* UE device config for ue_id ", reqs[i].ue_id, ) assert (self._s1_util.issue_cmd(s1ap_types.tfwCmd.UE_CONFIG, reqs[i]) == 0) response = self._s1_util.get_response() assert (s1ap_types.tfwCmd.UE_CONFIG_COMPLETE_IND.value == response.msg_type) # APN configuration below can be overwritten in the test case # after configuring UE device. self.configAPN("IMSI" + "".join([str(j) for j in reqs[i].imsi]), None) self._configuredUes.append(reqs[i]) def configAPN(self, imsi, apn_list, default=True): """ Configure the APN """ # add a default APN to be used in attach requests if default: magma_default_apn = { "apn_name": "magma.ipv4", # APN-name "qci": 9, # qci "priority": 15, # priority "pre_cap": 1, # preemption-capability "pre_vul": 0, # preemption-vulnerability "mbr_ul": 200000000, # MBR UL "mbr_dl": 100000000, # MBR DL } # APN list to be configured if apn_list is not None: apn_list.insert(0, magma_default_apn) else: apn_list = [magma_default_apn] self._sub_util.config_apn_data(imsi, apn_list) def check_gw_health_after_ue_load(self): """ Wait for the MME only after adding entries to HSS """ if self.wait_gateway_healthy: self._gateway_services.wait_for_healthy_gateway() self.init_s1ap_tester() self.wait_gateway_healthy = False def configDownlinkTest(self, *ues, **kwargs): """ Set up an downlink test, returning a TrafficTest object Args: ues (s1ap_types.ueConfig_t): the UEs to test kwargs: the keyword args to pass into generate_downlink_test Returns: a TrafficTest object, the traffic test generated based on the given UEs """ # Configure downlink route in TRF server assert self._trf_util.update_dl_route(self.TEST_IP_BLOCK) ips = self._getAddresses(*ues) for ip, ue in zip(ips, ues): if not ip: raise ValueError("Encountered invalid IP for UE ID %s." " Are you sure the UE is attached?" % ue) return self._trf_util.generate_traffic_test(ips, is_uplink=False, **kwargs) def configUplinkTest(self, *ues, **kwargs): """ Set up an uplink test, returning a TrafficTest object Args: ues (s1ap_types.ueConfig_t): the UEs to test kwargs: the keyword args to pass into generate_uplink_test Returns: a TrafficTest object, the traffic test generated based on the given UEs """ ips = self._getAddresses(*ues) for ip, ue in zip(ips, ues): if not ip: raise ValueError("Encountered invalid IP for UE ID %s." " Are you sure the UE is attached?" % ue) return self._trf_util.generate_traffic_test(ips, is_uplink=True, **kwargs) def get_gateway_services_util(self): """ Not a property, so return object is callable """ return self._gateway_services @property def ue_req(self): """ Get a configured UE """ req = self._configuredUes[self._ue_idx] self._ue_idx += 1 return req @property def s1_util(self): return self._s1_util @property def mobility_util(self): return self._mobility_util @property def traffic_util(self): return self._trf_util @property def magmad_util(self): return self._magmad_util def cleanup(self): time.sleep(0.5) print("************************* send SCTP SHUTDOWN") self._s1_util.issue_cmd(s1ap_types.tfwCmd.SCTP_SHUTDOWN_REQ, None) self._s1_util.cleanup() self._sub_util.cleanup() self._trf_util.cleanup() self._mobility_util.cleanup() # Cloud cleanup needs to happen after cleanup for # subscriber util and mobility util # if self._test_cloud: # self._cloud_manager.clean_up() def multiEnbConfig(self, num_of_enbs, enb_list=None): if enb_list is None: enb_list = [] req = s1ap_types.multiEnbConfigReq_t() req.numOfEnbs = num_of_enbs # ENB Parameter column index initialization CELLID_COL_IDX = 0 TAC_COL_IDX = 1 ENBTYPE_COL_IDX = 2 PLMNID_COL_IDX = 3 PLMN_LENGTH_IDX = 4 for idx1 in range(num_of_enbs): req.multiEnbCfgParam[idx1].cell_id = enb_list[idx1][CELLID_COL_IDX] req.multiEnbCfgParam[idx1].tac = enb_list[idx1][TAC_COL_IDX] req.multiEnbCfgParam[idx1].enbType = enb_list[idx1][ ENBTYPE_COL_IDX] req.multiEnbCfgParam[idx1].plmn_length = enb_list[idx1][ PLMN_LENGTH_IDX] for idx2 in range(req.multiEnbCfgParam[idx1].plmn_length): val = enb_list[idx1][PLMNID_COL_IDX][idx2] req.multiEnbCfgParam[idx1].plmn_id[idx2] = int(val) print("***************** Sending Multiple Enb Config Request\n") assert (self._s1_util.issue_cmd( s1ap_types.tfwCmd.MULTIPLE_ENB_CONFIG_REQ, req) == 0) def sendActDedicatedBearerAccept(self, ue_id, bearerId): act_ded_bearer_acc = s1ap_types.UeActDedBearCtxtAcc_t() act_ded_bearer_acc.ue_Id = ue_id act_ded_bearer_acc.bearerId = bearerId self._s1_util.issue_cmd(s1ap_types.tfwCmd.UE_ACT_DED_BER_ACC, act_ded_bearer_acc) print("************** Sending activate dedicated EPS bearer " "context accept\n") def sendDeactDedicatedBearerAccept(self, ue_id, bearerId): deact_ded_bearer_acc = s1ap_types.UeDeActvBearCtxtAcc_t() deact_ded_bearer_acc.ue_Id = ue_id deact_ded_bearer_acc.bearerId = bearerId self._s1_util.issue_cmd(s1ap_types.tfwCmd.UE_DEACTIVATE_BER_ACC, deact_ded_bearer_acc) print("************* Sending deactivate EPS bearer context accept\n") def sendPdnConnectivityReq(self, ue_id, apn, pdn_type=1, pcscf_addr_type=None, dns_ipv6_addr=False): req = s1ap_types.uepdnConReq_t() req.ue_Id = ue_id # Initial Request req.reqType = 1 req.pdnType_pr.pres = 1 # PDN Type 1 = IPv4, 2 = IPv6, 3 = IPv4v6 req.pdnType_pr.pdn_type = pdn_type req.pdnAPN_pr.pres = 1 req.pdnAPN_pr.len = len(apn) req.pdnAPN_pr.pdn_apn = (ctypes.c_ubyte * 100)( *[ctypes.c_ubyte(ord(c)) for c in apn[:100]]) print("********* PDN type", pdn_type) # Populate PCO if pcscf_addr_type is set if pcscf_addr_type or dns_ipv6_addr: self._s1_util.populate_pco(req.protCfgOpts_pr, pcscf_addr_type, dns_ipv6_addr) self.s1_util.issue_cmd(s1ap_types.tfwCmd.UE_PDN_CONN_REQ, req) print("************* Sending Standalone PDN Connectivity Request\n")
class TestWrapper(object): """ Module wrapping boiler plate code for all test setups and cleanups. """ # With the current mask value of 24 in TEST_IP_BLOCK, we can allocate a # maximum of 255 UE IP addresses only. Moreover, magma has reserved 12 IP # addresses for testing purpose, hence maximum allowed free IP addresses # are 243. We need to change this mask value in order to allocate more than # 243 UE IP addresses. Therefore, with the mask value of n, the maximum # number of UE IP addresses allowed will be ((2^(32-n)) - 13). # Example: # mask value 24, max allowed UE IP addresses = ((2^(32-24)) - 13) = 243 # mask value 20, max allowed UE IP addresses = ((2^(32-20)) - 13) = 4083 # mask value 17, max allowed UE IP addresses = ((2^(32-17)) - 13) = 32755 # Decreasing the mask value will provide more UE IP addresses in the free # IP address pool TEST_IP_BLOCK = "192.168.128.0/24" MSX_S1_RETRY = 2 TEST_CASE_EXECUTION_COUNT = 0 TEST_ERROR_TRACEBACKS = [] def __init__( self, stateless_mode=MagmadUtil.stateless_cmds.ENABLE, apn_correction=MagmadUtil.apn_correction_cmds.DISABLE, health_service=MagmadUtil.health_service_cmds.DISABLE, federated_mode=False, ip_version=4, ): """ Initialize the various classes required by the tests and setup. """ t = time.localtime() current_time = time.strftime("%H:%M:%S", t) if TestWrapper.TEST_CASE_EXECUTION_COUNT != 0: print("\n**Running the test case again to identify flaky behavior") TestWrapper.TEST_CASE_EXECUTION_COUNT += 1 print( "\nTest Case Execution Count:", TestWrapper.TEST_CASE_EXECUTION_COUNT, "[Start time: " + str(current_time) + "]", ) self._s1_util = S1ApUtil() self._enBConfig(ip_version) federated_mode = (os.environ.get("FEDERATED_MODE") == "True") print( f"\n *** Running the test in {'Non-' if not federated_mode else ''}" "Federated Mode\n", ) if self._test_oai_upstream: subscriber_client = SubscriberDbCassandra() self.wait_gateway_healthy = False elif federated_mode: subscriber_client = HSSGrpc() self.wait_gateway_healthy = True else: subscriber_client = SubscriberDbGrpc() self.wait_gateway_healthy = True mobility_client = MobilityServiceGrpc() magmad_client = MagmadServiceGrpc() self._sub_util = SubscriberUtil(subscriber_client) # Remove existing subscribers to start self._sub_util.cleanup() self._mobility_util = MobilityUtil(mobility_client) self._mobility_util.cleanup() self._magmad_util = MagmadUtil(magmad_client) self._magmad_util.config_stateless(stateless_mode) self._magmad_util.config_apn_correction(apn_correction) self._magmad_util.config_health_service(health_service) # gateway tests don't require restart, just wait for healthy now self._gateway_services = GatewayServicesUtil() if not self.wait_gateway_healthy: self.init_s1ap_tester() self._configuredUes = [] self._ue_idx = 0 # Index of UEs already used in test self._trf_util = TrafficUtil() def init_s1ap_tester(self): """ Initialize the s1ap tester and the UEApp. Doing this separately allows initialization to occur during tests rather than during setup stage. """ # config ip first, because cloud tests will restart gateway self.configIpBlock() self._s1setup() self._configUEApp() @property def _test_cloud(self): test_cloud = os.getenv("MAGMA_S1APTEST_USE_CLOUD") is not None return test_cloud @property def _test_oai_upstream(self): return os.getenv("TEST_OAI_UPSTREAM") is not None def _enBConfig(self, ip_version=4): """Configure the eNB in S1APTester""" # Using exaggerated prints makes the stdout easier to read. print("************************* Enb tester config") req = s1ap_types.FwNbConfigReq_t() req.cellId_pr.pres = True req.cellId_pr.cell_id = 10 req.ip_version = ip_version assert self._s1_util.issue_cmd(s1ap_types.tfwCmd.ENB_CONFIG, req) == 0 response = self._s1_util.get_response() assert response.msg_type == s1ap_types.tfwCmd.ENB_CONFIG_CONFIRM.value res = response.cast(s1ap_types.FwNbConfigCfm_t) assert res.status == s1ap_types.CfgStatus.CFG_DONE.value def _issue_s1setup_req(self): """ Issue the actual setup request and get the response""" req = None assert (self._s1_util.issue_cmd(s1ap_types.tfwCmd.ENB_S1_SETUP_REQ, req) == 0) response = self._s1_util.get_response() assert response.msg_type == s1ap_types.tfwCmd.ENB_S1_SETUP_RESP.value return response.cast(s1ap_types.FwNbS1setupRsp_t) def _s1setup(self): """Perform S1 setup to the EPC""" print("************************* S1 setup") res = self._issue_s1setup_req() retry = 0 while retry < TestWrapper.MSX_S1_RETRY: if (res.res == s1ap_types.S1_setp_Result.S1_SETUP_FAILED.value and res.waitIe.pres == 1): print( "Received time to wait in S1-Setup-Failure" " message is", res.waitIe.val, ) time.sleep(res.waitIe.val) res = self._issue_s1setup_req() retry += 1 else: # Not a failure in setup. break assert res.res == s1ap_types.S1_setp_Result.S1_SETUP_SUCCESS.value def _configUEApp(self): """ Update the internal configuration of the UEApp""" print("************************* UE App config") req = s1ap_types.ueAppConfig_t() req.nasProcGuardTimer_pr.pres = True req.nasProcGuardTimer_pr.nas_proc_guard_timer = 5 assert (self._s1_util.issue_cmd(s1ap_types.tfwCmd.UE_APPL_CONFIG, req) == 0) response = self._s1_util.get_response() assert (s1ap_types.tfwCmd.UE_APP_CONFIG_COMPLETE_IND.value == response.msg_type) def _getAddresses(self, *ues): """ Retrieve IP addresses for the given UEs Will put None for IPs in the cases where a UE has been included that doesn't have a cached IP (e.g. the UE has not yet been attached) Args: ues: (list(s1ap_types.ueAppConfig_t)): the UEs whose IPs we want Returns: A list of ipaddress.ip_address objects, corresponding in order with the input UE parameters """ return [self._s1_util.get_ip(ue.ue_id) for ue in ues] def configIpBlock(self): """ Remove any existing allocated blocks, then adds the ones used for testing """ print("************************* Configuring IP block") self._mobility_util.remove_all_ip_blocks() self._mobility_util.add_ip_block(self.TEST_IP_BLOCK) print("************************* Waiting for IP changes to propagate") self._mobility_util.wait_for_changes() def configUEDevice(self, num_ues, req_data=None, static_ips=None): """ Configure the device on the UE side """ if req_data is None: req_data = [] if static_ips is None: static_ips = [] reqs = self._sub_util.add_sub(num_ues=num_ues) for i in range(num_ues): print( "************************* UE device config for ue_id ", reqs[i].ue_id, ) if req_data and bool(req_data[i]): if req_data[i].ueNwCap_pr.pres: reqs[i].ueNwCap_pr.pres = req_data[i].ueNwCap_pr.pres reqs[i].ueNwCap_pr.eea2_128 = req_data[ i].ueNwCap_pr.eea2_128 reqs[i].ueNwCap_pr.eea1_128 = req_data[ i].ueNwCap_pr.eea1_128 reqs[i].ueNwCap_pr.eea0 = req_data[i].ueNwCap_pr.eea0 reqs[i].ueNwCap_pr.eia2_128 = req_data[ i].ueNwCap_pr.eia2_128 reqs[i].ueNwCap_pr.eia1_128 = req_data[ i].ueNwCap_pr.eia1_128 reqs[i].ueNwCap_pr.eia0 = req_data[i].ueNwCap_pr.eia0 assert (self._s1_util.issue_cmd(s1ap_types.tfwCmd.UE_CONFIG, reqs[i]) == 0) response = self._s1_util.get_response() assert (s1ap_types.tfwCmd.UE_CONFIG_COMPLETE_IND.value == response.msg_type) # APN configuration below can be overwritten in the test case # after configuring UE device. if i < len(static_ips): ue_ip = static_ips[i] else: ue_ip = None self.configAPN( imsi="IMSI" + "".join([str(j) for j in reqs[i].imsi]), apn_list=None, default=True, static_ip=ue_ip, ) self._configuredUes.append(reqs[i]) self.check_gw_health_after_ue_load() def configUEDevice_ues_same_imsi(self, num_ues): """ Configure the device on the UE side with same IMSI and having different ue-id Args: num_ues: Count of UEs to be configured """ reqs = self._sub_util.add_sub(num_ues=num_ues) for i in range(num_ues): print( "************************* UE device config for ue_id ", reqs[i].ue_id, ) assert (self._s1_util.issue_cmd(s1ap_types.tfwCmd.UE_CONFIG, reqs[i]) == 0) response = self._s1_util.get_response() assert (s1ap_types.tfwCmd.UE_CONFIG_COMPLETE_IND.value == response.msg_type) # APN configuration below can be overwritten in the test case # after configuring UE device. self.configAPN( "IMSI" + "".join([str(j) for j in reqs[i].imsi]), None, ) self._configuredUes.append(reqs[i]) for i in range(num_ues): reqs[i].ue_id = 2 print( "************************* UE device config for ue_id ", reqs[i].ue_id, ) assert (self._s1_util.issue_cmd(s1ap_types.tfwCmd.UE_CONFIG, reqs[i]) == 0) response = self._s1_util.get_response() assert (s1ap_types.tfwCmd.UE_CONFIG_COMPLETE_IND.value == response.msg_type) self._configuredUes.append(reqs[i]) self.check_gw_health_after_ue_load() def configUEDevice_without_checking_gw_health(self, num_ues): """ Configure the device on the UE side """ reqs = self._sub_util.add_sub(num_ues=num_ues) for i in range(num_ues): print( "************************* UE device config for ue_id ", reqs[i].ue_id, ) assert (self._s1_util.issue_cmd(s1ap_types.tfwCmd.UE_CONFIG, reqs[i]) == 0) response = self._s1_util.get_response() assert (s1ap_types.tfwCmd.UE_CONFIG_COMPLETE_IND.value == response.msg_type) # APN configuration below can be overwritten in the test case # after configuring UE device. self.configAPN( "IMSI" + "".join([str(j) for j in reqs[i].imsi]), None, ) self._configuredUes.append(reqs[i]) def configAPN(self, imsi, apn_list, default=True, static_ip=None): """ Configure the APN """ # add a default APN to be used in attach requests if default: magma_default_apn = { "apn_name": "magma.ipv4", # APN-name "qci": 9, # qci "priority": 15, # priority "pre_cap": 1, # preemption-capability "pre_vul": 0, # preemption-vulnerability "mbr_ul": 200000000, # MBR UL "mbr_dl": 100000000, # MBR DL "static_ip": static_ip, } # APN list to be configured if apn_list is not None: apn_list.insert(0, magma_default_apn) else: apn_list = [magma_default_apn] self._sub_util.config_apn_data(imsi, apn_list) def check_gw_health_after_ue_load(self): """ Wait for the MME only after adding entries to HSS """ if self.wait_gateway_healthy: self._gateway_services.wait_for_healthy_gateway() self.init_s1ap_tester() self.wait_gateway_healthy = False def configDownlinkTest(self, *ues, **kwargs): """ Set up an downlink test, returning a TrafficTest object Args: ues (s1ap_types.ueConfig_t): the UEs to test kwargs: the keyword args to pass into generate_downlink_test Returns: A TrafficTest object, the traffic test generated based on the given UEs Raises: ValueError: If no valid IP is found """ time.sleep(1) # Configure downlink route in TRF server assert self._trf_util.update_dl_route(self.TEST_IP_BLOCK) ips = self._getAddresses(*ues) for ip, ue in zip(ips, ues): if not ip: raise ValueError( "Encountered invalid IP for UE ID %s." " Are you sure the UE is attached?" % ue, ) return self._trf_util.generate_traffic_test( ips, is_uplink=False, **kwargs, ) def configMtuSize(self, set_mtu=False): """ Config MTU size for DL ipv6 data """ assert self._trf_util.update_mtu_size(set_mtu) def configUplinkTest(self, *ues, **kwargs): """ Set up an uplink test, returning a TrafficTest object Args: ues (s1ap_types.ueConfig_t): the UEs to test kwargs: the keyword args to pass into generate_uplink_test Returns: A TrafficTest object, the traffic test generated based on the given UEs Raises: ValueError: If no valid IP is found """ time.sleep(1) ips = self._getAddresses(*ues) for ip, ue in zip(ips, ues): if not ip: raise ValueError( "Encountered invalid IP for UE ID %s." " Are you sure the UE is attached?" % ue, ) return self._trf_util.generate_traffic_test( ips, is_uplink=True, **kwargs, ) def get_gateway_services_util(self): """ Not a property, so return object is callable """ return self._gateway_services @property def ue_req(self): """ Get a configured UE """ req = self._configuredUes[self._ue_idx] self._ue_idx += 1 return req @property def s1_util(self): """Get s1_util instance""" return self._s1_util @property def mobility_util(self): """Get mobility_util instance""" return self._mobility_util @property def traffic_util(self): """Get traffic_util instance""" return self._trf_util @property def magmad_util(self): """Get magmad_util instance""" return self._magmad_util @classmethod def generate_flaky_summary(cls): """Print the flaky report summary""" if TestWrapper.TEST_ERROR_TRACEBACKS: print("\n===Flaky Test Report===\n") for traceback in TestWrapper.TEST_ERROR_TRACEBACKS: print(traceback) print("===End Flaky Test Report===") @classmethod def is_test_successful(cls, test) -> bool: """Get current test case execution status""" if test is None: test = inspect.currentframe().f_back.f_back.f_locals["self"] if test is not None and hasattr(test, "_outcome"): result = test.defaultTestResult() test._feedErrorsToResult(result, test._outcome.errors) test_contains_error = (result.errors and result.errors[-1][0] is test) test_contains_failure = (result.failures and result.failures[-1][0] is test) if test_contains_error or test_contains_failure: TestWrapper.TEST_ERROR_TRACEBACKS.append( str(test) + " failed (Execution Count: " + str(TestWrapper.TEST_CASE_EXECUTION_COUNT) + ")." + result.failures[0][1] if test_contains_failure else result.errors[0][1], ) return not (test_contains_error or test_contains_failure) def cleanup(self, test=None): """Cleanup test setup after testcase execution""" is_test_successful = self.is_test_successful(test) time.sleep(0.5) print("************************* send SCTP SHUTDOWN") self._s1_util.issue_cmd(s1ap_types.tfwCmd.SCTP_SHUTDOWN_REQ, None) print("************************* Cleaning up TFW") self._s1_util.issue_cmd(s1ap_types.tfwCmd.TFW_CLEANUP, None) if not is_test_successful: self._s1_util.delete_ovs_flow_rules() self._s1_util.cleanup() self._sub_util.cleanup() self._trf_util.cleanup() self._mobility_util.cleanup() self._magmad_util.print_redis_state() if not is_test_successful: print("The test has failed. Restarting Sctpd for cleanup") self.magmad_util.restart_sctpd() self.magmad_util.print_redis_state() if TestWrapper.TEST_CASE_EXECUTION_COUNT == 3: self.generate_flaky_summary() elif TestWrapper.TEST_CASE_EXECUTION_COUNT > 1: self.generate_flaky_summary() def multiEnbConfig(self, num_of_enbs, enb_list=None): """Configure multiple eNB in S1APTester""" if enb_list is None: enb_list = [] req = s1ap_types.multiEnbConfigReq_t() req.numOfEnbs = num_of_enbs # ENB Parameter column index initialization cellid_col_idx = 0 tac_col_idx = 1 enbtype_col_idx = 2 plmnid_col_idx = 3 plmn_length_idx = 4 for idx1 in range(num_of_enbs): req.multiEnbCfgParam[idx1].cell_id = enb_list[idx1][cellid_col_idx] req.multiEnbCfgParam[idx1].tac = enb_list[idx1][tac_col_idx] req.multiEnbCfgParam[idx1].enbType = enb_list[idx1][ enbtype_col_idx] req.multiEnbCfgParam[idx1].plmn_length = enb_list[idx1][ plmn_length_idx] for idx2 in range(req.multiEnbCfgParam[idx1].plmn_length): val = enb_list[idx1][plmnid_col_idx][idx2] req.multiEnbCfgParam[idx1].plmn_id[idx2] = int(val) print("***************** Sending Multiple Enb Config Request\n") assert (self._s1_util.issue_cmd( s1ap_types.tfwCmd.MULTIPLE_ENB_CONFIG_REQ, req, ) == 0) def sendActDedicatedBearerAccept(self, ue_id, bearer_id): """Send Activate Dedicated Bearer Accept message""" act_ded_bearer_acc = s1ap_types.UeActDedBearCtxtAcc_t() act_ded_bearer_acc.ue_Id = ue_id act_ded_bearer_acc.bearerId = bearer_id self._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_ACT_DED_BER_ACC, act_ded_bearer_acc, ) print( "************** Sending activate dedicated EPS bearer " "context accept\n", ) def sendDeactDedicatedBearerAccept(self, ue_id, bearer_id): """Send Deactivate Dedicated Bearer Accept message""" deact_ded_bearer_acc = s1ap_types.UeDeActvBearCtxtAcc_t() deact_ded_bearer_acc.ue_Id = ue_id deact_ded_bearer_acc.bearerId = bearer_id self._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_DEACTIVATE_BER_ACC, deact_ded_bearer_acc, ) print("************* Sending deactivate EPS bearer context accept\n") def sendPdnConnectivityReq( self, ue_id, apn, pdn_type=1, pcscf_addr_type=None, dns_ipv6_addr=False, ): """Send PDN Connectivity Request message""" req = s1ap_types.uepdnConReq_t() req.ue_Id = ue_id # Initial Request req.reqType = 1 req.pdnType_pr.pres = 1 # PDN Type 1 = IPv4, 2 = IPv6, 3 = IPv4v6 req.pdnType_pr.pdn_type = pdn_type req.pdnAPN_pr.pres = 1 req.pdnAPN_pr.len = len(apn) req.pdnAPN_pr.pdn_apn = (ctypes.c_ubyte * 100)( *[ctypes.c_ubyte(ord(c)) for c in apn[:100]], ) print("********* PDN type", pdn_type) # Populate PCO if pcscf_addr_type is set if pcscf_addr_type or dns_ipv6_addr: self._s1_util.populate_pco( req.protCfgOpts_pr, pcscf_addr_type, dns_ipv6_addr, ) self.s1_util.issue_cmd(s1ap_types.tfwCmd.UE_PDN_CONN_REQ, req) print("************* Sending Standalone PDN Connectivity Request\n") def flush_arp(self): """Flush all ARP entries""" self._magmad_util.exec_command_output("sudo ip neigh flush all", ) print("magma-dev: ARP flushed") def enable_disable_ipv6_iface(self, cmd): """Enable or disable eth3 (ipv6) interface as nat_iface""" self._magmad_util.config_ipv6_iface(cmd)