def test_reboot_after_invasive_changes(self) -> None:
"""
Test the scenario where:
- eNodeB has already been powered for 10 minutes without configuration
- Setting parameters which are 'invasive' on the eNodeB
- Simulate the scenario up until reboot, and test that enodebd does
not try to complete configuration after reboot, because it is
waiting for REM process to finish running
- This test does not wait the ten minutes to simulate REM process
finishing on the Baicells eNodeB
'Invasive' parameters are those which require special behavior to apply
the changes for the eNodeB.
In the case of the Baicells eNodeB, properly applying changes to
invasive parameters requires rebooting the device.
"""
acs_state_machine = \
EnodebAcsStateMachineBuilder\
.build_acs_state_machine(EnodebDeviceName.BAICELLS_OLD)
# Send an Inform message, wait for an InformResponse
inform_msg = \
Tr069MessageBuilder.get_inform('48BF74',
'BaiStation_V100R001C00B110SPC002',
'120200002618AGP0003',
['2 PERIODIC'])
resp = acs_state_machine.handle_tr069_message(inform_msg)
self.assertTrue(isinstance(resp, models.InformResponse),
'Should respond with an InformResponse')
# Send an empty http request to kick off the rest of provisioning
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for an optional parameter, five times
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for read-only params
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_read_only_param_values_response()
# Send back some typical values
# And then SM should request regular parameter values
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
# Send back typical values for the regular parameters
req = Tr069MessageBuilder.get_regular_param_values_response()
resp = acs_state_machine.handle_tr069_message(req)
# SM will be requesting object parameter values
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting object param vals')
# Send back some typical values for object parameters
req = Tr069MessageBuilder.get_object_param_values_response()
resp = acs_state_machine.handle_tr069_message(req)
# In this scenario, the ACS and thus state machine will not need
# to delete or add objects to the eNB configuration.
# SM should then just be attempting to set parameter values
self.assertTrue(isinstance(resp, models.SetParameterValues),
'State machine should be setting param values')
# Send back confirmation that the parameters were successfully set
req = models.SetParameterValuesResponse()
req.Status = 0
resp = acs_state_machine.handle_tr069_message(req)
# Since invasive parameters have been set, then to apply the changes
# to the Baicells eNodeB, we need to reboot the device
self.assertTrue(isinstance(resp, models.Reboot))
req = Tr069MessageBuilder.get_reboot_response()
resp = acs_state_machine.handle_tr069_message(req)
# After the reboot has been received, enodebd should end the
# provisioning session
self.assertTrue(isinstance(resp, models.DummyInput),
'After sending command to reboot the Baicells eNodeB, '
'enodeb should end the TR-069 session.')
# At this point, sometime after the eNodeB reboots, we expect it to
# send an Inform indicating reboot. Since it should be in REM process,
# we hold off on finishing configuration, and end TR-069 sessions.
req = \
Tr069MessageBuilder.get_inform('48BF74',
'BaiStation_V100R001C00B110SPC002',
'120200002618AGP0003',
['1 BOOT', 'M Reboot'])
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.DummyInput),
'After receiving a post-reboot Inform, enodebd '
'should end TR-069 sessions for 10 minutes to wait '
'for REM process to finish.')
# Pretend that we have waited, and now we are in normal operation again
acs_state_machine.transition('wait_inform_post_reboot')
req = \
Tr069MessageBuilder.get_inform('48BF74',
'BaiStation_V100R001C00B110SPC002',
'120200002618AGP0003',
['2 PERIODIC'])
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.InformResponse),
'After receiving a post-reboot Inform, enodebd '
'should end TR-069 sessions for 10 minutes to wait '
'for REM process to finish.')
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'enodebd should be requesting params')
self.assertTrue(len(resp.ParameterNames.string) > 1,
'Should be requesting transient params.')
def test_count_plmns_less(self) -> None:
"""
Tests the Cavium provisioning up to GetObjectParameters.
In particular tests when the eNB reports NUM_PLMNS less
than actually listed. The eNB says there are no PLMNs
defined when actually there are two.
Verifies that the number of PLMNs is correctly accounted.
"""
acs_state_machine = \
EnodebAcsStateMachineBuilder \
.build_acs_state_machine(EnodebDeviceName.CAVIUM)
# Send an Inform message
inform_msg = Tr069MessageBuilder.get_inform('000FB7', 'OC-LTE',
'120200002618AGP0003',
['1 BOOT'])
resp = acs_state_machine.handle_tr069_message(inform_msg)
self.assertTrue(isinstance(resp, models.InformResponse),
'Should respond with an InformResponse')
# Send an empty http request to kick off the rest of provisioning
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(
isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values: %s' % resp)
# Transient config response and request for parameter values
req = Tr069MessageBuilder.get_read_only_param_values_response()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(
isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values: %s' % resp)
# Send back typical values for the regular parameters
req = Tr069MessageBuilder.get_cavium_param_values_response(num_plmns=0)
resp = acs_state_machine.handle_tr069_message(req)
# SM will be requesting object parameter values
self.assertTrue(
isinstance(resp, models.GetParameterValues),
'State machine should be requesting object param vals')
# Send back some object parameters with TWO plmns
req = Tr069MessageBuilder.get_cavium_object_param_values_response(
num_plmns=2)
resp = acs_state_machine.handle_tr069_message(req)
# In this scenario, the ACS and thus state machine will not need
# to delete or add objects to the eNB configuration.
# SM should then just be attempting to set parameter values
self.assertTrue(isinstance(resp, models.SetParameterValues),
'State machine should be setting param values')
# Number of PLMNs should reflect object count
num_plmns_cur = \
acs_state_machine \
.device_cfg.get_parameter(ParameterName.NUM_PLMNS)
self.assertEqual(num_plmns_cur, 2)
def test_provision_without_invasive_changes(self) -> None:
"""
Test the scenario where:
- eNodeB has already been powered for 10 minutes without configuration
- Setting parameters which are 'non-invasive' on the eNodeB
'Invasive' parameters are those which require special behavior to apply
the changes for the eNodeB.
"""
acs_state_machine = \
EnodebAcsStateMachineBuilder \
.build_acs_state_machine(EnodebDeviceName.BAICELLS_OLD)
# Send an Inform message, wait for an InformResponse
inform_msg = \
Tr069MessageBuilder.get_inform('48BF74',
'BaiStation_V100R001C00B110SPC001',
'120200002618AGP0003',
['2 PERIODIC'])
resp = acs_state_machine.handle_tr069_message(inform_msg)
self.assertTrue(isinstance(resp, models.InformResponse),
'Should respond with an InformResponse')
# Send an empty http request to kick off the rest of provisioning
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for an optional parameter, five times
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for read-only params
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_read_only_param_values_response()
# Send back some typical values
# And then SM should request regular parameter values
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
# Send back typical values for the regular parameters
req = Tr069MessageBuilder.\
get_regular_param_values_response(admin_state=False,
earfcndl=39150)
resp = acs_state_machine.handle_tr069_message(req)
# SM will be requesting object parameter values
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting object param vals')
# Send back some typical values for object parameters
req = Tr069MessageBuilder.get_object_param_values_response()
resp = acs_state_machine.handle_tr069_message(req)
# In this scenario, the ACS and thus state machine will not need
# to delete or add objects to the eNB configuration.
# SM should then just be attempting to set parameter values
self.assertTrue(isinstance(resp, models.SetParameterValues),
'State machine should be setting param values')
# Send back confirmation that the parameters were successfully set
req = models.SetParameterValuesResponse()
req.Status = 0
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for read-only params
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_read_only_param_values_response()
# Send back some typical values
# And then SM should continue polling the read-only params
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.DummyInput),
'State machine should be ending session')
# If a different eNB is suddenly plugged in, or the same eNB sends a
# new Inform, enodebd should be able to handle it.
# Send an Inform message, wait for an InformResponse
inform_msg = \
Tr069MessageBuilder.get_inform('48BF74',
'BaiStation_V100R001C00B110SPC002',
'120200002618AGP0003',
['2 PERIODIC'])
resp = acs_state_machine.handle_tr069_message(inform_msg)
self.assertTrue(isinstance(resp, models.InformResponse),
'Should respond with an InformResponse')
# Send an empty http request to kick off the rest of provisioning
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for an optional parameter, three times
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
def get_msg(self, message: Any) -> AcsMsgAndTransition:
return AcsMsgAndTransition(models.DummyInput(), None)
def test_provision(self) -> None:
"""
Test the basic provisioning workflow
1 - enodeb sends Inform, enodebd sends InformResponse
2 - enodeb sends empty HTTP message,
3 - enodebd sends get transient params, updates the device state.
4 - enodebd sends get param values, updates the device state
5 - enodebd, sets fields including SAS fields.
"""
logging.root.level = logging.DEBUG
acs_state_machine = self.build_freedomfi_one_acs_state_machine()
inform = Tr069MessageBuilder.get_inform(
oui="000E8F",
sw_version="TEST3920@210901",
enb_serial="2006CW5000023",
)
resp = acs_state_machine.handle_tr069_message(inform)
self.assertTrue(
isinstance(resp, models.InformResponse),
'Should respond with an InformResponse',
)
# Send an empty http request
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for read-only params
self.assertTrue(
isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values',
)
for tr_69_nodes in StatusParameters.STATUS_PARAMETERS.values():
self.assertIn(tr_69_nodes.path, resp.ParameterNames.string)
req = self._get_freedomfi_one_read_only_param_values_response()
get_resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(
isinstance(get_resp, models.GetParameterValues),
'State machine should be requesting param values',
)
req = self._get_freedomfi_one_param_values_response()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(
isinstance(resp, models.SetParameterValues),
'State machine should be setting parameters',
)
self.assertIsNotNone(
resp.ParameterKey.Data,
'ParameterKey should be set for FreedomFiOne eNB',
)
msg = models.SetParameterValuesResponse()
msg.Status = 1
get_resp = acs_state_machine.handle_tr069_message(msg)
self.assertTrue(
isinstance(get_resp, models.GetParameterValues),
'We should read back all parameters',
)
req = self._get_freedomfi_one_param_values_response()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(
isinstance(resp, models.DummyInput),
'Provisioning completed with Dummy response',
)
def test_provisioning(self) -> None:
acs_state_machine = self._build_acs_state_machine()
# Send an Inform message, wait for an InformResponse
inform_msg = self._get_inform()
resp = acs_state_machine.handle_tr069_message(inform_msg)
self.assertTrue(isinstance(resp, models.InformResponse),
'Should respond with an InformResponse')
# Send an empty http request to kick off the rest of provisioning
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for an optional parameter, three times
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = self._get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = self._get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = self._get_fault()
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for read-only params
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = self._get_read_only_param_values_response()
# Send back some typical values
# And then SM should request regular parameter values
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
# Send back typical values for the regular parameters
req = self._get_regular_param_values_response()
resp = acs_state_machine.handle_tr069_message(req)
# SM will be requesting object parameter values
self.assertTrue(
isinstance(resp, models.GetParameterValues),
'State machine should be requesting object param vals')
# Send back some typical values for object parameters
req = self._get_object_param_values_response()
resp = acs_state_machine.handle_tr069_message(req)
# In this scenario, the ACS and thus state machine will not need
# to delete or add objects to the eNB configuration.
# SM should then just be attempting to set parameter values
print(resp)
self.assertTrue(isinstance(resp, models.SetParameterValues),
'State machine should be setting param values')
# Send back confirmation that the parameters were successfully set
req = models.SetParameterValuesResponse()
req.Status = 0
resp = acs_state_machine.handle_tr069_message(req)
# And now the SM has finished provisioning, and should only request
# the transient, read-only parameters
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting read-only params')
# The eNodeB will send an Inform after ~10 minutes anyways, even
# during a provisioning session
req = self._get_inform()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.InformResponse),
'State machine should handle unexpected Inform msgs')
return
def get_msg(self, message: Any) -> AcsMsgAndTransition:
""" Reply with empty message """
return AcsMsgAndTransition(models.DummyInput(), self.done_transition)
def test_fault_after_set_parameters(self, _mock_func) -> None:
acs_state_machine = \
EnodebAcsStateMachineBuilder \
.build_acs_state_machine(EnodebDeviceName.BAICELLS)
# Send an Inform message, wait for an InformResponse
inform_msg = Tr069MessageBuilder.get_inform('48BF74',
'BaiBS_RTS_3.1.6',
'120200002618AGP0003',
['2 PERIODIC'])
resp = acs_state_machine.handle_tr069_message(inform_msg)
self.assertTrue(isinstance(resp, models.InformResponse),
'Should respond with an InformResponse')
# Send an empty http request to kick off the rest of provisioning
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for an optional parameter, three times
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for read-only params
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_read_only_param_values_response()
# Send back some typical values
# And then SM should request regular parameter values
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
# Send back typical values for the regular parameters
req = Tr069MessageBuilder.get_regular_param_values_response()
resp = acs_state_machine.handle_tr069_message(req)
# SM will be requesting object parameter values
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting object param vals')
# Send back some typical values for object parameters
req = Tr069MessageBuilder.get_object_param_values_response()
resp = acs_state_machine.handle_tr069_message(req)
# In this scenario, the ACS and thus state machine will not need
# to delete or add objects to the eNB configuration.
# SM should then just be attempting to set parameter values
self.assertTrue(isinstance(resp, models.SetParameterValues),
'State machine should be setting param values')
req = models.Fault()
req.FaultCode = 12345
req.FaultString = 'Test FaultString'
acs_state_machine.handle_tr069_message(req)
self.assertTrue('Error' in acs_state_machine.get_state(),
'Should be in error state')
def test_gps_coords(self) -> None:
""" Check GPS coordinates are processed and stored correctly """
acs_state_machine = \
EnodebAcsStateMachineBuilder \
.build_acs_state_machine(EnodebDeviceName.BAICELLS)
# Send an Inform message, wait for an InformResponse
inform_msg = Tr069MessageBuilder.get_inform('48BF74',
'BaiBS_RTS_3.1.6',
'120200002618AGP0003',
['2 PERIODIC'])
resp = acs_state_machine.handle_tr069_message(inform_msg)
self.assertTrue(isinstance(resp, models.InformResponse),
'Should respond with an InformResponse')
# Send an empty http request to kick off the rest of provisioning
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for an optional parameter, three times
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = models.GetParameterValuesResponse()
param_val_list = [Tr069MessageBuilder.get_parameter_value_struct(
name='Device.X_BAICELLS_COM_GpsSyncEnable',
val_type='boolean',
data='true',
)]
req.ParameterList = models.ParameterValueList()
req.ParameterList.ParameterValueStruct = param_val_list
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = models.GetParameterValuesResponse()
param_val_list = [Tr069MessageBuilder.get_parameter_value_struct(
name='Device.FAP.GPS.LockedLatitude',
val_type='int',
data='37483629',
)]
req.ParameterList = models.ParameterValueList()
req.ParameterList.ParameterValueStruct = param_val_list
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = models.GetParameterValuesResponse()
param_val_list = [Tr069MessageBuilder.get_parameter_value_struct(
name='Device.FAP.GPS.LockedLongitude',
val_type='int',
data='-122150583',
)]
req.ParameterList = models.ParameterValueList()
req.ParameterList.ParameterValueStruct = param_val_list
acs_state_machine.handle_tr069_message(req)
gps_long = acs_state_machine.get_parameter(ParameterName.GPS_LONG)
gps_lat = acs_state_machine.get_parameter(ParameterName.GPS_LAT)
self.assertTrue(gps_long == '-122.150583', 'Should be valid longitude')
self.assertTrue(gps_lat == '37.483629', 'Should be valid latitude')
def test_count_plmns_more_defined(self) -> None:
"""
Tests the Cavium provisioning up to GetObjectParameters.
In particular tests when the eNB has more PLMNs than is
currently defined in our data model (NUM_PLMNS_IN_CONFIG)
"""
acs_state_machine = \
EnodebAcsStateMachineBuilder \
.build_acs_state_machine(EnodebDeviceName.CAVIUM)
# Send an Inform message
inform_msg = Tr069MessageBuilder.get_inform(
'000FB7',
'OC-LTE',
'120200002618AGP0003',
['1 BOOT'],
)
resp = acs_state_machine.handle_tr069_message(inform_msg)
self.assertTrue(
isinstance(resp, models.InformResponse),
'Should respond with an InformResponse',
)
# Send an empty http request to kick off the rest of provisioning
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(
isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values: %s' % resp,
)
# Transient config response and request for parameter values
req = Tr069MessageBuilder.get_read_only_param_values_response()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(
isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values: %s' % resp,
)
# Send back regular parameters, and some absurd number of PLMNS
req = Tr069MessageBuilder.get_cavium_param_values_response(
num_plmns=100, )
resp = acs_state_machine.handle_tr069_message(req)
# SM will be requesting object parameter values
self.assertTrue(
isinstance(resp, models.GetParameterValues),
'State machine should be requesting object param vals',
)
# Send back some object parameters with an absurd number of PLMNs
req = Tr069MessageBuilder.get_cavium_object_param_values_response(
num_plmns=100, )
resp = acs_state_machine.handle_tr069_message(req)
# In this scenario, the ACS and thus state machine will not need
# to delete or add objects to the eNB configuration.
# SM should then just be attempting to set parameter values
self.assertTrue(
isinstance(resp, models.SetParameterValues),
'State machine should be setting param values',
)
# Number of PLMNs should reflect data model
num_plmns_cur = \
acs_state_machine \
.device_cfg.get_parameter(ParameterName.NUM_PLMNS)
self.assertEqual(num_plmns_cur, 6)
def test_provision_multi_without_invasive_changes(self, _mock_func) -> None:
"""
Test the scenario where:
- eNodeB has already been powered for 10 minutes without configuration
- Setting parameters which are 'non-invasive' on the eNodeB
- Using enodebd mconfig which has old style config with addition
of eNodeB config tied to a serial number
'Invasive' parameters are those which require special behavior to apply
the changes for the eNodeB.
"""
acs_state_machine = \
EnodebAcsStateMachineBuilder \
.build_multi_enb_acs_state_machine(EnodebDeviceName.BAICELLS)
# Send an Inform message, wait for an InformResponse
inform_msg = Tr069MessageBuilder.get_inform()
resp = acs_state_machine.handle_tr069_message(inform_msg)
self.assertTrue(isinstance(resp, models.InformResponse),
'Should respond with an InformResponse')
# Send an empty http request to kick off the rest of provisioning
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for an optional parameter, three times
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for read-only params
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_read_only_param_values_response()
# Send back some typical values
# And then SM should request regular parameter values
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
# Send back typical values for the regular parameters
req = Tr069MessageBuilder.\
get_regular_param_values_response(admin_state=False,
earfcndl=39150)
resp = acs_state_machine.handle_tr069_message(req)
# SM will be requesting object parameter values
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting object param vals')
# Send back some typical values for object parameters
req = Tr069MessageBuilder.get_object_param_values_response()
resp = acs_state_machine.handle_tr069_message(req)
# In this scenario, the ACS and thus state machine will not need
# to delete or add objects to the eNB configuration.
# SM should then just be attempting to set parameter values
self.assertTrue(isinstance(resp, models.SetParameterValues),
'State machine should be setting param values')
isEnablingAdminState = False
param = 'Device.Services.FAPService.1.FAPControl.LTE.AdminState'
for name_value in resp.ParameterList.ParameterValueStruct:
if name_value.Name == param:
isEnablingAdminState = True
self.assertTrue(isEnablingAdminState,
'eNB config is set to enable transmit, '
'while old enodebd config does not '
'enable transmit. Use eNB config.')
def get_msg(self, message: Any) -> AcsMsgAndTransition:
if self.rem_timer.is_done():
return AcsMsgAndTransition(models.DummyInput(),
self.done_transition)
return AcsMsgAndTransition(models.DummyInput(), None)
def get_msg(self) -> AcsMsgAndTransition:
request = models.DummyInput()
return AcsMsgAndTransition(request, None)
def test_provision(self, mock_get_state) -> None:
mock_get_state.return_value = MOCK_CBSD_STATE
acs_state_machine = EnodebAcsStateMachineBuilder.build_acs_state_machine(
EnodebDeviceName.BAICELLS_QRTB)
data_model = BaicellsQRTBTrDataModel()
# Send an Inform message, wait for an InformResponse
inform_msg = Tr069MessageBuilder.get_qrtb_inform(
params=DEFAULT_INFORM_PARAMS,
oui='48BF74',
enb_serial='1202000181186TB0006',
event_codes=['2 PERIODIC'],
)
resp = acs_state_machine.handle_tr069_message(inform_msg)
self.assertTrue(
isinstance(resp, models.InformResponse),
'Should respond with an InformResponse',
)
# Send an empty http request to kick off the rest of provisioning
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for transient params
self.assertTrue(
isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values',
)
should_ask_for = [p.name for p in GET_TRANSIENT_PARAMS_RESPONSE_PARAMS]
self.verify_acs_asking_enb_for_params(should_ask_for, resp)
# Send back some typical values
req = Tr069MessageBuilder.param_values_qrtb_response(
GET_TRANSIENT_PARAMS_RESPONSE_PARAMS,
models.GetParameterValuesResponse,
)
# And then SM should request all parameter values from the data model
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(
isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values',
)
should_ask_for = [
data_model.get_parameter(pn, ).path
for pn in data_model.get_parameter_names()
]
self.verify_acs_asking_enb_for_params(should_ask_for, resp)
# Send back typical values
req = Tr069MessageBuilder.param_values_qrtb_response(
GET_PARAMS_RESPONSE_PARAMS,
models.GetParameterValuesResponse,
)
# SM will be requesting object parameter values
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(
isinstance(resp, models.GetParameterValues),
'State machine should be requesting object param vals',
)
should_ask_for = [
'Device.Services.FAPService.1.CellConfig.LTE.EPC.PLMNList.1.CellReservedForOperatorUse',
'Device.Services.FAPService.1.CellConfig.LTE.EPC.PLMNList.1.Enable',
'Device.Services.FAPService.1.CellConfig.LTE.EPC.PLMNList.1.IsPrimary',
'Device.Services.FAPService.1.CellConfig.LTE.EPC.PLMNList.1.PLMNID',
]
self.verify_acs_asking_enb_for_params(should_ask_for, resp)
# Send back some typical values for object parameters
req = Tr069MessageBuilder.get_object_param_values_response(
cell_reserved_for_operator_use='true',
enable='true',
is_primary='true',
plmnid='00101',
)
resp = acs_state_machine.handle_tr069_message(req)
# All the radio responses were intentionally crafted so that they match enodebd desired config.
# Therefore the provisioning ends here. The radio goes directly into end_session -> notify_dp state
self.assertTrue(
isinstance(resp, models.DummyInput),
'State machine should send back an empty message',
)
self.assertIsInstance(
acs_state_machine.state,
BaicellsQRTBNotifyDPState,
)
def test_reboot_without_getting_optional(self) -> None:
"""
The state machine should not skip figuring out which optional
parameters are present.
"""
acs_state_machine = \
EnodebAcsStateMachineBuilder \
.build_acs_state_machine(EnodebDeviceName.BAICELLS_OLD)
# Send an Inform message, wait for an InformResponse
inform_msg = \
Tr069MessageBuilder.get_inform('48BF74',
'BaiStation_V100R001C00B110SPC002',
'120200002618AGP0003',
['2 PERIODIC'])
resp = acs_state_machine.handle_tr069_message(inform_msg)
self.assertTrue(isinstance(resp, models.InformResponse),
'Should respond with an InformResponse')
# And now reboot the eNodeB
acs_state_machine.transition('reboot')
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.Reboot))
req = Tr069MessageBuilder.get_reboot_response()
resp = acs_state_machine.handle_tr069_message(req)
# After the reboot has been received, enodebd should end the
# provisioning session
self.assertTrue(isinstance(resp, models.DummyInput),
'After sending command to reboot the Baicells eNodeB, '
'enodeb should end the TR-069 session.')
# At this point, sometime after the eNodeB reboots, we expect it to
# send an Inform indicating reboot. Since it should be in REM process,
# we hold off on finishing configuration, and end TR-069 sessions.
req = \
Tr069MessageBuilder.get_inform('48BF74',
'BaiStation_V100R001C00B110SPC002',
'120200002618AGP0003',
['1 BOOT', 'M Reboot'])
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.DummyInput),
'After receiving a post-reboot Inform, enodebd '
'should end TR-069 sessions for 10 minutes to wait '
'for REM process to finish.')
# Pretend that we have waited, and now we are in normal operation again
acs_state_machine.transition('wait_inform_post_reboot')
req = \
Tr069MessageBuilder.get_inform('48BF74',
'BaiStation_V100R001C00B110SPC002',
'120200002618AGP0003',
['2 PERIODIC'])
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.InformResponse),
'After receiving a post-reboot Inform, enodebd '
'should end TR-069 sessions for 10 minutes to wait '
'for REM process to finish.')
# Since we haven't figured out the presence of optional parameters, the
# state machine should be requesting them now. There are three for the
# Baicells state machine.
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'enodebd should be requesting params')
self.assertTrue(len(resp.ParameterNames.string) == 1,
'Should be requesting optional params.')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param')
self.assertTrue(len(resp.ParameterNames.string) == 1,
'Should be requesting optional params.')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param')
self.assertTrue(len(resp.ParameterNames.string) == 1,
'Should be requesting optional params.')
def test_provisioning(self) -> None:
acs_state_machine = self._build_acs_state_machine()
# Send an Inform message, wait for an InformResponse
inform_msg = self._get_inform()
resp = acs_state_machine.handle_tr069_message(inform_msg)
self.assertTrue(isinstance(resp, models.InformResponse),
'Should respond with an InformResponse')
# Send an empty http request to kick off the rest of provisioning
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for an optional parameter, three times
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = self._get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = self._get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = self._get_fault()
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for read-only params
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = self._get_read_only_param_values_response()
# Send back some typical values
# And then SM should request regular parameter values
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
# Send back typical values for the regular parameters
req = self._get_regular_param_values_response()
resp = acs_state_machine.handle_tr069_message(req)
# SM will be requesting object parameter values
self.assertTrue(
isinstance(resp, models.GetParameterValues),
'State machine should be requesting object param vals')
# Send back some typical values for object parameters
req = self._get_object_param_values_response()
resp = acs_state_machine.handle_tr069_message(req)
# In this scenario, the ACS and thus state machine will not need
# to delete or add objects to the eNB configuration.
# SM should then just be attempting to set parameter values
self.assertTrue(isinstance(resp, models.SetParameterValues),
'State machine should be setting param values')
# Send back confirmation that the parameters were successfully set
req = models.SetParameterValuesResponse()
req.Status = 0
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for read-only params
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = self._get_read_only_param_values_response()
# Send back some typical values
# And then SM should continue polling the read-only params
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
# Expect a request for read-only params
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = self._get_read_only_param_values_response()
# Send back some typical values
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
# If a different eNB is suddenly plugged in, or the same eNB sends a
# new Inform, enodebd should be able to handle it.
# Send an Inform message, wait for an InformResponse
inform_msg = self._get_inform()
resp = acs_state_machine.handle_tr069_message(inform_msg)
self.assertTrue(isinstance(resp, models.InformResponse),
'Should respond with an InformResponse')
# Send an empty http request to kick off the rest of provisioning
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for an optional parameter, three times
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
return
def test_handle_two_ips(self):
manager = self._get_manager()
ctx1 = get_spyne_context_with_ip("192.168.60.145")
ctx2 = get_spyne_context_with_ip("192.168.60.99")
##### Start session for the first IP #####
# Send an Inform message, wait for an InformResponse
inform_msg = Tr069MessageBuilder.get_inform('48BF74',
'BaiBS_RTS_3.1.6',
'120200002618AGP0001')
resp1 = manager.handle_tr069_message(ctx1, inform_msg)
self.assertTrue(isinstance(resp1, models.InformResponse),
'Should respond with an InformResponse')
# Send an empty http request to kick off the rest of provisioning
req1 = models.DummyInput()
resp1 = manager.handle_tr069_message(ctx1, req1)
# Expect a request for an optional parameter, three times
self.assertTrue(isinstance(resp1, models.GetParameterValues),
'State machine should be requesting param values')
req1 = Tr069MessageBuilder.get_fault()
resp1 = manager.handle_tr069_message(ctx1, req1)
self.assertTrue(isinstance(resp1, models.GetParameterValues),
'State machine should be requesting param values')
##### Start session for the second IP #####
# Send an Inform message, wait for an InformResponse
inform_msg = Tr069MessageBuilder.get_inform('48BF74',
'BaiBS_RTS_3.1.6',
'120200002618AGP0002')
resp2 = manager.handle_tr069_message(ctx2, inform_msg)
self.assertTrue(isinstance(resp2, models.InformResponse),
'Should respond with an InformResponse')
##### Continue session for the first IP #####
req1 = Tr069MessageBuilder.get_fault()
resp1 = manager.handle_tr069_message(ctx1, req1)
self.assertTrue(isinstance(resp1, models.GetParameterValues),
'State machine should be requesting param values')
req1 = Tr069MessageBuilder.get_fault()
resp1 = manager.handle_tr069_message(ctx1, req1)
# Expect a request for read-only params
self.assertTrue(isinstance(resp1, models.GetParameterValues),
'State machine should be requesting param values')
##### Continue session for the second IP #####
# Send an empty http request to kick off the rest of provisioning
req2 = models.DummyInput()
resp2 = manager.handle_tr069_message(ctx2, req2)
# Expect a request for an optional parameter, three times
self.assertTrue(isinstance(resp2, models.GetParameterValues),
'State machine should be requesting param values')
req2 = Tr069MessageBuilder.get_fault()
resp2 = manager.handle_tr069_message(ctx2, req2)
self.assertTrue(isinstance(resp2, models.GetParameterValues),
'State machine should be requesting param values')
req2 = Tr069MessageBuilder.get_fault()
resp2 = manager.handle_tr069_message(ctx2, req2)
self.assertTrue(isinstance(resp2, models.GetParameterValues),
'State machine should be requesting param values')
req2 = Tr069MessageBuilder.get_fault()
resp2 = manager.handle_tr069_message(ctx2, req2)
# Expect a request for read-only params
self.assertTrue(isinstance(resp2, models.GetParameterValues),
'State machine should be requesting param values')
def get_msg(self, message: Any) -> AcsReadMsgResult:
"""
Return a dummy message waiting for the empty message from CPE
"""
request = models.DummyInput()
return AcsMsgAndTransition(msg=request, next_state=None)
