def test_sniro(self):
template_sniro_data = self.vcpecommon.find_file(
'sniro_data', 'json', 'preload_templates')
template_sniro_request = self.vcpecommon.find_file(
'sniro_request', 'json', 'preload_templates')
vcperescust_csar = self.vcpecommon.find_file('rescust', 'csar', 'csar')
parser = csar_parser.CsarParser()
parser.parse_csar(vcperescust_csar)
tunnelxconn_ar_name = None
brg_ar_name = None
vgw_name = None
for model in parser.vnf_models:
if 'tunnel' in model['modelCustomizationName']:
tunnelxconn_ar_name = model['modelCustomizationName']
elif 'brg' in model['modelCustomizationName']:
brg_ar_name = model['modelCustomizationName']
elif 'vgw' in model['modelCustomizationName']:
vgw_name = model['modelCustomizationName']
if not (tunnelxconn_ar_name and brg_ar_name and vgw_name):
self.logger.error('Cannot find all names from %s.',
vcperescust_csar)
sys.exit(1)
vgmux_svc_instance_uuid = '88888888888888'
vbrg_svc_instance_uuid = '999999999999999'
self.preload_sniro(template_sniro_data, template_sniro_request,
tunnelxconn_ar_name, vgw_name, brg_ar_name,
vgmux_svc_instance_uuid, vbrg_svc_instance_uuid)
def test(self):
# this is for testing purpose
name_suffix = datetime.now().strftime('%Y%m%d%H%M')
vcpecommon = VcpeCommon()
preloader = Preload(vcpecommon)
network_dict = {'${' + k + '}': v for k, v in self.vcpecommon.common_preload_config.items()}
template_file = 'preload_templates/template.network.json'
for k, v in self.vcpecommon.preload_network_config.items():
if not preloader.preload_network(template_file, k, v[0], v[1], network_dict, name_suffix):
break
print('---------------------------------------------------------------')
print('Network related replacement dictionary:')
print(json.dumps(network_dict, indent=4, sort_keys=True))
print('---------------------------------------------------------------')
keys = ['infra', 'bng', 'gmux', 'brg']
for key in keys:
csar_file = self.vcpecommon.find_file(key, 'csar', 'csar')
template_file = self.vcpecommon.find_file(key, 'json', 'preload_templates')
if csar_file and template_file:
parser = csar_parser.CsarParser()
parser.parse_csar(csar_file)
service_instance_id = 'test112233'
preloader.preload_vfmodule(template_file, service_instance_id, parser.vnf_models[0],
parser.vfmodule_models[0], network_dict, name_suffix)
def config_sniro(vcpecommon, vgmux_svc_instance_uuid, vbrg_svc_instance_uuid):
logger = logging.getLogger(__name__)
logger.info('\n----------------------------------------------------------------------------------')
logger.info('Start to config SNIRO homing emulator')
preloader = preload.Preload(vcpecommon)
template_sniro_data = vcpecommon.find_file('sniro_data', 'json', 'preload_templates')
template_sniro_request = vcpecommon.find_file('sniro_request', 'json', 'preload_templates')
vcperescust_csar = vcpecommon.find_file('rescust', 'csar', 'csar')
parser = csar_parser.CsarParser()
parser.parse_csar(vcperescust_csar)
tunnelxconn_ar_name = None
brg_ar_name = None
vgw_name = None
for model in parser.vnf_models:
logger.info('modelCustomizationName = %s', model['modelCustomizationName'])
if 'tunnel' in model['modelCustomizationName'].lower():
logger.info('tunnel is in %s', model['modelCustomizationName'])
tunnelxconn_ar_name = model['modelCustomizationName']
elif 'brg' in model['modelCustomizationName'].lower():
logger.info('brg is in %s', model['modelCustomizationName'])
brg_ar_name = model['modelCustomizationName']
#elif 'vgw' in model['modelCustomizationName']:
else:
vgw_name = model['modelCustomizationName']
if not (tunnelxconn_ar_name and brg_ar_name and vgw_name):
logger.error('Cannot find all names from %s.', vcperescust_csar)
sys.exit(1)
preloader.preload_sniro(template_sniro_data, template_sniro_request, tunnelxconn_ar_name, vgw_name, brg_ar_name,
vgmux_svc_instance_uuid, vbrg_svc_instance_uuid)
def create_custom_service(self, csar_file, brg_mac, name_suffix=None):
parser = csar_parser.CsarParser()
if not parser.parse_csar(csar_file):
return False
# yyyymmdd_hhmm
if not name_suffix:
name_suffix = '_' + datetime.now().strftime('%Y%m%d%H%M')
# create service
instance_name = '_'.join([
self.vcpecommon.instance_name_prefix['service'],
parser.svc_model['modelName'][0:10], name_suffix
])
instance_name = instance_name.lower()
req = self.generate_custom_service_request(instance_name,
parser.svc_model,
parser.vfmodule_models,
brg_mac)
self.logger.info(json.dumps(req, indent=2, sort_keys=True))
self.logger.info('Creating custom service {0}.'.format(instance_name))
req_id, svc_instance_id = self.submit_create_req(req, 'service') # pylint: disable=W0612
if not self.check_progress(req_id, 140):
return False
return True
def insert_customer_service_to_sdnc(vcpecommon):
"""
INSERT INTO SERVICE_MODEL (`service_uuid`, `model_yaml`,`invariant_uuid`,`version`,`name`,`description`,`type`,`category`,`ecomp_naming`,`service_instance_name_prefix`,`filename`,`naming_policy`) values ('7e319b6f-e710-440e-bbd2-63c1004949ef', null, 'a99ace8a-6e3b-447d-b2ff-4614e4234eea',null,'vCPEService', 'vCPEService', 'Service','Network L1-3', 'N', 'vCPEService', 'vCpeResCust110701/service-Vcperescust110701-template.yml',null);
INSERT INTO ALLOTTED_RESOURCE_MODEL (`customization_uuid`,`model_yaml`,`invariant_uuid`,`uuid`,`version`,`naming_policy`,`ecomp_generated_naming`,`depending_service`,`role`,`type`,`service_dependency`,`allotted_resource_type`) VALUES ( '7e40b664-d7bf-47ad-8f7c-615631d53cd7', NULL, 'f51b0aae-e24a-4cff-b190-fe3daf3d15ee', 'f3137496-1605-40e9-b6df-64aa0f8e91a0', '1.0', NULL,'Y',NULL,NULL,'TunnelXConnect',NULL, 'TunnelXConnect');
INSERT INTO ALLOTTED_RESOURCE_MODEL (`customization_uuid`,`model_yaml`,`invariant_uuid`,`uuid`,`version`,`naming_policy`,`ecomp_generated_naming`,`depending_service`,`role`,`type`,`service_dependency`,`allotted_resource_type`) VALUES ( 'e46097e1-6a0c-4cf3-a7e5-c39ed407e65e', NULL, 'aa60f6ba-541b-48d6-a5ff-3b0e1f0ad9bf', '0e157d52-b945-422f-b3a8-ab685c2be079', '1.0', NULL,'Y',NULL,NULL,'BRG',NULL, 'TunnelXConnect');
INSERT INTO VF_MODEL (`customization_uuid`,`model_yaml`,`invariant_uuid`,`uuid`,`version`,`name`,`naming_policy`,`ecomp_generated_naming`,`avail_zone_max_count`,`nf_function`,`nf_code`,`nf_type`,`nf_role`,`vendor`,`vendor_version`) VALUES ( '3768afa5-cf9e-4071-bb25-3a2e2628dd87', NULL, '5f56893b-d026-4672-b785-7f5ffeb498c6', '7cf28b23-5719-485b-9ab4-dae1a2fa0e07', '1.0', 'vspvgw111601',NULL,'Y',1,NULL,NULL,NULL,NULL,'vCPE','1.0');
INSERT INTO VF_MODULE_MODEL (`customization_uuid`,`model_yaml`,`invariant_uuid`,`uuid`,`version`,`vf_module_type`,`availability_zone_count`,`ecomp_generated_vm_assignments`) VALUES ( '17a9c7d1-6f8e-4930-aa83-0d323585184f', NULL, 'd772ddd1-7623-40b4-a2a5-ec287916cb51', '6e1a0652-f5e9-4caa-bff8-39bf0c8589a3', '1.0', 'Base',NULL,NULL);
:return:
"""
logger = logging.getLogger('__name__')
logger.info('Inserting customer service data to SDNC DB')
csar_file = vcpecommon.find_file('rescust', 'csar', 'csar')
parser = csar_parser.CsarParser()
parser.parse_csar(csar_file)
cmds = []
if False:
cmds.append("INSERT INTO SERVICE_MODEL (`service_uuid`, `model_yaml`,`invariant_uuid`,`version`,`name`," \
"`description`,`type`,`category`,`ecomp_naming`,`service_instance_name_prefix`,`filename`," \
"`naming_policy`) values ('{0}', null, '{1}',null,'{2}', 'vCPEService', 'Service','Network L1-3'," \
"'N', 'vCPEService', '{3}/{4}',null);".format(parser.svc_model['modelVersionId'],
parser.svc_model['modelInvariantId'],
parser.svc_model['modelName'],
parser.svc_model['modelName'],
parser.svc_model['modelName']))
for model in parser.vnf_models:
if 'tunnel' in model['modelCustomizationName'].lower(
) or 'brg' in model['modelCustomizationName'].lower():
if False:
cmds.append("INSERT INTO ALLOTTED_RESOURCE_MODEL (`customization_uuid`,`model_yaml`,`invariant_uuid`," \
"`uuid`,`version`,`naming_policy`,`ecomp_generated_naming`,`depending_service`,`role`,`type`," \
"`service_dependency`,`allotted_resource_type`) VALUES ('{0}',NULL,'{1}','{2}','1.0'," \
"NULL,'Y', NULL,NULL,'TunnelXConnect'," \
"NULL, 'TunnelXConnect');".format(model['modelCustomizationId'], model['modelInvariantId'],
model['modelVersionId']))
cmds.append("UPDATE ALLOTTED_RESOURCE_MODEL SET `ecomp_generated_naming`='Y' " \
"WHERE `customization_uuid`='{0}'".format(model['modelCustomizationId']))
else:
if False:
cmds.append("INSERT INTO VF_MODEL (`customization_uuid`,`model_yaml`,`invariant_uuid`,`uuid`,`version`," \
"`name`,`naming_policy`,`ecomp_generated_naming`,`avail_zone_max_count`,`nf_function`," \
"`nf_code`,`nf_type`,`nf_role`,`vendor`,`vendor_version`) VALUES ('{0}',NULL,'{1}','{2}'," \
"'1.0', '{3}',NULL,'Y',1,NULL,NULL,NULL,NULL,'vCPE'," \
"'1.0');".format(model['modelCustomizationId'], model['modelInvariantId'],
model['modelVersionId'], model['modelCustomizationName'].split()[0]))
cmds.append("UPDATE VF_MODEL SET `ecomp_generated_naming`='Y' " \
"WHERE `customization_uuid`='{0}'".format(model['modelCustomizationId']))
if False:
model = parser.vfmodule_models[0]
cmds.append("INSERT INTO VF_MODULE_MODEL (`customization_uuid`,`model_yaml`,`invariant_uuid`,`uuid`,`version`," \
"`vf_module_type`,`availability_zone_count`,`ecomp_generated_vm_assignments`) VALUES ('{0}', NULL," \
"'{1}', '{2}', '1.0', 'Base',NULL,NULL)" \
";".format(model['modelCustomizationId'], model['modelInvariantId'], model['modelVersionId']))
print('\n'.join(cmds))
vcpecommon.execute_cmds_sdnc_db(cmds)
def insert_customer_service_to_so(vcpecommon):
logger = logging.getLogger(__name__)
cmds = []
if True:
csar_file = vcpecommon.find_file('rescust', 'csar', 'csar')
parser = csar_parser.CsarParser()
parser.parse_csar(csar_file)
cmds.append("INSERT INTO service_recipe (ACTION, VERSION_STR, DESCRIPTION, ORCHESTRATION_URI, " \
"SERVICE_PARAM_XSD, RECIPE_TIMEOUT, SERVICE_TIMEOUT_INTERIM, CREATION_TIMESTAMP, " \
"SERVICE_MODEL_UUID) VALUES ('createInstance','1','{0}'," \
"'/mso/async/services/CreateVcpeResCustService',NULL,181,NULL, NOW()," \
"'{1}');".format(parser.svc_model['modelName'], parser.svc_model['modelVersionId']))
logger.info(
'Please manually run the following sql command in SO catalogdb database to insert customer service recipe'
)
logger.info('\n'.join(cmds))
def insert_customer_service_to_so(vcpecommon):
logger = logging.getLogger(__name__)
cmds = []
csar_file = vcpecommon.find_file('rescust', 'csar', 'csar')
parser = csar_parser.CsarParser()
parser.parse_csar(csar_file)
cmds.append("INSERT IGNORE INTO service_recipe (ACTION, VERSION_STR, DESCRIPTION, ORCHESTRATION_URI, " \
"SERVICE_PARAM_XSD, RECIPE_TIMEOUT, SERVICE_TIMEOUT_INTERIM, CREATION_TIMESTAMP, " \
"SERVICE_MODEL_UUID) VALUES ('createInstance','1','{0}'," \
"'/mso/async/services/CreateVcpeResCustService',NULL,181,NULL, NOW()," \
"'{1}');".format(parser.svc_model['modelName'], parser.svc_model['modelVersionId']))
if vcpecommon.oom_mode:
logger.info(
'Inserting vcpe customer service workflow entry into SO catalogdb')
vcpecommon.execute_cmds_so_db(cmds)
else:
logger.info(
'\n\nManually run a command from Rancher node to insert vcpe'
'customer service workflow entry in SO catalogdb:\n'
'\nkubectl -n {0} exec {1}-mariadb-galera-mariadb-galera-0'
' -- mysql -uroot -psecretpassword catalogdb -e '
'"'.format(vcpecommon.onap_namespace,
vcpecommon.onap_environment) + '\n'.join(cmds) + '"')
def create_entire_service(self, csar_file, vnf_template_file, preload_dict, name_suffix, heatbridge=False):
"""
:param csar_file:
:param vnf_template_file:
:param preload_dict:
:param name_suffix:
:return: service instance UUID
"""
self.logger.info('\n----------------------------------------------------------------------------------')
self.logger.info('Start to create entire service defined in csar: {0}'.format(csar_file))
parser = csar_parser.CsarParser()
self.logger.info('Parsing csar ...')
if not parser.parse_csar(csar_file):
self.logger.error('Cannot parse csar: {0}'.format(csar_file))
return None
# create service
instance_name = '_'.join([self.vcpecommon.instance_name_prefix['service'],
parser.svc_model['modelName'], name_suffix])
instance_name = instance_name.lower()
self.logger.info('Creating service instance: {0}.'.format(instance_name))
req = self.generate_service_request(instance_name, parser.svc_model)
self.logger.debug(json.dumps(req, indent=2, sort_keys=True))
req_id, svc_instance_id = self.submit_create_req(req, 'service')
if not self.check_progress(req_id, eta=2, interval=1):
return None
# wait for AAI to complete traversal
self.wait_for_aai('service', svc_instance_id)
# create networks
for model in parser.net_models:
base_name = model['modelCustomizationName'].lower().replace('mux_vg', 'mux_gw')
network_name = '_'.join([self.vcpecommon.instance_name_prefix['network'], base_name, name_suffix])
network_name = network_name.lower()
self.logger.info('Creating network: ' + network_name)
req = self.generate_vnf_or_network_request('network', network_name, model, svc_instance_id,
parser.svc_model)
self.logger.debug(json.dumps(req, indent=2, sort_keys=True))
req_id, net_instance_id = self.submit_create_req(req, 'network', svc_instance_id)
if not self.check_progress(req_id, eta=20):
return None
self.logger.info('Changing subnet name to ' + self.vcpecommon.network_name_to_subnet_name(network_name))
self.vcpecommon.set_network_name(network_name)
subnet_name_changed = False
for i in range(20):
time.sleep(3)
if self.vcpecommon.set_subnet_name(network_name):
subnet_name_changed = True
break
if not subnet_name_changed:
self.logger.error('Failed to change subnet name for ' + network_name)
return None
vnf_model = None
vnf_instance_id = None
# create VNF
if len(parser.vnf_models) == 1:
vnf_model = parser.vnf_models[0]
vnf_instance_name = '_'.join([self.vcpecommon.instance_name_prefix['vnf'],
vnf_model['modelCustomizationName'].split(' ')[0], name_suffix])
vnf_instance_name = vnf_instance_name.lower()
self.logger.info('Creating VNF: ' + vnf_instance_name)
req = self.generate_vnf_or_network_request('vnf', vnf_instance_name, vnf_model, svc_instance_id,
parser.svc_model)
self.logger.debug(json.dumps(req, indent=2, sort_keys=True))
req_id, vnf_instance_id = self.submit_create_req(req, 'vnf', svc_instance_id)
if not self.check_progress(req_id, eta=2, interval=1):
self.logger.error('Failed to create VNF {0}.'.format(vnf_instance_name))
return False
# wait for AAI to complete traversal
if not vnf_instance_id:
self.logger.error('No VNF instance ID returned!')
sys.exit()
self.wait_for_aai('vnf', vnf_instance_id)
preloader = preload.Preload(self.vcpecommon)
preloader.preload_vfmodule(vnf_template_file, svc_instance_id, parser.vnf_models[0], parser.vfmodule_models[0],
preload_dict, name_suffix)
# create VF Module
if len(parser.vfmodule_models) == 1:
if not vnf_instance_id or not vnf_model:
self.logger.error('Invalid VNF instance ID or VNF model!')
sys.exit()
model = parser.vfmodule_models[0]
vfmodule_instance_name = '_'.join([self.vcpecommon.instance_name_prefix['vfmodule'],
model['modelCustomizationName'].split('..')[0], name_suffix])
vfmodule_instance_name = vfmodule_instance_name.lower()
self.logger.info('Creating VF Module: ' + vfmodule_instance_name)
req = self.generate_vfmodule_request(vfmodule_instance_name, model, svc_instance_id, parser.svc_model,
vnf_instance_id, vnf_model)
self.logger.debug(json.dumps(req, indent=2, sort_keys=True))
req_id, vfmodule_instance_id = self.submit_create_req(req, 'vfmodule', svc_instance_id, vnf_instance_id)
if not self.check_progress(req_id, eta=70, interval=50):
self.logger.error('Failed to create VF Module {0}.'.format(vfmodule_instance_name))
return None
# run heatbridge
if heatbridge:
self.vcpecommon.headbridge(vfmodule_instance_name, svc_instance_id)
self.vcpecommon.save_vgmux_vnf_name(vnf_instance_name)
return svc_instance_id
