def create_gateway_port_vlan(self, vlan_dict):
gw_id = vlan_dict.get('gateway')
gw_port_id = vlan_dict['gatewayport']
vlan_value = vlan_dict['value']
# Confirm that the gatewayport belongs to the gateway
gw_port = gw_helper.get_gateway_port(self.restproxy, gw_port_id, gw_id)
if not gw_port:
if gw_id:
msg = (_("Port %(port)s not found on gateway %(gw)s") % {
'port': gw_port_id,
'gw': gw_id
})
else:
msg = (_("Port %(port)s not found") % {'port': gw_port_id})
raise restproxy.ResourceNotFoundException(msg)
if not gw_id:
gw_id = gw_port['parentID']
gw = gw_helper.get_gateway(self.restproxy, gw_id)
req_params = {'port_id': gw_port_id, 'personality': gw['personality']}
nuage_gw_vlan = nuagelib.NuageVlanBase.factory(
create_params=req_params,
extra_params=None,
redundant=gw['redundant'])
return self.restproxy.post(nuage_gw_vlan.post_vlan(),
nuage_gw_vlan.post_vlan_data(vlan_value))
def get_l3domid_by_router_id(restproxy_serv, rtr_id):
l3domain = get_l3dom_by_router_id(restproxy_serv, rtr_id)
if not l3domain:
msg = _("No domain found for router %s") % rtr_id
raise restproxy.ResourceNotFoundException(msg)
return l3domain['ID']
def get_l3domid_by_router_id(restproxy_serv, rtr_id):
nuage_l3_domain, response = get_l3dom_by_router_id(restproxy_serv, rtr_id)
# response body will be '' when no domain is found
if not nuage_l3_domain.check_response_exist(response):
msg = _("No domain found for router %s") % rtr_id
raise restproxy.ResourceNotFoundException(msg)
return nuage_l3_domain.get_domainid(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 _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 _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 _create_domain(self, req_params, extra_params):
nuage_l3domain = nuagelib.NuageL3Domain(create_params=req_params,
extra_params=extra_params)
created_domain = self.restproxy.post(nuage_l3domain.post_resource(),
nuage_l3domain.post_data())[0]
req_params = {'domain_id': created_domain['ID']}
nuage_zone = nuagelib.NuageZone(req_params)
zone_list = self.restproxy.get(nuage_zone.list_resource())
if not zone_list:
self.delete_l3domain(created_domain['ID'])
msg = ("Cannot find zone under the created domain {} on VSD. "
"Delete the created domain".format(created_domain['ID']))
raise restproxy.ResourceNotFoundException(msg)
return created_domain, zone_list
def get_gateway_port(restproxy_serv, gw_port_id, gw_id=None):
# gw_port_id can actually be a name/id. In case of VSG, port name can
# have a '/'. In that case we just return.
if '/' in gw_port_id:
return
gw_port = None
any_hw_personality = 'VSG' # don't care which, as long as it is a HW one
# -------------------------------------------------------------------------
# Below loop iterates over non-redundant or redundant gw ports.
#
# When non-redundant, endpoint is always /ports.
# When redundant, for HW, endpoint is /vsgredundantports, for SW it is
# /ports. Hence, when we set personality to HW and loop over both
# redundancy modes, we cover all cases.
#
# If this invariant ever changes, we need a nested loop, looping over
# personalities, and inside, loop over redundancy modes
# -------------------------------------------------------------------------
for nuage_gw_port in [
nuagelib.NuageGatewayPortBase.factory(create_params={
'port_id':
gw_port_id,
'personality':
any_hw_personality
},
extra_params=None,
redundant=redundant)
for redundant in [False, True]
]:
try:
gw_port = restproxy_serv.get(nuage_gw_port.get_resource(),
required=True)[0]
break
except restproxy.ResourceNotFoundException:
continue
if not gw_port:
return []
if gw_id:
if gw_port['parentID'] != gw_id:
msg = (_("Port %(port)s not found on gateway %(gw)s") % {
'port': gw_port_id,
'gw': gw_id
})
raise restproxy.ResourceNotFoundException(msg)
return gw_port
def get_gateway(restproxy_serv, gw_id):
req_params = {'gw_id': gw_id}
for nuage_gw in [
nuagelib.NuageGatewayBase.factory(create_params=req_params,
extra_params=None,
redundant=redundant)
for redundant in [False, True]
]:
try:
gateway = restproxy_serv.get(nuage_gw.get_resource_by_id(),
required=True)[0]
gateway['redundant'] = 'redundantGatewayStatus' in gateway
return gateway
except restproxy.RESTProxyError:
continue
raise restproxy.ResourceNotFoundException(
msg='GW:{} not found!'.format(gw_id))
def get_domain_subnet_by_ext_id_and_cidr(restproxy_serv, neutron_subnet):
params = {
'externalID': get_subnet_external_id(neutron_subnet),
'cidr': netaddr.IPNetwork(neutron_subnet['cidr']),
'ip_type': neutron_subnet['ip_version']
}
nuagesubnet = nuagelib.NuageSubnet(create_params=params)
subnet = restproxy_serv.get(
nuagesubnet.get_all_resources(),
extra_headers=nuagesubnet.extra_headers_ext_id_and_cidr_get())
if subnet:
return subnet[0]
else:
msg = ("Cannot find subnet with externalID {} and cidr {}"
" in L3domains on VSD").format(params['externalID'],
params['cidr'])
raise restproxy.ResourceNotFoundException(msg)
def get_l2domain_by_ext_id_and_cidr(self, subnet):
params = {
'externalID': helper.get_subnet_external_id(subnet),
'cidr': netaddr.IPNetwork(subnet['cidr']),
'ip_type': subnet['ip_version']
}
nuagel2domain = nuagelib.NuageL2Domain(create_params=params)
l2domain = self.restproxy.get(
nuagel2domain.get_all_resources(),
extra_headers=nuagel2domain.extra_headers_ext_id_and_cidr_get())
if l2domain:
return l2domain[0]
else:
msg = ("Cannot find subnet with externalID {} and cidr {}"
" in L2domains on VSD").format(params['externalID'],
params['cidr'])
raise restproxy.ResourceNotFoundException(msg)
def _get_nuage_vm(self, params, isdelete=False):
req_params = {'id': params['id']}
extra_params = {
'tenant': params['tenant'],
'net_partition_name': params['netpart_name']
}
nuagevm = nuagelib.NuageVM(create_params=req_params,
extra_params=extra_params)
vms = self.restproxy.get(nuagevm.get_resource(),
extra_headers=nuagevm.extra_headers_get())
if not vms:
if isdelete:
return None
else:
msg = ('VM with uuid {} not found on '
'VSD').format(req_params['id'])
raise restproxy.ResourceNotFoundException(msg)
return vms[0]['ID']
def get_nuage_vport_by_neutron_id(restproxy_serv, params, required=True):
req_params = {'externalID': get_vsd_external_id(params['neutron_port_id'])}
l2domid = params.get('l2dom_id')
l3domid = params.get('l3dom_id')
vports = ''
if l2domid:
nuagel2domain = nuagelib.NuageL2Domain(create_params=req_params)
vports = restproxy_serv.get(
nuagel2domain.get_all_vports(l2domid),
extra_headers=nuagel2domain.extra_headers_get())
if not vports and l3domid:
nuagel3domsub = nuagelib.NuageSubnet(create_params=req_params)
vports = restproxy_serv.get(
nuagel3domsub.get_all_vports(l3domid),
extra_headers=nuagel3domsub.extra_headers_get())
if not vports and required:
raise restproxy.ResourceNotFoundException(
"vport for port '%s' not found" % params['neutron_port_id'])
return vports[0] if vports else None
def create_l3domain(self, neutron_router, router, net_partition,
tenant_name):
req_params = {
'net_partition_id': net_partition['id'],
'name': neutron_router['id'],
'templateID': net_partition['l3dom_tmplt_id'],
'externalID': get_vsd_external_id(neutron_router['id'])
}
if router.get('nuage_router_template'):
req_params['templateID'] = router['nuage_router_template']
extra_params = {
'description': neutron_router['name']
}
if 'rd' in router and router['rd']:
extra_params['routeDistinguisher'] = router['rd']
if 'rt' in router and router['rt']:
extra_params['routeTarget'] = router['rt']
if router.get('tunnel_type'):
neutron_tunnel_type = router['tunnel_type']
vsd_types = constants.VSD_TUNNEL_TYPES
extra_params['tunnelType'] = vsd_types[neutron_tunnel_type]
if 'ecmp_count' in router:
extra_params['ECMPCount'] = router.get('ecmp_count')
if ('nuage_backhaul_vnid' in router and
router['nuage_backhaul_vnid']):
extra_params['backHaulVNID'] = router['nuage_backhaul_vnid']
if ('nuage_backhaul_rd' in router and
router['nuage_backhaul_rd']):
extra_params['backHaulRouteDistinguisher'] = (
router['nuage_backhaul_rd'])
if ('nuage_backhaul_rt' in router and
router['nuage_backhaul_rt']):
extra_params['backHaulRouteTarget'] = router['nuage_backhaul_rt']
# PATEnabled & UnderlayEnabled
pat_enabled, underlay_enabled = self._calculate_pat_and_underlay(
router)
extra_params['PATEnabled'] = pat_enabled
extra_params['underlayEnabled'] = underlay_enabled
router_dict = {}
nuagel3domain, zone_list = self._create_domain(req_params,
extra_params)
nuage_domain_id = nuagel3domain['ID']
external_id = nuagel3domain['externalID']
parent_id = nuagel3domain['parentID']
router_dict['nuage_external_id'] = strip_cms_id(external_id)
router_dict['nuage_parent_id'] = parent_id
router_dict['nuage_domain_id'] = nuage_domain_id
router_dict['nuage_template_id'] = nuagel3domain.get('templateID')
router_dict['rt'] = nuagel3domain.get('routeTarget')
router_dict['rd'] = nuagel3domain.get('routeDistinguisher')
router_dict['ecmp_count'] = nuagel3domain.get('ECMPCount')
router_dict['tunnel_type'] = nuagel3domain.get('tunnelType')
router_dict['nuage_backhaul_vnid'] = nuagel3domain.get('backHaulVNID')
router_dict['nuage_backhaul_rd'] = (
nuagel3domain.get('backHaulRouteDistinguisher'))
router_dict['nuage_backhaul_rt'] = (
nuagel3domain.get('backHaulRouteTarget'))
isolated_id = None
shared_id = None
if router.get('nuage_router_template'):
for zone in zone_list:
if (zone['name'] == TEMPLATE_ISOLATED_ZONE and
not zone['publicZone']):
isolated_id = zone['ID']
elif (zone['name'] == TEMPLATE_SHARED_ZONE and
not zone['publicZone']):
shared_id = zone['ID']
external_id_params = {
'zone_id': zone['ID']
}
external_id_zone = nuagelib.NuageZone(
create_params=external_id_params)
helper.set_external_id_only(
self.restproxy,
resource=external_id_zone.get_resource(),
id=neutron_router['id'])
if not isolated_id or not shared_id:
msg = ("Mandatory zones %s or %s do not exist in VSD" % (
TEMPLATE_ISOLATED_ZONE, TEMPLATE_SHARED_ZONE))
self.delete_l3domain(nuage_domain_id)
raise restproxy.ResourceNotFoundException(msg)
router_dict['nuage_def_zone_id'] = isolated_id
router_dict['nuage_shared_zone_id'] = shared_id
self._make_nuage_zone_shared(net_partition['id'], shared_id,
neutron_router['tenant_id'])
elif net_partition.get('isolated_zone', None):
for zone in zone_list:
if zone['name'] == net_partition['isolated_zone']:
isolated_id = zone['ID']
if zone['name'] == net_partition['shared_zone']:
shared_id = zone['ID']
external_id_params = {
'zone_id': zone['ID']
}
external_id_zone = nuagelib.NuageZone(
create_params=external_id_params)
helper.set_external_id_only(
self.restproxy,
resource=external_id_zone.get_resource(),
id=neutron_router['id'])
if not isolated_id or not shared_id:
msg = "Default zones do not exist in VSD"
self.delete_l3domain(nuage_domain_id)
raise restproxy.ResourceNotFoundException(msg)
router_dict['nuage_def_zone_id'] = isolated_id
router_dict['nuage_shared_zone_id'] = shared_id
# TODO(Ronak) - Handle exception here
self._make_nuage_zone_shared(net_partition['id'], shared_id,
neutron_router['tenant_id'])
nuage_userid, nuage_groupid = \
helper.create_usergroup(self.restproxy,
neutron_router['tenant_id'],
net_partition['id'],
tenant_name)
router_dict['nuage_userid'] = nuage_userid
router_dict['nuage_groupid'] = nuage_groupid
self._attach_nuage_group_to_zone(nuage_groupid,
router_dict['nuage_def_zone_id'],
neutron_router['tenant_id'])
iacl_id, oacl_id = self._create_nuage_def_l3domain_acl(
nuage_domain_id, neutron_router['id'])
router_dict['iacl_id'] = iacl_id
router_dict['oacl_id'] = oacl_id
self._create_nuage_def_l3domain_adv_fwd_template(nuage_domain_id,
neutron_router['id'])
return router_dict
def create_gateway_vport_no_usergroup(self, tenant_id, params=False):
subnet = params.get('subnet')
enable_dhcp = params.get('enable_dhcp')
port = params.get('port')
type = params.get('type')
subn_id = subnet['id']
nuage_subnet = params.get('vsd_subnet')
if not nuage_subnet:
msg = (_("Nuage subnet for neutron subnet %(subn)s not found") % {
'subn': subn_id
})
raise restproxy.ResourceNotFoundException(msg)
# Create a vport with bridge/host interface
req_params = {
'nuage_vlan_id':
params['gatewayinterface'],
'neutron_subnet':
subnet,
'nuage_managed_subnet':
params.get('nuage_managed_subnet'),
'gw_type':
params['personality'],
'externalid':
get_vsd_external_id(port['id'] if port else subnet['network_id'])
}
if nuage_subnet['parentType'] == 'zone':
req_params['nuage_subnet_id'] = nuage_subnet['ID']
else:
req_params['l2domain_id'] = nuage_subnet['ID']
# Check if tenant has permission on gw interface
user_tenant = params.get('tenant')
if user_tenant:
# Give permissions for the enterprise
self.add_ent_perm(tenant_id, params['gatewayinterface'],
params['np_id'])
if type == constants.BRIDGE_VPORT_TYPE:
req_params[constants.PORTSECURITY] = True
resp = gw_helper.create_vport_interface(self.restproxy, req_params,
type)
else:
ips = {}
for fixed_ip in port.get('fixed_ips', []):
if netaddr.IPAddress(fixed_ip['ip_address']).version == 4:
ips[4] = fixed_ip['ip_address']
else:
ips[6] = fixed_ip['ip_address']
if enable_dhcp:
req_params['ipaddress'] = ips.get(4)
req_params['ipaddress_v6'] = ips.get(6)
else:
req_params['ipaddress'] = None
req_params['ipaddress_v6'] = ips.get(6)
req_params['mac'] = port['mac_address']
req_params['externalid'] = get_vsd_external_id(port['id'])
req_params[constants.PORTSECURITY] = port[constants.PORTSECURITY]
resp = gw_helper.create_vport_interface(self.restproxy, req_params,
type)
ret = resp
ret['vport_gw_type'] = self.get_personality_type(params['personality'])
return ret
def create_gateway_vport(self, tenant_id, params):
subnet = params.get('subnet')
enable_dhcp = params.get('enable_dhcp')
port = params.get('port')
type = params.get('type')
subn_id = subnet['id']
nuage_subnet = params.get('vsd_subnet')
if not nuage_subnet:
msg = (_("Nuage subnet for neutron subnet %(subn)s not found") % {
'subn': subn_id
})
raise restproxy.ResourceNotFoundException(msg)
# Create a vport with bridge/host interface
req_params = {
'nuage_vlan_id': params['gatewayinterface'],
'neutron_subnet': subnet,
'nuage_managed_subnet': params.get('nuage_managed_subnet')
}
# Get gateway from gw interface
gw = gw_helper.get_gateway_by_vlan(self.restproxy,
params['gatewayinterface'])
if nuage_subnet['parentType'] == 'zone':
req_params['nuage_subnet_id'] = nuage_subnet['ID']
else:
req_params['l2domain_id'] = nuage_subnet['ID']
req_params['gw_type'] = gw['personality']
# Check if tenant has permission on gw interface
user_tenant = params.get('tenant')
if user_tenant:
# Give permissions for the enterprise
self.add_ent_perm(tenant_id, params['gatewayinterface'],
params['np_id'])
# Give permissions for the tenant
self.add_tenant_perm(params['gatewayinterface'], user_tenant,
params['np_id'])
ret = dict()
if type == constants.BRIDGE_VPORT_TYPE:
req_params[constants.PORTSECURITY] = True
req_params['externalid'] = get_vsd_external_id(
port['id'] if port else subnet['network_id'])
resp = gw_helper.create_vport_interface(self.restproxy, req_params,
type)
else:
if enable_dhcp:
req_params['ipaddress'] = port['fixed_ips'][0]['ip_address']
else:
req_params['ipaddress'] = None
req_params['mac'] = port['mac_address']
req_params['externalid'] = get_vsd_external_id(port['id'])
req_params[constants.PORTSECURITY] = port[constants.PORTSECURITY]
resp = gw_helper.create_vport_interface(self.restproxy, req_params,
type)
ret = resp
ret['vport_gw_type'] = self.get_personality_type(gw['personality'])
return ret
def _check_parent_permissions(self, tenant_id, vlan_id, netpart_id):
req_params = {'vlan_id': vlan_id}
nuage_vlan = nuagelib.NuageVlan(create_params=req_params)
vlans = self.restproxy.get(nuage_vlan.get_resource(), required=True)
# Get ent permissions on port
gw_port_id = vlans[0]['parentID']
gw_port = gw_helper.get_gateway_port(self.restproxy, gw_port_id)
gw = gw_helper.get_gateway(self.restproxy, gw_port['parentID'])
req_params['port_id'] = gw_port_id
nuage_ent_perm = nuagelib.NuageEntPermission(create_params=req_params)
permissions = self.restproxy.get(nuage_ent_perm.get_resource_by_port(
gw['redundant']),
required=True)
ent_perm = permissions[0] if permissions else None
if ent_perm:
ent_id = ent_perm['permittedEntityID']
if ent_id != netpart_id:
ent_type = ent_perm['permittedEntityType']
LOG.debug(
"Port %(port)s already assigned to %(ent)s with id"
" %(ent_id)s", {
'port': vlan_id,
'ent': ent_type,
'ent_id': ent_id
})
return False
else:
LOG.debug("Port %(port)s is assigned to enterprise %(ent)s", {
'port': gw_port_id,
'ent': ent_id
})
return True
# Get ent permissions on gateway
gw_port = gw_helper.get_gateway_port(self.restproxy, gw_port_id,
gw_port['parentID'])
if not gw_port:
msg = (_("Port %s not found on gateway ", gw_port_id)) # noqa H702
raise restproxy.ResourceNotFoundException(msg)
gw_id = gw_port['parentID']
req_params['gw_id'] = gw_id
nuage_ent_perm = nuagelib.NuageEntPermission(create_params=req_params)
permissions = self.restproxy.get(nuage_ent_perm.get_resource_by_gw(),
required=True)
ent_perm = permissions[0] if permissions else None
if ent_perm:
ent_id = ent_perm['permittedEntityID']
if ent_id != netpart_id:
ent_type = ent_perm['permittedEntityType']
LOG.debug(
"Gateway %(gw)s already assigned to %(ent)s with "
"id %(ent_id)s", {
'gw': gw_id,
'ent': ent_type,
'ent_id': ent_id
})
return False
else:
LOG.debug("Gateway %(gw)s is assigned to enterprise %(ent)s", {
'gw': gw_id,
'ent': ent_id
})
return True
return False
