| #! /usr/bin/python |
| |
| import requests |
| import json |
| import sys |
| from datetime import datetime |
| from vcpecommon import * |
| import csar_parser |
| #import logging |
| from robot.api import logger |
| import base64 |
| |
| |
| class Preload: |
| def __init__(self, vcpecommon): |
| #self.logger = logging.getLogger(__name__) |
| self.logger = logger |
| self.vcpecommon = vcpecommon |
| |
| def replace(self, sz, replace_dict): |
| for old_string, new_string in replace_dict.items(): |
| sz = sz.replace(old_string, new_string) |
| if self.vcpecommon.template_variable_symbol in sz: |
| self.logger.error('Error! Cannot find a value to replace ' + sz) |
| return sz |
| |
| def generate_json(self, template_file, replace_dict): |
| with open(template_file) as json_input: |
| json_data = json.load(json_input) |
| stk = [json_data] |
| while len(stk) > 0: |
| data = stk.pop() |
| for k, v in data.items(): |
| if type(v) is dict: |
| stk.append(v) |
| elif type(v) is list: |
| stk.extend(v) |
| elif type(v) is str or type(v) is unicode: |
| if self.vcpecommon.template_variable_symbol in v: |
| data[k] = self.replace(v, replace_dict) |
| else: |
| self.logger.warning('Unexpected line in template: %s. Look for value %s', template_file, v) |
| return json_data |
| |
| def reset_sniro(self): |
| self.logger.debug('Clearing SNIRO data') |
| r = requests.post(self.vcpecommon.sniro_url + '/reset', headers=self.vcpecommon.sniro_headers) |
| if 2 != r.status_code / 100: |
| self.logger.debug(r.content) |
| self.logger.error('Clearing SNIRO date failed.') |
| sys.exit() |
| |
| def preload_sniro(self, template_sniro_data, template_sniro_request, tunnelxconn_ar_name, vgw_name, vbrg_ar_name, |
| vgmux_svc_instance_uuid, vbrg_svc_instance_uuid): |
| self.reset_sniro() |
| self.logger.info('Preloading SNIRO for homing service') |
| replace_dict = {'${tunnelxconn_ar_name}': tunnelxconn_ar_name, |
| '${vgw_name}': vgw_name, |
| '${brg_ar_name}': vbrg_ar_name, |
| '${vgmux_svc_instance_uuid}': vgmux_svc_instance_uuid, |
| '${vbrg_svc_instance_uuid}': vbrg_svc_instance_uuid |
| } |
| sniro_data = self.generate_json(template_sniro_data, replace_dict) |
| self.logger.debug('SNIRO data:') |
| self.logger.debug(json.dumps(sniro_data, indent=4, sort_keys=True)) |
| |
| base64_sniro_data = base64.b64encode(json.dumps(sniro_data)) |
| self.logger.debug('SNIRO data: 64') |
| self.logger.debug(base64_sniro_data) |
| replace_dict = {'${base64_sniro_data}': base64_sniro_data, '${sniro_ip}': self.vcpecommon.hosts['robot']} |
| sniro_request = self.generate_json(template_sniro_request, replace_dict) |
| self.logger.debug('SNIRO request:') |
| self.logger.debug(json.dumps(sniro_request, indent=4, sort_keys=True)) |
| |
| r = requests.post(self.vcpecommon.sniro_url, headers=self.vcpecommon.sniro_headers, json=sniro_request) |
| if 2 != r.status_code / 100: |
| response = r.json() |
| self.logger.debug(json.dumps(response, indent=4, sort_keys=True)) |
| self.logger.error('SNIRO preloading failed.') |
| sys.exit() |
| |
| return True |
| |
| def preload_network(self, template_file, network_role, subnet_start_ip, subnet_gateway, common_dict, name_suffix): |
| """ |
| :param template_file: |
| :param network_role: cpe_signal, cpe_public, brg_bng, bng_mux, mux_gw |
| :param subnet_start_ip: |
| :param subnet_gateway: |
| :param name_suffix: e.g. '201711201311' |
| :return: |
| """ |
| network_name = '_'.join([self.vcpecommon.instance_name_prefix['network'], network_role.lower(), name_suffix]) |
| subnet_name = self.vcpecommon.network_name_to_subnet_name(network_name) |
| common_dict['${' + network_role+'_net}'] = network_name |
| common_dict['${' + network_role+'_subnet}'] = subnet_name |
| replace_dict = {'${network_role}': network_role, |
| '${service_type}': 'vCPE', |
| '${network_type}': 'Generic NeutronNet', |
| '${network_name}': network_name, |
| '${subnet_start_ip}': subnet_start_ip, |
| '${subnet_gateway}': subnet_gateway |
| } |
| self.logger.info('Preloading network ' + network_role) |
| return self.preload(template_file, replace_dict, self.vcpecommon.sdnc_preload_network_url) |
| |
| def preload(self, template_file, replace_dict, url): |
| self.logger.debug(json.dumps(replace_dict, indent=4, sort_keys=True)) |
| json_data = self.generate_json(template_file, replace_dict) |
| self.logger.debug(json.dumps(json_data, indent=4, sort_keys=True)) |
| r = requests.post(url, headers=self.vcpecommon.sdnc_headers, auth=self.vcpecommon.sdnc_userpass, json=json_data) |
| response = r.json() |
| if int(response.get('output', {}).get('response-code', 0)) != 200: |
| self.logger.debug(json.dumps(response, indent=4, sort_keys=True)) |
| self.logger.error('Preloading failed.') |
| return False |
| return True |
| |
| def preload_vgw(self, template_file, brg_mac, commont_dict, name_suffix): |
| replace_dict = {'${brg_mac}': brg_mac, |
| '${suffix}': name_suffix |
| } |
| replace_dict.update(commont_dict) |
| self.logger.info('Preloading vGW') |
| return self.preload(template_file, replace_dict, self.vcpecommon.sdnc_preload_vnf_url) |
| |
| def preload_vgw_gra(self, template_file, brg_mac, commont_dict, name_suffix, vgw_vfmod_name_index): |
| replace_dict = {'${brg_mac}': brg_mac, |
| '${suffix}': name_suffix, |
| '${vgw_vfmod_name_index}': vgw_vfmod_name_index |
| } |
| replace_dict.update(commont_dict) |
| self.logger.info('Preloading vGW-GRA') |
| return self.preload(template_file, replace_dict, self.vcpecommon.sdnc_preload_gra_url) |
| |
| def preload_vfmodule(self, template_file, service_instance_id, vnf_model, vfmodule_model, common_dict, name_suffix): |
| """ |
| :param template_file: |
| :param service_instance_id: |
| :param vnf_model: parsing results from csar_parser |
| :param vfmodule_model: parsing results from csar_parser |
| :param common_dict: |
| :param name_suffix: |
| :return: |
| """ |
| |
| # examples: |
| # vfmodule_model['modelCustomizationName']: "Vspinfra111601..base_vcpe_infra..module-0", |
| # vnf_model['modelCustomizationName']: "vspinfra111601 0", |
| |
| vfmodule_name = '_'.join([self.vcpecommon.instance_name_prefix['vfmodule'], |
| vfmodule_model['modelCustomizationName'].split('..')[0].lower(), name_suffix]) |
| |
| # vnf_type and generic_vnf_type are identical |
| replace_dict = {'${vnf_type}': vfmodule_model['modelCustomizationName'], |
| '${generic_vnf_type}': vfmodule_model['modelCustomizationName'], |
| '${service_type}': service_instance_id, |
| '${generic_vnf_name}': vnf_model['modelCustomizationName'], |
| '${vnf_name}': vfmodule_name, |
| '${mr_ip_addr}': self.vcpecommon.mr_ip_addr, |
| '${mr_ip_port}': self.vcpecommon.mr_ip_port, |
| '${sdnc_oam_ip}': self.vcpecommon.sdnc_oam_ip, |
| '${suffix}': name_suffix} |
| replace_dict.update(common_dict) |
| self.logger.info('Preloading VF Module ' + vfmodule_name) |
| return self.preload(template_file, replace_dict, self.vcpecommon.sdnc_preload_vnf_url) |
| |
| def preload_all_networks(self, template_file, name_suffix): |
| common_dict = {'${' + k + '}': v for k, v in self.vcpecommon.common_preload_config.items()} |
| for network, v in self.vcpecommon.preload_network_config.items(): |
| subnet_start_ip, subnet_gateway_ip = v |
| if not self.preload_network(template_file, network, subnet_start_ip, subnet_gateway_ip, |
| common_dict, name_suffix): |
| return None |
| return common_dict |
| |
| 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 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() |
| |
| 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) |