test/vcpe/vcpe.py

   1 #!/usr/bin/env python
   2
   3 import logging
   4 logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s %(name)s.%(funcName)s(): %(message)s')
   5
   6 import sys
   7 from vcpecommon import * # pylint: disable=W0614
   8 import sdcutils
   9 import soutils
  10 from datetime import datetime
  11 import preload
  12 import vcpe_custom_service
  13 import csar_parser
  14 import config_sdnc_so
  15 import json
  16 import urllib3
  17 import argparse
  18 from collections import OrderedDict
  19
  20 # disable InsecureRequestWarning warning in requests < 2.16.0
  21 urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
  22 # disable InsecureRequestWarning warning in requests >= 2.16.0
  23 from requests.packages.urllib3.exceptions import InsecureRequestWarning
  24 requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
  25
  26 def config_sniro(vcpecommon, vgmux_svc_instance_uuid, vbrg_svc_instance_uuid):
  27     logger = logging.getLogger(__name__)
  28
  29     logger.info('\n----------------------------------------------------------------------------------')
  30     logger.info('Start to config SNIRO homing emulator')
  31
  32     preloader = preload.Preload(vcpecommon)
  33     template_sniro_data = vcpecommon.find_file('sniro_data', 'json', 'preload_templates')
  34     template_sniro_request = vcpecommon.find_file('sniro_request', 'json', 'preload_templates')
  35
  36     vcperescust_csar = vcpecommon.find_file('rescust', 'csar', 'csar')
  37     parser = csar_parser.CsarParser()
  38     parser.parse_csar(vcperescust_csar)
  39     tunnelxconn_ar_name = None
  40     brg_ar_name = None
  41     vgw_name = None
  42     for model in parser.vnf_models:
  43         logger.info('modelCustomizationName = %s', model['modelCustomizationName'])
  44         if 'tunnel' in model['modelCustomizationName'].lower():
  45             logger.info('tunnel is in %s', model['modelCustomizationName'])
  46             tunnelxconn_ar_name = model['modelCustomizationName']
  47         elif 'brg' in model['modelCustomizationName'].lower():
  48             logger.info('brg is in %s', model['modelCustomizationName'])
  49             brg_ar_name = model['modelCustomizationName']
  50         #elif 'vgw' in model['modelCustomizationName']:
  51         else:
  52             vgw_name = model['modelCustomizationName']
  53
  54     if not (tunnelxconn_ar_name and brg_ar_name and vgw_name):
  55         logger.error('Cannot find all names from %s.', vcperescust_csar)
  56         sys.exit(1)
  57
  58     preloader.preload_sniro(template_sniro_data, template_sniro_request, tunnelxconn_ar_name, vgw_name, brg_ar_name,
  59                             vgmux_svc_instance_uuid, vbrg_svc_instance_uuid)
  60
  61
  62 def create_one_service(vcpecommon, csar_file, vnf_template_file, preload_dict, suffix, heatbridge=False):
  63     """
  64     :return:  service instance UUID
  65     """
  66     so = soutils.SoUtils(vcpecommon, 'v4')
  67     return so.create_entire_service(csar_file, vnf_template_file, preload_dict, suffix, heatbridge)
  68
  69
  70 def deploy_brg_only():
  71     logger = logging.getLogger(__name__) # pylint: disable=W0612
  72
  73     vcpecommon = VcpeCommon(cfg_file=args.config)
  74     preload_dict = vcpecommon.load_preload_data()
  75 #    name_suffix = preload_dict['${brg_bng_net}'].split('_')[-1]
  76     name_suffix = datetime.now().strftime('%Y%m%d%H%M')
  77
  78     # create multiple services based on the pre-determined order
  79     svc_instance_uuid = vcpecommon.load_object(vcpecommon.svc_instance_uuid_file)
  80     for keyword in ['brgemu']:
  81         keyword_vnf=keyword + "_"
  82         keyword_gra=keyword + "gra_"
  83         heatbridge = 'gmux' == keyword
  84         csar_file = vcpecommon.find_file(keyword, 'csar', 'csar')
  85         vnf_template_file = vcpecommon.find_file(keyword_vnf, 'json', 'preload_templates')
  86         gra_template_file = vcpecommon.find_file(keyword_gra, 'json', 'preload_templates')
  87         if vcpecommon.gra_api_flag:
  88             vcpecommon.increase_ip_address_or_vni_in_template(gra_template_file, ['vbrgemu_private_ip_0'])
  89             svc_instance_uuid[keyword] = create_one_service(vcpecommon, csar_file, gra_template_file, preload_dict,
  90                                                             name_suffix, heatbridge)
  91         else:
  92             vcpecommon.increase_ip_address_or_vni_in_template(vnf_template_file, ['vbrgemu_private_ip_0'])
  93             svc_instance_uuid[keyword] = create_one_service(vcpecommon, csar_file, vnf_template_file, preload_dict,
  94                                                             name_suffix, heatbridge)
  95         if not svc_instance_uuid[keyword]:
  96             sys.exit(1)
  97
  98     # Setting up SNIRO
  99     config_sniro(vcpecommon, svc_instance_uuid['gmux'], svc_instance_uuid['brgemu'])
 100
 101
 102 def deploy_infra():
 103     logger = logging.getLogger(__name__)
 104
 105     vcpecommon = VcpeCommon(cfg_file=args.config)
 106
 107     # preload all VNF-API networks
 108     network_template = vcpecommon.find_file('network.', 'json', 'preload_templates')
 109     name_suffix = datetime.now().strftime('%Y%m%d%H%M')
 110     preloader = preload.Preload(vcpecommon)
 111     preload_dict = preloader.preload_all_networks(network_template, name_suffix)
 112     logger.debug('Initial preload dictionary:')
 113     logger.debug(json.dumps(preload_dict, indent=4, sort_keys=True))
 114     if not preload_dict:
 115         logger.error("Failed to preload networks.")
 116         sys.exit(1)
 117     vcpecommon.save_preload_data(preload_dict)
 118
 119     # preload all GRA-API networks
 120     network_template_gra = vcpecommon.find_file('networkgra.', 'json', 'preload_templates')
 121     preloader = preload.Preload(vcpecommon)
 122     preload_dict_gra = preloader.preload_all_networks(network_template_gra, name_suffix)
 123     logger.debug('Initial preload dictionary:')
 124     logger.debug(json.dumps(preload_dict, indent=4, sort_keys=True))
 125     if not preload_dict_gra:
 126         logger.error("Failed to preload networks.")
 127         sys.exit(1)
 128     vcpecommon.save_preload_data(preload_dict_gra)
 129
 130     # create multiple services based on the pre-determined order
 131     svc_instance_uuid = {}
 132     for keyword in ['infra', 'bng', 'gmux', 'brgemu']:
 133         keyword_vnf=keyword + "_"
 134         keyword_gra=keyword + "gra_"
 135         heatbridge = 'gmux' == keyword
 136         csar_file = vcpecommon.find_file(keyword, 'csar', 'csar')
 137         vnf_template_file = vcpecommon.find_file(keyword_vnf, 'json', 'preload_templates')
 138         gra_template_file = vcpecommon.find_file(keyword_gra, 'json', 'preload_templates')
 139         if vcpecommon.gra_api_flag:
 140             svc_instance_uuid[keyword] = create_one_service(vcpecommon, csar_file, gra_template_file, preload_dict,
 141                                                             name_suffix, heatbridge)
 142         else:
 143             svc_instance_uuid[keyword] = create_one_service(vcpecommon, csar_file, vnf_template_file, preload_dict,
 144                                                             name_suffix, heatbridge)
 145         if not svc_instance_uuid[keyword]:
 146             sys.exit(1)
 147
 148     vcpecommon.save_object(svc_instance_uuid, vcpecommon.svc_instance_uuid_file)
 149
 150     # Setting up SNIRO
 151     config_sniro(vcpecommon, svc_instance_uuid['gmux'], svc_instance_uuid['brgemu'])
 152
 153     print('----------------------------------------------------------------------------------------------------')
 154     print('Congratulations! The following have been completed correctly:')
 155     print(' - Infrastructure Service Instantiation: ')
 156     print('     * 4 VMs:      DHCP, AAA, DNS, Web Server')
 157     print('     * 2 Networks: CPE_PUBLIC, CPE_SIGNAL')
 158     print(' - vBNG Service Instantiation: ')
 159     print('     * 1 VM:       vBNG')
 160     print('     * 2 Networks: BRG_BNG, BNG_MUX')
 161     print(' - vGMUX Service Instantiation: ')
 162     print('     * 1 VM:       vGMUX')
 163     print('     * 1 Network:  MUX_GW')
 164     print(' - vBRG Service Instantiation: ')
 165     print('     * 1 VM:       vBRG')
 166     print(' - Adding vGMUX vServer information to AAI.')
 167     print(' - SNIRO Homing Emulator configuration.')
 168
 169
 170 def deploy_custom_service():
 171     nodes = ['brg', 'mux']
 172     vcpecommon = VcpeCommon(nodes, cfg_file=args.config)
 173     custom_service = vcpe_custom_service.CustomService(vcpecommon)
 174
 175     # clean up
 176     host_dic = {k: vcpecommon.hosts[k] for k in nodes}
 177     if False: # pylint: disable=W0125
 178         if not vcpecommon.delete_vxlan_interfaces(host_dic):
 179             sys.exit(1)
 180         custom_service.del_all_vgw_stacks(vcpecommon.vgw_name_keyword)
 181
 182     #custom_service.clean_up_sdnc()
 183
 184     # create new service
 185     csar_file = vcpecommon.find_file('rescust', 'csar', 'csar')
 186     vgw_template_file = vcpecommon.find_file('vgw', 'json', 'preload_templates')
 187     vgw_gra_template_file = vcpecommon.find_file('gwgra', 'json', 'preload_templates')
 188     preload_dict = vcpecommon.load_preload_data()
 189     custom_service.create_custom_service(csar_file, vgw_template_file, vgw_gra_template_file, preload_dict)
 190
 191
 192 def closed_loop(lossrate=0):
 193     nodes = ['brg', 'mux']
 194     logger = logging.getLogger('__name__')
 195     vcpecommon = VcpeCommon(nodes, cfg_file=args.config)
 196
 197     logger.info('Setting up closed loop policy')
 198     policy_template_file = vcpecommon.find_file('operational.vcpe', 'json', 'preload_templates')
 199     vcpecommon.set_closed_loop_policy(policy_template_file)
 200
 201     logger.info('Cleaning up vGMUX data reporting settings')
 202     vcpecommon.del_vgmux_ves_mode()
 203     time.sleep(2)
 204     vcpecommon.del_vgmux_ves_collector()
 205
 206     logger.info('Starting vGMUX data reporting to DCAE')
 207     time.sleep(2)
 208     vcpecommon.set_vgmux_ves_collector()
 209
 210     logger.info('Setting vGMUX to report packet loss rate: %s', lossrate)
 211     time.sleep(2)
 212     vcpecommon.set_vgmux_packet_loss_rate(lossrate, vcpecommon.load_vgmux_vnf_name())
 213     if lossrate > 0:
 214         print('Now please observe vGMUX being restarted')
 215
 216
 217 def init_so_sdnc():
 218     logger = logging.getLogger('__name__') # pylint: disable=W0612
 219     vcpecommon = VcpeCommon(cfg_file=args.config)
 220     config_sdnc_so.insert_sdnc_ip_pool(vcpecommon)
 221     config_sdnc_so.insert_customer_service_to_so(vcpecommon)
 222     #config_sdnc_so.insert_customer_service_to_sdnc(vcpecommon)
 223     vgw_vfmod_name_index=  0
 224     vcpecommon.save_object(vgw_vfmod_name_index, vcpecommon.vgw_vfmod_name_index_file)
 225
 226
 227 def init():
 228     vcpecommon = VcpeCommon(cfg_file=args.config)
 229     init_sdc(vcpecommon)
 230     download_vcpe_service_templates(vcpecommon)
 231     preloader = preload.Preload(vcpecommon)
 232     template_aai_region_data = vcpecommon.find_file('aai_region_data', 'json', 'preload_templates')
 233     preloader.preload_aai_data(template_aai_region_data)
 234
 235
 236 def init_sdc(vcpecommon):
 237     sdc = sdcutils.SdcUtils(vcpecommon) # pylint: disable=W0612
 238     # default SDC creates BRG - remove this in frankfurt
 239     #sdc.create_allotted_resource_subcategory('BRG')
 240
 241
 242 def download_vcpe_service_templates(vcpecommon):
 243     sdc = sdcutils.SdcUtils(vcpecommon)
 244     sdc.download_vcpe_service_template()
 245
 246
 247 def tmp_sniro():
 248     logger = logging.getLogger(__name__) # pylint: disable=W0612
 249
 250     vcpecommon = VcpeCommon(cfg_file=args.config)
 251
 252     svc_instance_uuid = vcpecommon.load_object(vcpecommon.svc_instance_uuid_file)
 253     # Setting up SNIRO
 254     config_sniro(vcpecommon, svc_instance_uuid['gmux'], svc_instance_uuid['brgemu'])
 255
 256
 257 def test():
 258     vcpecommon = VcpeCommon(cfg_file=args.config)
 259     print("oom-k8s-04 public ip: %s" % (vcpecommon.get_vm_public_ip_by_nova('oom-k8s-04')))
 260
 261
 262 def get_arg_parser(modes):
 263     """
 264     Parse cmd line options and return ArgumentParser object
 265     :param modes: map of supported script modes
 266     :return: ArgumentParser object
 267     """
 268     # Build usage synopsis string
 269     usage = "\n"*2
 270     for k,v in modes.items():
 271         usage += 'vcpe.py {0:12} {1}\n'.format(k + ':',v)
 272
 273     parser = argparse.ArgumentParser(usage=usage, formatter_class=
 274                                      argparse.ArgumentDefaultsHelpFormatter)
 275     parser.add_argument('mode',metavar='MODE',
 276                         help='Script mode: {0}'.format('|'.join(modes.keys())),
 277                         choices=modes.keys())
 278     parser.add_argument('--config',help='Configuration file path',default=None)
 279
 280     return parser
 281
 282 if __name__ == '__main__':
 283     # Supported modes matrix
 284     # OrderedDict object has to be used to preserve desired modes
 285     # order in synopsis text
 286     modes = OrderedDict()
 287 #    modes["sdc"]      = "Onboard VNFs, design and distribute vCPE services (under development)"
 288     modes["init"]     = "Add customer service data to SDNC and SO DBs"
 289     modes["infra"]    = "Deploy infrastructure, including DHCP, AAA, DNS, Web Server, vBNG, vGMUX, vBRG"
 290     modes["brg"]      = "Deploy brg only (for testing after infra succeeds)"
 291     modes["customer"] = "Deploy customer service, including vGW and VxLANs"
 292     modes["loop"]     = "Test closed loop control (packet loss set to 22)"
 293     modes["noloss"]   = "Set vGMUX packet loss to 0"
 294     modes["test"]     = ""
 295     modes["sniro"]    = "Config SNIRO homing emulator"
 296
 297     parser = get_arg_parser(modes)
 298
 299     try:
 300         assert len(sys.argv) != 1
 301     except AssertionError:
 302         # No cmd line opts given, print help
 303         parser.print_help()
 304         sys.exit(1)
 305     else:
 306         args = parser.parse_args()
 307
 308     if args.mode == 'init':
 309         init()
 310         init_so_sdnc()
 311     elif args.mode == 'infra':
 312         #if 'y' == raw_input('Ready to deploy infrastructure? y/n: ').lower():
 313         deploy_infra()
 314     elif args.mode == 'customer':
 315         if 'y' == raw_input('Ready to deploy customer service? y/n: ').lower(): # pylint: disable=E0602
 316             deploy_custom_service()
 317     elif args.mode == 'loop':
 318         closed_loop(22)
 319     elif args.mode == 'noloss':
 320         closed_loop(0)
 321     elif args.mode == 'brg':
 322         deploy_brg_only()
 323     elif args.mode == 'sniro':
 324         tmp_sniro()
 325     elif args.mode == 'test':
 326         test()