def get_param_values_to_set(
desired_cfg: EnodebConfiguration,
device_cfg: EnodebConfiguration,
data_model: DataModel,
exclude_admin: bool = False,
) -> Dict[ParameterName, Any]:
"""
Get a map of param names to values for parameters that we will
set on the eNB's configuration, excluding parameters for objects that can
be added/removed.
Also exclude special parameters like admin state, since it may be set at
a different time in the provisioning process than most parameters.
"""
param_values = {}
# Get the parameters we might set
params = set(desired_cfg.get_parameter_names()) - set(READ_ONLY_PARAMETERS)
if exclude_admin:
params = set(params) - {ParameterName.ADMIN_STATE}
# Values of parameters
for name in params:
new = desired_cfg.get_parameter(name)
old = device_cfg.get_parameter(name)
_type = data_model.get_parameter(name).type
if not are_tr069_params_equal(new, old, _type):
param_values[name] = new
return param_values
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 _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_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 parse_get_parameter_values_response(
data_model: DataModel,
message: models.GetParameterValuesResponse,
) -> Dict[ParameterName, Any]:
""" Returns a map of ParameterName to the value read from the response """
param_values_by_path = {}
for param_value_struct in message.ParameterList.ParameterValueStruct:
param_values_by_path[param_value_struct.Name] = \
param_value_struct.Value.Data
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
return name_to_val
def get_params_to_get(
self,
data_model: DataModel,
) -> List[ParameterName]:
names = []
# First get base params
names = get_params_to_get(
self.acs.device_cfg,
self.acs.data_model,
request_all_params=True,
)
# Add object params.
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 += desired
return names
def get_params_to_get(
device_cfg: EnodebConfiguration,
data_model: DataModel,
) -> List[ParameterName]:
"""
Returns the names of params not belonging to objects that are added/removed
"""
desired_names = data_model.get_present_params()
known_names = device_cfg.get_parameter_names()
names = list(set(desired_names) - set(known_names))
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
def get_obj_param_values_to_set(
desired_cfg: EnodebConfiguration,
device_cfg: EnodebConfiguration,
data_model: DataModel,
) -> Dict[ParameterName, Dict[ParameterName, Any]]:
""" Returns a map from object name to (a map of param name to value) """
param_values = {}
objs = desired_cfg.get_object_names()
for obj_name in objs:
param_values[obj_name] = {}
params = desired_cfg.get_parameter_names_for_object(obj_name)
for name in params:
new = desired_cfg.get_parameter_for_object(name, obj_name)
old = device_cfg.get_parameter_for_object(name, obj_name)
_type = data_model.get_parameter(name).type
if not are_tr069_params_equal(new, old, _type):
param_values[obj_name][name] = new
return param_values
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)
