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 init():
vcpecommon = VcpeCommon(cfg_file=args.config)
init_sdc(vcpecommon)
download_vcpe_service_templates(vcpecommon)
preloader = preload.Preload(vcpecommon)
template_aai_region_data = vcpecommon.find_file('aai_region_data', 'json', 'preload_templates')
preloader.preload_aai_data(template_aai_region_data)
def create_custom_service(self,
csar_file,
vgw_template_file,
vgw_gra_template_file,
preload_dict=None):
name_suffix = datetime.now().strftime('%Y%m%d%H%M')
brg_mac = self.vcpecommon.get_brg_mac_from_sdnc()
brg_mac_enc = brg_mac.replace(':', '-')
# get name index
self.vgw_vfmod_name_index = self.vcpecommon.load_object(
self.vcpecommon.vgw_vfmod_name_index_file)
self.vgw_vfmod_name_index = self.vgw_vfmod_name_index + 1
self.vcpecommon.save_object(self.vgw_vfmod_name_index,
self.vcpecommon.vgw_vfmod_name_index_file)
# preload vGW
if preload_dict:
preloader = preload.Preload(self.vcpecommon)
parameters_to_change = [
'vgw_private_ip_0', 'vgw_private_ip_1', 'vgw_private_ip_2',
'vg_vgmux_tunnel_vni'
]
self.vcpecommon.increase_ip_address_or_vni_in_template(
vgw_template_file, parameters_to_change)
preloader.preload_vgw(vgw_template_file, brg_mac, preload_dict,
name_suffix)
# preload vGW-GRA
preloader.preload_vgw_gra(vgw_gra_template_file, brg_mac_enc,
preload_dict, name_suffix,
str(self.vgw_vfmod_name_index))
# create service
so = soutils.SoUtils(self.vcpecommon, 'v5')
if so.create_custom_service(csar_file, brg_mac, name_suffix):
self.print_success_info()
def deploy_infra():
logger = logging.getLogger(__name__)
vcpecommon = VcpeCommon()
# preload all networks
network_template = vcpecommon.find_file('network', 'json',
'preload_templates')
name_suffix = datetime.now().strftime('%Y%m%d%H%M')
preloader = preload.Preload(vcpecommon)
preload_dict = preloader.preload_all_networks(network_template,
name_suffix)
logger.debug('Initial preload dictionary:')
logger.debug(json.dumps(preload_dict, indent=4, sort_keys=True))
if not preload_dict:
logger.error("Failed to preload networks.")
sys.exit()
vcpecommon.save_preload_data(preload_dict)
# create multiple services based on the pre-determined order
svc_instance_uuid = {}
for keyword in ['infra', 'bng', 'gmux', 'brg']:
heatbridge = 'gmux' == keyword
csar_file = vcpecommon.find_file(keyword, 'csar', 'csar')
vnf_template_file = vcpecommon.find_file(keyword, 'json',
'preload_templates')
svc_instance_uuid[keyword] = create_one_service(
vcpecommon, csar_file, vnf_template_file, preload_dict,
name_suffix, heatbridge)
if not svc_instance_uuid[keyword]:
sys.exit()
vcpecommon.save_object(svc_instance_uuid,
vcpecommon.svc_instance_uuid_file)
# Setting up SNIRO
config_sniro(vcpecommon, svc_instance_uuid['gmux'],
svc_instance_uuid['brg'])
print(
'----------------------------------------------------------------------------------------------------'
)
print('Congratulations! The following have been completed correctly:')
print(' - Infrastructure Service Instantiation: ')
print(' * 4 VMs: DHCP, AAA, DNS, Web Server')
print(' * 2 Networks: CPE_PUBLIC, CPE_SIGNAL')
print(' - vBNG Service Instantiation: ')
print(' * 1 VM: vBNG')
print(' * 2 Networks: BRG_BNG, BNG_MUX')
print(' - vGMUX Service Instantiation: ')
print(' * 1 VM: vGMUX')
print(' * 1 Network: MUX_GW')
print(' - vBRG Service Instantiation: ')
print(' * 1 VM: vBRG')
print(' - Adding vGMUX vServer information to AAI.')
print(' - SNIRO Homing Emulator configuration.')
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
