def get_object_params_to_get(
desired_cfg: Optional[EnodebConfiguration],
device_cfg: EnodebConfiguration,
data_model: DataModel,
) -> List[ParameterName]:
"""
Returns a list of parameter names for object parameters we don't know the
current value of
"""
names = []
# TODO: This might a string for some strange reason, investigate why
num_plmns = \
int(device_cfg.get_parameter(ParameterName.NUM_PLMNS))
for i in range(1, num_plmns + 1):
obj_name = ParameterName.PLMN_N % i
if not device_cfg.has_object(obj_name):
device_cfg.add_object(obj_name)
obj_to_params = data_model.get_numbered_param_names()
desired = obj_to_params[obj_name]
current = []
if desired_cfg is not None:
current = desired_cfg.get_parameter_names_for_object(obj_name)
names_to_add = list(set(desired) - set(current))
names = names + names_to_add
return names
def get_object_params_to_get(
desired_cfg: Optional[EnodebConfiguration],
device_cfg: EnodebConfiguration,
data_model: DataModel,
request_all_params: bool = False,
) -> List[ParameterName]:
"""
Returns a list of parameter names for object parameters we don't know the
current value of
If `request_all_params` is set to True, the function will return a list
of all device model param names, including already known ones.
"""
names = []
# TODO: This might a string for some strange reason, investigate why
num_plmns = \
int(device_cfg.get_parameter(ParameterName.NUM_PLMNS))
for i in range(1, num_plmns + 1):
obj_name = ParameterName.PLMN_N % i
if not device_cfg.has_object(obj_name):
device_cfg.add_object(obj_name)
obj_to_params = data_model.get_numbered_param_names()
desired = obj_to_params[obj_name]
if request_all_params:
names += desired
else:
current = []
if desired_cfg is not None:
current = desired_cfg.get_parameter_names_for_object(obj_name)
names_to_add = list(set(desired) - set(current))
names += names_to_add
return names
def _get_object_params_to_get(
device_cfg: EnodebConfiguration,
data_model: DataModel,
) -> List[ParameterName]:
"""
Returns a list of parameter names for object parameters we don't know the
current value of.
Since there is no parameter for tracking the number of PLMNs, then we
make the assumption that if any PLMN object exists, then we've already
fetched the object parameter values.
"""
if device_cfg.has_object(ParameterName.PLMN_N % 1):
return []
names = []
num_plmns = data_model.get_num_plmns()
obj_to_params = data_model.get_numbered_param_names()
for i in range(1, num_plmns + 1):
obj_name = ParameterName.PLMN_N % i
desired = obj_to_params[obj_name]
names = names + desired
return names
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')
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)
