def add_tenant_perm(self, vlan_id, user_tenant, netpart_id): req_params = {'vlan_id': vlan_id} # Check if the grp exists in VSD, if not create it nuage_user, nuage_group = helper.create_usergroup( self.restproxy, user_tenant, netpart_id) # Check if permission already exists perm = gw_helper.get_tenant_perm(self.restproxy, vlan_id) if perm: msg = _("Vlan %(vlan)s already assigned to %(ten)s") % \ {'vlan': vlan_id, 'ten': perm['permittedEntityName']} if perm['permittedEntityID'] != nuage_group: raise restproxy.RESTProxyError(msg) else: LOG.debug(msg) return nuage_perm = nuagelib.NuagePermission(create_params=req_params) data = nuage_perm.perm_update(nuage_group) data.update({'externalID': get_vsd_external_id(user_tenant)}) response = self.restproxy.rest_call('POST', nuage_perm.get_resource_by_vlan(), data) if not nuage_perm.validate(response): raise restproxy.RESTProxyError(nuage_perm.error_msg)
def _create_pg_for_rt(self, context, security_group_id, rt, vsd_managed): security_group = self.core_plugin.get_security_group(context, security_group_id) # pop rules, make empty policygroup first security_group_rules = security_group.pop('security_group_rules') try: policy_group = self.vsdclient.create_security_group_using_parent( rt['parentID'], rt['parentType'], security_group) except restproxy.RESTProxyError as e: if e.vsd_code == restproxy.REST_PG_EXISTS_ERR_CODE: # PG is being concurrently created external_id = cms_id_helper.get_vsd_external_id( security_group_id) policygroups = self._get_policygroups( external_id, rt['parentID'], rt['parentType']) return policygroups[0] else: raise # Before creating rules, we might have to make other policygroups first # if the rule uses remote_group_id to have rule related to other PG. for rule in security_group_rules: remote_sg_id = rule.get('remote_group_id') if remote_sg_id: self._find_or_create_policygroup_using_rt(context, remote_sg_id, rt, vsd_managed) if not vsd_managed: self.vsdclient.create_security_group_rules(policy_group, security_group_rules) return policy_group
def create_nuage_sharedresource(self, params): subnet = params['neutron_subnet'] req_params = { 'name': subnet['id'], 'gateway_ip': subnet['gateway_ip'], 'net': params['net'], 'type': params['type'], 'net_id': params['net_id'], 'externalID': get_vsd_external_id(subnet['id']) } desc_str = params['net_id'] + '_' + subnet['name'] extra_params = {'description': desc_str} if params.get('underlay_config'): extra_params['underlay'] = True if params.get('underlay') is not None: extra_params['underlay'] = params['underlay'] if params.get('nuage_uplink'): extra_params['sharedResourceParentID'] = params['nuage_uplink'] nuage_sharedresource = nuagelib.NuageSharedResources( create_params=req_params, extra_params=extra_params) response = self.restproxy.rest_call( 'POST', nuage_sharedresource.post_resource(), nuage_sharedresource.post_data()) if not nuage_sharedresource.validate(response): code = nuage_sharedresource.get_error_code(response) raise restproxy.RESTProxyError(nuage_sharedresource.error_msg, code) return nuage_sharedresource.get_sharedresource_id(response)
def create_update_qos(self, parent_type, parent_id, qos_policy_id, qos_policy_options, original_qos_policy_id=None): if parent_type == constants.L2DOMAIN: parent_type = nuagelib.NuageL2Domain.resource elif parent_type == constants.SUBNET: parent_type = nuagelib.NuageSubnet.resource elif parent_type == constants.VPORT: parent_type = nuagelib.NuageVPort.resource if original_qos_policy_id: # If there is already a QOS policy active on the resource # Delete it. self.delete_qos(parent_type, parent_id, original_qos_policy_id) if not qos_policy_options: return qos_data = { 'name': 'OS_QOS_policy_' + qos_policy_id, 'active': True, 'commitedInformationRate': 0, 'externalID': get_vsd_external_id(qos_policy_id) } qos_data.update(qos_policy_options) self.restproxy.post( self.qos_obj.post_url(parent=parent_type, parent_id=parent_id), qos_data)
def process_address_pairs_of_subnet(self, context, subnet_mapping, subnet_type): subnet_id = subnet_mapping.subnet_id vsd_subnet_id = subnet_mapping.nuage_subnet_id filters = {'fixed_ips': {'subnet_id': [subnet_id]}} ports = self.core_plugin.get_ports(context, filters=filters) ports_to_process = [ p for p in ports if (p['allowed_address_pairs'] or len(p['fixed_ips']) > 1) and self.needs_vport_creation(p['device_owner']) ] if ports_to_process: external_ids = [ get_vsd_external_id(port['id']) for port in ports_to_process ] vports = self.vsdclient.get_vports_by_external_ids( subnet_type, vsd_subnet_id, external_ids) vports_by_port_id = dict([ (vport['externalID'].split('@')[0], vport) for vport in vports ]) for port in ports_to_process: LOG.debug("Process address pairs for port: %s", port) vport = vports_by_port_id.get(port['id']) self.calculate_vips_for_port_ips(context, port) self.create_allowed_address_pairs(context, port, vport)
def get_nuage_port_by_id(restproxy_serv, params): req_params = {'externalID': get_vsd_external_id(params['neutron_port_id'])} vport_type = params.get('nuage_vport_type') if vport_type == constants.HOST_VPORT_TYPE: req_params['vport_id'] = params['nuage_vport_id'] nuage_intf = nuagelib.NuageHostInterface(create_params=req_params) nuage_extra_headers = nuage_intf.extra_headers_by_externalid() else: nuage_intf = nuagelib.NuageVMInterface(create_params=req_params) nuage_extra_headers = nuage_intf.extra_headers_for_all_vmifs() response = restproxy_serv.rest_call('GET', nuage_intf.get_all_resource(), '', extra_headers=nuage_extra_headers) if not nuage_intf.validate(response): raise restproxy.RESTProxyError(nuage_intf.error_msg, nuage_intf.vsd_error_code) if len(response[3]) > 0: port = response[3][0] req_params = {'vport_id': port['VPortID']} nuage_vport = nuagelib.NuageVPort(create_params=req_params) vport_resp = restproxy_serv.rest_call('GET', nuage_vport.get_resource(), '') if not nuage_vport.validate(vport_resp): raise restproxy.RESTProxyError(nuage_vport.error_msg, nuage_vport.vsd_error_code) vport = vport_resp[3][0] vport['nuage_vif_id'] = port['ID'] return vport
def create_vip_on_vport(self, params): req_params = { 'vport_id': params['vport_id'], 'externalID': get_vsd_external_id(params['externalID']) } extra_params = { 'vip': params['vip'], 'subnet': params['subnet_id'], 'mac': params['mac'] } if params.get('IPType') == constants.IPV6: extra_params['IPType'] = constants.IPV6 else: extra_params['IPType'] = constants.IPV4 nuage_vip = nuagelib.NuageVIP(create_params=req_params, extra_params=extra_params) vip = self.restproxy.post(nuage_vip.get_resource_for_vport(), nuage_vip.post_vip_data())[0] LOG.debug( "VIP with ip %(vip)s and mac %(mac)s created for %(vport)s", { 'vip': params['vip'], 'mac': params['mac'], 'vport': params['vport_id'] }) return vip
def get_nuage_port_by_id(restproxy_serv, params): req_params = { 'externalID': get_vsd_external_id(params['neutron_port_id']) } vport_type = params.get('nuage_vport_type') if vport_type == constants.HOST_VPORT_TYPE: req_params['vport_id'] = params['nuage_vport_id'] nuage_intf = nuagelib.NuageHostInterface(create_params=req_params) nuage_extra_headers = nuage_intf.extra_headers_by_externalid() else: nuage_intf = nuagelib.NuageVMInterface(create_params=req_params) nuage_extra_headers = nuage_intf.extra_headers_for_all_vmifs() interfaces = restproxy_serv.get(nuage_intf.get_all_resource(), extra_headers=nuage_extra_headers, required=True) if interfaces: interface = interfaces[0] req_params = {'vport_id': interface['VPortID']} nuage_vport = nuagelib.NuageVPort(create_params=req_params) vport = restproxy_serv.get(nuage_vport.get_resource(), required=True)[0] vport['nuage_vif_id'] = interface['ID'] return vport return None
def create_nuage_redirect_target(self, context, nuage_redirect_target): redirect_target = nuage_redirect_target['nuage_redirect_target'] has_subnet_id = is_attr_set(redirect_target.get('subnet_id')) has_router_id = is_attr_set(redirect_target.get('router_id')) if not has_subnet_id and not has_router_id: msg = _('subnet_id or router_id should be specified') raise n_exc.BadRequest(resource='subnets', msg=msg) subnet_mapping = nuagedb.get_subnet_l2dom_by_id( context.session, redirect_target.get('subnet_id')) or {} router_mapping = nuagedb.get_ent_rtr_mapping_by_rtrid( context.session, redirect_target.get('router_id')) or {} if not subnet_mapping and not router_mapping: raise ext_rtarget.RedirectTargetNoDomainOrL2Domain() if has_subnet_id: subnet = self.core_plugin.get_subnet(context, redirect_target['subnet_id']) if subnet: redirect_target['external_id'] = \ cms_id_helper.get_vsd_external_id(subnet['network_id']) try: nuage_redirect_target = self.vsdclient\ .create_nuage_redirect_target( redirect_target, l2dom_id=subnet_mapping.get('nuage_subnet_id'), domain_id=router_mapping.get('nuage_router_id')) except Exception as e: if getattr(e, "vsd_code", None) == '7016': msg = _("A Nuage redirect target with name '%s' already " "exists") % redirect_target['name'] raise nuage_exc.NuageBadRequest(msg=msg) raise return self._make_redirect_target_dict(nuage_redirect_target, context=context)
def _create_policygroup(self, context, security_group_id, vsd_subnet): security_group = self.core_plugin.get_security_group( context, security_group_id) # pop rules, make empty policygroup first security_group_rules = security_group.pop('security_group_rules') try: policy_group = self.vsdclient.create_security_group( vsd_subnet, security_group) except restproxy.RESTProxyError as e: if e.vsd_code == restproxy.REST_PG_EXISTS_ERR_CODE: # PG is being concurrently created external_id = cms_id_helper.get_vsd_external_id( security_group_id) policygroups = self.get_policygroups(external_id, vsd_subnet) return policygroups[0] else: raise # Before creating rules, we might have to make other policygroups first # if the rule uses remote_group_id to have rule related to other PG. with nuage_utils.rollback() as on_exc: on_exc(self.vsdclient.delete_nuage_policy_group, policy_group['ID']) remote_sg_ids = [] for rule in security_group_rules: remote_sg_id = rule.get('remote_group_id') if remote_sg_id and remote_sg_id not in remote_sg_ids: remote_sg_ids.append(remote_sg_id) self._find_or_create_policygroup(context, remote_sg_id, vsd_subnet) self.vsdclient.create_security_group_rules(policy_group, security_group_rules) return policy_group
def get_l3dom_by_router_id(restproxy_serv, rtr_id): req_params = {'externalID': get_vsd_external_id(rtr_id)} nuage_l3_domain = nuagelib.NuageL3Domain(create_params=req_params) l3domain = restproxy_serv.get( nuage_l3_domain.get_all_resources(), extra_headers=nuage_l3_domain.extra_headers_get(), required=True) return l3domain[0] if l3domain else None
def _create_nuage_def_l3domain_adv_fwd_template(self, l3dom_id, neutron_router_id): nuageadvfwdtmplt = nuagelib.NuageInAdvFwdTemplate() fwd_temps = self.restproxy.post( nuageadvfwdtmplt.post_resource_l3(l3dom_id), nuageadvfwdtmplt.post_data_default_l3( l3dom_id, get_vsd_external_id(neutron_router_id))) return fwd_temps[0]['ID'] if fwd_temps else None
def delete_qos(self, parent_type, parent_id, qos_policy_id): qos_resource = nuagelib.NuageQos() filters = {'externalID': get_vsd_external_id(qos_policy_id)} qos = self.restproxy.get( qos_resource.get_url(parent=parent_type, parent_id=parent_id), extra_headers=qos_resource.extra_header_filter(**filters)) if qos: self.restproxy.delete(qos_resource.delete_url() % qos[0]['ID'])
def get_router_by_external(self, ext_id): params = {'externalID': get_vsd_external_id(ext_id)} nuagerouter = nuagelib.NuageL3Domain(create_params=params) l3_doms = self.restproxy.get( nuagerouter.get_resource_with_ext_id(), extra_headers=nuagerouter.extra_headers_get(), required=True) return l3_doms[0] if l3_doms else None
def _create_nuage_def_l2domain_adv_fwd_template(self, l2dom_id, neutron_subnet_id): nuageadvfwdtmplt = nuagelib.NuageInAdvFwdTemplate() response = self.restproxy.rest_call( 'POST', nuageadvfwdtmplt.post_resource_l2(l2dom_id), nuageadvfwdtmplt.post_data_default_l2( l2dom_id, get_vsd_external_id(neutron_subnet_id))) if not nuageadvfwdtmplt.validate(response): raise restproxy.RESTProxyError(nuageadvfwdtmplt.error_msg) return nuageadvfwdtmplt.get_response_objid(response)
def _get_by_openstack_id(self, resource, id, parent=None, parent_id=None, required=False): external_id = get_vsd_external_id(id) objects = self.get(resource, parent=parent, parent_id=parent_id, externalID=external_id) if not objects and required: raise restproxy.ResourceNotFoundException( "Can not find %s with externalID %s on vsd" % (resource.resource, external_id)) return objects[0] if objects else None
def _create_nuage_l3dom_egress_tmplt(self, id, neutron_router_id): req_params = { 'parent_id': id, 'name': id, 'externalID': get_vsd_external_id(neutron_router_id) } nuageobacl = nuagelib.NuageOutboundACL(create_params=req_params) acls = self.restproxy.post(nuageobacl.post_resource_l3(), nuageobacl.post_data_default_l3()) return acls[0]['ID'] if acls else None
def get_nuage_vm_interface_by_neutron_id(restproxy_serv, neutron_port_id): req_params = {'externalID': get_vsd_external_id(neutron_port_id)} nuage_intf = nuagelib.NuageVMInterface(create_params=req_params) nuage_extra_headers = nuage_intf.extra_headers_for_all_vmifs() interfaces = restproxy_serv.get(nuage_intf.get_all_resource(), extra_headers=nuage_extra_headers, required=True) return interfaces[0] if interfaces else None
def create_in_adv_fwd_policy_template(rest_proxy, parent_type, parent_id, params): params['externalID'] = get_vsd_external_id(params['externalID']) adv_fwd_tmplt = nuagelib.NuageInAdvFwdTemplate() if parent_type == constants.L2DOMAIN: return rest_proxy.post(adv_fwd_tmplt.post_resource_l2(parent_id), params)[0] else: return rest_proxy.post(adv_fwd_tmplt.post_resource_l3(parent_id), params)[0]
def create_nuage_floatingip_details(self, params): req_params = { 'domain_id': params['nuage_rtr_id'], 'shared_netid': params['nuage_fippool_id'], 'address': params['neutron_fip_ip'], 'externalID': get_vsd_external_id(params['neutron_fip_id']) } nuage_fip = nuagelib.NuageFloatingIP(create_params=req_params) response = self.restproxy.post(nuage_fip.post_resource(), nuage_fip.post_data()) return response[0]
def _get_vips_for_subnet(self, neutron_subnet_id, **filters): external_id = get_vsd_external_id(neutron_subnet_id) subnets = helper.get_l3_subnets(self.restproxy, externalID=external_id) if not subnets: msg = ("Could not find subnet with externalID '%s'" % neutron_subnet_id) raise restproxy.ResourceNotFoundException(msg) return self.get_vips(nuagelib.NuageSubnet.resource, subnets[0]['ID'], **filters)
def create_nuage_l2dom_ingress_tmplt(restproxy_serv, id, neutron_subnet_id): req_params = { 'parent_id': id, 'name': id, 'externalID': get_vsd_external_id(neutron_subnet_id) } nuageibacl = nuagelib.NuageInboundACL(create_params=req_params) response = restproxy_serv.rest_call('POST', nuageibacl.post_resource_l2(), nuageibacl.post_data_default_l2()) if not nuageibacl.validate(response): raise restproxy.RESTProxyError(nuageibacl.error_msg)
def _get_sharedresource_by_external(self, neutron_id): create_params = {'externalID': get_vsd_external_id(neutron_id)} nuage_sharedresource = nuagelib.NuageSharedResources(create_params) url = nuage_sharedresource.get_resource() extra_headers = nuage_sharedresource.extra_headers_get_by_externalID() shared_resouces = self.restproxy.get(url, extra_headers=extra_headers) if not shared_resouces: raise restproxy.ResourceNotFoundException( "Cannot find sharednetworkresource with externalID '%s'" % create_params['externalID']) return shared_resouces[0]
def get_nuage_fip_by_id(self, neutron_fip_id): req_params = { 'externalID': get_vsd_external_id(neutron_fip_id) } nuage_fip = nuagelib.NuageFloatingIP(create_params=req_params) nuage_extra_headers = nuage_fip.extra_headers() fips = self.restproxy.get(nuage_fip.get_resource(), extra_headers=nuage_extra_headers, required=True) return fips[0] if fips else None
def get_nuage_fip_by_id(self, params): req_params = {'externalID': get_vsd_external_id(params['fip_id'])} nuage_fip = nuagelib.NuageFloatingIP(create_params=req_params) nuage_extra_headers = nuage_fip.extra_headers() fips = self.restproxy.get(nuage_fip.get_resource(), extra_headers=nuage_extra_headers, required=True) return { 'nuage_fip_id': fips[0]['ID'], 'nuage_assigned': fips[0]['assigned'] } if fips else None
def _find_or_create_policygroup(self, context, security_group_id, vsd_subnet): external_id = cms_id_helper.get_vsd_external_id(security_group_id) policygroups = self.get_policygroups(external_id, vsd_subnet) if len(policygroups) > 1: msg = _("Found multiple policygroups with externalID %s") raise n_exc.Conflict(msg=msg % external_id) elif len(policygroups) == 1: return policygroups[0] else: return self._create_policygroup(context, security_group_id, vsd_subnet)
def _create_nuage_l3dom_egress_tmplt(self, id, neutron_router_id): req_params = { 'parent_id': id, 'name': id, 'externalID': get_vsd_external_id(neutron_router_id) } nuageobacl = nuagelib.NuageOutboundACL(create_params=req_params) response = self.restproxy.rest_call('POST', nuageobacl.post_resource_l3(), nuageobacl.post_data_default_l3()) if not nuageobacl.validate(response): raise restproxy.RESTProxyError(nuageobacl.error_msg) return nuageobacl.get_oacl_id(response)
def _create_nuage_vm(self, params): vsd_subnet = params['vsd_subnet'] req_params = { 'id': params['id'], 'mac': params['mac'], 'ipv4': params['ipv4'], 'ipv6': params['ipv6'], 'externalID': get_vsd_external_id(params['port_id']) } # if vport_id passed in VMInterface and attachedNetworkId is not set, # VM create associates the passed vport to the VMInterface if params.get('vport_id') and not params.get('attached_network'): req_params['vport_id'] = params.get('vport_id') elif params.get('attached_network'): req_params['attachedNetworkID'] = vsd_subnet['ID'] if vsd_subnet['type'] == constants.SUBNET: if not params['portOnSharedSubn']: self._attach_reqd_perm_for_vm_boot(params, vsd_subnet['parentID'], on_l2=False) elif vsd_subnet['type'] == constants.L2DOMAIN: self._clear_vsd_unmanaged_l2_domain_vm_ip(vsd_subnet, req_params) if not params['portOnSharedSubn']: self._attach_reqd_perm_for_vm_boot(params, vsd_subnet['ID'], on_l2=True) extra_params = { 'tenant': params['tenant'], 'net_partition_name': params['netpart_name'] } nuagevm = nuagelib.NuageVM(create_params=req_params, extra_params=extra_params) response = self.restproxy.post( nuagevm.post_resource(), nuagevm.post_data(), extra_headers=nuagevm.extra_headers_post(), on_res_exists=self.restproxy.retrieve_by_external_id, ignore_err_codes=[ restproxy.REST_EXISTS_INTERNAL_ERR_CODE, restproxy.REST_VM_UUID_IN_USE_ERR_CODE ]) vm_dict = {} new_vmif = nuagevm.get_new_vmif(response) if new_vmif: vm_dict['ip'] = nuagevm.get_vmif_ip(new_vmif) vm_dict['vport_id'] = nuagevm.get_vmif_vportid(new_vmif) vm_dict['vif_id'] = nuagevm.get_vmif_id(new_vmif) return vm_dict
def get_nuage_floatingip_assigned_to_port(self, context, filters=None): port_id = filters['ports'][0] vsd_mapping = nuagedb.get_subnet_l2dom_by_port_id( context.session, port_id) if vsd_mapping['nuage_l2dom_tmplt_id']: return [] vports = self.vsdclient.get_vports( constants.L3SUBNET, vsd_mapping['nuage_subnet_id'], externalID=get_vsd_external_id(port_id)) fip_id = vports[0]['associatedFloatingIPID'] if vports else None return (self.vsdclient.get_nuage_floatingips(required=True, ID=fip_id) if fip_id else [])
def bulk_update_existing_qos(self, qos_policy_id, qos_policy_options): # find all existing QOS objects filters = {'externalID': get_vsd_external_id(qos_policy_id)} qoss = self.restproxy.get( self.qos_obj.get_url(), extra_headers=self.qos_obj.extra_header_filter(**filters)) if not qoss: return updates = [{'ID': qos['ID']} for qos in qoss] for update in updates: update.update(qos_policy_options) self.restproxy.bulk_put(self.qos_obj.get_url() + '?responseChoice=1', updates)