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)
