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