def setUp(self): super(TestPnfServiceAppliance, self).setUp() logger.debug("setUp called") # Create Global system config object self.gsc_obj = self.api.global_system_config_read( GlobalSystemConfig().fq_name) self.default_gsc_name = 'default-global-system-config' # Create Service Appliance Set object self.sas_obj = ServiceApplianceSet('sas-' + self.id(), self.gsc_obj) self.sas_obj.set_service_appliance_set_virtualization_type( 'physical-device') self.api.service_appliance_set_create(self.sas_obj) # Create PNF Physical Router object self.pnf_obj = PhysicalRouter('pnf-' + self.id(), self.gsc_obj) self.pnf_obj.set_physical_router_role('pnf') self.api.physical_router_create(self.pnf_obj) # Create spine Physical Router object self.spine_obj = PhysicalRouter('spine-' + self.id(), self.gsc_obj) self.api.physical_router_create(self.spine_obj) # create left, right PNF PI self.left_pnf_pi_obj = PhysicalInterface( 'ge-0/0/1-' + self.id(), parent_obj=self.pnf_obj) self.right_pnf_pi_obj = PhysicalInterface( 'ge-0/0/2-' + self.id(), parent_obj=self.pnf_obj) self.api.physical_interface_create(self.left_pnf_pi_obj) self.api.physical_interface_create(self.right_pnf_pi_obj) # create left, right spine PI self.left_spine_pi_obj = PhysicalInterface( 'xe-0/0/1-' + self.id(), parent_obj=self.spine_obj) self.right_spine_pi_obj = PhysicalInterface( 'xe-0/0/2-' + self.id(), parent_obj=self.spine_obj) self.api.physical_interface_create(self.left_spine_pi_obj) self.api.physical_interface_create(self.right_spine_pi_obj)
def _pr_object_create_update(self, oid_mapped, fq_name, update): pr_uuid = None msg = None try: os_version = oid_mapped.get('os-version', None) serial_num = oid_mapped.get('serial-number', None) physicalrouter = PhysicalRouter( parent_type='global-system-config', fq_name=fq_name, physical_router_management_ip=oid_mapped.get('host'), physical_router_vendor_name=oid_mapped.get('vendor'), physical_router_product_name=oid_mapped.get('product'), physical_router_device_family=oid_mapped.get('family'), physical_router_vnc_managed=True, physical_router_user_credentials={ 'username': oid_mapped.get('username'), 'password': oid_mapped.get('password') }) if update: pr_unicode_obj = self.vncapi.physical_router_update( physicalrouter) if pr_unicode_obj: pr_obj_dict = ast.literal_eval(pr_unicode_obj) pr_uuid = pr_obj_dict['physical-router']['uuid'] msg = "Discovered %s:\n Host name: %s\n Vendor: %s\n" \ " Model: %s" % ( oid_mapped.get('host'), fq_name[1], oid_mapped.get('vendor'), oid_mapped.get('product') ) self.logger.info("Discovered {} : {}".format( oid_mapped.get('host'), pr_uuid)) else: # underlay_managed flag should only be set at physical-router # creation time physicalrouter.set_physical_router_underlay_managed( self.job_ctx.get('job_input').get('manage_underlay', True)) pr_uuid = self.vncapi.physical_router_create(physicalrouter) msg = "Discovered device details: {} : {} : {}".format( oid_mapped.get('host'), fq_name[1], oid_mapped.get('product')) self.logger.info("Device created with uuid- {} : {}".format( oid_mapped.get('host'), pr_uuid)) self.module.send_prouter_object_log(fq_name, "DISCOVERED", os_version, serial_num) except (RefsExistError, Exception) as ex: if isinstance(ex, RefsExistError): return REF_EXISTS_ERROR, None self.logger.error("VNC create failed with error: {}".format( str(ex))) return False, None self.module.send_job_object_log( msg, JOB_IN_PROGRESS, None, job_success_percent=self.per_greenlet_percentage) self.discovery_percentage_write() return True, pr_uuid
def test_logical_interface_create_qfx_l3(self): # create test device object phy_router_obj = PhysicalRouter( parent_type='global-system-config', fq_name=[ "default-global-system-config", "test_device_qfx_%s" % self.id() ], physical_router_management_ip="1.1.1.1", physical_router_vendor_name="juniper", physical_router_product_name="qfx5k", physical_router_user_credentials={ "username": "******", "password": "******" }, physical_router_device_family='junos-qfx') self._vnc_lib.physical_router_create(phy_router_obj) phy_int_obj = PhysicalInterface(name="phy_intf_qfx_%s" % self.id(), parent_obj=phy_router_obj) self._vnc_lib.physical_interface_create(phy_int_obj) log_int_obj = LogicalInterface(name="log_intf_qfx_%s" % self.id(), parent_obj=phy_int_obj, logical_interface_vlan_tag=2, logical_interface_type='l3') self.assertIsNotNone( self._vnc_lib.logical_interface_create(log_int_obj))
def test_logical_interface_create_qfx_l2(self): # create test device object phy_router_obj = PhysicalRouter( parent_type='global-system-config', fq_name=[ "default-global-system-config", "test_device_qfx_%s" % self.id() ], physical_router_management_ip="1.1.1.1", physical_router_vendor_name="juniper", physical_router_product_name="qfx5k", physical_router_user_credentials={ "username": "******", "password": "******" }, physical_router_device_family='junos-qfx') self._vnc_lib.physical_router_create(phy_router_obj) phy_int_obj = PhysicalInterface(name="phy_intf_qfx_%s" % self.id(), parent_obj=phy_router_obj) self._vnc_lib.physical_interface_create(phy_int_obj) log_int_obj = LogicalInterface(name="log_intf_qfx_%s" % self.id(), parent_obj=phy_int_obj, logical_interface_vlan_tag=2, logical_interface_type='l2') regex_msg = (r"Vlan ids \[1, 2, 4094\] are not allowed on " "QFX logical interface type: l2") self.assertRaisesRegexp(BadRequest, regex_msg, self._vnc_lib.logical_interface_create, log_int_obj)
def create_qfx_and_pi(self, pr_and_pi): logger.warn("Creating PR") for pr_data in pr_and_pi: pr = PhysicalRouter(pr_data) pr_uuid = self.api.physical_router_create(pr) pr_obj = self.api.physical_router_read(id=pr_uuid) logger.warn("Created PR: " + pr_data) for pi_data in pr_and_pi[pr_data]: logger.warn(" Created PI: " + pr_data + " => " + pi_data) pi_obj = PhysicalInterface(name=pi_data, parent_obj=pr_obj) self.api.physical_interface_create(pi_obj)
def create_image_and_device(self, img_name, img_uri, img_version, img_family, img_vendor, device_family, device_vendor, prouter_ip, prouter_password, device_name): """create image and physical device""" img_fqname = None device_fqname = None try: self._logger.info('Creating image: %s', img_name) img_fqname = ['default-global-system-config', img_name] image = DeviceImage(name=img_name, fq_name=img_fqname, parent_type='global-system-config', device_image_file_uri=img_uri, device_image_os_version=img_version, device_image_device_family=img_family, device_image_vendor_name=img_vendor) img_uuid = self._api.device_image_create(image) image = self._api.device_image_read(id=img_uuid) except RefsExistError: self._logger.warn("Image '%s' already exists", img_name) image = self._api.device_image_read(fq_name=img_fqname) self._logger.debug( "Image created:\n%s", pprint.pformat(self._api.obj_to_dict(image), indent=4)) try: self._logger.info('Creating device: %s', device_name) device_fqname = ['default-global-system-config', device_name] device = PhysicalRouter( name=device_name, fq_name=device_fqname, physical_router_device_family=device_family, physical_router_management_ip=prouter_ip, physical_router_vendor_name=device_vendor, physical_router_user_credentials={ 'username': '******', 'password': prouter_password }) device_uuid = self._api.physical_router_create(device) device = self._api.physical_router_read(id=device_uuid) except RefsExistError: self._logger.warn("Device '%s' already exists", device_name) device = self._api.physical_router_read(fq_name=device_fqname) self._logger.debug( "Device created:\n%s", pprint.pformat(self._api.obj_to_dict(device), indent=4)) return image, device
def _pr_object_create_update(vncapi, device_info, fq_name, module, update, per_greenlet_percentage): pr_uuid = None logger = module.logger try: os_version = device_info.get('os-version', None) serial_num = device_info.get('serial-number', None) physicalrouter = PhysicalRouter( parent_type='global-system-config', fq_name=fq_name, physical_router_management_ip=device_info.get('host'), physical_router_vendor_name=device_info.get('vendor'), physical_router_product_name=device_info.get('product'), physical_router_device_family=device_info.get('family'), physical_router_vnc_managed=True, physical_router_user_credentials={ 'username': device_info.get('username'), 'password': device_info.get('password') }) if update: pr_unicode_obj = vncapi.physical_router_update(physicalrouter) if pr_unicode_obj: pr_obj_dict = ast.literal_eval(pr_unicode_obj) pr_uuid = pr_obj_dict['physical-router']['uuid'] msg = "Updated device info for: {} : {} : {}".format( device_info.get('host'), fq_name[1], device_info.get('product')) logger.info("Updated device info for: {} : {}".format( device_info.get('host'), pr_uuid)) else: pr_uuid = vncapi.physical_router_create(physicalrouter) msg = "Discovered device details: {} : {} : {}".format( device_info.get('host'), fq_name[1], device_info.get('product')) logger.info("Device created with uuid- {} : {}".format( device_info.get('host'), pr_uuid)) module.send_prouter_object_log(fq_name, "DISCOVERED", os_version, serial_num) except (RefsExistError, Exception) as ex: if isinstance(ex, RefsExistError): return REF_EXISTS_ERROR, None logger.error("VNC create failed with error: {}".format(str(ex))) return False, None module.send_job_object_log(msg, JOB_IN_PROGRESS, None, job_success_percent=per_greenlet_percentage) return True, pr_uuid
def test_physical_interface_ae_id_alloc_and_free(self): AE_ID_TEST_CASES = [3, 127] mock_zk = self._api_server._db_conn._zk_db pr_name = self.id() + '_physical_router' pr = PhysicalRouter(pr_name) pr_uuid = self._vnc_lib.physical_router_create(pr) pr_obj = self._vnc_lib.physical_router_read(id=pr_uuid) for ae_id in AE_ID_TEST_CASES: pi_name = 'ae' + str(ae_id) pi = PhysicalInterface(name=pi_name, parent_obj=pr_obj) pi_uuid = self._vnc_lib.physical_interface_create(pi) self.assertEqual(pi_name, mock_zk.ae_id_is_occupied(pr_name, ae_id)) self._vnc_lib.physical_interface_delete(id=pi_uuid) self.assertFalse(mock_zk.ae_id_is_occupied(pr_name, ae_id)) self._vnc_lib.physical_router_delete(id=pr_uuid)
def test_physical_interface_ae_id_is_busy(self): AE_ID = 3 NAME_OF_OBJECT_OCCUPING_AE_ID = 'VPG_1' mock_zk = self._api_server._db_conn._zk_db pr_name = self.id() + '_physical_router' pr = PhysicalRouter(pr_name) pr_uuid = self._vnc_lib.physical_router_create(pr) pr_obj = self._vnc_lib.physical_router_read(id=pr_uuid) pi_name = 'ae' + str(AE_ID) mock_zk.alloc_ae_id(pr_name, NAME_OF_OBJECT_OCCUPING_AE_ID, AE_ID) self.assertEqual(NAME_OF_OBJECT_OCCUPING_AE_ID, mock_zk.ae_id_is_occupied(pr_name, AE_ID)) pi = PhysicalInterface(name=pi_name, parent_obj=pr_obj) self.assertRaises(PermissionDenied, self._vnc_lib.physical_interface_create, pi) self.assertEqual(NAME_OF_OBJECT_OCCUPING_AE_ID, mock_zk.ae_id_is_occupied(pr_name, AE_ID)) self._vnc_lib.physical_router_delete(id=pr_uuid) mock_zk.free_ae_id(pr_name, AE_ID, NAME_OF_OBJECT_OCCUPING_AE_ID)
def _pr_object_create( vncapi, oid_mapped, fq_name, logger, object_log, fabric_uuid): try: physicalrouter = PhysicalRouter( parent_type='global-system-config', fq_name=fq_name, physical_router_management_ip=oid_mapped.get('host'), physical_router_vendor_name=oid_mapped.get('vendor'), physical_router_product_name=oid_mapped.get('product'), physical_router_device_family=oid_mapped.get('family'), physical_router_vnc_managed=True, physical_router_user_credentials={ 'username': oid_mapped.get('username'), 'password': oid_mapped.get('password') } ) pr_uuid = vncapi.physical_router_create(physicalrouter) except(RefsExistError, Exception) as ex: if isinstance(ex, RefsExistError): return REF_EXISTS_ERROR logger.error("VNC create failed with error: {}".format(str(ex))) return False msg = "Discovered device details: {} : {} : {}".format( oid_mapped.get('host'), fq_name[1], oid_mapped.get('product')) logger.info("Device created with uuid- {} : {}".format(oid_mapped.get( 'host'), pr_uuid)) vncapi.ref_update( "fabric", fabric_uuid, "physical_router", pr_uuid, None, "ADD") _send_sandesh_log(object_log, msg, logger, False) return True
def _pr_object_create_update(self, oid_mapped, fq_name, update): pr_uuid = None msg = None dhcp_fq_name = None try: os_version = oid_mapped.get('os-version', None) serial_num = oid_mapped.get('serial-number', None) physicalrouter = PhysicalRouter( parent_type='global-system-config', fq_name=fq_name, physical_router_management_ip=oid_mapped.get('host'), physical_router_vendor_name=oid_mapped.get('vendor'), physical_router_product_name=oid_mapped.get('product'), physical_router_device_family=oid_mapped.get('family'), physical_router_vnc_managed=True, physical_router_snmp_credentials={ 'version': 2, 'v2_community': 'public', 'local_port': 161 }, physical_router_hostname=fq_name[-1], display_name=fq_name[-1], physical_router_serial_number=serial_num, physical_router_managed_state='active', physical_router_user_credentials={ 'username': oid_mapped.get('username'), 'password': oid_mapped.get('password') }, physical_router_encryption_type='none', physical_router_supplemental_config=oid_mapped.get( 'supplemental_config') # noqa: E501 ) if update: pr_unicode_obj = self.vncapi.physical_router_update( physicalrouter) if pr_unicode_obj: pr_obj_dict = ast.literal_eval(pr_unicode_obj) pr_uuid = pr_obj_dict['physical-router']['uuid'] msg = "Discovered %s:\n Host name: %s\n Vendor: %s\n" \ " Model: %s" % ( oid_mapped.get('host'), fq_name[1], oid_mapped.get('vendor'), oid_mapped.get('product') ) self.logger.info("Discovered {} : {}".format( oid_mapped.get('host'), pr_uuid)) else: # underlay_managed flag should only be set at physical-router # creation time physicalrouter.set_physical_router_underlay_managed( self.job_ctx.get('job_input').get('manage_underlay', True)) pr_uuid = self.vncapi.physical_router_create(physicalrouter) msg = "Discovered device details: {} : {} : {}".format( oid_mapped.get('host'), fq_name[1], oid_mapped.get('product')) self.logger.info("Device created with uuid- {} : {}".format( oid_mapped.get('host'), pr_uuid)) self.module.send_prouter_object_log(fq_name, "DISCOVERED", os_version, serial_num) except (RefsExistError, Exception) as ex: if isinstance(ex, RefsExistError): return REF_EXISTS_ERROR, None self.logger.error("VNC create failed with error: {}".format( str(ex))) return False, None try: # delete the corresponding dhcp state PR object if it exists dhcp_fq_name = [ 'default-global-system-config', oid_mapped.get('serial-number') ] pr_obj = self.vncapi.physical_router_read( fq_name=dhcp_fq_name, fields=['physical_router_managed_state']) if pr_obj.get_physical_router_managed_state() == 'dhcp': self.vncapi.physical_router_delete(fq_name=dhcp_fq_name) self.logger.info( "Router {} in dhcp state deleted".format(dhcp_fq_name)) except (NoIdError, Exception) as ex: self.logger.info( "Router {} in dhcp state doesn't exist. Failed with " "error {}".format(dhcp_fq_name, str(ex))) pass self.module.send_job_object_log( msg, JOB_IN_PROGRESS, None, job_success_percent=self.per_greenlet_percentage) self.discovery_percentage_write() return True, pr_uuid
def main(): logging.basicConfig(filename=DEFAULT_LOG_PATH, level=logging.INFO, format=LOGGING_FORMAT, datefmt=DATE_FORMAT) logger = logging.getLogger("dnsmasq") logger.setLevel(logging.INFO) vnc_api = _initialize_vnc() if sys.argv[1] == 'read': # read from DB mac:ip filters = {} lease = 0 filters['physical_router_managed_state'] = "dhcp" for pr in vnc_api.physical_routers_list( filters=filters).get('physical-routers'): device_obj = vnc_api.physical_router_read( id=pr.get('uuid'), fields=[ 'physical_router_management_mac', 'physical_router_management_ip', 'physical_router_dhcp_parameters' ]) if device_obj.get_physical_router_dhcp_parameters(): lease = device_obj.get_physical_router_dhcp_parameters().\ lease_expiry_time print("DNSMASQ_LEASE=%s %s %s * *" % (lease, device_obj.get_physical_router_management_mac(), device_obj.get_physical_router_management_ip())) logger.info( "DNSMASQ_LEASE=%s %s %s * *" % (lease, device_obj.get_physical_router_management_mac(), device_obj.get_physical_router_management_ip())) elif sys.argv[1] == 'write': # write to the DB dummy PR with mac:ip fq_name = ['default-global-system-config', sys.argv[4]] physicalrouter = PhysicalRouter( parent_type='global-system-config', fq_name=fq_name, physical_router_management_mac=sys.argv[2], physical_router_management_ip=sys.argv[3], physical_router_managed_state='dhcp', physical_router_hostname=sys.argv[4], physical_router_dhcp_parameters={'lease_expiry_time': sys.argv[5]}, physical_router_device_family=sys.argv[6]) try: pr_uuid = vnc_api.physical_router_create(physicalrouter) except Exception: logger.info("Router '%s' already exists, hence updating it" % fq_name[-1]) pr_uuid = vnc_api.physical_router_update(physicalrouter) logger.info("DNSMASQ_LEASE_OBTAINED=%s %s %s" % (sys.argv[4], sys.argv[2], sys.argv[3])) logger.info("Router created id: %s" % pr_uuid) elif sys.argv[1] == 'delete': object_type = "physical_router" device_family = "" fq_name = ['default-global-system-config', sys.argv[2]] try: pr_uuid = vnc_api.fq_name_to_id(object_type, fq_name) device_obj = vnc_api.physical_router_read( id=pr_uuid, fields=['physical_router_device_family']) device_family = device_obj.get_physical_router_device_family() logger.info("Device Family %s", device_family) if "qfx5220" not in device_family: vnc_api.physical_router_delete(fq_name=fq_name) except Exception: logger.info("Router '%s' doesnot exist" % fq_name[-1])
def _pr_object_create_update( self, oid_mapped, fq_name, update): pr_uuid = None msg = None try: os_version = oid_mapped.get('os-version', None) serial_num = oid_mapped.get('serial-number', None) physicalrouter = PhysicalRouter( parent_type='global-system-config', fq_name=fq_name, physical_router_management_ip=oid_mapped.get('host'), physical_router_vendor_name=oid_mapped.get('vendor'), physical_router_product_name=oid_mapped.get('product'), physical_router_device_family=oid_mapped.get('family'), physical_router_vnc_managed=True, physical_router_hostname=fq_name[-1], display_name=fq_name[-1], physical_router_serial_number=serial_num, physical_router_managed_state='active', physical_router_user_credentials={ 'username': oid_mapped.get('username'), 'password': oid_mapped.get('password') } ) if update: pr_unicode_obj = self.vncapi.physical_router_update( physicalrouter) if pr_unicode_obj: pr_obj_dict = ast.literal_eval(pr_unicode_obj) pr_uuid = pr_obj_dict['physical-router']['uuid'] msg = "Discovered %s:\n Host name: %s\n Vendor: %s\n" \ " Model: %s" % ( oid_mapped.get('host'), fq_name[1], oid_mapped.get('vendor'), oid_mapped.get('product') ) self.logger.info("Discovered {} : {}".format( oid_mapped.get('host'), pr_uuid )) else: # underlay_managed flag should only be set at physical-router # creation time physicalrouter.set_physical_router_underlay_managed( self.job_ctx.get('job_input').get('manage_underlay', True) ) pr_uuid = self.vncapi.physical_router_create(physicalrouter) msg = "Discovered device details: {} : {} : {}".format( oid_mapped.get('host'), fq_name[1], oid_mapped.get( 'product')) self.logger.info("Device created with uuid- {} : {}".format( oid_mapped.get( 'host'), pr_uuid)) self.module.send_prouter_object_log(fq_name, "DISCOVERED", os_version, serial_num) except(RefsExistError, Exception) as ex: if isinstance(ex, RefsExistError): return REF_EXISTS_ERROR, None self.logger.error("VNC create failed with error: {}".format(str( ex))) return False, None self.module.send_job_object_log( msg, JOB_IN_PROGRESS, None, job_success_percent=self.per_greenlet_percentage) self.discovery_percentage_write() return True, pr_uuid
def test_physical_interface_esi(self): pr_name = self.id() + '_physical_router' pr = PhysicalRouter(pr_name) pr_uuid = self._vnc_lib.physical_router_create(pr) pr_obj = self._vnc_lib.physical_router_read(id=pr_uuid) esi_id = '00:11:22:33:44:55:66:77:88:99' pi1_name = self.id() + '_physical_interface1' pi1 = PhysicalInterface(name=pi1_name, parent_obj=pr_obj, ethernet_segment_identifier=esi_id) pi1_uuid = self._vnc_lib.physical_interface_create(pi1) pi1_obj = self._vnc_lib.physical_interface_read(id=pi1_uuid) li1_name = pi1_name + '_li1' li1 = LogicalInterface(name=li1_name, parent_obj=pi1_obj, logical_interface_vlan_tag=2) vn_name = self.id() + '_test_vn' vn = VirtualNetwork(vn_name) vn_uuid = self._vnc_lib.virtual_network_create(vn) vn_obj = self._vnc_lib.virtual_network_read(id=vn_uuid) vmi_name = self.id() + '_common_vmi' vmi_obj = self._create_vmi(vmi_name, vn_obj) li1.add_virtual_machine_interface(vmi_obj) li1_uuid = self._vnc_lib.logical_interface_create(li1) self._vnc_lib.logical_interface_read(id=li1_uuid) pi2_name = self.id() + '_physical_interface2' pi2 = PhysicalInterface(name=pi2_name, parent_obj=pr_obj, ethernet_segment_identifier=esi_id) pi2_uuid = self._vnc_lib.physical_interface_create(pi2) pi2_obj = self._vnc_lib.physical_interface_read(id=pi2_uuid) li2_name = pi2_name + '_li2' li2 = LogicalInterface(name=li2_name, parent_obj=pi2_obj, logical_interface_vlan_tag=2) second_vmi_name = self.id() + '_2nd_vmi' second_vmi_obj = self._create_vmi(second_vmi_name, vn_obj, 'AA:AA:AA:AA:AA:AA') li2.add_virtual_machine_interface(second_vmi_obj) self.assertRaises(PermissionDenied, self._vnc_lib.logical_interface_create, li2) li2 = LogicalInterface(name=li2_name, parent_obj=pi2_obj, logical_interface_vlan_tag=2) li2_uuid = self._vnc_lib.logical_interface_create(li2) li2_obj = self._vnc_lib.logical_interface_read(id=li2_uuid) li2_obj.add_virtual_machine_interface(second_vmi_obj) self.assertRaises(PermissionDenied, self._vnc_lib.logical_interface_update, li2_obj) pi3_name = self.id() + '_physical_interface3' pi3 = PhysicalInterface( name=pi3_name, parent_obj=pr_obj, ethernet_segment_identifier='00:00:00:00:00:00:00:00:00:AA') pi3_uuid = self._vnc_lib.physical_interface_create(pi3) pi3_obj = self._vnc_lib.physical_interface_read(id=pi3_uuid) li3_name = pi3_name + '_li3' li3 = LogicalInterface(name=li3_name, parent_obj=pi3_obj, logical_interface_vlan_tag=2) li3.add_virtual_machine_interface(vmi_obj) self._vnc_lib.logical_interface_create(li3) pi3_obj.set_ethernet_segment_identifier(esi_id) self._vnc_lib.physical_interface_update(pi3_obj)
def setUp(self): def _carve_out_subnets(subnets, cidr): carved_subnets = [] for subnet in subnets: slash_x_subnets = IPNetwork(subnet.get('cidr')).subnet(cidr) for slash_x_sn in slash_x_subnets: carved_subnets.append({'cidr': str(slash_x_sn)}) return carved_subnets # end _carve_out_subnets def _get_network_ipam(ipam_name, subnets, subnetting): def _new_subnet(cidr): split_cidr = cidr.split('/') return SubnetType( ip_prefix=split_cidr[0], ip_prefix_len=split_cidr[1]) # end _new_subnet ipam = NetworkIpam( name=ipam_name, ipam_subnets=IpamSubnets([ IpamSubnetType( subnet=_new_subnet(sn.get('cidr')), default_gateway=sn.get('gateway'), subnet_uuid=str(uuid.uuid1()) ) for sn in subnets if int( sn.get('cidr').split('/')[-1]) < 31 ]), ipam_subnet_method='flat-subnet', ipam_subnetting=subnetting ) return ipam # end _add_network_ipam super(TestPnfPortTuple, self).setUp() logger.debug("setUp called") # Create Global objects default_gsc_name = 'default-global-system-config' gsc_obj = self.api.global_system_config_read( GlobalSystemConfig().fq_name) proj_obj = self.api.project_read(Project().fq_name) # Create PNF and spine Physical Router pnf_obj = PhysicalRouter('pnf-' + self.id(), gsc_obj) pnf_obj.set_physical_router_role('pnf') self.pnf_uuid = self.api.physical_router_create(pnf_obj) # Create spine Physical Router spine_obj = PhysicalRouter('spine-' + self.id(), gsc_obj) self.spine_uuid = self.api.physical_router_create(spine_obj) # Create left/right LR left_lr_name = 'left_lr-' + self.id() left_lr_obj = LogicalRouter(name=left_lr_name, parent_obj=proj_obj) left_lr_obj.add_physical_router(spine_obj) self.left_lr_uuid = self.api.logical_router_create(left_lr_obj) right_lr_name = 'right_lr-' + self.id() right_lr_obj = LogicalRouter(name=right_lr_name, parent_obj=proj_obj) right_lr_obj.add_physical_router(spine_obj) self.right_lr_uuid = self.api.logical_router_create(right_lr_obj) # create left, right PNF PI left_pnf_pi_obj = PhysicalInterface( 'ge-0/0/1-' + self.id(), parent_obj=pnf_obj) right_pnf_pi_obj = PhysicalInterface( 'ge-0/0/2-' + self.id(), parent_obj=pnf_obj) lo_pnf_pi_obj = PhysicalInterface('lo0', parent_obj=pnf_obj) self.left_pnf_pi_uuid = self.api.physical_interface_create( left_pnf_pi_obj) self.right_pnf_pi_uuid = self.api.physical_interface_create( right_pnf_pi_obj) self.lo_pnf_pi_uuid = self.api.physical_interface_create(lo_pnf_pi_obj) # create left, right spine PI left_spine_pi_obj = PhysicalInterface( 'xe-0/0/1-' + self.id(), parent_obj=spine_obj) right_spine_pi_obj = PhysicalInterface( 'xe-0/0/2-' + self.id(), parent_obj=spine_obj) self.left_spine_pi_uuid = self.api.physical_interface_create( left_spine_pi_obj) self.right_spine_pi_uuid = self.api.physical_interface_create( right_spine_pi_obj) # Create Service Appliance Set sas_obj = ServiceApplianceSet('sas-' + self.id(), gsc_obj) sas_obj.set_service_appliance_set_virtualization_type( 'physical-device') self.sas_uuid = self.api.service_appliance_set_create(sas_obj) # Create Service template st_obj = ServiceTemplate(name='st-' + self.id()) st_obj.set_service_appliance_set(sas_obj) svc_properties = ServiceTemplateType() svc_properties.set_service_virtualization_type('physical-device') if_type = ServiceTemplateInterfaceType() if_type.set_service_interface_type('left') svc_properties.add_interface_type(if_type) if_type = ServiceTemplateInterfaceType() if_type.set_service_interface_type('right') svc_properties.add_interface_type(if_type) st_obj.set_service_template_properties(svc_properties) self.st_uuid = self.api.service_template_create(st_obj) # Create Service Instance object si_fqn = ['default-domain', 'default-project', 'si-' + self.id()] si_obj = ServiceInstance(fq_name=si_fqn) si_obj.fq_name = si_fqn si_obj.add_service_template(st_obj) kvp_array = [] kvp = KeyValuePair("left-svc-vlan", "100") kvp_array.append(kvp) kvp = KeyValuePair("right-svc-vlan", "101") kvp_array.append(kvp) kvp = KeyValuePair("left-svc-asns", "66000,66001") kvp_array.append(kvp) kvp = KeyValuePair("right-svc-asns", "66000,66002") kvp_array.append(kvp) kvps = KeyValuePairs() kvps.set_key_value_pair(kvp_array) si_obj.set_annotations(kvps) props = ServiceInstanceType() props.set_service_virtualization_type('physical-device') props.set_ha_mode("active-standby") si_obj.set_service_instance_properties(props) self.si_uuid = self.api.service_instance_create(si_obj) # Create service appliance sa_obj = ServiceAppliance('sa-' + self.id(), parent_obj=sas_obj) kvp_array = [] kvp = KeyValuePair( "left-attachment-point", default_gsc_name + ':' + 'spine-' + self.id() + ':' + 'xe-0/0/1-' + self.id()) kvp_array.append(kvp) kvp = KeyValuePair( "right-attachment-point", default_gsc_name + ':' + 'spine-' + self.id() + ':' + 'xe-0/0/2-' + self.id()) kvp_array.append(kvp) kvps = KeyValuePairs() kvps.set_key_value_pair(kvp_array) sa_obj.set_service_appliance_properties(kvps) sa_obj.set_service_appliance_virtualization_type('physical-device') attr = ServiceApplianceInterfaceType(interface_type='left') sa_obj.add_physical_interface(left_pnf_pi_obj, attr) attr = ServiceApplianceInterfaceType(interface_type='right') sa_obj.add_physical_interface(right_pnf_pi_obj, attr) self.sa_uuid = self.api.service_appliance_create(sa_obj) # Create fabric and add it to spine and PNF fab_obj = Fabric('fab-' + self.id()) self.fab_uuid = self.api.fabric_create(fab_obj) pnf_obj.add_fabric(fab_obj) self.api.physical_router_update(pnf_obj) spine_obj.add_fabric(fab_obj) self.api.physical_router_update(spine_obj) fab_obj = self.api.fabric_read(id=self.fab_uuid) # Create PNF service chain IPAM/network pnf_cidr = [{'cidr': "10.1.1.0/28"}] peer_subnets = _carve_out_subnets(pnf_cidr, 29) pnf_vn_obj = VirtualNetwork( name='fab-' + self.id() + '-pnf-servicechain-network', virtual_network_properties=VirtualNetworkType( forwarding_mode='l3'), address_allocation_mode='flat-subnet-only') self.pnf_vn_uuid = self.api.virtual_network_create(pnf_vn_obj) pnf_ipam_obj = _get_network_ipam( 'fab-' + self.id() + '-pnf-servicechain-network-ipam', peer_subnets, True) self.pnf_ipam_uuid = self.api.network_ipam_create(pnf_ipam_obj) pnf_vn_obj.add_network_ipam(pnf_ipam_obj, VnSubnetsType([])) self.api.virtual_network_update(pnf_vn_obj) fab_obj = self.api.fabric_read(id=self.fab_uuid) fab_obj.add_virtual_network( pnf_vn_obj, FabricNetworkTag( network_type='pnf-servicechain')) self.api.fabric_update(fab_obj) # Create loopback IPAM/network lo_cidr = [{'cidr': "100.100.100.0/28"}] peer_subnets = _carve_out_subnets(lo_cidr, 28) lo_vn_obj = VirtualNetwork( name='fab-' + self.id() + '-loopback-network', virtual_network_properties=VirtualNetworkType( forwarding_mode='l3'), address_allocation_mode='flat-subnet-only') self.lo_vn_uuid = self.api.virtual_network_create(lo_vn_obj) lo_ipam_obj = _get_network_ipam( 'fab-' + self.id() + '-loopback-network-ipam', peer_subnets, False) self.lo_ipam_uuid = self.api.network_ipam_create(lo_ipam_obj) lo_vn_obj.add_network_ipam(lo_ipam_obj, VnSubnetsType([])) self.api.virtual_network_update(lo_vn_obj) fab_obj = self.api.fabric_read(id=self.fab_uuid) fab_obj.add_virtual_network( lo_vn_obj, FabricNetworkTag( network_type='loopback')) self.api.fabric_update(fab_obj)
class TestPnfServiceAppliance(TestServiceApplianceBase): def setUp(self): super(TestPnfServiceAppliance, self).setUp() logger.debug("setUp called") # Create Global system config object self.gsc_obj = self.api.global_system_config_read( GlobalSystemConfig().fq_name) self.default_gsc_name = 'default-global-system-config' # Create Service Appliance Set object self.sas_obj = ServiceApplianceSet('sas-' + self.id(), self.gsc_obj) self.sas_obj.set_service_appliance_set_virtualization_type( 'physical-device') self.api.service_appliance_set_create(self.sas_obj) # Create PNF Physical Router object self.pnf_obj = PhysicalRouter('pnf-' + self.id(), self.gsc_obj) self.pnf_obj.set_physical_router_role('pnf') self.api.physical_router_create(self.pnf_obj) # Create spine Physical Router object self.spine_obj = PhysicalRouter('spine-' + self.id(), self.gsc_obj) self.api.physical_router_create(self.spine_obj) # create left, right PNF PI self.left_pnf_pi_obj = PhysicalInterface( 'ge-0/0/1-' + self.id(), parent_obj=self.pnf_obj) self.right_pnf_pi_obj = PhysicalInterface( 'ge-0/0/2-' + self.id(), parent_obj=self.pnf_obj) self.api.physical_interface_create(self.left_pnf_pi_obj) self.api.physical_interface_create(self.right_pnf_pi_obj) # create left, right spine PI self.left_spine_pi_obj = PhysicalInterface( 'xe-0/0/1-' + self.id(), parent_obj=self.spine_obj) self.right_spine_pi_obj = PhysicalInterface( 'xe-0/0/2-' + self.id(), parent_obj=self.spine_obj) self.api.physical_interface_create(self.left_spine_pi_obj) self.api.physical_interface_create(self.right_spine_pi_obj) def tearDown(self): super(TestPnfServiceAppliance, self).tearDown() logger.debug("TearDown called") # delete PNF PI self.api.physical_interface_delete(id=self.left_pnf_pi_obj.uuid) self.api.physical_interface_delete(id=self.right_pnf_pi_obj.uuid) # delete spine PI self.api.physical_interface_delete(id=self.left_spine_pi_obj.uuid) self.api.physical_interface_delete(id=self.right_spine_pi_obj.uuid) # delete PNF PR and spine PR self.api.physical_router_delete(id=self.spine_obj.uuid) self.api.physical_router_delete(id=self.pnf_obj.uuid) # delete sas self.api.service_appliance_set_delete(id=self.sas_obj.uuid) def test_valid_sa(self): sa_obj = ServiceAppliance('sa-' + self.id(), parent_obj=self.sas_obj) kvp_array = [] kvp = KeyValuePair( "left-attachment-point", self.default_gsc_name + ':' + 'spine-' + self.id() + ':' + 'xe-0/0/1-' + self.id()) kvp_array.append(kvp) kvp = KeyValuePair( "right-attachment-point", self.default_gsc_name + ':' + 'spine-' + self.id() + ':' + 'xe-0/0/2-' + self.id()) kvp_array.append(kvp) kvps = KeyValuePairs() kvps.set_key_value_pair(kvp_array) sa_obj.set_service_appliance_properties(kvps) sa_obj.set_service_appliance_virtualization_type('physical-device') # Add PNF PI refs attr = ServiceApplianceInterfaceType(interface_type='left') sa_obj.add_physical_interface(self.left_pnf_pi_obj, attr) attr = ServiceApplianceInterfaceType(interface_type='right') sa_obj.add_physical_interface(self.right_pnf_pi_obj, attr) # Create SA self.api.service_appliance_create(sa_obj) self.left_pnf_pi_obj = self.api.physical_interface_read( id=self.left_pnf_pi_obj.uuid) self.right_pnf_pi_obj = self.api.physical_interface_read( id=self.right_pnf_pi_obj.uuid) # Check if spine PI <-> PNF PI link has been created self.assertEqual( self.left_pnf_pi_obj.physical_interface_refs[0].get('uuid'), self.left_spine_pi_obj.uuid) self.assertEqual( self.right_pnf_pi_obj.physical_interface_refs[0].get('uuid'), self.right_spine_pi_obj.uuid) # Delete service appliance self.api.service_appliance_delete(id=sa_obj.uuid) # Check if spine PI <-> PNF PI link got removed self.left_pnf_pi_obj = self.api.physical_interface_read( id=self.left_pnf_pi_obj.uuid) self.right_pnf_pi_obj = self.api.physical_interface_read( id=self.right_pnf_pi_obj.uuid) self.assertFalse( hasattr( self.left_pnf_pi_obj, "physical_interface_refs")) self.assertFalse( hasattr( self.right_pnf_pi_obj, "physical_interface_refs")) def test_sa_with_invalid_kvp(self): sa_obj = ServiceAppliance('sa-' + self.id(), parent_obj=self.sas_obj) kvp_array = [] kvp = KeyValuePair( "left-attachment-point", self.default_gsc_name + ':' + 'spine-' + self.id() + ':' + 'xe-0/0/1-' + self.id()) kvp_array.append(kvp) kvp = KeyValuePair( "right-attachment-point", self.default_gsc_name + ':' + 'spine-' + self.id() + ':' + 'xe-0/0/2-' + self.id()) # The next line is intentionally commented out # kvp_array.append(kvp) kvps = KeyValuePairs() kvps.set_key_value_pair(kvp_array) sa_obj.set_service_appliance_properties(kvps) sa_obj.set_service_appliance_virtualization_type('physical-device') # Add PNF PI refs attr = ServiceApplianceInterfaceType(interface_type='left') sa_obj.add_physical_interface(self.left_pnf_pi_obj, attr) attr = ServiceApplianceInterfaceType(interface_type='right') sa_obj.add_physical_interface(self.right_pnf_pi_obj, attr) # Create SA should raise exception self.assertRaises( BadRequest, self.api.service_appliance_create, sa_obj) def test_sa_with_invalid_pr_role(self): sa_obj = ServiceAppliance('sa-' + self.id(), parent_obj=self.sas_obj) kvp_array = [] kvp = KeyValuePair( "left-attachment-point", self.default_gsc_name + ':' + 'spine-' + self.id() + ':' + 'xe-0/0/1-' + self.id()) kvp_array.append(kvp) kvp = KeyValuePair( "right-attachment-point", self.default_gsc_name + ':' + 'spine-' + self.id() + ':' + 'xe-0/0/2-' + self.id()) kvp_array.append(kvp) kvps = KeyValuePairs() kvps.set_key_value_pair(kvp_array) sa_obj.set_service_appliance_properties(kvps) sa_obj.set_service_appliance_virtualization_type('physical-device') # Add PNF PI refs attr = ServiceApplianceInterfaceType(interface_type='left') sa_obj.add_physical_interface(self.left_pnf_pi_obj, attr) attr = ServiceApplianceInterfaceType(interface_type='right') sa_obj.add_physical_interface(self.right_pnf_pi_obj, attr) # Overwrite the role as leaf instead of pnf self.pnf_obj.set_physical_router_role('leaf') self.api.physical_router_update(self.pnf_obj) # Create SA should raise exception self.assertRaises(BadRequest, self.api.service_appliance_create, sa_obj)