def test_router_matches_to_l3domain(self): # Create a router name = data_utils.rand_name('router-') create_body = self.routers_client.create_router( name=name, external_gateway_info={ "network_id": CONF.network.public_network_id }, admin_state_up=False) router = create_body['router'] self.addCleanup(self.routers_client.delete_router, router['id']) self.assertEqual(router['name'], name) vsd_l3domain = self.MatchingVsdl3domain(self, router).get_by_external_id() vsd_l3domain.has_zones( with_external_id=ExternalId(router['id']).at_cms_id()) vsd_l3domain.has_permissions( with_external_id=ExternalId(router['tenant_id']).at_cms_id()) vsd_l3domain.has_egress_acl_template( with_external_id=ExternalId(router['id']).at_cms_id()) vsd_l3domain.has_ingress_acl_template( with_external_id=ExternalId(router['id']).at_cms_id()) vsd_l3domain.has_forwarding_policy_template( with_external_id=ExternalId(router['id']).at_cms_id()) # Delete vsd_l3domain.verify_cannot_delete()
def _create_and_validate_os_managed_subnet(self, reload_session=True, validate_equals=True): # Provision OpenStack network if reload_session: network = self.create_network(manager=self.get_client_manager()) ipv4_subnet = self.create_subnet(network, manager=self.get_client_manager()) value = self.manager.subnets_client.tenant_name + '-update' else: network = self.create_network(manager=self.manager) ipv4_subnet = self.create_subnet(network, manager=self.manager) value = self.manager.subnets_client.tenant_name # When I create an IPv4 subnet self.assertIsNotNone(ipv4_subnet) # Then a VSD L2 domain is created with type IPv4 vsd_l2_domain = self.vsd.get_l2domain( vspk_filter='externalID == "{}"'.format( ExternalId(ipv4_subnet['id']).at_cms_id())) self.assertIsNotNone(vsd_l2_domain) vsd_group = self.nuage_client.get_usergroup( netpart_name=net_partition_name, parent=nuage_constants.L2_DOMAIN, parent_id=vsd_l2_domain.id) self._validate_user_group_description(validate_equals, value, vsd_group)
def _create_and_validate_on_router_create(self, reload_session=True, validate_equals=True): # Provision OpenStack network if reload_session: value = self.manager.routers_client.tenant_name + '-update' router = self.create_router(manager=self.get_client_manager()) else: router = self.create_router(manager=self.manager) value = self.manager.routers_client.tenant_name self.assertIsNotNone(router) vsd_l3_domain = self.vsd.get_l3domain( vspk_filter='externalID == "{}"'.format( ExternalId(router['id']).at_cms_id())) self.assertIsNotNone(vsd_l3_domain) vsd_l3_domain_zones = self.nuage_client.get_zone( parent_id=vsd_l3_domain.id) self.assertIsNotNone(vsd_l3_domain_zones) for vsd_l3_domain_zone in vsd_l3_domain_zones: if '-pub-' not in vsd_l3_domain_zone['name']: vsd_group = self.nuage_client.get_usergroup( netpart_name=net_partition_name, parent=nuage_constants.ZONE, parent_id=vsd_l3_domain_zone['ID']) self._validate_user_group_description(validate_equals, value, vsd_group)
def has_dhcp_options(self, with_external_id=None): # vsd dhcp_options object has external ID vsd_dhcp_options = self.test.nuage_client.get_dhcpoption( parent=n_constants.VPORT, parent_id=self.vsd_vport['ID']) self.test.assertEqual(len(vsd_dhcp_options), len(extra_dhcp_opts), "dhcp_options not found by VSD parent ID") if with_external_id is None: self.test.assertIsNone(vsd_dhcp_options[0]['externalID']) else: vsd_dhcp_options = self.test.nuage_client.\ get_child_resource( resource=n_constants.VPORT, resource_id=self.vsd_vport['ID'], child_resource=n_constants.DHCPOPTION, filters='externalID', filter_values=with_external_id) self.test.assertEqual(len(vsd_dhcp_options), len(extra_dhcp_opts), "dhcp_options not found by ExternalID") for vsd_dhcp_option in vsd_dhcp_options: self.test.assertEqual( with_external_id, ExternalId(vsd_dhcp_option['externalID']).at_cms_id())
def _verify_vsd_policy_grp(self, remote_group_id, nuage_domain=None, name=None): if not nuage_domain: nuage_domain = self.nuage_any_domain nuage_policy_grps = self.nuage_client.get_policygroup( self.nuage_domain_type, nuage_domain[0]['ID']) self.assertGreater(len(nuage_policy_grps), 0) found = False for nuage_policy_grp in nuage_policy_grps: if ExternalId(remote_group_id).at_cms_id() == \ nuage_policy_grp['externalID']: found = True if name and name != nuage_policy_grp['description']: found = False self.assertTrue( found, "Must have nuage policy group" " with matching security group name") break break self.assertTrue( found, "Must have nuage policy group" " with matching externalID") # can retrieve VSD policy group by the externalID nuage_policy_grp = self.nuage_client.get_policygroup( self.nuage_domain_type, nuage_domain[0]['ID'], filters='externalID', filter_values=remote_group_id) self.assertEqual(nuage_policy_grp[0]['name'], remote_group_id)
def fixme_test_neutron_isolated_shared_subnet_matches_to_l2domain(self): # Create a network name = data_utils.rand_name('network-') body = self.os_admin.networks_client.create_network( name=name, shared=True) network = body['network'] self.assertEqual('ACTIVE', network['status']) # Create a subnet subnet = self.create_subnet(network, manager=self.admin_manager) # Create a second subnet subnet_b = self.create_subnet(network, manager=self.admin_manager) vsd_l2domain_a = self.MatchingVsdL2domain( self, subnet).get_by_external_id() vsd_l2domain_a.has_permissions( with_external_id=ExternalId(subnet['tenant_id']).at_cms_id()) vsd_l2domain_a.has_group_everybody() vsd_l2domain_a.has_user( with_external_id=ExternalId(subnet['tenant_id']).at_openstack()) vsd_l2domain_a.has_egress_acl_template( with_external_id=ExternalId(subnet['id']).at_cms_id()) vsd_l2domain_a.has_ingress_acl_template( with_external_id=ExternalId(subnet['id']).at_cms_id()) vsd_l2domain_a.has_forwarding_policy_template( with_external_id=ExternalId(subnet['id']).at_cms_id()) vsd_l2domain_b = self.MatchingVsdL2domain( self, subnet_b).get_by_external_id() vsd_l2domain_b.has_permissions( with_external_id=ExternalId(subnet_b['tenant_id']).at_cms_id()) vsd_l2domain_b.has_group_everybody() vsd_l2domain_b.has_user( with_external_id=ExternalId(subnet_b['tenant_id']).at_openstack()) vsd_l2domain_b.has_egress_acl_template( with_external_id=ExternalId(subnet_b['id']).at_cms_id()) vsd_l2domain_b.has_ingress_acl_template( with_external_id=ExternalId(subnet_b['id']).at_cms_id()) vsd_l2domain_b.has_forwarding_policy_template( with_external_id=ExternalId(subnet_b['id']).at_cms_id()) # Delete vsd_l2domain_a.verify_cannot_delete()
def test_port_security_fix_openstack_1451_true(self): # Create a network name = data_utils.rand_name('network-') network = self.create_network(network_name=name) self.addCleanup(self.networks_client.delete_network, network['id']) subnet = self.create_subnet(network) name = data_utils.rand_name('port-nosec') port = self.create_port( name=name, network=network, port_security_enabled=False) self.addCleanup(self.ports_client.delete_port, port['id']) # switch port security to true/false self.ports_client.update_port(port['id'], port_security_enabled=True) self.ports_client.update_port(port['id'], port_security_enabled=False) self.ports_client.update_port(port['id'], port_security_enabled=True) vsd_vport = self.MatchingVsdVPort( self, port, subnet).get_by_external_id() if Topology.is_v5: vsd_vport.has_default_security_policy_group( with_external_id=ExternalId( self._build_policy_group_allow_all_external_id( vsd_vport.vsd_vport['parentID'])).at_cms_id()) vsd_vport.has_default_egress_policy_entries( with_external_id=ExternalId(subnet['id']).at_cms_id()) vsd_vport.has_default_ingress_policy_entries( with_external_id=ExternalId(subnet['id']).at_cms_id()) else: vsd_vport.has_default_security_policy_group( with_external_id=self. _build_policy_group_allow_all_external_id()) vsd_vport.has_default_egress_policy_entries( with_external_id=ExternalId( n_constants.NUAGE_PLCY_GRP_ALLOW_ALL).at_cms_id()) vsd_vport.has_default_ingress_policy_entries( with_external_id=ExternalId( n_constants.NUAGE_PLCY_GRP_ALLOW_ALL).at_cms_id()) # Delete vsd_vport.verify_cannot_delete()
def test_neutron_isolated_subnet_in_netpartition(self): # Create a dedicated netpartition netpartition_a = self._create_netpartition() netpartition_b = self._create_netpartition() # Create a network 1 in netpartition A name = data_utils.rand_name('networkA1') network_a1 = self.create_network(network_name=name) subnet_a1 = self.create_subnet(network_a1, net_partition=netpartition_a['name']) # Create a network 2 in netpartition A name = data_utils.rand_name('networkA2') network_a2 = self.create_network(network_name=name) subnet_a2 = self.create_subnet(network_a2, net_partition=netpartition_a['name']) self.assertIsNotNone(subnet_a2) # dummy check to use local variable # Create a network 1 in netpartition B name = data_utils.rand_name('networkB1') network_b1 = self.create_network(network_name=name) subnet_b1 = self.create_subnet(network_b1, net_partition=netpartition_b['name']) # has only 1 group and 1 user with same External ID as subnet in # netpartition A vsd_l2domain_a1 = self.MatchingVsdL2domain( self, subnet_a1).get_by_external_id( net_partition_name=netpartition_a['name']) vsd_l2domain_a1.has_group( with_external_id=ExternalId(subnet_a1['tenant_id']).at_openstack()) vsd_l2domain_a1.has_user( with_external_id=ExternalId(subnet_a1['tenant_id']).at_openstack()) # has group and user with same External ID as subnet in netpartition A vsd_l2domain_b1 = self.MatchingVsdL2domain( self, subnet_b1).get_by_external_id( net_partition_name=netpartition_b['name']) vsd_l2domain_b1.has_group( with_external_id=ExternalId(subnet_a1['tenant_id']).at_openstack()) vsd_l2domain_b1.has_user( with_external_id=ExternalId(subnet_a1['tenant_id']).at_openstack())
def get_by_external_id(self): vsd_network_macro = \ self.test.nuage_client.get_enterprise_net_macro( netpart_name=self.net_partition['name']) self.test.assertEqual(1, len(vsd_network_macro), "should have network macros") vsd_network_macros = \ self.test.nuage_client.get_enterprise_net_macro( netpart_name=self.net_partition['name'], filters='externalID', filter_values=ExternalId( self.net_partition['id']).at_openstack()) self.test.assertEqual(1, len(vsd_network_macros)) self.vsd_network_macro = vsd_network_macros[0] self.test.assertEqual( ExternalId(self.net_partition['id']).at_openstack(), self.vsd_network_macro['externalID']) return self
def has_default_ingress_policy_entries(self, with_external_id=None): # vsd ingress_acl_template object has external ID vsd_ingress_acl_templates = \ self.test.nuage_client.get_ingressacl_template( parent=n_constants.L2_DOMAIN, parent_id=self.vsd_l2domain['ID']) self.test.assertEqual( len(vsd_ingress_acl_templates), 1, "ingress_acl_template not found by VSD parent ID") vsd_ingress_security_policy_entries = \ self.test.nuage_client.get_child_resource( resource=n_constants.INGRESS_ACL_TEMPLATE, resource_id=vsd_ingress_acl_templates[0]['ID'], child_resource=n_constants.INGRESS_ACL_ENTRY_TEMPLATE, filters='locationID', filter_values=self.vsd_security_policy_group['ID']) if NUAGE_FEATURES.os_managed_dualstack_subnets: self.test.assertEqual( 2, len(vsd_ingress_security_policy_entries), "Should find exact 2 matches for ingress policy entries") else: self.test.assertEqual( 1, len(vsd_ingress_security_policy_entries), "Should find exact 1 match for ingress policy entries") if with_external_id is None: self.test.assertIsNone( vsd_ingress_security_policy_entries[0]['externalID']) else: vsd_ingress_security_policy_entries = \ self.test.nuage_client.get_child_resource( resource=n_constants.INGRESS_ACL_TEMPLATE, resource_id=vsd_ingress_acl_templates[0]['ID'], child_resource=n_constants.INGRESS_ACL_ENTRY_TEMPLATE, filters='externalID', filter_values=with_external_id) if NUAGE_FEATURES.os_managed_dualstack_subnets: self.test.assertEqual( 2, len(vsd_ingress_security_policy_entries), "Policy groups not found by external id") else: self.test.assertEqual( 1, len(vsd_ingress_security_policy_entries), "Policy group not found by external id") self.test.assertEqual( with_external_id, ExternalId(vsd_ingress_security_policy_entries[0] ['externalID']).at_cms_id())
def _router_create_get_check_vsd(self, nuage_aggregate_flows, aggregation_flows_enabled, aggregation_flow_type): name = data_utils.rand_name('test-NuageRouterAggregateFlows-') if nuage_aggregate_flows: router = self.create_router( router_name=name, external_network_id=CONF.network.public_network_id, nuage_aggregate_flows=nuage_aggregate_flows) else: router = self.create_router( router_name=name, external_network_id=CONF.network.public_network_id) self.assertIsNotNone( router, "Unable to create router with " "nuage_aggregate_flows={}.".format(nuage_aggregate_flows)) self.assertEqual( nuage_aggregate_flows if nuage_aggregate_flows else 'off', router.get('nuage_aggregate_flows'), "nuage_aggregate_flows in create router should be " "{} but was: {}.".format( nuage_aggregate_flows if nuage_aggregate_flows else 'off', router.get('nuage_aggregate_flows'))) router_get = self.get_router(router['id']) self.assertEqual( router['nuage_aggregate_flows'], router_get.get('nuage_aggregate_flows'), "nuage_aggregate_flows in show router should be " "{} but was: {}.".format(router['nuage_aggregate_flows'], router_get.get('nuage_aggregate_flows'))) nuage_router = self.vsd.get_l3domain( vspk_filter='externalID == "{}"'.format( ExternalId(router['id']).at_cms_id())) self.assertIsNotNone( nuage_router, "Unable to retrieve router from VSD with " "nuage_aggregate_flows={}.".format(nuage_aggregate_flows)) self.assertEqual( aggregation_flows_enabled, nuage_router.aggregate_flows_enabled, "AggregateFlowsEnabled expected to be: {}, " "but was {} for nuage_aggregate_flows={}.".format( aggregation_flows_enabled, nuage_router.aggregate_flows_enabled, nuage_aggregate_flows)) self.assertEqual( aggregation_flow_type, nuage_router.aggregation_flow_type, "AggregationFlowType expected to be: {}, but was {} " "for nuage_aggregate_flows={}.".format( aggregation_flow_type, nuage_router.aggregation_flow_type, nuage_aggregate_flows)) LOG.debug("Verified for nuage_aggregate_flows={}.".format( nuage_aggregate_flows))
def test_neutron_isolated_subnet_matches_to_l2domain(self): # Create a network name = data_utils.rand_name('network-') network = self.create_network(network_name=name) self.assertEqual('ACTIVE', network['status']) # Create a subnet # subnet = self.create_subnet(network) subnet = self.create_subnet(network) dhcp_opts = [ {'actualType': 3, 'actualValues': subnet['gateway_ip']} ] vsd_l2domain = self.MatchingVsdL2domain( self, subnet).get_by_external_id() vsd_l2domain.has_l2domain_template( with_external_id=vsd_l2domain.expected_ext_id(subnet)) vsd_l2domain.has_dhcp_options( with_external_id=ExternalId(subnet['id']).at_cms_id(), with_dhcp_opts=dhcp_opts) vsd_l2domain.has_permissions( with_external_id=ExternalId(subnet['tenant_id']).at_cms_id()) vsd_l2domain.has_group( with_external_id=ExternalId( subnet['tenant_id']).at_openstack()) vsd_l2domain.has_user( with_external_id=ExternalId( subnet['tenant_id']).at_openstack()) vsd_l2domain.has_egress_acl_template( with_external_id=vsd_l2domain.expected_ext_id(subnet)) vsd_l2domain.has_ingress_acl_template( with_external_id=vsd_l2domain.expected_ext_id(subnet)) vsd_l2domain.has_forwarding_policy_template( with_external_id=vsd_l2domain.expected_ext_id(subnet)) # Delete vsd_l2domain.verify_cannot_delete()
def get_by_external_id(self): vsd_vports = self.test.nuage_client.get_vport( parent=n_constants.L2_DOMAIN, parent_id=self.vsd_l2domain['ID'], filters='externalID', filter_values=ExternalId(self.port['id']).at_cms_id()) # should have exact 1 match self.test.assertEqual(len(vsd_vports), 1) self.vsd_vport = vsd_vports[0] self.test.assertNotEmpty(self.vsd_vport) self.test.assertEqual(self.vsd_vport['name'], self.port['id']) return self
def test_with_vm_on_neutron_port_in_vsd_managed_network_matching_vsd( self): net_name = data_utils.rand_name() cidr = IPNetwork('10.10.100.0/24') vsd_l2domain_templates = self.create_vsd_dhcpmanaged_l2dom_template( name=net_name, cidr=cidr, gateway='10.10.100.1') self.assertEqual( len(vsd_l2domain_templates), 1, "Failed to create vsd l2 domain template") vsd_l2domain_template = vsd_l2domain_templates[0] vsd_l2domains = self.nuage_client.create_l2domain( name=net_name, templateId=vsd_l2domain_template['ID']) self.assertEqual( len(vsd_l2domains), 1, "Failed to create vsd l2 domain") vsd_l2domain = vsd_l2domains[0] self.addCleanup( self.nuage_client.delete_l2domain, vsd_l2domain['ID']) network = self.create_network(namestart='network-') subnet_kwargs = { 'name': network['name'], 'cidr': '10.10.100.0/24', 'gateway_ip': None, 'network_id': network['id'], 'nuagenet': vsd_l2domain['ID'], 'net_partition': Topology.def_netpartition, 'enable_dhcp': True, 'ip_version': 4} subnet = self.subnets_client.create_subnet(**subnet_kwargs) self.assertIsNotNone(subnet) # dummy check to use local variable port = self.create_port(network['id']) name = data_utils.rand_name('server-smoke') server = self._create_server(name, network, port['id']) # get the neutron port, based on the servers MAC address # (expect only 1 interface) port_mac = server['addresses'][network['name']][0][ 'OS-EXT-IPS-MAC:mac_addr'] ports_response = self.ports_client.list_ports(mac_address=port_mac) port = ports_response['ports'][0] vsd_vm = self.MatchingVsdVm(self, server).get_by_external_id() vsd_vm.has_parent_vm_interface(ExternalId(port['id']).at_cms_id()) # Delete vsd_vm.verify_cannot_delete()
def get_by_external_id(self): vsd_vms = self.test.nuage_client.get_vm( parent=None, parent_id='', filters='externalID', filter_values=self.vm['id']) # should have exact 1 match self.test.assertEqual(len(vsd_vms), 1) self.vsd_vm = vsd_vms[0] # VSD UUID is the Openstack VM ID self.test.assertEqual(self.vsd_vm['UUID'], self.vm['id']) self.test.assertEqual( self.vsd_vm['externalID'], ExternalId(self.vm['id']).at_cms_id()) return self
def test_with_vm_on_neutron_port_matching_vsd(self): # Create a network network = self.create_network(namestart='network-') subnet = self.create_subnet(network, namestart='subnet-') self.assertIsNotNone(subnet) # dummy check to use local variable port = self.create_port(network['id']) name = data_utils.rand_name('server-smoke') server = self._create_server(name, network, port['id']) vsd_vm = self.MatchingVsdVm(self, server).get_by_external_id() vsd_vm.has_parent_vm_interface(ExternalId(port['id']).at_cms_id()) # Delete vsd_vm.verify_cannot_delete()
def test_port_dhcp_options_matches_to_port(self): net_name = data_utils.rand_name() cidr = IPNetwork('10.10.100.0/24') vsd_l2domain_templates = self.create_vsd_dhcpmanaged_l2dom_template( name=net_name, cidr=cidr, gateway='10.10.100.1') self.assertEqual(len(vsd_l2domain_templates), 1, "Failed to create vsd l2 domain template") vsd_l2domain_template = vsd_l2domain_templates[0] vsd_l2domains = self.nuage_client.create_l2domain( name=net_name, templateId=vsd_l2domain_template['ID']) self.assertEqual(len(vsd_l2domains), 1, "Failed to create vsd l2 domain") vsd_l2domain = vsd_l2domains[0] self.addCleanup(self.nuage_client.delete_l2domain, vsd_l2domain['ID']) body = self.networks_client.create_network(name=net_name) network = body['network'] self.addCleanup(self.networks_client.delete_network, network['id']) subnet_kwargs = { 'name': network['name'], 'cidr': '10.10.100.0/24', 'gateway_ip': None, 'network_id': network['id'], 'nuagenet': vsd_l2domain['ID'], 'net_partition': Topology.def_netpartition, 'enable_dhcp': True, 'ip_version': 4 } subnet = self.subnets_client.create_subnet(**subnet_kwargs) self.assertIsNotNone(subnet) # dummy check to use local variable name = data_utils.rand_name('extra-dhcp-opt-port-name') port = self.create_port(name=name, network=network, extra_dhcp_opts=extra_dhcp_opts) self.addCleanup(self.ports_client.delete_port, port['id']) vsd_vport = self.MatchingVsdVPort(self, port, subnet, vsd_l2domain).get_by_external_id() vsd_vport.has_dhcp_options( with_external_id=ExternalId(port['id']).at_cms_id()) # Delete vsd_vport.verify_cannot_delete()
def _router_no_op_update_check_no_change(self, nuage_underlay, enable_snat, pat_enabled, underlay_enabled, no_op_nuage_underlay, no_op_enable_snat): name = data_utils.rand_name('test-NuagePATAndRouteUnderlayDomain-') router = self.create_router(manager=self.admin_manager, router_name=name, external_network_id=self.ext_net_id, external_gateway_info_on=enable_snat is not None, enable_snat=enable_snat, nuage_underlay=nuage_underlay) self.assertIsNotNone(router, "Unable to create router.") updated = self.update_router(router, manager=self.admin_manager, external_network_id=self.ext_net_id, external_gateway_info_on=no_op_enable_snat is not None, enable_snat=no_op_enable_snat, nuage_underlay=no_op_nuage_underlay) self.assertIsNotNone( updated, "Unable to update router with " "nuage_underlay={}, " "ext_gw_info.enable_snat={}".format(nuage_underlay, enable_snat)) nuage_router = self.vsd.get_l3domain( vspk_filter='externalID == "{}"'.format( ExternalId(router['id']).at_cms_id())) self.assertIsNotNone( nuage_router, "Unable to retrieve router from VSD with " " nuage_underlay={}, " "ext_gw_info.enable_snat={}".format(nuage_underlay, enable_snat)) self.assertEqual( pat_enabled, nuage_router.pat_enabled, "PATEnabled expected to be: {}, but was {} " "for nuage_underlay={}, ext_gw_info.enable_snat={}.".format( pat_enabled, nuage_router.pat_enabled, nuage_underlay, enable_snat)) self.assertEqual( underlay_enabled, nuage_router.underlay_enabled, "UnderlayEnabled expected to be: {}, but was {} " "for nuage_underlay ={}, ext_gw_info.enable_snat={}.".format( underlay_enabled, nuage_router.underlay_enabled, nuage_underlay, enable_snat)) LOG.debug("Verified for nuage_underlay={} ," "ext_gw_info.enable_snat={}".format(nuage_underlay, enable_snat))
def test_port_dhcp_options_matches_to_port(self): # Create a network name = data_utils.rand_name('network-') network = self.create_network(network_name=name) self.addCleanup(self.networks_client.delete_network, network['id']) subnet = self.create_subnet(network) name = data_utils.rand_name('extra-dhcp-opt-port-name') port = self.create_port(name=name, network=network, extra_dhcp_opts=extra_dhcp_opts) self.addCleanup(self.ports_client.delete_port, port['id']) vsd_vport = self.MatchingVsdVPort(self, port, subnet).get_by_external_id() vsd_vport.has_dhcp_options( with_external_id=ExternalId(port['id']).at_cms_id()) # Delete vsd_vport.verify_cannot_delete()
def test_with_vm_on_neutron_network_matching_vsd(self): # Create a network network = self.create_network(namestart='network-') subnet = self.create_subnet(network, namestart='subnet-') self.assertIsNotNone(subnet) # dummy check to use local variable name = data_utils.rand_name('server-smoke') server = self._create_server(name, network) # get the neutron port, based on the servers MAC address # (expect only 1 interface) port_mac = server['addresses'][network['name']][0][ 'OS-EXT-IPS-MAC:mac_addr'] ports_response = self.ports_client.list_ports(mac_address=port_mac) port = ports_response['ports'][0] vsd_vm = self.MatchingVsdVm(self, server).get_by_external_id() vsd_vm.has_parent_vm_interface(ExternalId(port['id']).at_cms_id()) # Delete vsd_vm.verify_cannot_delete()
def has_permissions(self, with_external_id=None): for zone in self.vsd_zones: # vsd permissions object has external ID vsd_permissions = self.test.nuage_client.get_permissions( parent=n_constants.ZONE, parent_id=zone['ID']) self.test.assertEqual(1, len(vsd_permissions), "VSD Permission not found by parent ID") group_external_id = \ ExternalId(with_external_id).at_openstack() \ if with_external_id else None if zone['name'].split('-')[1] == 'pub': self.test.assertEqual( vsd_permissions[0]['permittedEntityName'], "Everybody") self.has_user(group_external_id) else: self.test.assertEqual( self.router['tenant_id'], vsd_permissions[0]['permittedEntityName']) self.has_group(group_external_id, for_zone=zone) self.has_user(group_external_id) if with_external_id is None: self.test.assertIsNone(vsd_permissions[0]['externalID']) else: # permission object has external ID self.test.assertEqual(with_external_id, vsd_permissions[0]['externalID']) # can find vsd permissions by external ID vsd_permissions = \ self.test.nuage_client.get_permissions( parent=n_constants.ZONE, parent_id=zone['ID'], filters='externalID', filter_values=with_external_id) self.test.assertEqual( 1, len(vsd_permissions), "VSD Permission not found by ExternalID")
def _router_name_update_check_no_change(self, nuage_aggregate_flows, aggregation_flows_enabled, aggregation_flow_type): name = data_utils.rand_name('test-NuageRouterAggregateFlows-') if nuage_aggregate_flows: router = self.create_router( router_name=name, external_network_id=CONF.network.public_network_id, nuage_aggregate_flows=nuage_aggregate_flows) else: router = self.create_router( router_name=name, external_network_id=CONF.network.public_network_id) self.assertIsNotNone(router, "Unable to create router.") name = data_utils.rand_name('test-NuageRouterAggregateFlows2-') updated = self.update_router(router, name=name) self.assertIsNotNone( updated, "Unable to update router with new name for " "nuage_aggregate_flows={}.".format(nuage_aggregate_flows)) nuage_router = self.vsd.get_l3domain( vspk_filter='externalID == "{}"'.format( ExternalId(router['id']).at_cms_id())) self.assertIsNotNone( nuage_router, "Unable to retrieve router from VSD with " "nuage_aggregate_flows={}.".format(nuage_aggregate_flows)) self.assertEqual( aggregation_flows_enabled, nuage_router.aggregate_flows_enabled, "AggregateFlowsEnabled expected to be: {}, " "but was {} for nuage_aggregate_flows={}.".format( aggregation_flows_enabled, nuage_router.aggregate_flows_enabled, nuage_aggregate_flows)) self.assertEqual( aggregation_flow_type, nuage_router.aggregation_flow_type, "AggregationFlowType expected to be: {}, but was {} " "for nuage_aggregate_flows={}.".format( aggregation_flow_type, nuage_router.aggregation_flow_type, nuage_aggregate_flows)) LOG.debug("Verified for nuage_aggregate_flows={}.".format( nuage_aggregate_flows))
def test_subnet_attached_to_router_matches_to_l3domain(self): # Create a network name = data_utils.rand_name('network-') network = self.create_network(network_name=name) # Create a subnet subnet = self.create_subnet(network) # Create a router name = data_utils.rand_name('router-') create_body = self.routers_client.create_router( name=name, external_gateway_info={ "network_id": CONF.network.public_network_id }, admin_state_up=False) router = create_body['router'] self.addCleanup(self.routers_client.delete_router, router['id']) self.assertEqual(router['name'], name) # Attach subnet to router # Add router interface with subnet id self.routers_client.add_router_interface(router['id'], subnet_id=subnet['id']) self.addCleanup(self._remove_router_interface_with_subnet_id, router['id'], subnet['id']) vsd_l3domain = self.MatchingVsdl3domain(self, router).get_by_external_id() vsd_l3domain.has_zones( with_external_id=ExternalId(router['id']).at_cms_id()) vsd_l3domain.has_subnet( with_external_id=vsd_l3domain.expected_ext_id(subnet), subnet=subnet) # Delete vsd_l3domain.verify_cannot_delete() vsd_l3domain.verify_cannot_delete_subnets()
def has_default_security_policy_group(self, with_external_id=None): # vsd has_default_security_policy_group object has external ID # vsd_security_policy_groups = self.test.nuage_client.\ # get_policygroup( # parent=n_constants.POLICYGROUP, # parent_id=self.vsd_vport['parentID']) vsd_security_policy_groups = \ self.test.nuage_client.get_child_resource( resource=n_constants.L2_DOMAIN, resource_id=self.vsd_vport['parentID'], child_resource=n_constants.POLICYGROUP) self.test.assertEqual(1, len(vsd_security_policy_groups), "policy group not found by VSD parent ID") self.vsd_security_policy_group = vsd_security_policy_groups[0] if with_external_id is None: self.test.assertIsNone( vsd_security_policy_groups[0]['externalID']) else: vsd_security_policy_groups = \ self.test.nuage_client.get_child_resource( resource=n_constants.L2_DOMAIN, resource_id=self.vsd_vport['parentID'], child_resource=n_constants.POLICYGROUP, filters='externalID', filter_values=with_external_id) self.test.assertEqual(1, len(vsd_security_policy_groups), "policy group not found by ExternalID") self.test.assertEqual( with_external_id, ExternalId(vsd_security_policy_groups[0] ['externalID']).at_cms_id())
def expected_ext_id(subnet): return ExternalId(subnet['id'] if Topology. is_v5 else subnet['network_id']).at_cms_id()
def test_external_id_format_default_security_policy_group(self): external_id = ExternalId(n_constants.NUAGE_PLCY_GRP_ALLOW_ALL + '@1b501982-2da1-48b9-931b-af49b6ee065f') self.assertEqual( external_id.uuid, n_constants.NUAGE_PLCY_GRP_ALLOW_ALL)
def test_external_id_empty(self): external_id = ExternalId("") self.assertEqual(external_id.uuid, "")
def test_external_id_none(self): external_id = ExternalId(None) self.assertEqual(external_id.uuid, "")
def test_external_id_format_short(self): external_id = ExternalId("aa-bb-cc-dd") self.assertEqual(external_id.uuid, "aa-bb-cc-dd")
def test_external_id_format_cmsid(self): external_id = ExternalId("aa-bb-cc-dd@ee-ff-gg-hh") self.assertEqual(external_id.uuid, "aa-bb-cc-dd") self.assertEqual(external_id.cms, "ee-ff-gg-hh")