def create_measurement_group(subscription, measurement_group_name, body):
"""
Creates a measurement group for a subscription
Args:
subscription (SubscriptionModel): Subscription.
measurement_group_name (String): Name of MeasGroup
body (dict): measurement group request body to save.
"""
logger.info(
f'Initiating create measurement group for: {measurement_group_name}')
check_duplication(subscription.subscription_name, measurement_group_name)
check_measurement_group_names_comply(measurement_group_name, body)
new_mg = [
save_measurement_group(body["measurementGroup"],
subscription.subscription_name)
]
if body["measurementGroup"][
"administrativeState"] == AdministrativeState.UNLOCKED.value:
filtered_nfs = nf_service.capture_filtered_nfs(
subscription.subscription_name)
subscription_service.add_new_filtered_nfs(filtered_nfs, new_mg,
subscription)
else:
logger.info(
f'Measurement Group {measurement_group_name} is not in an unlocked state'
)
db.session.commit()
def test_publish_measurement_grp_to_nfs_failed(self, mock_filter_call,
mock_logger, mock_publish,
mock_model_aai, mock_aai):
mock_aai.return_value = json.loads(self.aai_response_data)
mock_model_aai.return_value = json.loads(self.good_model_info)
mock_publish.side_effect = Exception('Publish failed')
subscription = self.create_test_subs('xtraPM-All-gNB-R2B-new2',
'msrmt_grp_name-new2')
subscription = json.loads(subscription)['subscription']
sub_model = SubscriptionModel(subscription["subscriptionName"],
subscription['operationalPolicyName'],
subscription['controlLoopName'],
'LOCKED')
measurement_grp = MeasurementGroupModel('subscription_name_1',
'msrmt_grp_name', 'UNLOCKED',
15, 'pm.xml', [], [])
measurement2 = self.create_measurement_grp(measurement_grp, 'meas2',
'UNLOCKED')
measurement3 = self.create_measurement_grp(measurement_grp, 'meas3',
'LOCKED')
measurement_grps = [measurement_grp, measurement2, measurement3]
mock_filter_call.return_value = NetworkFunctionFilter(
**subscription["nfFilter"])
filtered_nfs = nf_service.capture_filtered_nfs(
subscription["subscriptionName"])
subscription_service.publish_measurement_grp_to_nfs(
sub_model, filtered_nfs, measurement_grps)
mock_logger.assert_called_with(
'Publish event failed for nf name, measure_grp_name, '
'sub_name: pnf_33_ericsson,meas2, xtraPM-All-gNB-R2B-new2 '
'with error: Publish failed')
def create_subscription(subscription):
"""
Creates a subscription
Args:
subscription (dict): subscription to save.
Raises:
DuplicateDataException: contains details on duplicate fields
Exception: contains runtime error details
"""
logger.info(f'Initiating create subscription for: {subscription["subscriptionName"]}')
perform_validation(subscription)
try:
sub_model = save_subscription_request(subscription)
db.session.commit()
logger.info(f'Successfully saved subscription request for: '
f'{subscription["subscriptionName"]}')
filtered_nfs = nf_service.capture_filtered_nfs(sub_model.subscription_name)
unlocked_mgs = get_unlocked_measurement_grps(sub_model)
add_new_filtered_nfs(filtered_nfs, unlocked_mgs, sub_model)
except IntegrityError as e:
db.session.rollback()
raise DuplicateDataException(f'DB Integrity issue encountered: {e.orig.args[0]}') from e
except Exception as e:
db.session.rollback()
raise e
finally:
db.session.remove()
def test_publish_measurement_grp_to_nfs(self, mock_filter_call,
mock_publish, mock_model_aai,
mock_aai):
mock_aai.return_value = json.loads(self.aai_response_data)
mock_model_aai.return_value = json.loads(self.good_model_info)
mock_publish.return_value = None
subscription = self.create_test_subs('xtraPM-All-gNB-R2B-new2',
'msrmt_grp_name-new2')
subscription = json.loads(subscription)['subscription']
sub_model = SubscriptionModel(subscription["subscriptionName"],
subscription['operationalPolicyName'],
subscription['controlLoopName'],
'LOCKED')
measurement_grp = MeasurementGroupModel('subscription_name_1',
'msrmt_grp_name', 'UNLOCKED',
15, 'pm.xml', [], [])
measurement2 = self.create_measurement_grp(measurement_grp, 'meas2',
'UNLOCKED')
measurement3 = self.create_measurement_grp(measurement_grp, 'meas3',
'UNLOCKED')
measurement_grps = [measurement_grp, measurement2, measurement3]
mock_filter_call.return_value = NetworkFunctionFilter(
**subscription["nfFilter"])
filtered_nfs = nf_service.capture_filtered_nfs(
subscription["subscriptionName"])
subscription_service.publish_measurement_grp_to_nfs(
sub_model, filtered_nfs, measurement_grps)
# Two unlocked measurement Group published
self.assertEqual(mock_publish.call_count, 6)
def test_capture_filtered_nfs(self, mock_filter_call, mock_model_aai,
mock_aai):
mock_aai.return_value = json.loads(self.aai_response_data)
mock_model_aai.return_value = json.loads(self.good_model_info)
subscription = json.loads(self.subscription_request)['subscription']
mock_filter_call.return_value = NetworkFunctionFilter(
**subscription["nfFilter"])
filtered_nfs = nf_service.capture_filtered_nfs(
subscription["subscriptionName"])
self.assertEqual(len(filtered_nfs), 2)
self.assertEqual(filtered_nfs[0].nf_name, 'pnf201')
self.assertEqual(filtered_nfs[1].nf_name, 'pnf_33_ericsson')
def test_save_nf_new_nf(self, mock_filter_call, mock_model_aai, mock_aai):
mock_aai.return_value = json.loads(self.aai_response_data)
mock_model_aai.return_value = json.loads(self.good_model_info)
subscription = json.loads(self.subscription_request)['subscription']
mock_filter_call.return_value = NetworkFunctionFilter(
**subscription["nfFilter"])
nf = nf_service.capture_filtered_nfs(
subscription["subscriptionName"])[0]
nf.nf_name = 'newnf1'
nf_service.save_nf(nf)
network_function = NetworkFunctionModel.query.filter(
NetworkFunctionModel.nf_name == nf.nf_name).one_or_none()
self.assertIsNotNone(network_function)
def test_apply_subscription_to_nfs(self, mock_filter_call, mock_model_aai,
mock_aai):
mock_aai.return_value = json.loads(self.aai_response_data)
mock_model_aai.return_value = json.loads(self.good_model_info)
subscription = json.loads(self.subscription_request)['subscription']
mock_filter_call.return_value = NetworkFunctionFilter(
**subscription["nfFilter"])
filtered_nfs = nf_service.capture_filtered_nfs(
subscription["subscriptionName"])
subscription_service.apply_subscription_to_nfs(filtered_nfs,
'xtraPM-All-gNB-R2B')
for nf in filtered_nfs:
saved_nf_sub_rel = (NfSubRelationalModel.query.filter(
NfSubRelationalModel.subscription_name == 'xtraPM-All-gNB-R2B',
NfSubRelationalModel.nf_name == nf.nf_name).one_or_none())
self.assertIsNotNone(saved_nf_sub_rel)
def test_save_filtered_nfs(self, mock_filter_call, mock_model_aai,
mock_aai):
mock_aai.return_value = json.loads(self.aai_response_data)
mock_model_aai.return_value = json.loads(self.good_model_info)
subscription = self.create_test_subs('xtraPM-All-gNB-R2B-new',
'msrmt_grp_name-new')
subscription = json.loads(subscription)['subscription']
mock_filter_call.return_value = NetworkFunctionFilter(
**subscription["nfFilter"])
filtered_nfs = nf_service.capture_filtered_nfs(
subscription["subscriptionName"])
subscription_service.save_filtered_nfs(filtered_nfs)
for nf in filtered_nfs:
saved_nf = (NetworkFunctionModel.query.filter(
NetworkFunctionModel.nf_name == nf.nf_name).one_or_none())
self.assertIsNotNone(saved_nf)
def extract_del_new_nfs(sub_model):
"""
Captures nfs to be deleted and created for the subscription
Args:
sub_model (SubscriptionModel): Subscription model to perform nfs delete
Returns:
del_nfs (List[String]): Names of nfs to be deleted
new_nfs (List[NetworkFunction]): nfs to be inserted
"""
filtered_nfs = nf_service.capture_filtered_nfs(sub_model.subscription_name)
filtered_nf_names = [nf.nf_name for nf in filtered_nfs]
existing_nf_names = [nf.nf_name for nf in sub_model.nfs]
new_nfs = list(filter(lambda x: x.nf_name not in existing_nf_names, filtered_nfs))
del_nfs = [nf.nf_name for nf in sub_model.nfs if nf.nf_name not in filtered_nf_names]
return del_nfs, new_nfs
def activate_nfs(sub_model, measurement_group):
"""
Activates network functions associated with measurement group
Args:
sub_model (SubscriptionModel): Subscription model
measurement_group (MeasurementGroupModel): Measurement group to update
"""
new_nfs = []
sub_nf_names = [nf.nf_name for nf in sub_model.nfs]
filtered_nfs = nf_service.capture_filtered_nfs(sub_model.subscription_name)
for nf in filtered_nfs:
if nf.nf_name not in sub_nf_names:
new_nfs.append(nf)
if new_nfs:
logger.info(f'Adding new nfs to the subscription: '
f'{sub_model.subscription_name}')
subscription_service.save_filtered_nfs(new_nfs)
subscription_service.apply_subscription_to_nfs(
new_nfs, sub_model.subscription_name)
for nf in filtered_nfs:
logger.info(
f'Saving measurement group to nf name, measure_grp_name: {nf.nf_name},'
f'{measurement_group.measurement_group_name} with CREATE request')
apply_nf_status_to_measurement_group(
nf.nf_name, measurement_group.measurement_group_name,
MgNfState.PENDING_CREATE.value)
db.session.commit()
try:
network_function = NetworkFunction(**nf.serialize_nf())
logger.info(
f'Publishing event for nf name, measure_grp_name: {nf.nf_name},'
f'{measurement_group.measurement_group_name} with CREATE request'
)
publish_measurement_group(sub_model, measurement_group,
network_function, 'CREATE')
except Exception as ex:
logger.error(
f'Publish event failed for nf name, measure_grp_name, sub_name: '
f'{nf.nf_name},{measurement_group.measurement_group_name}, '
f'{sub_model.subscription_name} with error: {ex}')
def test_apply_measurement_grp_to_nfs(self, mock_filter_call,
mock_apply_nf, mock_model_aai,
mock_aai):
mock_aai.return_value = json.loads(self.aai_response_data)
mock_model_aai.return_value = json.loads(self.good_model_info)
mock_apply_nf.return_value = None
subscription = self.create_test_subs('xtraPM-All-gNB-R2B-new2',
'msrmt_grp_name-new2')
subscription = json.loads(subscription)['subscription']
measurement_grp = MeasurementGroupModel('subscription_name_1',
'msrmt_grp_name', 'UNLOCKED',
15, 'pm.xml', [], [])
measurement2 = self.create_measurement_grp(measurement_grp, 'meas2',
'UNLOCKED')
unlocked_msgs = [measurement_grp, measurement2]
mock_filter_call.return_value = NetworkFunctionFilter(
**subscription["nfFilter"])
filtered_nfs = nf_service.capture_filtered_nfs(
subscription["subscriptionName"])
subscription_service.apply_measurement_grp_to_nfs(
filtered_nfs, unlocked_msgs)
# 2 measurement group with 2 nfs each contribute 4 calls
self.assertEqual(mock_apply_nf.call_count, 4)
def test_create_nf_event_body(self, mock_filter_call, mock_model_aai,
mock_aai):
mock_aai.return_value = json.loads(self.aai_response_data)
mock_model_aai.return_value = json.loads(self.good_model_info)
subscription = json.loads(self.subscription_request)['subscription']
mock_filter_call.return_value = NetworkFunctionFilter(
**subscription["nfFilter"])
nf = nf_service.capture_filtered_nfs(
subscription["subscriptionName"])[0]
sub_model = SubscriptionModel(subscription["subscriptionName"],
subscription['operationalPolicyName'],
subscription['controlLoopName'],
'LOCKED')
event_body = nf_service.create_nf_event_body(nf, 'CREATE', sub_model)
self.assertEqual(event_body['nfName'], nf.nf_name)
self.assertEqual(event_body['ipAddress'], nf.ipv6_address)
self.assertEqual(event_body['blueprintName'], nf.sdnc_model_name)
self.assertEqual(event_body['blueprintVersion'], nf.sdnc_model_version)
self.assertEqual(event_body['operationalPolicyName'],
sub_model.operational_policy_name)
self.assertEqual(event_body['changeType'], 'CREATE')
self.assertEqual(event_body['controlLoopName'],
sub_model.control_loop_name)
