def get_subnet_by_netpart(self, netpart_id):
nuagel2dom = nuagelib.NuageL2Domain({'net_partition_id': netpart_id})
l2_doms = self.restproxy.get(nuagel2dom.get_all_resources_in_ent(),
required=True)
res = []
for l2dom in l2_doms:
np_dict = dict()
np_dict['name'] = l2dom['name']
np_dict['ID'] = l2dom['ID']
np_dict['subnet_os_id'] = strip_cms_id(l2dom['externalID'])
np_dict['dhcp_managed'] = l2dom['DHCPManaged']
np_dict['IPType'] = l2dom['IPType']
np_dict['ipv4_cidr'] = \
str(netaddr.IPNetwork("{}/{}".format(l2dom['address'],
l2dom['netmask'])))\
if l2dom.get('address') else ""
np_dict['IPv6Address'] = l2dom['IPv6Address']
np_dict['ipv4_gateway'] = \
self.get_gw_from_dhcp_options(l2dom['ID'])
np_dict['IPv6Gateway'] = l2dom['IPv6Gateway']
np_dict['net_partition_id'] = netpart_id
np_dict['enableDHCPv4'] = l2dom['enableDHCPv4']
np_dict['enableDHCPv6'] = l2dom['enableDHCPv6']
res.append(np_dict)
return res
def get_subnet_by_netpart(self, netpart_id):
nuagel2dom = nuagelib.NuageL2Domain({'net_partition_id': netpart_id})
l2_doms = self.restproxy.get(nuagel2dom.get_all_resources_in_ent(),
required=True)
res = []
for l2dom in l2_doms:
# backend_l2domain for domain linked to shared infrastructure
l2_backend_dom = l2dom
shared_resource = l2dom['associatedSharedNetworkResourceID']
if shared_resource:
# find backend l2dom
l2_backend_doms = self.restproxy.get(
nuagel2dom.get_resource(shared_resource), required=True)
l2_backend_dom = l2_backend_doms[0]
np_dict = dict()
np_dict['name'] = l2dom['name']
np_dict['ID'] = l2dom['ID']
np_dict['net_partition_id'] = netpart_id
np_dict['subnet_os_id'] = strip_cms_id(l2dom['externalID'])
np_dict['dhcp_managed'] = l2_backend_dom['DHCPManaged']
np_dict['IPType'] = l2_backend_dom['IPType']
np_dict['ipv4_cidr'] = (str(
netaddr.IPNetwork("{}/{}".format(l2_backend_dom['address'],
l2_backend_dom['netmask'])))
if l2_backend_dom.get('address') else "")
np_dict['IPv6Address'] = l2_backend_dom['IPv6Address']
np_dict['ipv4_gateway'] = self.get_gw_from_dhcp_options(
l2_backend_dom['ID'])
np_dict['IPv6Gateway'] = l2_backend_dom['IPv6Gateway']
np_dict['enableDHCPv4'] = l2_backend_dom['enableDHCPv4']
np_dict['enableDHCPv6'] = l2_backend_dom['enableDHCPv6']
res.append(np_dict)
return res
def get_gateway_vport(self, context, tenant_id, netpart_id,
nuage_vport_id):
nuage_vport = gw_helper.get_nuage_vport(self.restproxy, nuage_vport_id)
if not nuage_vport:
# Just return empty list. Plugin will throw 404
return []
subnet_mapping = nuagedb.get_subnet_l2dom_by_nuage_id(
context.session, nuage_vport['parentID'])
if nuage_vport['VLANID']:
nuage_gw_vport = self._get_gateway_vport(context, tenant_id,
netpart_id,
nuage_vport['VLANID'])
nuage_gw_vport['vlanid'] = nuage_vport['VLANID']
return nuage_gw_vport
ret = dict()
ret['subnet_id'] = strip_cms_id(subnet_mapping["subnet_id"])
# gridinv - for VSD managed subnets external ID is empty,
# se we have to compute subnet_id in plugin from nuage_subnet_id
ret['nuage_subnet_id'] = subnet_mapping["nuage_subnet_id"]
nuage_vport_type = nuage_vport['type']
if nuage_vport_type == constants.BRIDGE_VPORT_TYPE:
# Get the bridge interface on the vport
nuage_br_intf = gw_helper.get_interface_by_vport(
self.restproxy, nuage_vport_id, nuage_vport_type)
if nuage_br_intf:
ret['interface'] = nuage_br_intf['ID']
elif nuage_vport_type == constants.HOST_VPORT_TYPE:
# Get the host interface on the vport
nuage_host_intf = gw_helper.get_interface_by_vport(
self.restproxy, nuage_vport_id, nuage_vport_type)
if nuage_host_intf:
ret['interface'] = nuage_host_intf['ID']
ret['port_id'] = strip_cms_id(nuage_host_intf['externalID'])
ret['vport_type'] = nuage_vport_type
ret['vport_name'] = nuage_vport['name']
ret['vlanid'] = None
return ret
def make_subnet_dict(subnet):
res = dict()
res['subnet_id'] = subnet['ID']
res['subnet_name'] = subnet['name']
res['subnet_os_id'] = strip_cms_id(subnet['externalID'])
res['subnet_shared_net_id'] = \
subnet['associatedSharedNetworkResourceID']
res['subnet_address'] = subnet['address']
res['subnet_netmask'] = subnet['netmask']
res['subnet_gateway'] = subnet['gateway']
res['subnet_iptype'] = subnet['IPType']
return res
def get_nuage_domain_by_zoneid(restproxy_serv, zone_id):
nuage_dom = get_nuage_zone_by_id(restproxy_serv, zone_id)
req_params = {
'domain_id': nuage_dom['nuage_parent_id']
}
nuage_l3domain = nuagelib.NuageL3Domain(create_params=req_params)
l3domain = restproxy_serv.get(nuage_l3domain.get_resource(),
required=True)[0]
return {'nuage_domain_id': l3domain['ID'],
'externalID': (strip_cms_id(l3domain['externalID'])
if l3domain['externalID'] else None)}
def get_subnet_by_netpart(self, netpart_id):
nuagel2dom = nuagelib.NuageL2Domain({'net_partition_id': netpart_id})
response = self.restproxy.rest_call(
'GET', nuagel2dom.get_all_resources_in_ent(), '')
if not nuagel2dom.validate(response):
raise restproxy.RESTProxyError(nuagel2dom.error_msg)
res = []
for l2dom in nuagel2dom.get_response_objlist(response):
np_dict = dict()
np_dict['domain_name'] = l2dom['name']
np_dict['domain_id'] = l2dom['ID']
np_dict['subnet_os_id'] = strip_cms_id(l2dom['externalID'])
res.append(np_dict)
return res
def get_nuage_domain_by_zoneid(restproxy_serv, zone_id):
nuage_dom = get_nuage_zone_by_id(restproxy_serv, zone_id)
req_params = {'domain_id': nuage_dom['nuage_parent_id']}
nuage_l3domain = nuagelib.NuageL3Domain(create_params=req_params)
dom_resp = restproxy_serv.rest_call('GET', nuage_l3domain.get_resource(),
'')
if not nuage_l3domain.validate(dom_resp):
raise restproxy.RESTProxyError(nuage_l3domain.error_msg)
if len(dom_resp[3]) > 0:
ret = {'nuage_domain_id': dom_resp[3][0]['ID'], 'externalID': None}
if dom_resp[3][0]['externalID']:
ret['externalID'] = strip_cms_id(dom_resp[3][0]['externalID'])
return ret
def get_gateway_vport(self, context, tenant_id, netpart_id,
nuage_vport_id):
nuage_vport = gw_helper.get_nuage_vport(self.restproxy,
nuage_vport_id)
if not nuage_vport:
# Just return empty list. Plugin will throw 404
return []
nuage_subnet_id = nuage_vport['parentID']
if nuage_vport['VLANID']:
nuage_gw_vport = self._get_gateway_vport(context, tenant_id,
netpart_id,
nuage_vport['VLANID'])
nuage_gw_vport['vlanid'] = nuage_vport['VLANID']
return nuage_gw_vport
ret = dict()
ret['nuage_subnet_id'] = nuage_subnet_id
nuage_vport_type = nuage_vport['type']
if nuage_vport_type == constants.BRIDGE_VPORT_TYPE:
# Get the bridge interface on the vport
nuage_br_intf = gw_helper.get_interface_by_vport(
self.restproxy,
nuage_vport_id,
nuage_vport_type)
if nuage_br_intf:
ret['interface'] = nuage_br_intf['ID']
elif nuage_vport_type == constants.HOST_VPORT_TYPE:
# Get the host interface on the vport
nuage_host_intf = gw_helper.get_interface_by_vport(
self.restproxy,
nuage_vport_id,
nuage_vport_type)
if nuage_host_intf:
ret['interface'] = nuage_host_intf['ID']
ret['port_id'] = strip_cms_id(
nuage_host_intf['externalID'])
ret['vport_type'] = nuage_vport_type
ret['vport_name'] = nuage_vport['name']
ret['vlanid'] = None
return ret
def get_gateway_vports(self, context, tenant_id, netpart_id, filters):
subnet_id = filters['subnet'][0]
nuage_subnet_id = filters['nuage_subnet_id'][0]
# Get the nuage l2domain/subnet corresponding to neutron subnet
# nuage_subnet_id passed in filters by plugin
subnet_mapping = nuagedb.get_subnet_l2dom_by_nuage_id(
context.session, nuage_subnet_id)
if not subnet_mapping:
msg = _("Nuage subnet for neutron subnet %(subn)s not found " %
{'subn': subnet_id}) # noqa H702
raise restproxy.RESTProxyError(msg)
if subnet_mapping['nuage_l2dom_tmplt_id']:
subnet_type = constants.L2DOMAIN
else:
subnet_type = constants.SUBNET
if 'id' in filters:
# This is to get vport by id
vport = gw_helper.get_nuage_vport(self.restproxy, filters['id'][0])
# Return an empty list for neutronclient get_res_by_id_or_name()
if not vport:
return []
if vport['parentID'] != subnet_mapping['nuage_subnet_id']:
return []
vport_list = [vport]
elif 'name' in filters:
# This is to get vport by name
vport = gw_helper.get_nuage_vport_by_name(
self.restproxy, subnet_mapping['nuage_subnet_id'],
filters['name'][0], subnet_type)
# Return an empty list for neutronclient get_res_by_id_or_name()
if not vport:
return []
if vport['parentID'] != subnet_mapping['nuage_subnet_id']:
return []
vport_list = [vport]
else:
if subnet_type == constants.SUBNET:
# Get all host/bridge vports
vport_list = gw_helper.get_vports_for_subnet(
self.restproxy, subnet_mapping['nuage_subnet_id'])
else:
# Get all host/bridge vports
vport_list = gw_helper.get_vports_for_l2domain(
self.restproxy, subnet_mapping['nuage_subnet_id'])
resp_list = []
for vport in vport_list:
vport_type = vport['type']
resp = dict()
if vport_type in [
constants.HOST_VPORT_TYPE, constants.BRIDGE_VPORT_TYPE
]:
resp['vport_id'] = vport['ID']
resp['vport_type'] = vport_type
resp['vport_name'] = vport['name']
# Get the host/bridge interface
nuage_interface = gw_helper.get_interface_by_vport(
self.restproxy, vport['ID'], vport_type)
resp['port_id'] = None
if nuage_interface:
resp['interface'] = nuage_interface['ID']
resp['port_id'] = strip_cms_id(
nuage_interface['externalID'])
if vport_type == constants.HOST_VPORT_TYPE:
resp['subnet_id'] = subnet_id
else:
resp['subnet_id'] = subnet_id
if not vport['VLANID']:
# Skip this vport as it does not have any vlan.
# This should never happen as if vport is created a vlan
# is always associated with it
continue
# Get the gw interface
nuage_vlan = gw_helper.get_gateway_port_vlan(
self.restproxy, vport['VLANID'])
resp['nuage_vlan_id'] = nuage_vlan['ID']
resp['gateway'] = nuage_vlan['gatewayID']
resp['gatewayport'] = nuage_vlan['parentID']
resp['value'] = nuage_vlan['value']
resp_list.append(resp)
if tenant_id:
updated_vport_list = []
for vport in resp_list:
ent_perm = gw_helper.get_ent_permission_on_vlan(
self.restproxy, vport['nuage_vlan_id'])
if ent_perm:
vlan_perm = self._check_tenant_perm(
vport['nuage_vlan_id'], tenant_id,
ent_perm['permittedEntityID'])
if vlan_perm:
updated_vport_list.append(vport)
return updated_vport_list
return resp_list
def _get_gateway_vport(self, context, tenant_id, netpart_id,
nuage_vlan_id):
# subnet is required to keep the o/p format consistent with
# create_gateway_vport o/p
ret = {
'subnet_id': None,
'interface': None,
'vport_id': None,
'vport_type': None,
'vport_name': None,
'port_id': None
}
# Get the gw interface
try:
nuage_vlan = gw_helper.get_gateway_port_vlan(
self.restproxy, nuage_vlan_id)
except Exception as e:
if e.code == constants.RES_NOT_FOUND:
return
raise
# Check for tenant permission
# tenant_id is None in case of admin. We don't check permissions
# for admin.netpart_id will be None when called from
# delete_gateway_vport. We don't have to check permissions for
# delete as client always calls get() before delete and we check
# permissions during get()
if tenant_id and netpart_id:
ent_perm = gw_helper.get_ent_permission_on_vlan(
self.restproxy, nuage_vlan['ID'])
has_perm = self._check_tenant_perm(nuage_vlan_id, tenant_id,
ent_perm['permittedEntityID'])
if not has_perm:
msg = _("Tenant %(ten)s does not have permission for vlan %("
"vlan)s" % {
'ten': tenant_id, # noqa H702
'vlan': nuage_vlan_id
})
LOG.warn(msg)
raise restproxy.RESTProxyError(msg)
ret['gateway'] = nuage_vlan['gatewayID']
ret['gatewayport'] = nuage_vlan['parentID']
ret['value'] = nuage_vlan['value']
# Check if it is associated with a vport
nuage_vport_id = nuage_vlan['vportID']
if not nuage_vport_id:
msg = _("Nuage gateway interface %s is not associated with any "
"vport" % nuage_vlan_id) # noqa H702
raise restproxy.RESTProxyError(msg)
# Get the vport
nuage_vport = gw_helper.get_nuage_vport(self.restproxy, nuage_vport_id)
if nuage_vport:
subnet_mapping = nuagedb.get_subnet_l2dom_by_nuage_id(
context.session, nuage_vport['parentID'])
ret['subnet_id'] = subnet_mapping["subnet_id"]
ret['nuage_subnet_id'] = nuage_vport['parentID']
nuage_vport_type = nuage_vport['type']
if nuage_vport_type == constants.BRIDGE_VPORT_TYPE:
# Get the bridge interface on the vport
nuage_br_intf = gw_helper.get_interface_by_vport(
self.restproxy, nuage_vport_id, nuage_vport_type)
if nuage_br_intf:
ret['interface'] = nuage_br_intf['ID']
elif nuage_vport_type == constants.HOST_VPORT_TYPE:
# Get the host interface on the vport
nuage_host_intf = gw_helper.get_interface_by_vport(
self.restproxy, nuage_vport_id, nuage_vport_type)
if nuage_host_intf:
ret['interface'] = nuage_host_intf['ID']
ret['port_id'] = strip_cms_id(
nuage_host_intf['externalID'])
else:
msg = _("Nuage vport associated with gateway interface %s is"
" not connected to a bridge/host interface" %
nuage_vlan_id) # noqa H702
raise restproxy.RESTProxyError(msg)
ret['vport_id'] = nuage_vport_id
ret['vport_type'] = nuage_vport_type
ret['vport_name'] = nuage_vport['name']
return ret
def create_subnet(self, ipv4_subnet, ipv6_subnet, params):
subnet = ipv4_subnet or ipv6_subnet
req_params = {
'net_partition_id': params['netpart_id'],
'name': helper.get_subnet_name(subnet)
}
ext_params = {
'externalID': helper.get_subnet_external_id(subnet),
'DHCPManaged': True,
'dualStackDynamicIPAllocation': False
}
if ipv4_subnet:
net = netaddr.IPNetwork(ipv4_subnet['cidr'])
ext_params.update({
'address': str(net.ip),
'netmask': str(net.netmask),
'gateway': params['dhcp_ip'],
'IPType': constants.IPV4,
'enableDHCPv4': ipv4_subnet['enable_dhcp']
})
elif ipv6_subnet:
net = netaddr.IPNetwork(ipv6_subnet['cidr'])
ext_params.update({
'IPv6Address': str(net.cidr),
'IPv6Gateway': params['dhcpv6_ip'],
'IPType': constants.IPV6,
'enableDHCPv6': ipv6_subnet['enable_dhcp']
})
if ipv4_subnet and ipv6_subnet:
params.update({'network_id': subnet['network_id']})
ext_params.update(
helper.get_subnet_update_data(ipv4_subnet=ipv4_subnet,
ipv6_subnet=ipv6_subnet,
params=params))
if not ext_params.get('description'):
ext_params['description'] = helper.get_subnet_description(subnet)
nuagel2domtmplt = nuagelib.NuageL2DomTemplate(create_params=req_params,
extra_params=ext_params)
nuagel2domtemplate = self.restproxy.post(
nuagel2domtmplt.post_resource(),
nuagel2domtmplt.post_data(),
on_res_exists=self.restproxy.retrieve_by_ext_id_and_cidr)[0]
l2dom_tmplt_id = nuagel2domtemplate['ID']
req_params['template'] = l2dom_tmplt_id
req_params['externalID'] = ext_params['externalID']
ext_params = {
'address': ext_params.get('address'),
'IPv6Address': ext_params.get('IPv6Address'),
'description': ext_params['description'],
'IPType': ext_params['IPType'],
'ingressReplicationEnabled': params['ingressReplicationEnabled']
}
if (params.get('tunnelType') == constants.VSD_TUNNEL_TYPES['MPLS']):
ext_params['l2EncapType'] = constants.VSD_TUNNEL_TYPES['MPLS']
nuagel2domain = nuagelib.NuageL2Domain(create_params=req_params,
extra_params=ext_params)
try:
l2domain = self.restproxy.post(
nuagel2domain.post_resource(),
nuagel2domain.post_data(),
on_res_exists=self.restproxy.retrieve_by_ext_id_and_cidr)[0]
except Exception:
self.restproxy.delete(
nuagel2domtmplt.delete_resource(nuagel2domtemplate['ID']))
raise
l2domain_id = l2domain['ID']
subnet_dict = {
'nuage_l2template_id': l2dom_tmplt_id,
'nuage_l2domain_id': l2domain_id,
'nuage_external_id': strip_cms_id(l2domain['externalID']),
'nuage_parent_id': l2domain['parentID']
}
nuagedhcpoptions = dhcpoptions.NuageDhcpOptions(self.restproxy)
if ipv4_subnet:
nuagedhcpoptions.create_nuage_dhcp(
ipv4_subnet,
parent_id=l2domain_id,
network_type=constants.NETWORK_TYPE_L2)
if ipv6_subnet:
nuagedhcpoptions.create_nuage_dhcp(
ipv6_subnet,
parent_id=l2domain_id,
network_type=constants.NETWORK_TYPE_L2)
nuage_userid, nuage_groupid = helper.create_usergroup(
self.restproxy, params['tenant_id'], params['netpart_id'],
params.get('tenant_name'))
subnet_dict['nuage_userid'] = nuage_userid
subnet_dict['nuage_groupid'] = nuage_groupid
self._attach_nuage_group_to_l2domain(nuage_groupid, l2domain_id,
params['netpart_id'],
params.get('shared'),
params['tenant_id'])
self._create_nuage_def_l2domain_acl(
l2domain_id, subnet, allow_non_ip=params['allow_non_ip'])
self._create_nuage_def_l2domain_adv_fwd_template(l2domain_id, subnet)
return subnet_dict
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_subnet(self, os_subnet, params):
net = netaddr.IPNetwork(os_subnet['cidr'])
req_params = {
'net_partition_id': params['netpart_id'],
'name': os_subnet['id'],
}
ext_params = {
"DHCPManaged": os_subnet['enable_dhcp'],
"address": str(net.ip),
"netmask": str(net.netmask),
"gateway": params['dhcp_ip'],
'externalID': get_vsd_external_id(os_subnet['id'])
}
nuagel2domtmplt = nuagelib.NuageL2DomTemplate(create_params=req_params,
extra_params=ext_params)
nuagel2domtemplate = self.restproxy.post(
nuagel2domtmplt.post_resource(),
nuagel2domtmplt.post_data(),
on_res_exists=self.restproxy.retrieve_by_name)[0]
l2dom_tmplt_id = nuagel2domtemplate['ID']
req_params = {
'net_partition_id': params['netpart_id'],
'name': os_subnet['id'],
'template': l2dom_tmplt_id,
'externalID': get_vsd_external_id(os_subnet['id'])
}
ext_params = {'description': os_subnet['name']}
nuagel2domain = nuagelib.NuageL2Domain(create_params=req_params,
extra_params=ext_params)
try:
l2domain = self.restproxy.post(nuagel2domain.post_resource(),
nuagel2domain.post_data())[0]
except Exception:
self.restproxy.delete(
nuagel2domtmplt.delete_resource(nuagel2domtemplate['ID']))
raise
l2domain_id = l2domain['ID']
subnet_dict = {
'nuage_l2template_id': l2dom_tmplt_id,
'nuage_l2domain_id': l2domain_id,
'nuage_external_id': strip_cms_id(l2domain['externalID']),
'nuage_parent_id': l2domain['parentID']
}
nuagedhcpoptions = dhcpoptions.NuageDhcpOptions(self.restproxy)
nuagedhcpoptions.create_nuage_dhcp(
os_subnet,
parent_id=l2domain_id,
network_type=constants.NETWORK_TYPE_L2)
nuage_userid, nuage_groupid = \
helper.create_usergroup(self.restproxy,
params['tenant_id'],
params['netpart_id'])
subnet_dict['nuage_userid'] = nuage_userid
subnet_dict['nuage_groupid'] = nuage_groupid
self._attach_nuage_group_to_l2domain(nuage_groupid, l2domain_id,
params['netpart_id'],
params.get('shared'),
params['tenant_id'])
self._create_nuage_def_l2domain_acl(l2domain_id, os_subnet['id'])
self._create_nuage_def_l2domain_adv_fwd_template(
l2domain_id, os_subnet['id'])
pnet_binding = params.get('pnet_binding', None)
if pnet_binding:
pnet_params = {
'pnet_binding': pnet_binding,
'netpart_id': params['netpart_id'],
'l2domain_id': l2domain_id,
'neutron_subnet_id': os_subnet['id']
}
try:
pnet_helper.process_provider_network(self.restproxy,
self.policygroups,
pnet_params)
except Exception:
self.delete_subnet(os_subnet['id'])
raise
return subnet_dict
def create_router(self, neutron_router, router, params):
net_partition = params['net_partition']
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['nuage_router_template']:
req_params['templateID'] = router['nuage_router_template']
extra_params = {'description': neutron_router['name']}
if 'rd' in router.keys() and router['rd']:
extra_params['routeDistinguisher'] = router['rd']
if 'rt' in router.keys() 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.keys()
and router['nuage_backhaul_vnid']):
extra_params['backHaulVNID'] = router['nuage_backhaul_vnid']
if ('nuage_backhaul_rd' in router.keys()
and router['nuage_backhaul_rd']):
extra_params['backHaulRouteDistinguisher'] = (
router['nuage_backhaul_rd'])
if ('nuage_backhaul_rt' in router.keys()
and router['nuage_backhaul_rt']):
extra_params['backHaulRouteTarget'] = router['nuage_backhaul_rt']
# PATEnabled
extra_params['PATEnabled'] = self._nuage_pat_enabled_or_disabled(
router, params)
extra_params['underlayEnabled'] = extra_params['PATEnabled']
router_dict = {}
nuagel3domain = nuagelib.NuageL3Domain(create_params=req_params,
extra_params=extra_params)
response = self.restproxy.rest_call('POST',
nuagel3domain.post_resource(),
nuagel3domain.post_data())
if not nuagel3domain.validate(response):
if not nuagel3domain.resource_exists(response):
code = nuagel3domain.get_error_code(response)
raise restproxy.RESTProxyError(nuagel3domain.error_msg,
error_code=code)
response = self.restproxy.rest_call(
'GET',
nuagel3domain.get_resource_with_ext_id(),
'',
extra_headers=nuagel3domain.extra_headers_get())
if not nuagel3domain.get_validate(response):
raise restproxy.RESTProxyError(nuagel3domain.error_msg)
nuage_domain_id = nuagel3domain.get_domainid(response)
external_id = nuagel3domain.get_response_externalid(response)
parent_id = nuagel3domain.get_response_parentid(response)
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['rt'] = nuagel3domain.get_domain_rt(response)
router_dict['rd'] = nuagel3domain.get_domain_rd(response)
router_dict['ecmp_count'] = nuagel3domain.get_domain_ecmp_count(
response)
router_dict['tunnel_type'] = nuagel3domain.get_domain_tunnel_type(
response)
router_dict['nuage_backhaul_vnid'] = (
nuagel3domain.get_domain_backhaul_vnid(response))
router_dict['nuage_backhaul_rd'] = (
nuagel3domain.get_domain_backhaul_rd(response))
router_dict['nuage_backhaul_rt'] = (
nuagel3domain.get_domain_backhaul_rt(response))
req_params = {'domain_id': nuage_domain_id}
nuage_zone = nuagelib.NuageZone(req_params)
response = self.restproxy.rest_call('GET', nuage_zone.list_resource(),
'')
if not nuage_zone.validate(response):
self.delete_router(nuage_domain_id)
raise restproxy.RESTProxyError(nuage_zone.error_msg)
isolated_id = None
shared_id = None
if router['nuage_router_template'] is not None:
for zone in nuage_zone.zone_list(response):
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_router(nuage_domain_id)
raise restproxy.RESTProxyError(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,
params['tenant_id'])
elif net_partition.get('isolated_zone', None):
for zone in nuage_zone.zone_list(response):
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_router(nuage_domain_id)
raise restproxy.RESTProxyError(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,
params['tenant_id'])
# TODO(Divya) - the following else block seems redudant, see if can
# be removed
else:
router_dict['nuage_def_zone_id'] = nuage_zone.get_isolated_zone_id(
response)
external_id_params = {'zone_id': router_dict['nuage_def_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'])
shared_id = nuage_zone.get_shared_zone_id(response)
external_id_zone['zone_id'] = shared_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'])
self._make_nuage_zone_shared(net_partition['id'], shared_id,
params['tenant_id'])
nuage_userid, nuage_groupid = \
helper.create_usergroup(self.restproxy, params['tenant_id'],
params['net_partition']['id'])
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'],
params['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
