robotframework-onap/vcpeutils/SoUtils.py

   1 #! /usr/bin/python
   2
   3 import time
   4
   5 from vcpeutils.preload import *
   6 from vcpeutils.vcpecommon import *
   7
   8 from robot.api import logger
   9
  10
  11 class SoUtils:
  12
  13     def __init__(self):
  14         self.region_name = None  # set later
  15         self.tenant_id = None  # set later
  16         self.logger = logger
  17         self.vcpecommon = VcpeCommon()
  18         self.api_version = 'v4'
  19         self.service_req_api_url = self.vcpecommon.so_req_api_url[self.api_version]
  20
  21     def submit_create_req(self, req_json, req_type, service_instance_id=None, vnf_instance_id=None):
  22         """
  23         POST    {serverRoot}/serviceInstances/v4
  24         POST    {serverRoot}/serviceInstances/v4/{serviceInstanceId}/vnfs
  25         POST    {serverRoot}/serviceInstances/v4/{serviceInstanceId}/networks
  26         POST    {serverRoot}/serviceInstances/v4/{serviceInstanceId}/vnfs/{vnfInstanceId}/vfModules
  27         :param req_json:
  28         :param service_instance_id:  this is required only for networks, vnfs, and vf modules
  29         :param req_type:
  30         :param vnf_instance_id:
  31         :return: req_id, instance_id
  32         """
  33         if req_type == 'service':
  34             url = self.service_req_api_url
  35         elif req_type == 'vnf':
  36             url = '/'.join([self.service_req_api_url, service_instance_id, 'vnfs'])
  37         elif req_type == 'network':
  38             url = '/'.join([self.service_req_api_url, service_instance_id, 'networks'])
  39         elif req_type == 'vfmodule':
  40             url = '/'.join([self.service_req_api_url, service_instance_id, 'vnfs', vnf_instance_id, 'vfModules'])
  41         else:
  42             self.logger.error('Invalid request type: {0}. Can only be service/vnf/network/vfmodule'.format(req_type))
  43             return None, None
  44
  45         self.logger.info(url)
  46         r = requests.post(url, headers=self.vcpecommon.so_headers, auth=self.vcpecommon.so_userpass, json=req_json)
  47         self.logger.debug(r)
  48         response = r.json()
  49
  50         self.logger.debug('---------------------------------------------------------------')
  51         self.logger.debug('------- Creation request submitted to SO, got response --------')
  52         self.logger.debug(json.dumps(response, indent=4, sort_keys=True))
  53         self.logger.debug('---------------------------------------------------------------')
  54         req_id = response.get('requestReferences', {}).get('requestId', '')
  55         instance_id = response.get('requestReferences', {}).get('instanceId', '')
  56
  57         return req_id, instance_id
  58
  59     def check_progress(self, req_id, interval=5):
  60         if not req_id:
  61             self.logger.error('Error when checking SO request progress, invalid request ID: ' + req_id)
  62             return False
  63         duration = 0.0
  64         url = self.vcpecommon.so_check_progress_api_url + '/' + req_id
  65
  66         while True:
  67             time.sleep(interval)
  68             r = requests.get(url, headers=self.vcpecommon.so_headers, auth=self.vcpecommon.so_userpass)
  69             response = r.json()
  70
  71             duration += interval
  72
  73             if response['request']['requestStatus']['requestState'] == 'IN_PROGRESS':
  74                 self.logger.debug('------------------Request Status-------------------------------')
  75                 self.logger.debug(json.dumps(response, indent=4, sort_keys=True))
  76             else:
  77                 self.logger.debug('---------------------------------------------------------------')
  78                 self.logger.debug('----------------- Creation Request Results --------------------')
  79                 self.logger.debug(json.dumps(response, indent=4, sort_keys=True))
  80                 self.logger.debug('---------------------------------------------------------------')
  81                 flag = response['request']['requestStatus']['requestState'] == 'COMPLETE'
  82                 if not flag:
  83                     self.logger.error('Request failed.')
  84                     self.logger.error(json.dumps(response, indent=4, sort_keys=True))
  85                 return flag
  86
  87     @staticmethod
  88     def add_req_info(req_details, instance_name, product_family_id=None):
  89         req_details['requestInfo'] = {
  90                     'instanceName': instance_name,
  91                     'source': 'VID',
  92                     'suppressRollback': 'true',
  93                     'requestorId': 'vCPE-Robot'
  94         }
  95         if product_family_id:
  96             req_details['requestInfo']['productFamilyId'] = product_family_id
  97
  98     @staticmethod
  99     def add_related_instance(req_details, instance_id, instance_model):
 100         instance = {"instanceId": instance_id, "modelInfo": instance_model}
 101         if 'relatedInstanceList' not in req_details:
 102             req_details['relatedInstanceList'] = [{"relatedInstance": instance}]
 103         else:
 104             req_details['relatedInstanceList'].append({"relatedInstance": instance})
 105
 106     def generate_vnf_or_network_request(self, instance_name, vnf_or_network_model, service_instance_id, service_model):
 107         req_details = {
 108             'modelInfo':  vnf_or_network_model,
 109             'cloudConfiguration': {"lcpCloudRegionId": self.region_name,
 110                                    "tenantId": self.tenant_id},
 111             'requestParameters':  {"userParams": []},
 112             'platform': {"platformName": "Platform-Demonstration"}
 113         }
 114         self.add_req_info(req_details, instance_name, self.vcpecommon.product_family_id)
 115         self.add_related_instance(req_details, service_instance_id, service_model)
 116         return {'requestDetails': req_details}
 117
 118     def generate_vfmodule_request(self, instance_name, vfmodule_model, service_instance_id,
 119                                   service_model, vnf_instance_id, vnf_model):
 120         req_details = {
 121             'modelInfo':  vfmodule_model,
 122             'cloudConfiguration': {"lcpCloudRegionId": self.region_name,
 123                                    "tenantId": self.tenant_id},
 124             'requestParameters': {"usePreload": 'true'}
 125         }
 126         self.add_req_info(req_details, instance_name, self.vcpecommon.product_family_id)
 127         self.add_related_instance(req_details, service_instance_id, service_model)
 128         self.add_related_instance(req_details, vnf_instance_id, vnf_model)
 129         return {'requestDetails': req_details}
 130
 131     def generate_service_request(self, instance_name, model):
 132         req_details = {
 133             'modelInfo':  model,
 134             'subscriberInfo':  {'globalSubscriberId': self.vcpecommon.global_subscriber_id},
 135             'requestParameters': {
 136                 "userParams": [],
 137                 "subscriptionServiceType": "vCPE",
 138                 "aLaCarte": 'true'
 139             }
 140         }
 141         self.add_req_info(req_details, instance_name)
 142         self.add_project_info(req_details)
 143         self.add_owning_entity(req_details)
 144         return {'requestDetails': req_details}
 145
 146     def add_project_info(self, req_details):
 147         req_details['project'] = {'projectName': self.vcpecommon.project_name}
 148
 149     def add_owning_entity(self, req_details):
 150         req_details['owningEntity'] = {'owningEntityId': self.vcpecommon.owning_entity_id,
 151                                        'owningEntityName': self.vcpecommon.owning_entity_name}
 152
 153     def generate_custom_service_request(self, instance_name, model, brg_mac):
 154         brg_mac_enc = brg_mac.replace(':', '-')
 155         req_details = {
 156             'modelInfo':  model,
 157             'subscriberInfo':  {'subscriberName': 'Kaneohe',
 158                                 'globalSubscriberId': self.vcpecommon.global_subscriber_id},
 159             'cloudConfiguration': {"lcpCloudRegionId": self.region_name,
 160                                    "tenantId": self.tenant_id},
 161             'requestParameters': {
 162                 "userParams": [
 163                     {
 164                         'name': 'BRG_WAN_MAC_Address',
 165                         'value': brg_mac
 166                     },
 167                     {
 168                        'name': 'VfModuleNames',
 169                        'value': [
 170                             {
 171                                 'VfModuleModelInvariantUuid': self.vcpecommon.vgw_VfModuleModelInvariantUuid,
 172                                 'VfModuleName': 'VGW2BRG-{0}'.format(brg_mac_enc)
 173                             }
 174                        ]
 175                     },
 176                     {
 177                          "name": "Customer_Location",
 178                          "value": self.vcpecommon.customer_location_used_by_oof
 179                     },
 180                     {
 181                          "name": "Homing_Solution",
 182                          "value": self.vcpecommon.homing_solution
 183                     }
 184                 ],
 185                 "subscriptionServiceType": "vCPE",
 186                 'aLaCarte': 'false'
 187             }
 188         }
 189         self.add_req_info(req_details, instance_name, self.vcpecommon.custom_product_family_id)
 190         self.add_project_info(req_details)
 191         self.add_owning_entity(req_details)
 192         return {'requestDetails': req_details}
 193
 194     def create_custom_service(self, csar_file, brg_mac, name_suffix=None):
 195         parser = CsarParser()
 196         if not parser.parse_csar(csar_file):
 197             return False
 198
 199         # yyyymmdd_hhmm
 200         if not name_suffix:
 201             name_suffix = '_' + datetime.now().strftime('%Y%m%d%H%M')
 202
 203         # create service
 204         instance_name = '_'.join([self.vcpecommon.instance_name_prefix['service'],
 205                                   parser.svc_model['modelName'][0:10], name_suffix])
 206         instance_name = instance_name.lower()
 207         req = self.generate_custom_service_request(instance_name, parser.svc_model, brg_mac)
 208         self.logger.info(json.dumps(req, indent=2, sort_keys=True))
 209         self.logger.info('Creating custom service {0}.'.format(instance_name))
 210         req_id, svc_instance_id = self.submit_create_req(req, 'service')
 211         if not self.check_progress(req_id):
 212             return False
 213         return True
 214
 215     def wait_for_aai(self, node_type, uuid):
 216         self.logger.info('Waiting for AAI traversal to complete...')
 217         for i in range(30):
 218             time.sleep(1)
 219             if self.vcpecommon.is_node_in_aai(node_type, uuid):
 220                 return
 221
 222         self.logger.error("AAI traversal didn't finish in 30 seconds. Something is wrong. Type {0}, UUID {1}".format(
 223             node_type, uuid))
 224         sys.exit()
 225
 226     def create_entire_service(self, csar_file, vnf_template_file, preload_dict, name_suffix, region_name, tenant_id):
 227         """
 228         :param csar_file:
 229         :param vnf_template_file:
 230         :param preload_dict:
 231         :param name_suffix:
 232         :param region_name:
 233         :param tenant_id
 234         :return:  service instance UUID
 235         """
 236         self.region_name = region_name
 237         self.tenant_id = tenant_id
 238         self.logger.info('\n----------------------------------------------------------------------------------')
 239         self.logger.info('Start to create entire service defined in csar: {0}'.format(csar_file))
 240         parser = CsarParser()
 241         self.logger.info('Parsing csar ...')
 242         if not parser.parse_csar(csar_file):
 243             self.logger.error('Cannot parse csar: {0}'.format(csar_file))
 244             return None
 245
 246         # Set Global timestamp for instancenames
 247         global_timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
 248         # create service
 249         instance_name = '_'.join([self.vcpecommon.instance_name_prefix['service'],
 250                                   parser.svc_model['modelName'], global_timestamp, name_suffix])
 251         instance_name = instance_name.lower()
 252         instance_name = instance_name.replace(' ', '')
 253         instance_name = instance_name.replace(':', '')
 254         self.logger.info('Creating service instance: {0}.'.format(instance_name))
 255         req = self.generate_service_request(instance_name, parser.svc_model)
 256         self.logger.debug(json.dumps(req, indent=2, sort_keys=True))
 257         req_id, svc_instance_id = self.submit_create_req(req, 'service')
 258         if not self.check_progress(req_id, interval=5):
 259             return None
 260
 261         # wait for AAI to complete traversal
 262         self.wait_for_aai('service', svc_instance_id)
 263
 264         # create networks
 265         for model in parser.net_models:
 266             base_name = model['modelCustomizationName'].lower().replace('mux_vg', 'mux_gw')
 267             network_name = '_'.join([self.vcpecommon.instance_name_prefix['network'], base_name, name_suffix])
 268             network_name = network_name.lower()
 269             self.logger.info('Creating network: ' + network_name)
 270             req = self.generate_vnf_or_network_request(network_name, model, svc_instance_id, parser.svc_model)
 271             self.logger.debug(json.dumps(req, indent=2, sort_keys=True))
 272             req_id, net_instance_id = self.submit_create_req(req, 'network', svc_instance_id)
 273             if not self.check_progress(req_id):
 274                 return None
 275
 276             self.logger.info('Changing subnet name to ' + self.vcpecommon.network_name_to_subnet_name(network_name))
 277             self.vcpecommon.set_network_name(network_name)
 278             subnet_name_changed = False
 279             for i in range(20):
 280                 time.sleep(3)
 281                 if self.vcpecommon.set_subnet_name(network_name):
 282                     subnet_name_changed = True
 283                     break
 284
 285             if not subnet_name_changed:
 286                 self.logger.error('Failed to change subnet name for ' + network_name)
 287                 return None
 288
 289         vnf_model = None
 290         vnf_instance_id = None
 291         # create VNF
 292         if len(parser.vnf_models) == 1:
 293             vnf_model = parser.vnf_models[0]
 294             vnf_instance_name = '_'.join([self.vcpecommon.instance_name_prefix['vnf'],
 295                                           vnf_model['modelCustomizationName'].split(' ')[0],  name_suffix])
 296             vnf_instance_name = vnf_instance_name.lower()
 297             vnf_instance_name = vnf_instance_name.replace(' ', '')
 298             vnf_instance_name = vnf_instance_name.replace(':', '')
 299             self.logger.info('Creating VNF: ' + vnf_instance_name)
 300             req = self.generate_vnf_or_network_request(vnf_instance_name, vnf_model, svc_instance_id, parser.svc_model)
 301             self.logger.debug(json.dumps(req, indent=2, sort_keys=True))
 302             req_id, vnf_instance_id = self.submit_create_req(req, 'vnf', svc_instance_id)
 303             if not self.check_progress(req_id, interval=5):
 304                 self.logger.error('Failed to create VNF {0}.'.format(vnf_instance_name))
 305                 return False
 306
 307             # wait for AAI to complete traversal
 308             if not vnf_instance_id:
 309                 self.logger.error('No VNF instance ID returned!')
 310                 sys.exit()
 311             self.wait_for_aai('vnf', vnf_instance_id)
 312
 313         # SDNC Preload
 314
 315         preloader = Preload(self.vcpecommon)
 316         preloader.preload_vfmodule(vnf_template_file, svc_instance_id, parser.vnf_models[0], parser.vfmodule_models[0],
 317                                    preload_dict, name_suffix)
 318
 319         # create VF Module
 320         if len(parser.vfmodule_models) == 1:
 321             if not vnf_instance_id or not vnf_model:
 322                 self.logger.error('Invalid VNF instance ID or VNF model!')
 323                 sys.exit()
 324
 325             model = parser.vfmodule_models[0]
 326             vfmodule_instance_name = '_'.join([self.vcpecommon.instance_name_prefix['vfmodule'],
 327                                                model['modelCustomizationName'].split('..')[0], name_suffix])
 328             vfmodule_instance_name = vfmodule_instance_name.lower()
 329             vfmodule_instance_name = vfmodule_instance_name.replace(' ', '')
 330             vfmodule_instance_name = vfmodule_instance_name.replace(':', '')
 331             self.logger.info('Creating VF Module: ' + vfmodule_instance_name)
 332             req = self.generate_vfmodule_request(vfmodule_instance_name, model, svc_instance_id, parser.svc_model,
 333                                                  vnf_instance_id, vnf_model)
 334             self.logger.debug(json.dumps(req, indent=2, sort_keys=True))
 335             req_id, vfmodule_instance_id = self.submit_create_req(req, 'vfmodule', svc_instance_id, vnf_instance_id)
 336             if not self.check_progress(req_id, interval=50):
 337                 self.logger.error('Failed to create VF Module {0}.'.format(vfmodule_instance_name))
 338                 return None
 339
 340         return svc_instance_id