def __init__(self, vsd_server=None, user='******', password='******', enterprise='csp', version=None): self.vsd = vsd_server or Topology.vsd_server self.uri = 'https://{}'.format(self.vsd) self.user = user self.password = password self.enterprise = enterprise self.vspk = importlib.import_module('vspk.' + str( version or self.base_uri_to_version(Topology.base_uri))) self._session = None self.default_enterprise = None # temporarily reusing RESTClient for missing ops self.nuage_rest_client = NuageRestClient() self.enterprise_name_to_enterprise = {}
def setup_clients(cls): super(PortsScaleTest, cls).setup_clients() cls.nuage_client = NuageRestClient() # Increase api read timeout because router interface attach can # take a long time if there are many ports with aaps cls.manager.routers_client = cls.manager.network.RoutersClient( http_timeout=100)
def setup_clients(cls): super(BaseNuageGatewayTest, cls).setup_clients() cls.nuage_client = NuageRestClient() cls.client = NuageNetworkClientJSON(cls.os_primary.auth_provider, **cls.os_primary.default_params) # initialize admin client cls.admin_client = NuageNetworkClientJSON( cls.os_admin.auth_provider, **cls.os_admin.default_params)
def setup_clients(cls): super(FloatingIPTestAdminNuage, cls).setup_clients() cls.nuage_client = NuageRestClient() # Overriding cls.client with Nuage network client cls.client = NuageNetworkClientJSON( cls.os_primary.auth_provider, **cls.os_primary.default_params)
def setup_clients(cls): super(BaremetalPortsTest, cls).setup_clients() cls.vsd_client = NuageRestClient()
def setup_clients(cls): super(FloatingIPTestJSONNuage, cls).setup_clients() cls.nuage_client = NuageRestClient()
def setup_clients(cls): super(ExternalIdForNetworkMacroTest, cls).setup_clients() cls.nuage_client = NuageRestClient() cls.nuage_network_client = NuageNetworkClientJSON( cls.os_primary.auth_provider, **cls.os_primary.default_params)
def setup_clients(cls): super(VSDUserGroup, cls).setup_clients() cls.manager = cls.get_client_manager() cls.admin_manager = cls.get_client_manager(credential_type='admin') cls.nuage_client = NuageRestClient()
def setup_clients(cls): super(AllowedAddressPairTest, cls).setup_clients() cls.nuage_client = NuageRestClient()
class VsdHelper(object): """VsdHelper Base class for VSD interactions. This class will have all the common functions to communicate with vsd using vspk """ CONST_ETHER_TYPE_IPV4 = "0x0800" CONST_ETHER_TYPE_IPV6 = "0x86DD" cms_id = Topology.cms_id default_netpartition_name = Topology.def_netpartition def __init__(self, vsd_server=None, user='******', password='******', enterprise='csp', version=None): self.vsd = vsd_server or Topology.vsd_server self.uri = 'https://{}'.format(self.vsd) self.user = user self.password = password self.enterprise = enterprise self.vspk = importlib.import_module( 'vspk.' + str(version or self.base_uri_to_version(Topology.base_uri))) self._session = None self.default_enterprise = None # temporarily reusing RESTClient for missing ops self.nuage_rest_client = NuageRestClient() self.enterprise_name_to_enterprise = {} @staticmethod def assertIsNotNone(obj, message): if obj is None: raise AssertionError(message or "{} is None".format(obj)) @staticmethod def base_uri_to_version(base_uri): pattern = re.compile(r'(v\d+_?\d*$)') match = pattern.search(base_uri) version = match.group() return str(version) def get_enterprise_by_id(self, ent_id): return get_by_id(self.session().user.enterprises, ent_id) def get_enterprise_by_name(self, ent_name): if ent_name in self.enterprise_name_to_enterprise: enterprise = self.enterprise_name_to_enterprise[ent_name] else: enterprise = get_by_name(self.session().user.enterprises, ent_name) self.enterprise_name_to_enterprise[ent_name] = enterprise return enterprise def new_session(self): """new_session Start a new API session via vspk an return the corresponding 'vspk.NUVSDSession` object. Note that this object is also exposed as `self()` """ self._session = self.vspk.NUVSDSession(username=self.user, password=self.password, enterprise=self.enterprise, api_url=self.uri) self._session.start() if not self.default_enterprise: self.default_enterprise = self.get_enterprise_by_name( self.default_netpartition_name) self.assertIsNotNone( self.default_enterprise, "Should have a default " "enterprise for Nuage plugin") return self._session def session(self): if not self._session: self._session = self.new_session() return self._session def get_default_enterprise(self): if not self.default_enterprise: self.session() return self.default_enterprise def external_id(self, obj_id): return obj_id + '@' + self.cms_id @staticmethod def filter_str(keys, values): filter_str = "" if not isinstance(keys, list): keys = [keys] if not isinstance(values, list): values = [values] for key, value in zip(keys, values): if filter_str: filter_str += " AND " if isinstance(value, int): filter_str += "{} IS {}".format(key, value) else: filter_str += "{} IS '{}'".format(key, value) return filter_str def get_external_id_filter(self, object_id): return self.filter_str('externalID', self.external_id(object_id)) def create_l2domain_template(self, name=None, enterprise=None, dhcp_managed=True, ip_type="IPV4", cidr4=None, gateway4=None, cidr6=None, gateway6=None, enable_dhcpv4=True, enable_dhcpv6=False, **kwargs): if enterprise and not isinstance(enterprise, self.vspk.NUEnterprise): # get enterprise by _name_ enterprise = self.get_enterprise_by_name(enterprise) elif not enterprise: enterprise = self.get_default_enterprise() template_name = name or data_utils.rand_name('test-l2template') params = {} if not Topology.is_v5: params.update({'enable_dhcpv4': enable_dhcpv4}) params.update({'enable_dhcpv6': enable_dhcpv6}) if dhcp_managed: params['dhcp_managed'] = dhcp_managed if ip_type in ("IPV4", "IPV6", "DUALSTACK"): params.update({'ip_type': ip_type}) if cidr4: params.update({'address': str(cidr4.ip)}) if "netmask" in kwargs: netmask = kwargs['netmask'] else: netmask = str(cidr4.netmask) params.update({'netmask': netmask}) if not gateway4 and (enable_dhcpv4 or Topology.is_v5): # fill in gateway when dhcp is enabled only; # or in v5, always fill it when a cidr is set ('managed') gateway4 = str(IPAddress(cidr4) + 1) if gateway4: params.update({'gateway': gateway4}) if cidr6: params.update({'ipv6_address': str(cidr6)}) if "netmask6" in kwargs: netmask6 = kwargs['netmask6'] else: netmask6 = str(cidr6.netmask) params.update({'netmask6': netmask6}) if not gateway6 and (enable_dhcpv6 or Topology.is_v5): # fill in gateway when dhcp is enabled only; # or in v5, always fill it when a cidr is set ('managed') gateway6 = str(IPAddress(cidr6) + 1) if gateway6: params.update({'ipv6_gateway': gateway6}) # add all other kwargs as attributes (key,value) pairs for key, value in iteritems(kwargs): params.update({key: value}) if kwargs.get('no_gateway'): params.update({'gateway': None, 'ipv6_gateway': None}) template = self.vspk.NUL2DomainTemplate(name=template_name, **params) return enterprise.create_child(template)[0] def delete_l2domain_template(self, l2dom_t_id): return self.nuage_rest_client.delete_l2domaintemplate(l2dom_t_id) def create_l2domain(self, name=None, enterprise=None, template=None, **kwargs): if enterprise and not isinstance(enterprise, self.vspk.NUEnterprise): # get enterprise by _name_ enterprise = self.get_enterprise_by_name(enterprise) if not enterprise: enterprise = self.get_default_enterprise() self.assertIsNotNone(template, "Must provide a valid template") name = name or data_utils.rand_name('test-l2domain') l2domain = self.vspk.NUL2Domain(name=name, template=template, **kwargs) return enterprise.instantiate_child(l2domain, template)[0] def delete_l2domain(self, l2dom_id): return self.nuage_rest_client.delete_l2domain(l2dom_id) def _get_enterprise_or_default(self, enterprise): if enterprise and not isinstance(enterprise, self.vspk.NUEnterprise): # get enterprise by _name_ enterprise = self.get_enterprise_by_name(enterprise) if not enterprise: enterprise = self.get_default_enterprise() return enterprise def _get_vspk_filter_for_subnet(self, by_id=None, by_subnet=None): vspk_filter = None if by_id: vspk_filter = 'ID is "{}"'.format(by_id) elif by_subnet: if Topology.is_v5: vspk_filter = self.get_external_id_filter(by_subnet['id']) else: if by_subnet['ip_version'] == 6: vspk_filter = self.filter_str( ['externalID', 'IPv6Address'], [ self.external_id(by_subnet['network_id']), by_subnet['cidr'] ]) else: vspk_filter = self.filter_str(['externalID', 'address'], [ self.external_id(by_subnet['network_id']), by_subnet['cidr'].split('/')[0] ]) return vspk_filter def get_l2domain(self, enterprise=None, vspk_filter=None, by_id=None, by_subnet=None): """get_l2domain @params: enterprise object or enterprise id filter following vspk filter structure @return l2 domain object @Example: self.vsd.get_l2domain(enterprise=enterprise, vspk_filter='name == "{}"'.format(name)) self.vsd.get_l2domain(enterprise=enterprise_name, vspk_filter='name == "{}"'.format(name)) self.vsd.get_l2domain( vspk_filter='externalID == "{}"'.format(ext_id)) """ enterprise = self._get_enterprise_or_default(enterprise) vspk_filter = (vspk_filter or self._get_vspk_filter_for_subnet( by_id=by_id, by_subnet=by_subnet)) return enterprise.l2_domains.get_first(filter=vspk_filter) def get_l2domain_template(self, enterprise=None, vspk_filter=None, by_id=None, by_subnet=None): """get_l2domain_template @params: enterprise object or enterprise id filter following vspk filter structure @return l2 domain template object @Example: self.vsd.get_l2domain_template(enterprise=enterprise, vspk_filter='name == "{}"'.format(name)) self.vsd.get_l2domain_template(enterprise=enterprise_name, vspk_filter='name == "{}"'.format(name)) self.vsd.get_l2domain_template( vspk_filter='externalID == "{}"'.format(ext_id)) """ enterprise = self._get_enterprise_or_default(enterprise) vspk_filter = (vspk_filter or self._get_vspk_filter_for_subnet( by_id=by_id, by_subnet=by_subnet)) return enterprise.l2_domain_templates.get_first(filter=vspk_filter) ### # l3 domain ### def create_l3domain_template(self, name=None, enterprise=None): if enterprise and not isinstance(enterprise, self.vspk.NUEnterprise): # get enterprise by _name_ enterprise = self.get_enterprise_by_name(enterprise) elif not enterprise: enterprise = self.get_default_enterprise() template_name = name or data_utils.rand_name('test-l3template') template = self.vspk.NUDomainTemplate(name=template_name) return enterprise.create_child(template)[0] def delete_l3domain_template(self, l3dom_t_id): return self.nuage_rest_client.delete_l3domaintemplate(l3dom_t_id) def create_domain(self, name=None, enterprise=None, template_id=None): return self.create_l3domain(name, enterprise, template_id) def create_l3domain(self, name=None, enterprise=None, template_id=None, **kwargs): if enterprise and not isinstance(enterprise, self.vspk.NUEnterprise): # get enterprise by _name_ enterprise = self.get_enterprise_by_name(enterprise) elif not enterprise: enterprise = self.get_default_enterprise() self.assertIsNotNone(template_id, "Must provide a valid template ID") name = name or data_utils.rand_name('test-l3domain') l3domain_data = self.vspk.NUDomain(name=name, template_id=template_id, **kwargs) return enterprise.create_child(l3domain_data)[0] def delete_domain(self, l3dom_id): return self.delete_l3domain(l3dom_id) def delete_l3domain(self, l3dom_id): return self.nuage_rest_client.delete_domain(l3dom_id) def get_l3_domain_by_subnet(self, by_subnet): # get the subnet subnet = self.get_subnet_from_domain(by_subnet=by_subnet) if not subnet: return None _, domain = self.get_zone_and_domain_parent_of_subnet(subnet) return domain def get_domain(self, enterprise=None, vspk_filter=None, by_router_id=None): return self.get_l3domain(enterprise, vspk_filter, by_router_id) def get_l3domain(self, enterprise=None, vspk_filter=None, by_router_id=None): """get_l3domain @params: enterprise object or enterprise id filter following vspk filter structure @return: domain object @Example: self.vsd.get_l3domain(enterprise=enterprise, vspk_filter='name == "{}"'.format(name)) self.vsd.get_l3domain(enterprise=enterprise_name, vspk_filter='name == "{}"'.format(name)) self.vsd.get_l3domain(vspk_filter='externalID == "{}"'.format(ext_id)) """ if by_router_id: domain = self.get_l3domain( enterprise, self.get_external_id_filter(by_router_id)) else: if enterprise and not isinstance(enterprise, self.vspk.NUEnterprise): # get enterprise by _name_ enterprise = self.get_enterprise_by_name(enterprise) elif not enterprise: enterprise = self.get_default_enterprise() domain = enterprise.domains.get_first(filter=vspk_filter) return domain def create_zone(self, name=None, domain=None, **kwargs): zone_name = name or data_utils.rand_name('test-zone') zone_data = self.vspk.NUZone(name=zone_name, **kwargs) zone_tuple = domain.create_child(zone_data) return zone_tuple[0] def create_subnet(self, name=None, zone=None, ip_type="IPV4", cidr4=None, gateway4=None, enable_dhcpv4=True, cidr6=None, gateway6=None, enable_dhcpv6=False, **kwargs): self.assertIsNotNone(zone, "Must provide a valid zone") subnet_name = name or data_utils.rand_name('test-subnet') params = {} if not enable_dhcpv4: params.update({'enable_dhcpv4': False}) if not enable_dhcpv6: params.update({'enable_dhcpv6': False}) for key, value in iteritems(kwargs): params.update({key: value}) if cidr4: params.update({'address': str(cidr4.ip)}) if enable_dhcpv4: params.update({'enable_dhcpv4': True}) if "netmask" not in kwargs: params.update({'netmask': str(cidr4.netmask)}) if gateway4: params.update({'gateway': gateway4}) if cidr6: params.update({'ipv6_address': str(cidr6)}) if enable_dhcpv6: params.update({'enable_dhcpv6': True}) if gateway6: params.update({'ipv6_gateway': gateway6}) subnet_data = self.vspk.NUSubnet(name=subnet_name, ip_type=ip_type, **params) return zone.create_child(subnet_data)[0] def delete_subnet(self, subnet_id): return self.nuage_rest_client.delete_domain_subnet(subnet_id) ### # policy groups ### def create_policy_group(self, domain, name=None): pg = self.vspk.NUPolicyGroup(name=name, type='SOFTWARE') domain.create_child(pg) return domain.policy_groups.get_first( filter='name is "{}"'.format(name)) def create_ingress_acl_template(self, domain, name='default-acl-template'): acl_params = { 'name': name, 'active': True, 'default_allow_ip': True, 'default_allow_non_ip': False, 'allow_address_spoof': True } ingress_tpl = self.vspk.NUIngressACLTemplate(**acl_params) domain.create_child(ingress_tpl) return domain.ingress_acl_templates.get_first( filter='name is "{}"'.format(name)) def create_egress_acl_template(self, domain, name='default-acl-template'): acl_params = { 'name': name, 'active': True, 'default_allow_ip': True, 'default_allow_non_ip': False, 'allow_address_spoof': True } egress_tpl = self.vspk.NUEgressACLTemplate(**acl_params) domain.create_child(egress_tpl) return domain.egress_acl_templates.get_first( filter='name is "{}"'.format(name)) def add_egress_acl_template_rule(self, template, name='default-acl-rule', protocol='ANY', location_type='ANY', network_type='ANY', stateful=False, egress="FORWARD"): entry = self.vspk.NUIngressACLEntryTemplate( name=name, protocol=protocol, location_type=location_type, network_type=network_type, stateful=stateful, action=egress) return template.create_child(entry)[0] def create_acl_templates(self, the_domain, allow_spoofing=False): acl_params = { 'name': 'default-acl-template', 'active': True, 'default_allow_ip': False, 'default_allow_non_ip': False, 'allow_address_spoof': allow_spoofing, 'default_install_acl_implicit_rules': False } ingress_template = self.vspk.NUIngressACLTemplate(**acl_params) the_domain.create_child(ingress_template) egress_template = self.vspk.NUEgressACLTemplate(**acl_params) the_domain.create_child(egress_template) return ingress_template, egress_template def define_ssh_acl(self, ingress_tpl, egress_tpl, stateful=True): res = [] # Add SSH rule for FIP access entry = self.vspk.NUIngressACLEntryTemplate( ether_type=self.CONST_ETHER_TYPE_IPV4, protocol='6', location_type='ANY', network_type='ANY', stateful=stateful, destination_port='*', source_port='22', action='FORWARD') obj = ingress_tpl.create_child(entry)[0] res.append(obj.stats_id) entry = self.vspk.NUEgressACLEntryTemplate( ether_type=self.CONST_ETHER_TYPE_IPV4, protocol='6', location_type='ANY', network_type='ANY', stateful=stateful, destination_port='22', source_port='*', action='FORWARD') obj = egress_tpl.create_child(entry)[0] res.append(obj.stats_id) return res def define_tcp_acl(self, direction, acl_template, ip_version, s_port='*', d_port='80', stateful=True, location_type='ANY', location_id=None): res = [] ether_type = (self.CONST_ETHER_TYPE_IPV4 if ip_version == 4 else self.CONST_ETHER_TYPE_IPV6) if direction == 'ingress': entry = self.vspk.NUIngressACLEntryTemplate( ether_type=ether_type, protocol='6', location_type=location_type, location_id=location_id, network_type='ANY', stateful=stateful, destination_port=d_port, source_port=s_port, action='FORWARD') obj = acl_template.create_child(entry)[0] res.append(obj.stats_id) elif direction == 'egress': entry = self.vspk.NUEgressACLEntryTemplate(ether_type=ether_type, protocol='6', location_type='ANY', network_type='ANY', stateful=stateful, destination_port=d_port, source_port=s_port, action='FORWARD') obj = acl_template.create_child(entry)[0] res.append(obj.stats_id) return res def define_any_to_any_acl(self, domain, ingress='FORWARD', egress='FORWARD', allow_ipv4=True, allow_ipv6=False, stateful=False, spoof=False): # always delete first for acl in domain.ingress_acl_templates.get(): acl.delete() for acl in domain.egress_acl_templates.get(): acl.delete() # and then create new res = [] ingress_tpl, egress_tpl = self.create_acl_templates(domain, spoof) if allow_ipv4: entry = self.vspk.NUIngressACLEntryTemplate(protocol='ANY', location_type='ANY', network_type='ANY', stateful=stateful, action=ingress) obj = ingress_tpl.create_child(entry)[0] res.append(obj.stats_id) entry = self.vspk.NUEgressACLEntryTemplate(protocol='ANY', location_type='ANY', network_type='ANY', stateful=stateful, action=egress) obj = egress_tpl.create_child(entry)[0] res.append(obj.stats_id) if allow_ipv6: entry = self.vspk.NUIngressACLEntryTemplate( ether_type=self.CONST_ETHER_TYPE_IPV6, protocol='ANY', location_type='ANY', network_type='ANY', stateful=stateful, action=ingress) obj = ingress_tpl.create_child(entry)[0] res.append(obj.stats_id) entry = self.vspk.NUEgressACLEntryTemplate( ether_type=self.CONST_ETHER_TYPE_IPV6, protocol='ANY', location_type='ANY', network_type='ANY', stateful=stateful, action=egress) obj = egress_tpl.create_child(entry)[0] res.append(obj.stats_id) if not allow_ipv4: # Add SSH rule for FIP access entry = self.vspk.NUEgressACLEntryTemplate( ether_type=self.CONST_ETHER_TYPE_IPV4, protocol='6', location_type='ANY', network_type='ANY', stateful=True, destination_port='22', source_port='*', action=egress) obj = egress_tpl.create_child(entry)[0] res.append(obj.stats_id) return res ### # Floating ip ### def get_vport_vip(self, enterprise=None, vport_id=None, router_id=None): """get_vport_vip @params: @return associated virtual ip TODO(team) this only works when there is only one virtual ip associated TODO(team) someone have a better idea on how to get down to the virtual ip port? """ if enterprise and not isinstance(enterprise, self.vspk.NUEnterprise): # get enterprise by _name_ enterprise = self.get_enterprise_by_name(enterprise) elif not enterprise: enterprise = self.get_default_enterprise() self.assertIsNotNone(vport_id, "Must provide a vport id") self.assertIsNotNone(router_id, "Must provide a router id") domain = enterprise.domains.get_first( filter='externalID == "{}"'.format(router_id + "@" + Topology.cms_id)) vport = domain.vports.get_first( filter='externalID == "{}"'.format(vport_id + "@" + Topology.cms_id)) return vport.virtual_ips.get_first() if vport else None def get_domain_template(self, enterprise=None, vspk_filter=None, by_router_id=None): """get_domain_template @params: enterprise object or enterprise id filter following vspk filter structure @return: domain template object @Example: self.vsd.get_domain_template(enterprise=enterprise, filter='name == "{}"'.format(name)) self.vsd.get_domain_template(enterprise=enterprise_name, filter='name == "{}"'.format(name)) self.vsd.get_domain_template( filter='externalID == "{}"'.format(ext_id)) """ if by_router_id: domain_template = self.get_domain_template( enterprise, self.get_external_id_filter(by_router_id)) else: if enterprise and not isinstance(enterprise, self.vspk.NUEnterprise): # get enterprise by _name_ enterprise = self.get_enterprise_by_name(enterprise) elif not enterprise: enterprise = self.get_default_enterprise() domain_template = enterprise.domain_templates.get_first( filter=vspk_filter) return domain_template def get_zone(self, domain=None, vspk_filter=None, by_router_id=None): """get_zone @params: domain object or domain id filter following vspk filter structure @return: zone object @Example: self.vsd.get_zone(domain=domain, filter='name == "{}"'.format(name)) self.vsd.get_zone(domain=domain_id, filter='name == "{}"'.format(name)) self.vsd.get_zone(filter='externalID == "{}"'.format(ext_id)) """ if by_router_id: # this is actually not advised as there will be 2 zone = self.get_zone(domain, self.get_external_id_filter(by_router_id)) else: if domain: if not isinstance(domain, self.vspk.NUDomain): domain = self.vspk.NUDomain(id=domain) zone = domain.zones.get_first(filter=vspk_filter) else: zone = self.session().user.zones.get_first(filter=vspk_filter) return zone def get_subnet(self, zone=None, vspk_filter=None, by_id=None, by_subnet=None): """get_subnet @params: zone object or zone id filter following vspk filter structure @return: subnet object @Example: self.vsd.get_subnet(zone=zone, filter='name == "{}"'.format(name)) self.vsd.get_subnet(zone=zone_id, filter='name == "{}"'.format(name)) self.vsd.get_subnet(filter='externalID == "{}"'.format(ext_id)) """ if by_id: subnet = self.get_subnet(vspk_filter='ID is "{}"'.format(by_id)) elif by_subnet: vspk_filter = self._get_vspk_filter_for_subnet(by_subnet=by_subnet) subnet = self.get_subnet(zone, vspk_filter) else: if zone: if not isinstance(zone, self.vspk.NUZone): zone = self.vspk.NUZone(id=zone) subnet = zone.subnets.get_first(filter=vspk_filter) else: subnet = self.session().user.subnets.get_first( filter=vspk_filter) return subnet def get_zone_and_domain_parent_of_subnet(self, subnet): zone, _ = self.vspk.NUZone(id=subnet.parent_id).fetch() domain, _ = self.vspk.NUDomain(id=zone.parent_id).fetch() return zone, domain def get_subnet_from_domain(self, domain=None, vspk_filter=None, by_subnet=None): """get_subnet_from_domain @params: domain object or domain id filter following vspk filter structure @return: subnet object @Example: self.vsd.get_subnet(domain=domain, filter='name == "{}"'.format(name)) self.vsd.get_subnet(domain=domain_id, filter='name == "{}"'.format(name)) self.vsd.get_subnet(filter='externalID == "{}"'.format(ext_id)) """ if by_subnet: vspk_filter = self._get_vspk_filter_for_subnet(by_subnet=by_subnet) subnet = self.get_subnet_from_domain(domain, vspk_filter) else: if domain: if not isinstance(domain, self.vspk.NUDomain): domain = self.vspk.NUDomain(id=domain) subnet = domain.subnets.get_first(filter=vspk_filter) else: subnet = self.session().user.subnets.get_first( filter=vspk_filter) return subnet def get_vm(self, subnet=None, vspk_filter=None, by_device_id=None): """get_vm @params: subnet object or subnet id filter following vspk filter structure @return: vm object @Example: self.vsd.get_vm(subnet=subnet, filter='name == "{}"'.format(name)) self.vsd.get_vm(subnet=subnet_id, filter='name == "{}"'.format(name)) self.vsd.get_vm(filter='externalID == "{}"'.format(ext_id)) """ if by_device_id: vm = self.get_vm(subnet, self.get_external_id_filter(by_device_id)) else: if subnet: if not isinstance(subnet, self.vspk.NUSubnet): subnet = self.vspk.NUSubnet(id=subnet) vm = subnet.vms.get_first(filter=vspk_filter) else: vm = self.session().user.vms.get_first(filter=vspk_filter) return vm def get_subnet_dhcp_options(self, subnet=None, vspk_filter=None): """get_subnet_dhcp_options @params: subnet object or subnet filter following vspk filter structure @return: subnet dhcp_options object @Example: self.vsd.get_subnet_dhcp_options(subnet=subnet) self.vsd.get_subnet_dhcp_options( filter='externalID == "{}"'.format(subnet_externalID)) """ subnet = subnet or self.session().user.subnets.get_first( filter=vspk_filter) return subnet.dhcp_options.get() def get_l2domain_dhcp_options(self, l2domain=None, vspk_filter=None): """get_subnet_dhcp_options @params: subnet object or subnet filter following vspk filter structure @return: subnet dhcp_options object @Example: self.vsd.get_subnet_dhcp_options(subnet=subnet) self.vsd.get_subnet_dhcp_options( filter='externalID == "{}"'.format(subnet_externalID)) """ l2domain = l2domain or self.session().user.l2domain.get_first( filter=vspk_filter) return l2domain.dhcp_options.get() def get_vport(self, l2domain=None, subnet=None, vspk_filter=None, by_port_id=None): """get_vport @params: l2domain object subnet object vport filter following vspk filter structure @return: vport object @Example: self.vsd.get_vport(subnet=subnet, vspk_filter='externalID == "{}"'.format(ext_id)) """ assert l2domain or subnet # one of both is required parent = l2domain if l2domain else subnet if by_port_id: vport = self.get_vport(l2domain, subnet, self.get_external_id_filter(by_port_id)) else: vport = parent.vports.get_first(filter=vspk_filter) return vport def get_vm_interface(self, vspk_filter): """get_vm_interface @params: vm interface filter following vspk filter structure @return: vm interface object @Example: self.vsd.get_vm_interface( filter='externalID == "{}"'.format(ext_id)) """ return self.session().user.vm_interfaces.get_first(filter=vspk_filter) def get_vm_interface_policy_decisions(self, vm_interface=None, vspk_filter=None): """get_vm_interface_policy_decisions @params: vm interface object or vm interface filter following vspk filter structure @return: vm interface policy_decisions object @Example: self.vsd.get_vm_interface_policy_decisions(vm_interface=vm_interface) self.vsd.get_vm_interface_policy_decisions( filter='externalID == "{}"'.format(vm_interface_externalID)) """ vm_interface = ( vm_interface or self.session().user.vm_interfaces.get_first(filter=vspk_filter)) return self.vspk.NUPolicyDecision( id=vm_interface.policy_decision_id).fetch() def get_vm_interface_dhcp_options(self, vm_interface=None, vspk_filter=None): """get_vm_interface_dhcp_options @params: vm interface object or vm interface filter following vspk filter structure @return: vm interface dhcp_options object @Example: self.vsd.get_vm_interface_dhcp_options(vm_interface=vm_interface) self.vsd.get_vm_interface_dhcp_options( filter='externalID == "{}"'.format(vm_interface_externalID)) """ if vm_interface: if not isinstance(vm_interface, self.vspk.NUVMInterface): vm_interface = self.vspk.NUVMInterfacein(id=vm_interface) else: vm_interface = self.session().user.vm_interfaces.get_first( filter=vspk_filter) return vm_interface.dhcp_options.get() if vm_interface else [] def get_ingress_acl_entries(self, vspk_filter): """get_ingress_acl_entries @params: ingress acl entry filter following vspk filter structure @return: ingress acl entry object list @Example: self.vsd.get_ingress_acl_entry( filter='externalID == "{}"'.format(ext_id)) """ return self.session().user.ingress_acl_entry_templates.get( filter=vspk_filter) def get_egress_acl_entries(self, vspk_filter): """get_egress_acl_entry @params: egress acl entry filter following vspk filter structure @return: egress acl entry object list @Example: self.vsd.get_egress_acl_entry( filter='externalID == "{}"'.format(ext_id)) """ return self.session().user.egress_acl_entry_templates.get( filter=vspk_filter) def get_floating_ip(self, vspk_filter): """get_floating_ip @params: floating ip filter following vspk filter structure @return: floating ip object @Example: self.vsd.get_floating_ip( filter='externalID == "{}"'.format(ext_id)) """ return self.session().user.floating_ips.get_first(filter=vspk_filter) def create_floating_ip(self, domain, shared_network_resource_id, address=None): floating_ip_data = self.vspk.NUFloatingIp( associated_shared_network_resource_id=shared_network_resource_id, address=address) return domain.create_child(floating_ip_data)[0] def get_ingress_acl_template_entries(self, vspk_filter): """get_ingress_acl_template_entries @params: ingress template filter following vspk filter structure @return: ingress acl entries (objects) list under found template @Example: self.vsd.get_ingress_acl_entries( filter='externalID == "{}"'.format(ext_id)) """ acls = [] templates = self.session().user.ingress_acl_templates.get( filter=vspk_filter) or [] for template in templates: tmp = self.vspk.NUIngressACLTemplate(id=template.id) acl = tmp.ingress_acl_entry_templates.get() acls.append(acl) return acls def get_egress_acl_template_entries(self, vspk_filter): """get_egress_acl_template_entries @params: egress template filter following vspk filter structure @return: egress acl entries (objects) list under found template @Example: self.vsd.get_egress_acl_entries( filter='externalID == "{}"'.format(ext_id)) """ acls = [] templates = self.session().user.egress_acl_templates.get( filter=vspk_filter) or [] for template in templates: tmp = self.vspk.NUEgressACLTemplate(id=template.id) acl = tmp.egress_acl_entry_templates.get() acls.append(acl) return acls def get_shared_network_resource(self, vspk_filter=None, by_fip_subnet_id=None): """get_shared_network_resource @params: shared network resource filter following vspk filter structure @return: shared network resource object @Example: self.vsd.get_shared_network_resource( filter='externalID == "{}"'.format(ext_id)) """ if by_fip_subnet_id: shared_network_resource = self.get_shared_network_resource( self.get_external_id_filter(by_fip_subnet_id)) else: shared_network_resource = \ self.session().user.shared_network_resources.get_first( filter=vspk_filter) return shared_network_resource @staticmethod def get_virtual_ip(vport, vspk_filter): """get_virtual_ip @params: vport object vspk_filter following vspk filter structure @return: virtual_ip object @Example: self.vsd.get_virtual_ip(vport=vport, filter='externalID == "{}"'.format(ext_id)) """ return vport.virtual_ips.get_first(filter=vspk_filter) def get_firewall_acl(self, ent=None, vspk_filter=None, by_fw_policy_id=None): """get_firewall_acl @params: enterprise object vspk_filter following vspk filter structure @return: firewall_acl object @Example: self.vsd.get_firewall_acl(ent=ent1, filter='externalID == "{}"'.format(ext_id)) """ ent = ent or self.get_default_enterprise() if by_fw_policy_id: firewall_acl = self.get_firewall_acl( ent, self.get_external_id_filter(by_fw_policy_id)) else: firewall_acl = ent.firewall_acls.get_first(filter=vspk_filter) return firewall_acl def get_firewall_acls(self, ent=None, vspk_filter=None, by_fw_policy_id=None): """get_firewall_acls @params: enterprise object vspk_filter following vspk filter structure @return: firewall_acl object @Example: self.vsd.get_firewall_acl(ent=ent1, filter='externalID == "{}"'.format(ext_id)) """ ent = ent or self.get_default_enterprise() if by_fw_policy_id: firewall_acls = self.get_firewall_acls( ent, self.get_external_id_filter(by_fw_policy_id)) else: firewall_acls = ent.firewall_acls.get(filter=vspk_filter) return firewall_acls def get_firewall_rule(self, ent=None, vspk_filter=None, by_fw_rule_id=None): """get_firewall_rule @params: enterprise object vspk_filter following vspk filter structure @return: get_firewall_rule object @Example: self.vsd.get_firewall_rule(ent=ent1, filter='externalID == "{}"'.format(ext_id)) """ ent = ent or self.get_default_enterprise() if by_fw_rule_id: firewall_rule = self.get_firewall_rule( ent, self.get_external_id_filter(by_fw_rule_id)) else: firewall_rule = ent.firewall_rules.get_first(filter=vspk_filter) return firewall_rule @staticmethod def get_firewall_acl_domains(acl): """get_firewall_acl_domains @params: acl object get_firewall_acl NUFirewallAcl following vspk structure @return: get_l3domain(s) object @Example: self.vsd.get_firewall_acl_domains(acl=acl1) """ return acl.domains.get()
def setup_clients(cls): super(BaseVSDManagedNetworksIPv6Test, cls).setup_clients() cls.nuage_client = NuageRestClient()
def setup_clients(cls): super(OsManagedDualStackL3SubnetsTest, cls).setup_clients() cls.nuage_client = NuageRestClient()
def setup_clients(cls): super(NetworkNuageAdminTest, cls).setup_clients() cls.nuage_client = NuageRestClient()
def setup_clients(cls): super(SwitchdevPortTest, cls).setup_clients() cls.vsd_client = NuageRestClient()
def resource_setup(cls): super(NetworksTestJSONNuage, cls).resource_setup() cls.nuage_client = NuageRestClient()
def setup_clients(cls): super(NuageHybridMplsSriovTest, cls).setup_clients() cls.nuage_client = NuageRestClient()
def setup_clients(cls): super(CorrectHwvtepTrunkingTest, cls).setup_clients() cls.vsd_client = NuageRestClient()
def setup_clients(cls): super(VlanTransparentConnectivityTest, cls).setup_clients() cls.nuage_client = NuageRestClient() cls.client = NuageNetworkClientJSON(cls.os_primary.auth_provider, **cls.os_primary.default_params)
def setup_clients(cls): super(PortsDirectTest, cls).setup_clients() cls.vsd_client = NuageRestClient()
def setup_clients(cls): super(NuageServiceChaining, cls).setup_clients() cls.nuage_client = NuageRestClient() cls.client = NuageNetworkClientJSON(cls.os_primary.auth_provider, **cls.os_primary.default_params)
def setup_clients(cls): super(BaremetalRedcyTest, cls).setup_clients() cls.vsd_client = NuageRestClient() cls.trunk_client = NuageNetworkClientJSON( cls.os_admin.auth_provider, **cls.os_admin.default_params)
def setup_clients(cls): super(StatelessSecuritygroupTest, cls).setup_clients() cls.vsd_client = NuageRestClient()
def setup_clients(cls): super(UpgradeTo2010Test, cls).setup_clients() cls.vsd_client = NuageRestClient()
def setup_clients(cls): super(ExternalIdForL3domainTest, cls).setup_clients() cls.nuage_client = NuageRestClient()
def setup_clients(cls): super(SecGroupTestNuageBase, cls).setup_clients() cls.nuage_client = NuageRestClient()