def _set_misc_static_params( device_cfg: EnodebConfiguration, cfg: EnodebConfiguration, data_model: DataModel, ) -> None: """ Set the following parameters: - Local gateway enable - GPS enable """ _set_param_if_present( cfg, data_model, ParameterName.LOCAL_GATEWAY_ENABLE, 0, ) _set_param_if_present(cfg, data_model, ParameterName.GPS_ENABLE, True) # For BaiCells eNodeBs, IPSec enable may be either integer or bool. # Set to false/0 depending on the current type if data_model.is_parameter_present(ParameterName.IP_SEC_ENABLE): try: int(device_cfg.get_parameter(ParameterName.IP_SEC_ENABLE)) cfg.set_parameter(ParameterName.IP_SEC_ENABLE, value=0) except ValueError: cfg.set_parameter(ParameterName.IP_SEC_ENABLE, value=False) _set_param_if_present(cfg, data_model, ParameterName.CELL_RESERVED, False) _set_param_if_present( cfg, data_model, ParameterName.MME_POOL_ENABLE, False, )
def _set_tdd_subframe_config( device_cfg: EnodebConfiguration, cfg: EnodebConfiguration, subframe_assignment: Any, special_subframe_pattern: Any, ) -> None: """ Set the following parameters: - Subframe assignment - Special subframe pattern """ # Don't try to set if this is not TDD mode if device_cfg.get_parameter(ParameterName.DUPLEX_MODE_CAPABILITY) != \ 'TDDMode': return config_assert(subframe_assignment in range(0, 6 + 1), 'Invalid TDD subframe assignment (%d)' % subframe_assignment) config_assert( special_subframe_pattern in range(0, 9 + 1), 'Invalid TDD special subframe pattern (%d)' % special_subframe_pattern) cfg.set_parameter(ParameterName.SUBFRAME_ASSIGNMENT, subframe_assignment) cfg.set_parameter(ParameterName.SPECIAL_SUBFRAME_PATTERN, special_subframe_pattern)
def _set_cell_id( cfg: EnodebConfiguration, cell_id: int, ) -> None: config_assert(cell_id in range(0, 268435456), 'Cell Identity should be from 0 - (2^28 - 1)') cfg.set_parameter(ParameterName.CELL_ID, cell_id)
def process_inform_message( inform: Any, data_model: DataModel, device_cfg: EnodebConfiguration, ) -> None: """ Modifies the device configuration based on what is received in the Inform message. Will raise an error if it turns out that the data model we are using is incorrect. This is decided based on the device OUI and software-version that is reported in the Inform message. Args: inform: Inform Tr069 message device_handler: The state machine we are using for our device """ param_values_by_path = _get_param_values_by_path(inform) param_name_list = data_model.get_parameter_names() name_to_val = {} for name in param_name_list: path = data_model.get_parameter(name).path if path in param_values_by_path: value = param_values_by_path[path] name_to_val[name] = value for name, val in name_to_val.items(): device_cfg.set_parameter(name, val)
def qrtb_update_desired_config_from_cbsd_state( state: CBSDStateResult, config: EnodebConfiguration) -> None: """ Call grpc endpoint on the Domain Proxy to update the desired config based on sas grant Args: state (CBSDStateResult): state result as received from DP config (EnodebConfiguration): configuration to update """ logger.debug("Updating desired config based on sas grant") config.set_parameter(ParameterName.SAS_RADIO_ENABLE, state.radio_enabled) if not state.radio_enabled: return earfcn = calc_earfcn(state.channel.low_frequency_hz, state.channel.high_frequency_hz) bandwidth_mhz = calc_bandwidth_mhz(state.channel.low_frequency_hz, state.channel.high_frequency_hz) bandwidth_rbs = calc_bandwidth_rbs(bandwidth_mhz) psd = _calc_psd(state.channel.max_eirp_dbm_mhz) params_to_set = { ParameterName.SAS_RADIO_ENABLE: True, ParameterName.BAND: BAND, ParameterName.DL_BANDWIDTH: bandwidth_rbs, ParameterName.UL_BANDWIDTH: bandwidth_rbs, ParameterName.EARFCNDL: earfcn, ParameterName.EARFCNUL: earfcn, ParameterName.POWER_SPECTRAL_DENSITY: psd, } for param, value in params_to_set.items(): config.set_parameter(param, value)
def process_inform_message( inform: Any, data_model: DataModel, device_cfg: EnodebConfiguration, ) -> None: """ Modifies the device configuration based on what is received in the Inform message. Will raise an error if it turns out that the data model we are using is incorrect. This is decided based on the device OUI and software-version that is reported in the Inform message. Args: inform: Inform Tr069 message device_handler: The state machine we are using for our device """ param_values_by_path = _get_param_values_by_path(inform) param_name_list = data_model.get_parameter_names() name_to_val = {} for name in param_name_list: path = data_model.get_parameter(name).path if path in param_values_by_path: value = param_values_by_path[path] name_to_val[name] = value for name, val in name_to_val.items(): device_cfg.set_parameter(name, val) # In case the SerialNumber does not come in the inform ParameterList # it can still be present in the Inform structure, fill it in. if (hasattr(inform, 'DeviceId') and hasattr(inform.DeviceId, 'SerialNumber')): device_cfg.set_parameter(ParameterName.SERIAL_NUMBER, inform.DeviceId.SerialNumber)
def postprocess(self, mconfig: Any, service_cfg: Any, desired_cfg: EnodebConfiguration) -> None: """ Add some params to the desired config Args: mconfig (Any): mconfig service_cfg (Any): service config desired_cfg (EnodebConfiguration): desired config """ desired_cfg.set_parameter(ParameterName.SAS_ENABLED, 1) desired_cfg.set_parameter_for_object( ParameterName.PLMN_N_CELL_RESERVED % 1, True, # noqa: WPS345,WPS425 ParameterName.PLMN_N % 1, # noqa: WPS345 ) parameters_to_delete = [ ParameterName.RADIO_ENABLE, ParameterName.POWER_SPECTRAL_DENSITY, ParameterName.EARFCNDL, ParameterName.EARFCNUL, ParameterName.BAND, ParameterName.DL_BANDWIDTH, ParameterName.UL_BANDWIDTH, ParameterName.SAS_RADIO_ENABLE, ] for p in parameters_to_delete: if desired_cfg.has_parameter(p): desired_cfg.delete_parameter(p)
def _set_param_if_present( cfg: EnodebConfiguration, data_model: DataModel, param: ParameterName, value: Any, ) -> None: if data_model.is_parameter_present(param): cfg.set_parameter(param, value)
def _set_management_server(cfg: EnodebConfiguration) -> None: """ Set the following parameters: - Periodic inform enable - Periodic inform interval (hard-coded) """ cfg.set_parameter(ParameterName.PERIODIC_INFORM_ENABLE, True) # In seconds cfg.set_parameter(ParameterName.PERIODIC_INFORM_INTERVAL, 5)
def build_desired_config( mconfig: Any, service_config: Any, device_config: EnodebConfiguration, data_model: DataModel, post_processor: EnodebConfigurationPostProcessor, ) -> EnodebConfiguration: """ Factory for initializing DESIRED data model configuration. When working with the configuration of an eNodeB, we track the current state of configuration for that device, as well as what configuration we want to set on the device. Args: mconfig: Managed configuration, eNodeB protobuf message service_config: Returns: Desired data model configuration for the device """ cfg_desired = EnodebConfiguration(data_model) # Determine configuration parameters _set_management_server(cfg_desired) # Attempt to load device configuration from YANG before service mconfig enb_config = _get_enb_yang_config(device_config) or \ _get_enb_config(mconfig, device_config) _set_earfcn_freq_band_mode(device_config, cfg_desired, data_model, enb_config.earfcndl) if enb_config.subframe_assignment is not None: _set_tdd_subframe_config(device_config, cfg_desired, enb_config.subframe_assignment, enb_config.special_subframe_pattern) _set_pci(cfg_desired, enb_config.pci) _set_plmnids_tac(cfg_desired, enb_config.plmnid_list, enb_config.tac) _set_bandwidth(cfg_desired, data_model, enb_config.bandwidth_mhz) _set_cell_id(cfg_desired, enb_config.cell_id) _set_perf_mgmt( cfg_desired, get_ip_from_if(service_config['tr069']['interface']), service_config['tr069']['perf_mgmt_port']) _set_misc_static_params(device_config, cfg_desired, data_model) if enb_config.mme_address is not None and enb_config.mme_port is not None: _set_s1_connection(cfg_desired, enb_config.mme_address, enb_config.mme_port) else: _set_s1_connection( cfg_desired, get_ip_from_if(service_config['s1_interface'])) # Enable LTE if we should cfg_desired.set_parameter(ParameterName.ADMIN_STATE, enb_config.allow_enodeb_transmit) post_processor.postprocess(cfg_desired) return cfg_desired
def build_desired_config( mconfig: Any, service_config: Any, device_config: EnodebConfiguration, data_model: DataModel, post_processor: EnodebConfigurationPostProcessor, ) -> EnodebConfiguration: """ Factory for initializing DESIRED data model configuration. When working with the configuration of an eNodeB, we track the current state of configuration for that device, as well as what configuration we want to set on the device. Args: mconfig: Managed configuration, eNodeB protobuf message service_config: Returns: Desired data model configuration for the device """ cfg_desired = EnodebConfiguration(data_model) # Determine configuration parameters _set_management_server(cfg_desired) if mconfig.tdd_config is not None and str(mconfig.tdd_config) != '': _set_earfcn_freq_band_mode(device_config, cfg_desired, data_model, mconfig.tdd_config.earfcndl) _set_tdd_subframe_config(device_config, cfg_desired, mconfig.tdd_config.subframe_assignment, mconfig.tdd_config.special_subframe_pattern) elif mconfig.fdd_config is not None and str(mconfig.fdd_config) != '': _set_earfcn_freq_band_mode(device_config, cfg_desired, data_model, mconfig.fdd_config.earfcndl) else: # back-compat: use legacy fields if tdd/fdd aren't set _set_earfcn_freq_band_mode(device_config, cfg_desired, data_model, mconfig.earfcndl) _set_tdd_subframe_config(device_config, cfg_desired, mconfig.subframe_assignment, mconfig.special_subframe_pattern) _set_pci(cfg_desired, mconfig.pci) _set_plmnids_tac(cfg_desired, mconfig.plmnid_list, mconfig.tac) _set_bandwidth(cfg_desired, data_model, mconfig.bandwidth_mhz) _set_s1_connection(cfg_desired, get_ip_from_if(service_config['s1_interface'])) _set_perf_mgmt(cfg_desired, get_ip_from_if(service_config['tr069']['interface']), service_config['tr069']['perf_mgmt_port']) _set_misc_static_params(device_config, cfg_desired, data_model) # Enable LTE if we should cfg_desired.set_parameter(ParameterName.ADMIN_STATE, mconfig.allow_enodeb_transmit) post_processor.postprocess(cfg_desired) return cfg_desired
def _set_pci( cfg: EnodebConfiguration, pci: Any, ) -> None: """ Set the following parameters: - PCI """ if pci not in range(0, 504 + 1): raise ConfigurationError('Invalid PCI (%d)' % pci) cfg.set_parameter(ParameterName.PCI, pci)
def _set_plmnids_tac( cfg: EnodebConfiguration, plmnids: Union[int, str], tac: Any, ) -> None: """ Set the following parameters: - PLMNID list (including all child parameters) Input 'plmnids' is comma-separated list of PLMNIDs """ # Convert int PLMNID to string if type(plmnids) == int: plmnid_str = str(plmnids) else: config_assert(type(plmnids) == str, 'PLMNID must be string') plmnid_str = plmnids # Multiple PLMNIDs will be supported using comma-separated list. # Currently, just one supported for char in plmnid_str: config_assert(char in '0123456789, ', 'Unhandled character (%s) in PLMNID' % char) plmnid_list = plmnid_str.split(',') # TODO - add support for multiple PLMNIDs config_assert(len(plmnid_list) == 1, 'Exactly one PLMNID must be configured') # Validate PLMNIDs plmnid_list[0] = plmnid_list[0].strip() config_assert(len(plmnid_list[0]) <= 6, 'PLMNID must be length <=6 (%s)' % plmnid_list[0]) # We just need one PLMN element in the config. Delete all others. for i in range(1, 2):#data_model.get_num_plmns() + 1): object_name = ParameterName.PLMN_N % i enable_plmn = i == 1 cfg.add_object(object_name) cfg.set_parameter_for_object(ParameterName.PLMN_N_ENABLE % i, enable_plmn, object_name) if enable_plmn: cfg.set_parameter_for_object( ParameterName.PLMN_N_CELL_RESERVED % i, False, object_name) cfg.set_parameter_for_object(ParameterName.PLMN_N_PRIMARY % i, enable_plmn, object_name) cfg.set_parameter_for_object(ParameterName.PLMN_N_PLMNID % i, plmnid_list[i - 1], object_name) cfg.set_parameter(ParameterName.TAC, tac)
def _set_bandwidth( cfg: EnodebConfiguration, data_model: DataModel, bandwidth_mhz: Any, ) -> None: """ Set the following parameters: - DL bandwidth - UL bandwidth """ cfg.set_parameter(ParameterName.DL_BANDWIDTH, bandwidth_mhz) _set_param_if_present(cfg, data_model, ParameterName.UL_BANDWIDTH, bandwidth_mhz)
def _set_s1_connection( cfg: EnodebConfiguration, mme_ip: Any, mme_port: Any = DEFAULT_S1_PORT, ) -> None: """ Set the following parameters: - MME IP - MME port (defalts to 36412 as per TR-196 recommendation) """ config_assert(type(mme_ip) == str, 'Invalid MME IP type') config_assert(type(mme_port) == int, 'Invalid MME Port type') cfg.set_parameter(ParameterName.MME_IP, mme_ip) cfg.set_parameter(ParameterName.MME_PORT, mme_port)
def postprocess(self, mconfig: Any, service_cfg: Any, desired_cfg: EnodebConfiguration) -> None: """ Add some params to the desired config Args: mconfig (Any): mconfig service_cfg (Any): service config desired_cfg (EnodebConfiguration): desired config """ desired_cfg.set_parameter(ParameterName.SAS_ENABLED, 1) # Set Cell reservation for both cells desired_cfg.set_parameter_for_object( ParameterName.PLMN_N_CELL_RESERVED % 1, True, # noqa: WPS345,WPS425 ParameterName.PLMN_N % 1, # noqa: WPS345 ) desired_cfg.set_parameter( CarrierAggregationParameters.CA_PLMN_CELL_RESERVED, True, ) # Make sure FAPService.1. is Primary desired_cfg.set_parameter_for_object( ParameterName.PLMN_N_PRIMARY % 1, True, # noqa: WPS345,WPS425 ParameterName.PLMN_N % 1, # noqa: WPS345 ) desired_cfg.set_parameter( CarrierAggregationParameters.CA_PLMN_PRIMARY, False, ) # Enable both cells desired_cfg.set_parameter_for_object( ParameterName.PLMN_N_ENABLE % 1, True, # noqa: WPS345,WPS425 ParameterName.PLMN_N % 1, # noqa: WPS345 ) desired_cfg.set_parameter( CarrierAggregationParameters.CA_PLMN_ENABLE, True, ) parameters_to_delete = [ ParameterName.RADIO_ENABLE, ParameterName.POWER_SPECTRAL_DENSITY, ParameterName.EARFCNDL, ParameterName.EARFCNUL, ParameterName.BAND, ParameterName.DL_BANDWIDTH, ParameterName.UL_BANDWIDTH, ParameterName.SAS_RADIO_ENABLE, ] for p in parameters_to_delete: if desired_cfg.has_parameter(p): desired_cfg.delete_parameter(p)
def postprocess( self, mconfig: Any, service_cfg: Any, desired_cfg: EnodebConfiguration, ) -> None: # TODO: Get this config from the domain proxy # TODO @amarpad, set these when DProxy integration is done. # For now the radio will directly talk to the SAS and get these # attributes. desired_cfg.delete_parameter(ParameterName.EARFCNDL) desired_cfg.delete_parameter(ParameterName.DL_BANDWIDTH) desired_cfg.delete_parameter(ParameterName.UL_BANDWIDTH) # go through misc parameters and set them to default. for name, val in FreedomFiOneMiscParameters.defaults.items(): desired_cfg.set_parameter(name, val) # Bump up the parameter key version self.acs.parameter_version_inc() # Workaround a bug in Sercomm firmware in release 3920, 3921 # where the meaning of CellReservedForOperatorUse is wrong. # Set to True to ensure the PLMN is not reserved num_plmns = self.acs.data_model.get_num_plmns() for i in range(1, num_plmns + 1): object_name = ParameterName.PLMN_N % i desired_cfg.set_parameter_for_object( param_name=ParameterName.PLMN_N_CELL_RESERVED % i, value=True, object_name=object_name, ) if self.WEB_UI_ENABLE_LIST_KEY in service_cfg: serial_nos = service_cfg.get(self.WEB_UI_ENABLE_LIST_KEY) if self.acs.device_cfg.has_parameter( ParameterName.SERIAL_NUMBER, ): if self.acs.get_parameter(ParameterName.SERIAL_NUMBER) in \ serial_nos: desired_cfg.set_parameter( FreedomFiOneMiscParameters.WEB_UI_ENABLE, True, ) else: # This should not happen EnodebdLogger.error("Serial number unknown for device") if self.SAS_KEY not in service_cfg: return sas_cfg = service_cfg[self.SAS_KEY] sas_param_names = self.acs.data_model.get_sas_param_names() for name, val in sas_cfg.items(): if name not in sas_param_names: EnodebdLogger.warning("Ignoring attribute %s", name) continue desired_cfg.set_parameter(name, val)
def postprocess( self, mconfig: Any, service_cfg: Any, desired_cfg: EnodebConfiguration, ) -> None: # TODO: Get this config from the domain proxy # TODO @amarpad, set these when DProxy integration is done. # For now the radio will directly talk to the SAS and get these # attributes. desired_cfg.delete_parameter(ParameterName.EARFCNDL) desired_cfg.delete_parameter(ParameterName.DL_BANDWIDTH) desired_cfg.delete_parameter(ParameterName.UL_BANDWIDTH) # go through misc parameters and set them to default. for name, val in FreedomFiOneMiscParameters.defaults.items(): desired_cfg.set_parameter(name, val) # Bump up the parameter key version self.acs.parameter_version_inc() if self.WEB_UI_ENABLE_LIST_KEY in service_cfg: serial_nos = service_cfg.get(self.WEB_UI_ENABLE_LIST_KEY) if self.acs.device_cfg.has_parameter( ParameterName.SERIAL_NUMBER, ): if self.acs.get_parameter(ParameterName.SERIAL_NUMBER) in \ serial_nos: desired_cfg.set_parameter( FreedomFiOneMiscParameters.WEB_UI_ENABLE, True, ) else: # This should not happen EnodebdLogger.error("Serial number unknown for device") if self.SAS_KEY not in service_cfg: return sas_cfg = service_cfg[self.SAS_KEY] sas_param_names = self.acs.data_model.get_sas_param_names() for name, val in sas_cfg.items(): if name not in sas_param_names: EnodebdLogger.warning("Ignoring attribute %s", name) continue desired_cfg.set_parameter(name, val)
def _set_perf_mgmt( cfg: EnodebConfiguration, perf_mgmt_ip: str, perf_mgmt_port: int, ) -> None: """ Set the following parameters: - Perf mgmt enable - Perf mgmt upload interval - Perf mgmt upload URL """ cfg.set_parameter(ParameterName.PERF_MGMT_ENABLE, True) # Upload interval supported values (in secs): # [60, 300, 900, 1800, 3600] # Note: eNodeB crashes have been experienced with 60-sec interval. # Hence using 300sec cfg.set_parameter(ParameterName.PERF_MGMT_UPLOAD_INTERVAL, 300) cfg.set_parameter(ParameterName.PERF_MGMT_UPLOAD_URL, 'http://%s:%d/' % (perf_mgmt_ip, perf_mgmt_port))
def postprocess(self, desired_cfg: EnodebConfiguration) -> None: desired_cfg.set_parameter(ParameterName.CELL_BARRED, False)
def postprocess(self, desired_cfg: EnodebConfiguration) -> None: desired_cfg.set_parameter(ParameterName.CELL_BARRED, True) desired_cfg.set_parameter(ParameterName.ADMIN_STATE, True)
class EnodebConfigurationFactoryTest(TestCase): def setUp(self): self.data_model = BaicellsTrDataModel() self.cfg = EnodebConfiguration(BaicellsTrDataModel()) self.device_cfg = EnodebConfiguration(BaicellsTrDataModel()) def tearDown(self): self.data_model = None self.cfg = None self.device_cfg = None def test_set_pci(self): pci = 3 _set_pci(self.cfg, pci) self.assertEqual(self.cfg.get_parameter(ParameterName.PCI), pci, 'PCI value should be same as what was set') with self.assertRaises(ConfigurationError): _set_pci(self.cfg, 505) def test_set_bandwidth(self): mhz = 15 _set_bandwidth(self.cfg, self.data_model, mhz) self.assertEqual(self.cfg.get_parameter(ParameterName.DL_BANDWIDTH), mhz, 'Should have set %s' % ParameterName.DL_BANDWIDTH) self.assertEqual(self.cfg.get_parameter(ParameterName.UL_BANDWIDTH), mhz, 'Should have set %s' % ParameterName.UL_BANDWIDTH) def test_set_tdd_subframe_config(self): # Not TDD mode, should not try to set anything self.device_cfg.set_parameter(ParameterName.DUPLEX_MODE_CAPABILITY, 'Not TDDMode') subframe = 0 special_subframe = 0 _set_tdd_subframe_config(self.device_cfg, self.cfg, subframe, special_subframe) self.assertTrue(ParameterName.SUBFRAME_ASSIGNMENT not in self.cfg.get_parameter_names()) # Invalid subframe assignment self.device_cfg.set_parameter(ParameterName.DUPLEX_MODE_CAPABILITY, 'TDDMode') _set_tdd_subframe_config(self.device_cfg, self.cfg, subframe, special_subframe) self.assertIn(ParameterName.SUBFRAME_ASSIGNMENT, self.cfg.get_parameter_names(), 'Expected a subframe assignment') def test_set_management_server(self): _set_management_server(self.cfg) self.assertEqual( self.cfg.get_parameter(ParameterName.PERIODIC_INFORM_ENABLE), True, 'Expected periodic inform enable to be true') self.assertTrue( isinstance( self.cfg.get_parameter(ParameterName.PERIODIC_INFORM_INTERVAL), int), 'Expected periodic inform interval to ani integer') def test_set_s1_connection(self): invalid_mme_ip = 1234 invalid_mme_port = '8080' mme_ip = '192.168.0.1' mme_port = 8080 # MME IP should be a string with self.assertRaises(ConfigurationError): _set_s1_connection(self.cfg, invalid_mme_ip, mme_port) # MME Port should be an integer with self.assertRaises(ConfigurationError): _set_s1_connection(self.cfg, mme_ip, invalid_mme_port) # Check the ip and port are sort properly _set_s1_connection(self.cfg, mme_ip, mme_port) self.assertEqual(self.cfg.get_parameter(ParameterName.MME_IP), mme_ip, 'Expected mme ip to be set') self.assertEqual(self.cfg.get_parameter(ParameterName.MME_PORT), mme_port, 'Expected mme port to be set') def test_set_perf_mgmt(self): mgmt_ip = '192.168.0.1' mgmt_upload_interval = 300 mgmt_port = 8080 _set_perf_mgmt(self.cfg, mgmt_ip, mgmt_port) self.assertTrue(self.cfg.get_parameter(ParameterName.PERF_MGMT_ENABLE), 'Expected perf mgmt to be enabled') self.assertEqual( self.cfg.get_parameter(ParameterName.PERF_MGMT_UPLOAD_INTERVAL), mgmt_upload_interval, 'Expected upload interval to be set') expected_url = 'http://192.168.0.1:8080/' self.assertEqual( self.cfg.get_parameter(ParameterName.PERF_MGMT_UPLOAD_URL), expected_url, 'Incorrect Url') def test_set_misc_static_params(self): # IPSec enable as integer self.device_cfg.set_parameter(ParameterName.IP_SEC_ENABLE, 0) self.data_model.set_parameter_presence(ParameterName.GPS_ENABLE, True) _set_misc_static_params(self.device_cfg, self.cfg, self.data_model) self.assertTrue( isinstance(self.cfg.get_parameter(ParameterName.IP_SEC_ENABLE), int), 'Should support an integer IP_SEC_ENABLE parameter') # IPSec enable as boolean self.device_cfg.set_parameter(ParameterName.IP_SEC_ENABLE, 'False') _set_misc_static_params(self.device_cfg, self.cfg, self.data_model) self.assertTrue( isinstance(self.cfg.get_parameter(ParameterName.IP_SEC_ENABLE), bool), 'Should support a boolean IP_SEC_ENABLE parameter') self.assertEqual( self.cfg.get_parameter(ParameterName.LOCAL_GATEWAY_ENABLE), 0, 'Should be disabled') self.assertEqual(self.cfg.get_parameter(ParameterName.CELL_RESERVED), False, 'Should be disabled') self.assertEqual(self.cfg.get_parameter(ParameterName.MME_POOL_ENABLE), False, 'Should be disabled') def test_set_plmnids_tac(self): # We only handle a single PLMNID for now plmnids = '1, 2, 3, 4' tac = 1 with self.assertRaises(ConfigurationError): _set_plmnids_tac(self.cfg, plmnids, tac) # Max PLMNID length is 6 characters plmnids = '1234567' with self.assertRaises(ConfigurationError): _set_plmnids_tac(self.cfg, plmnids, tac) # Check that only one PLMN element is enabled plmnids = '1' _set_plmnids_tac(self.cfg, plmnids, tac) self.assertTrue( self.cfg.get_parameter_for_object(ParameterName.PLMN_N_ENABLE % 1, ParameterName.PLMN_N % 1), 'First PLMN should be enabled') self.assertFalse(self.cfg.has_object(ParameterName.PLMN_N % 2), 'Second PLMN should be disabled') def test_set_earafcn_freq_band_mode(self): # Invalid earfcndl with self.assertRaises(ConfigurationError): invalid_earfcndl = -1 _set_earfcn_freq_band_mode(self.device_cfg, self.cfg, self.data_model, invalid_earfcndl) # Duplex_mode is TDD but capability is FDD with self.assertRaises(ConfigurationError): self.device_cfg.set_parameter(ParameterName.DUPLEX_MODE_CAPABILITY, 'FDDMode') earfcndl = 38650 # Corresponds to TDD _set_earfcn_freq_band_mode(self.device_cfg, self.cfg, self.data_model, earfcndl) # Duplex_mode is FDD but capability is TDD with self.assertRaises(ConfigurationError): self.device_cfg.set_parameter(ParameterName.DUPLEX_MODE_CAPABILITY, 'TDDMode') earfcndl = 0 # Corresponds to FDD _set_earfcn_freq_band_mode(self.device_cfg, self.cfg, self.data_model, earfcndl) def test_get_enb_config(self): mconfig = EnodebConfigBuilder.get_mconfig() enb_config = _get_enb_config(mconfig, self.device_cfg) self.assertTrue(enb_config.earfcndl == 39150, "Should give earfcndl from default eNB config") mconfig = EnodebConfigBuilder.get_multi_enb_mconfig() self.device_cfg.set_parameter(ParameterName.SERIAL_NUMBER, '120200002618AGP0003') enb_config = _get_enb_config(mconfig, self.device_cfg) self.assertTrue(enb_config.earfcndl == 39151, "Should give earfcndl from specific eNB config")
class EnodebConfigurationTest(TestCase): def setUp(self): self.config = EnodebConfiguration(CaviumTrDataModel) def tearDown(self): self.config = None def test_data_model(self) -> None: data_model = self.config.data_model expected = CaviumTrDataModel self.assertEqual(data_model, expected, 'Data model fetch incorrect') def test_get_has_set_parameter(self) -> None: param = ParameterName.ADMIN_STATE self.config.set_parameter(param, True) self.assertTrue(self.config.has_parameter(param), 'Expected to have parameter') param_value = self.config.get_parameter(param) expected = True self.assertEqual(param_value, expected, 'Parameter value does not match what was set') def test_add_has_delete_object(self) -> None: object_name = ParameterName.PLMN_N % 1 self.assertFalse(self.config.has_object(object_name)) self.config.add_object(object_name) self.assertTrue(self.config.has_object(object_name)) self.config.delete_object(object_name) self.assertFalse(self.config.has_object(object_name)) def test_get_parameter_names(self) -> None: # Should start off as an empty list names_list = self.config.get_parameter_names() self.assertEqual(len(names_list), 0, 'Expected 0 names') # Should grow as we set parameters self.config.set_parameter(ParameterName.ADMIN_STATE, True) names_list = self.config.get_parameter_names() self.assertEqual(len(names_list), 1, 'Expected 1 name') # Parameter names should not include objects self.config.add_object(ParameterName.PLMN) names_list = self.config.get_parameter_names() self.assertEqual(len(names_list), 1, 'Expected 1 name') def test_get_object_names(self) -> None: # Should start off as an empty list obj_list = self.config.get_object_names() self.assertEqual(len(obj_list), 0, 'Expected 0 names') # Should grow as we set parameters self.config.add_object(ParameterName.PLMN) obj_list = self.config.get_object_names() self.assertEqual(len(obj_list), 1, 'Expected 1 names') def test_get_set_parameter_for_object(self) -> None: self.config.add_object(ParameterName.PLMN_N % 1) self.config.set_parameter_for_object( ParameterName.PLMN_N_CELL_RESERVED % 1, True, ParameterName.PLMN_N % 1) param_value = self.config.get_parameter_for_object( ParameterName.PLMN_N_CELL_RESERVED % 1, ParameterName.PLMN_N % 1) self.assertTrue( param_value, 'Expected that the param for object was set correctly') def test_get_parameter_names_for_object(self) -> None: # Should start off empty self.config.add_object(ParameterName.PLMN_N % 1) param_list = self.config.get_parameter_names_for_object( ParameterName.PLMN_N % 1) self.assertEqual(len(param_list), 0, 'Should be an empty param list') # Should increment as we set parameters self.config.set_parameter_for_object( ParameterName.PLMN_N_CELL_RESERVED % 1, True, ParameterName.PLMN_N % 1) param_list = self.config.get_parameter_names_for_object( ParameterName.PLMN_N % 1) self.assertEqual(len(param_list), 1, 'Should not be an empty list')
def process_inform_message( inform: Any, device_name: EnodebDeviceName, data_model: DataModel, device_cfg: EnodebConfiguration, ) -> None: """ Modifies the device configuration based on what is received in the Inform message. Will raise an error if it turns out that the data model we are using is incorrect. This is decided based on the device OUI and software-version that is reported in the Inform message. Args: inform: Inform Tr069 message device_handler: The state machine we are using for our device """ logging.info('Processing Inform message') def _get_param_value_from_path_suffix( suffix: str, path_list: List[str], param_values_by_path: Dict[str, Any], ) -> Any: for path in path_list: if path.endswith(suffix): return param_values_by_path[path] raise ConfigurationError('Did not receive expected info in Inform') if hasattr(inform, 'ParameterList') and \ hasattr(inform.ParameterList, 'ParameterValueStruct'): param_values_by_path = {} for param_value in inform.ParameterList.ParameterValueStruct: path = param_value.Name value = param_value.Value.Data logging.debug('(Inform msg) Received parameter: %s = %s', path, value) param_values_by_path[path] = value # Check the OUI and version number to see if the data model matches path_list = list(param_values_by_path.keys()) device_oui = _get_param_value_from_path_suffix( 'DeviceInfo.ManufacturerOUI', path_list, param_values_by_path, ) sw_version = _get_param_value_from_path_suffix( 'DeviceInfo.SoftwareVersion', path_list, param_values_by_path, ) logging.info('OUI: %s, Software: %s', device_oui, sw_version) correct_device_name = get_device_name(device_oui, sw_version) if device_name is not correct_device_name: raise IncorrectDeviceHandlerError( device_name=correct_device_name) param_name_list = data_model.get_parameter_names() name_to_val = {} for name in param_name_list: path = data_model.get_parameter(name).path if path in param_values_by_path: value = param_values_by_path[path] name_to_val[name] = value for name, val in name_to_val.items(): device_cfg.set_parameter(name, val)
def qrtb_update_desired_config_from_cbsd_state(state: CBSDStateResult, config: EnodebConfiguration) -> None: """ Call grpc endpoint on the Domain Proxy to update the desired config based on sas grant Args: state (CBSDStateResult): state result as received from DP config (EnodebConfiguration): configuration to update """ logger.debug("Updating desired config based on Domain Proxy state.") num_of_channels = len(state.channels) radio_enabled = num_of_channels > 0 and state.radio_enabled config.set_parameter(ParameterName.SAS_RADIO_ENABLE, radio_enabled) if not radio_enabled: return # FAPService.1 channel = state.channels[0] earfcn = calc_earfcn(channel.low_frequency_hz, channel.high_frequency_hz) bandwidth_mhz = calc_bandwidth_mhz(channel.low_frequency_hz, channel.high_frequency_hz) bandwidth_rbs = calc_bandwidth_rbs(bandwidth_mhz) psd = _calc_psd(channel.max_eirp_dbm_mhz) logger.debug(f"Channel1: {earfcn=}, {bandwidth_rbs=}, {psd=}") can_enable_carrier_aggregation = _qrtb_check_state_compatibility_with_ca(state) logger.debug(f"Should Carrier Aggregation be enabled on eNB: {can_enable_carrier_aggregation=}") # Enabling Carrier Aggregation on QRTB eNB means: # 1. Set CA_ENABLE to 1 # 2. Set CA_NUM_OF_CELLS to 2 # 3. Configure appropriate TR nodes for FAPSerivce.2 like EARFCNDL/UL etc # Otherwise we need to disable Carrier Aggregation on eNB and switch to Single Carrier configuration # 1. Set CA_ENABLE to 0 # 2. Set CA_NUM_OF_CELLS to 1 # Those two nodes should handle everything else accordingly. # (NOTE: carrier aggregation may still be enabled on Domain Proxy, but Domain Proxy may not have 2 channels granted by SAS. # In such case, we still have to switch eNB to Single Carrier) num_of_cells = 2 if can_enable_carrier_aggregation else 1 ca_enable = 1 if can_enable_carrier_aggregation else 0 params_to_set = { ParameterName.SAS_RADIO_ENABLE: True, ParameterName.BAND: BAND, ParameterName.DL_BANDWIDTH: bandwidth_rbs, ParameterName.UL_BANDWIDTH: bandwidth_rbs, ParameterName.EARFCNDL: earfcn, ParameterName.EARFCNUL: earfcn, ParameterName.POWER_SPECTRAL_DENSITY: psd, CarrierAggregationParameters.CA_ENABLE: ca_enable, CarrierAggregationParameters.CA_NUM_OF_CELLS: num_of_cells, } if can_enable_carrier_aggregation: # Configure FAPService.2 # NOTE: We set PCI and CELL_ID to the values of FAP1 "+1" # This was suggested by BaiCells channel = state.channels[1] earfcn = calc_earfcn(channel.low_frequency_hz, channel.high_frequency_hz) bandwidth_mhz = calc_bandwidth_mhz(channel.low_frequency_hz, channel.high_frequency_hz) bandwidth_rbs = calc_bandwidth_rbs(bandwidth_mhz) psd = _calc_psd(channel.max_eirp_dbm_mhz) logger.debug(f"Channel2: {earfcn=}, {bandwidth_rbs=}, {psd=}") params_to_set.update({ CarrierAggregationParameters.CA_DL_BANDWIDTH: bandwidth_rbs, CarrierAggregationParameters.CA_UL_BANDWIDTH: bandwidth_rbs, CarrierAggregationParameters.CA_BAND: BAND, CarrierAggregationParameters.CA_EARFCNDL: earfcn, CarrierAggregationParameters.CA_EARFCNUL: earfcn, CarrierAggregationParameters.CA_PCI: config.get_parameter(ParameterName.PCI) + 1, CarrierAggregationParameters.CA_CELL_ID: config.get_parameter(ParameterName.CELL_ID) + 1, CarrierAggregationParameters.CA_RADIO_ENABLE: True, }) for param, value in params_to_set.items(): config.set_parameter(param, value)
def set_magma_device_cfg( cls, name_to_val: Dict, device_cfg: EnodebConfiguration, ): """ Convert FreedomFiOne name_to_val representation to magma device_cfg """ success_str = "SUCCESS" # String constant returned by radio insync_str = "INSYNC" if (name_to_val.get(cls.DEFAULT_GW) and name_to_val[cls.DEFAULT_GW].upper() != success_str): # Nothing will proceed if the eNB doesn't have an IP on the WAN serial_num = "unknown" if device_cfg.has_parameter(ParameterName.SERIAL_NUMBER): serial_num = device_cfg.get_parameter( ParameterName.SERIAL_NUMBER, ) EnodebdLogger.error( "Radio with serial number %s doesn't have IP address " "on WAN", serial_num, ) device_cfg.set_parameter( param_name=ParameterName.RF_TX_STATUS, value=False, ) device_cfg.set_parameter( param_name=ParameterName.GPS_STATUS, value=False, ) device_cfg.set_parameter( param_name=ParameterName.PTP_STATUS, value=False, ) device_cfg.set_parameter( param_name=ParameterName.MME_STATUS, value=False, ) device_cfg.set_parameter( param_name=ParameterName.OP_STATE, value=False, ) return if (name_to_val.get(cls.SAS_STATUS) and name_to_val[cls.SAS_STATUS].upper() == success_str): device_cfg.set_parameter( param_name=ParameterName.RF_TX_STATUS, value=True, ) else: # No sas grant so not transmitting. There is no explicit node for Tx # in FreedomFiOne device_cfg.set_parameter( param_name=ParameterName.RF_TX_STATUS, value=False, ) if (name_to_val.get(cls.GPS_SCAN_STATUS) and name_to_val[cls.GPS_SCAN_STATUS].upper() == success_str): device_cfg.set_parameter( param_name=ParameterName.GPS_STATUS, value=True, ) # Time comes through GPS so can only be insync with GPS is # in sync, we use PTP_STATUS field to overload timer is in Sync. if (name_to_val.get(cls.SYNC_STATUS) and name_to_val[cls.SYNC_STATUS].upper() == insync_str): device_cfg.set_parameter( param_name=ParameterName.PTP_STATUS, value=True, ) else: device_cfg.set_parameter( param_name=ParameterName.PTP_STATUS, value=False, ) else: device_cfg.set_parameter( param_name=ParameterName.GPS_STATUS, value=False, ) device_cfg.set_parameter( param_name=ParameterName.PTP_STATUS, value=False, ) if (name_to_val.get(cls.DEFAULT_GW) and name_to_val[cls.DEFAULT_GW].upper() == success_str): device_cfg.set_parameter( param_name=ParameterName.MME_STATUS, value=True, ) else: device_cfg.set_parameter( param_name=ParameterName.MME_STATUS, value=False, ) if (name_to_val.get(cls.ENB_STATUS) and name_to_val[cls.ENB_STATUS].upper() == success_str): device_cfg.set_parameter( param_name=ParameterName.OP_STATE, value=True, ) else: device_cfg.set_parameter( param_name=ParameterName.OP_STATE, value=False, ) pass_through_params = [ParameterName.GPS_LAT, ParameterName.GPS_LONG] for name in pass_through_params: device_cfg.set_parameter(name, name_to_val[name])
class EnodebConfigurationFactoryTest(TestCase): def setUp(self): self.cfg = EnodebConfiguration(BaicellsTrDataModel) self.device_cfg = EnodebConfiguration(BaicellsTrDataModel) def tearDown(self): self.cfg = None self.device_cfg = None def _get_mconfig(self): return { "@type": "type.googleapis.com/magma.mconfig.EnodebD", "bandwidthMhz": 20, "specialSubframePattern": 7, "earfcndl": 44490, "logLevel": "INFO", "plmnidList": "00101", "pci": 260, "allowEnodebTransmit": False, "subframeAssignment": 2, "tac": 1 }, def _get_service_config(self): return { "tr069": { "interface": "eth1", "port": 48080, "perf_mgmt_port": 8081, "public_ip": "192.88.99.142", }, "reboot_enodeb_on_mme_disconnected": True, "s1_interface": "eth1", } def test_set_pci(self): pci = 3 _set_pci(self.cfg, pci) self.assertEqual(self.cfg.get_parameter(ParameterName.PCI), pci, 'PCI value should be same as what was set') with self.assertRaises(ConfigurationError): _set_pci(self.cfg, 505) def test_set_bandwidth(self): mhz = 15 _set_bandwidth(self.cfg, mhz) self.assertEqual(self.cfg.get_parameter(ParameterName.DL_BANDWIDTH), mhz, 'Should have set %s' % ParameterName.DL_BANDWIDTH) self.assertEqual(self.cfg.get_parameter(ParameterName.UL_BANDWIDTH), mhz, 'Should have set %s' % ParameterName.UL_BANDWIDTH) def test_set_tdd_subframe_config(self): # Not TDD mode, should not try to set anything self.device_cfg.set_parameter( ParameterName.DUPLEX_MODE_CAPABILITY, 'Not TDDMode') subframe = 0 special_subframe = 0 _set_tdd_subframe_config(self.device_cfg, self.cfg, subframe, special_subframe) self.assertTrue(ParameterName.SUBFRAME_ASSIGNMENT not in self.cfg.get_parameter_names()) # Invalid subframe assignment self.device_cfg.set_parameter( ParameterName.DUPLEX_MODE_CAPABILITY, 'TDDMode') _set_tdd_subframe_config(self.device_cfg, self.cfg, subframe, special_subframe) self.assertIn(ParameterName.SUBFRAME_ASSIGNMENT, self.cfg.get_parameter_names(), 'Expected a subframe assignment') def test_set_management_server(self): _set_management_server(self.cfg) self.assertEqual( self.cfg.get_parameter(ParameterName.PERIODIC_INFORM_ENABLE), True, 'Expected periodic inform enable to be true') self.assertTrue( isinstance( self.cfg.get_parameter(ParameterName.PERIODIC_INFORM_INTERVAL), int), 'Expected periodic inform interval to ani integer' ) def test_set_s1_connection(self): invalid_mme_ip = 1234 invalid_mme_port = '8080' mme_ip = '192.168.0.1' mme_port = 8080 # MME IP should be a string with self.assertRaises(ConfigurationError): _set_s1_connection(self.cfg, invalid_mme_ip, mme_port) # MME Port should be an integer with self.assertRaises(ConfigurationError): _set_s1_connection(self.cfg, mme_ip, invalid_mme_port) # Check the ip and port are sort properly _set_s1_connection(self.cfg, mme_ip, mme_port) self.assertEqual( self.cfg.get_parameter(ParameterName.MME_IP), mme_ip, 'Expected mme ip to be set') self.assertEqual( self.cfg.get_parameter(ParameterName.MME_PORT), mme_port, 'Expected mme port to be set') def test_set_perf_mgmt(self): mgmt_ip = '192.168.0.1' mgmt_upload_interval = 300 mgmt_port = 8080 _set_perf_mgmt(self.cfg, mgmt_ip, mgmt_port) self.assertTrue( self.cfg.get_parameter(ParameterName.PERF_MGMT_ENABLE), 'Expected perf mgmt to be enabled') self.assertEqual( self.cfg.get_parameter(ParameterName.PERF_MGMT_UPLOAD_INTERVAL), mgmt_upload_interval, 'Expected upload interval to be set') expected_url = 'http://192.168.0.1:8080/' self.assertEqual( self.cfg.get_parameter(ParameterName.PERF_MGMT_UPLOAD_URL), expected_url, 'Incorrect Url') def test_set_misc_static_params(self): # IPSec enable as integer data_model = BaicellsTrDataModel self.device_cfg.set_parameter(ParameterName.IP_SEC_ENABLE, 0) _set_misc_static_params(self.device_cfg, self.cfg, data_model) self.assertTrue( isinstance( self.cfg.get_parameter(ParameterName.IP_SEC_ENABLE), int), 'Should support an integer IP_SEC_ENABLE parameter') # IPSec enable as boolean self.device_cfg.set_parameter(ParameterName.IP_SEC_ENABLE, 'False') _set_misc_static_params(self.device_cfg, self.cfg, data_model) self.assertTrue( isinstance( self.cfg.get_parameter(ParameterName.IP_SEC_ENABLE), bool), 'Should support a boolean IP_SEC_ENABLE parameter') self.assertEqual( self.cfg.get_parameter(ParameterName.LOCAL_GATEWAY_ENABLE), 0, 'Should be disabled') self.assertEqual( self.cfg.get_parameter(ParameterName.CELL_RESERVED), False, 'Should be disabled') self.assertEqual( self.cfg.get_parameter(ParameterName.MME_POOL_ENABLE), False, 'Should be disabled') def test_set_plmnids_tac(self): # We only handle a single PLMNID for now data_model = BaicellsTrDataModel plmnids = '1, 2, 3, 4' tac = 1 with self.assertRaises(ConfigurationError): _set_plmnids_tac(self.cfg, data_model, plmnids, tac) # Max PLMNID length is 6 characters plmnids = '1234567' with self.assertRaises(ConfigurationError): _set_plmnids_tac(self.cfg, data_model, plmnids, tac) # Check that only one PLMN element is enabled plmnids = '1' _set_plmnids_tac(self.cfg, data_model, plmnids, tac) self.assertTrue( self.cfg.get_parameter_for_object( ParameterName.PLMN_N_ENABLE % 1, ParameterName.PLMN_N % 1), 'First PLMN should be enabled') self.assertFalse(self.cfg.has_object(ParameterName.PLMN_N % 2), 'Second PLMN should be disabled') def test_set_earafcn_freq_band_mode(self): # Invalid earfcndl with self.assertRaises(ConfigurationError): invalid_earfcndl = -1 _set_earfcn_freq_band_mode(self.device_cfg, self.cfg, invalid_earfcndl) # Duplex_mode is TDD but capability is FDD with self.assertRaises(ConfigurationError): self.device_cfg.set_parameter( ParameterName.DUPLEX_MODE_CAPABILITY, 'FDDMode') earfcndl = 38650 # Corresponds to TDD _set_earfcn_freq_band_mode(self.device_cfg, self.cfg, earfcndl) # Duplex_mode is FDD but capability is TDD with self.assertRaises(ConfigurationError): self.device_cfg.set_parameter( ParameterName.DUPLEX_MODE_CAPABILITY, 'TDDMode') earfcndl = 0 # Corresponds to FDD _set_earfcn_freq_band_mode(self.device_cfg, self.cfg, earfcndl)
def _set_earfcn_freq_band_mode( device_cfg: EnodebConfiguration, cfg: EnodebConfiguration, data_model: DataModel, earfcndl: int, ) -> None: """ Set the following parameters: - EARFCNDL - EARFCNUL - Band """ # Note: validation of EARFCNDL done by mapping function. If invalid # EARFCN, raise ConfigurationError try: band, duplex_mode, earfcnul = map_earfcndl_to_band_earfcnul_mode( earfcndl) except ValueError as err: raise ConfigurationError(err) # Verify capabilities duplex_capability =\ device_cfg.get_parameter(ParameterName.DUPLEX_MODE_CAPABILITY) if duplex_mode == DuplexMode.TDD and duplex_capability != 'TDDMode': raise ConfigurationError( ('eNodeB duplex mode capability is <{0}>, ' 'but earfcndl is <{1}>, giving duplex ' 'mode <{2}> instead').format(duplex_capability, str(earfcndl), str(duplex_mode))) elif duplex_mode == DuplexMode.FDD and duplex_capability != 'FDDMode': raise ConfigurationError( ('eNodeB duplex mode capability is <{0}>, ' 'but earfcndl is <{1}>, giving duplex ' 'mode <{2}> instead').format(duplex_capability, str(earfcndl), str(duplex_mode))) elif duplex_mode not in [DuplexMode.TDD, DuplexMode.FDD]: raise ConfigurationError('Invalid duplex mode (%s)' % str(duplex_mode)) # Baicells indicated that they no longer use the band capability list, # so it may not be populated correctly band_capability_list = device_cfg.get_parameter( ParameterName.BAND_CAPABILITY) band_capabilities = band_capability_list.split(',') if str(band) not in band_capabilities: logging.warning( 'Band %d not in capabilities list (%s). Continuing' ' with config because capabilities list may not be' ' correct', band, band_capabilities) cfg.set_parameter(ParameterName.EARFCNDL, earfcndl) if duplex_mode == DuplexMode.FDD: cfg.set_parameter(ParameterName.EARFCNUL, earfcnul) else: logging.debug('Not setting EARFCNUL - duplex mode is not FDD') _set_param_if_present(cfg, data_model, ParameterName.BAND, band) if duplex_mode == DuplexMode.TDD: logging.debug('Set EARFCNDL=%d, Band=%d', earfcndl, band) else: logging.debug('Set EARFCNDL=%d, EARFCNUL=%d, Band=%d', earfcndl, earfcnul, band)