def _make_grp_id_list(self, params):
nuage_grp_id_list = []
if params['subn_tenant'] != params['tenant']:
nuage_userid, nuage_groupid = helper.create_usergroup(
self.restproxy, params['subn_tenant'], params['netpart_id'])
nuage_grp_id_list.append(nuage_groupid)
nuage_userid, nuage_groupid = helper.create_usergroup(
self.restproxy, params['tenant'], params['netpart_id'])
nuage_grp_id_list.append(nuage_groupid)
return nuage_grp_id_list
def _check_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)
nuage_perm = nuagelib.NuagePermission(create_params=req_params)
response = self.restproxy.rest_call('GET',
nuage_perm.get_resource_by_vlan(),
'')
if not nuage_perm.validate(response):
LOG.error("Permissions not available for vlan %s", vlan_id)
return False
if nuage_perm.check_response_exist(response):
perm = nuage_perm.get_response_obj(response)
if perm['permittedEntityID'] == nuage_group:
LOG.debug(
"user tenant %(ten)s has permission on vlan "
"%(vlan)s", {
'ten': user_tenant,
'vlan': vlan_id
})
return True
return False
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 remove_tenant_perm(self, vlan_id, user_tenant, netpart_id):
nuage_user, nuage_group = helper.create_usergroup(
self.restproxy, user_tenant, netpart_id)
req_params = {'vlan_id': vlan_id}
extra_params = {'entity_id': nuage_group}
nuage_perm = nuagelib.NuagePermission(create_params=req_params,
extra_params=extra_params)
permissions = self.restproxy.get(nuage_perm.get_resource_by_vlan())
for perm in permissions:
if perm['permittedEntityID'] == nuage_group:
LOG.debug("Removing %(grp)s permission from vlan %(vlan)s", {
'grp': user_tenant,
'vlan': vlan_id
})
req_params['perm_id'] = perm['ID']
self.restproxy.delete(nuage_perm.get_resource_by_id() +
'?responseChoice=1')
# return the num of remaining groups
return len(permissions) - 1
msg = _("Vlan %(vlan)s is not assigned to tenant "
"%(grp)s") % {
'grp': user_tenant,
'vlan': vlan_id
}
LOG.debug(msg)
return len(permissions) - 1
def _check_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)
nuage_perm = nuagelib.NuagePermission(create_params=req_params)
permissions = self.restproxy.get(nuage_perm.get_resource_by_vlan(),
required=True)
if not permissions:
return False
else:
return permissions[0]['permittedEntityID'] == nuage_group
def attach_nuage_group_to_nuagenet(self, tenant, nuage_npid,
nuage_subnetid, shared):
nuage_uid, nuage_gid = helper.create_usergroup(self.restproxy, tenant,
nuage_npid)
nuagesubn = nuagelib.NuageSubnet()
nuagegroup = nuagelib.NuageGroup()
if shared:
# Get the id for grp 'everybody'
params = {'net_partition_id': nuage_npid}
nuagegroup = nuagelib.NuageGroup(create_params=params)
response = self.restproxy.rest_call(
'GET', nuagegroup.list_resource(), '',
nuagegroup.extra_headers_get_for_everybody())
if not nuagegroup.validate(response):
raise restproxy.RESTProxyError(nuagegroup.error_msg)
nuage_all_groupid = nuagegroup.get_groupid(response)
response = self.restproxy. \
rest_call('GET', nuagesubn.get_resource(nuage_subnetid),
'')
if not nuagesubn.validate(response):
nuagel2dom = nuagelib.NuageL2Domain()
response = self.restproxy. \
rest_call('GET', nuagel2dom.get_resource(nuage_subnetid),
'')
if not nuagel2dom.validate(response):
raise restproxy.RESTProxyError(nuagel2dom.error_msg)
if shared:
self.create_permission(nuage_subnetid,
nuage_all_groupid,
tenant,
perm_on='l2domains')
else:
self.create_permission(nuage_subnetid,
nuage_gid,
tenant,
perm_on='l2domains')
return nuage_uid, nuage_gid
else:
if shared:
self.create_permission(nuagesubn.get_parentzone(response),
nuage_all_groupid, tenant)
else:
self.create_permission(nuagesubn.get_parentzone(response),
nuage_gid, tenant)
return nuage_uid, nuage_gid
def remove_tenant_perm(self, vlan_id, user_tenant, netpart_id):
nuage_user, nuage_group = helper.create_usergroup(
self.restproxy, user_tenant, netpart_id)
req_params = {'vlan_id': vlan_id}
extra_params = {'entity_id': nuage_group}
nuage_perm = nuagelib.NuagePermission(create_params=req_params,
extra_params=extra_params)
response = self.restproxy.rest_call('GET',
nuage_perm.get_resource_by_vlan(),
'')
if not nuage_perm.validate(response):
raise restproxy.RESTProxyError(nuage_perm.error_msg)
perm_list = nuage_perm.get_response_objlist(response)
for perm in perm_list:
if perm['permittedEntityID'] == nuage_group:
LOG.debug("Removing %(grp)s permission from vlan %(vlan)s", {
'grp': user_tenant,
'vlan': vlan_id
})
req_params['perm_id'] = perm['ID']
response = self.restproxy.rest_call(
'DELETE',
nuage_perm.get_resource_by_id() + '?responseChoice=1', '')
if not nuage_perm.validate(response):
raise restproxy.RESTProxyError(nuage_perm.error_msg)
# return the num of remaining groups
return len(perm_list) - 1
msg = _("Vlan %(vlan)s is not assigned to tenant "
"%(grp)s") % {
'grp': user_tenant,
'vlan': vlan_id
}
LOG.debug(msg)
return len(perm_list) - 1
def attach_nuage_group_to_nuagenet(self, tenant, nuage_npid,
nuage_subnetid, shared, tenant_name):
nuage_uid, nuage_gid = helper.create_usergroup(self.restproxy, tenant,
nuage_npid, tenant_name)
nuagesubn = nuagelib.NuageSubnet()
if shared:
# Get the id for grp 'everybody'
params = {'net_partition_id': nuage_npid}
nuagegroup = nuagelib.NuageGroup(create_params=params)
groups = self.restproxy.get(
nuagegroup.list_resource(),
extra_headers=nuagegroup.extra_headers_get_for_everybody(),
required=True)
nuage_all_groupid = groups[0]['ID'] if groups else None
try:
subnet = self.restproxy.get(nuagesubn.get_resource(nuage_subnetid),
required=True)[0]
except restproxy.ResourceNotFoundException:
nuagel2dom = nuagelib.NuageL2Domain()
self.restproxy.get(nuagel2dom.get_resource(nuage_subnetid),
required=True)
if shared:
self.create_permission(nuage_subnetid,
nuage_all_groupid,
tenant,
perm_on='l2domains')
else:
self.create_permission(nuage_subnetid,
nuage_gid,
tenant,
perm_on='l2domains')
return nuage_uid, nuage_gid
else:
if shared:
self.create_permission(subnet['parentID'], nuage_all_groupid,
tenant)
else:
self.create_permission(subnet['parentID'], nuage_gid, tenant)
return nuage_uid, nuage_gid
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_usergroup(self, tenant, net_partition_id):
return helper.create_usergroup(self.restproxy, tenant,
net_partition_id)
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
